Question: 可以通过变量拿到该变量的地址，但是只知道地址的话，怎么知道是那个变量呢？

有时不将“调用函数名字＋各参数值，进入函数后各参数值，中间变量值，退出函数前准备返回的值，返回函数到调用处后函数名字＋各参数值＋返回值”这些信息写日志到文件中是无论如何也发现不了问题在哪里的，包括捕获各种异常、写日志到屏幕、单步或设断点或生成core文件、……这些方法都不行！ 写日志到文件参考下面： //循环向a函数每次发送200个字节长度（这个是固定的）的buffer, //a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理， //在处理的时候每次从新buffer中取两个字节打印 #ifdef _MSC_VER     #pragma warning(disable:4996) #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef _MSC_VER     #include <windows.h>     #include <process.h>     #include <io.h>     #define  MYVOID             void     #define  vsnprintf          _vsnprintf #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  MYVOID             void * #endif //Log{ #define MAXLOGSIZE 20000000 #define MAXLINSIZE 16000 #include <time.h> #include <sys/timeb.h> #include <stdarg.h> char logfilename1[]="MyLog1.log"; char logfilename2[]="MyLog2.log"; static char logstr[MAXLINSIZE+1]; char datestr[16]; char timestr[16]; char mss[4]; CRITICAL_SECTION cs_log; FILE *flog; #ifdef _MSC_VER void Lock(CRITICAL_SECTION *l) {     EnterCriticalSection(l); } void Unlock(CRITICAL_SECTION *l) {     LeaveCriticalSection(l); } void sleep_ms(int ms) {     Sleep(ms); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } void sleep_ms(int ms) {     usleep(ms*1000); } #endif void LogV(const char *pszFmt,va_list argp) {     struct tm *now;     struct timeb tb;      if (NULL==pszFmt||0==pszFmt[0]) return;     vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,"%03d",tb.millitm);     printf("%s %s.%s %s",datestr,timestr,mss,logstr);     flog=fopen(logfilename1,"a");     if (NULL!=flog) {         fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);         if (ftell(flog)>MAXLOGSIZE) {             fclose(flog);             if (rename(logfilename1,logfilename2)) {                 remove(logfilename2);                 rename(logfilename1,logfilename2);             }         } else {             fclose(flog);         }     } } void Log(const char *pszFmt,...) {     va_list argp;      Lock(&cs_log);     va_start(argp,pszFmt);     LogV(pszFmt,argp);     va_end(argp);     Unlock(&cs_log); } //Log} #define ASIZE    200 #define BSIZE    240 #define CSIZE      2 char Abuf[ASIZE]; char Cbuf[CSIZE]; CRITICAL_SECTION cs_HEX ; CRITICAL_SECTION cs_BBB ; struct FIFO_BUFFER {     int  head;     int  tail;     int  size;     char data[BSIZE]; } BBB; int No_Loop=0; void HexDump(int cn,char *buf,int len) {     int i,j,k;     char binstr[80];      Lock(&cs_HEX);     for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%03d %04x -",cn,i);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             Log("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         Log("%s\n",binstr);     }     Unlock(&cs_HEX); } int GetFromRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      lent=0;     Lock(cs);     if (fbuf->size>=len) {         lent=len;         if (fbuf->head+lent>BSIZE) {             len1=BSIZE-fbuf->head;             memcpy(buf     ,fbuf->data+fbuf->head,len1);             len2=lent-len1;             memcpy(buf+len1,fbuf->data           ,len2);             fbuf->head=len2;         } else {             memcpy(buf     ,fbuf->data+fbuf->head,lent);             fbuf->head+=lent;         }         fbuf->size-=lent;     }     Unlock(cs);     return lent; } MYVOID thdB(void *pcn) {     char        *recv_buf;     int          recv_nbytes;     int          cn;     int          wc;     int          pb;      cn=(int)pcn;     Log("%03d thdB              thread begin...\n",cn);     while (1) {         sleep_ms(10);         recv_buf=(char *)Cbuf;         recv_nbytes=CSIZE;         wc=0;         while (1) {             pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);             if (pb) {                 Log("%03d recv %d bytes\n",cn,pb);                 HexDump(cn,recv_buf,pb);                 sleep_ms(1);             } else {                 sleep_ms(1000);             }             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef _MSC_VER     pthread_exit(NULL); #endif } int PutToRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      Lock(cs);     lent=len;     if (fbuf->size+lent>BSIZE) {         lent=BSIZE-fbuf->size;     }     if (fbuf->tail+lent>BSIZE) {         len1=BSIZE-fbuf->tail;         memcpy(fbuf->data+fbuf->tail,buf     ,len1);         len2=lent-len1;         memcpy(fbuf->data           ,buf+len1,len2);         fbuf->tail=len2;     } else {         memcpy(fbuf->data+fbuf->tail,buf     ,lent);         fbuf->tail+=lent;     }     fbuf->size+=lent;     Unlock(cs);     return lent; } MYVOID thdA(void *pcn) {     char        *send_buf;     int          send_nbytes;     int          cn;     int          wc;     int           a;     int          pa;      cn=(int)pcn;     Log("%03d thdA              thread begin...\n",cn);     a=0;     while (1) {         sleep_ms(100);         memset(Abuf,a,ASIZE);         a=(a+1)%256;         if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop         send_buf=(char *)Abuf;         send_nbytes=ASIZE;         Log("%03d sending %d bytes\n",cn,send_nbytes);         HexDump(cn,send_buf,send_nbytes);         wc=0;         while (1) {             pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);             Log("%03d sent %d bytes\n",cn,pa);             HexDump(cn,send_buf,pa);             send_buf+=pa;             send_nbytes-=pa;             if (send_nbytes<=0) break;//             sleep_ms(1000);             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef _MSC_VER     pthread_exit(NULL); #endif } int main() { #ifdef _MSC_VER     InitializeCriticalSection(&cs_log);     InitializeCriticalSection(&cs_HEX );     InitializeCriticalSection(&cs_BBB ); #else     pthread_t threads[2];     int threadsN;     int rc;     pthread_mutex_init(&cs_log,NULL);     pthread_mutex_init(&cs_HEX,NULL);     pthread_mutex_init(&cs_BBB,NULL); #endif     Log("Start===========================================================\n");      BBB.head=0;     BBB.tail=0;     BBB.size=0;  #ifdef _MSC_VER     _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);     _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2); #else     threadsN=0;     rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);     rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1); #endif      if (!access("No_Loop",0)) {         remove("No_Loop");         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     while (1) {         sleep_ms(1000);         if (No_Loop) break;//         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     sleep_ms(3000);     Log("End=============================================================\n"); #ifdef _MSC_VER     DeleteCriticalSection(&cs_BBB );     DeleteCriticalSection(&cs_HEX );     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_BBB);     pthread_mutex_destroy(&cs_HEX);     pthread_mutex_destroy(&cs_log); #endif     return 0; }

引用 4 楼 zhao4zhong1 的回复:[quote=引用 3 楼 zifeiyuuuu 的回复:] [quote=引用 1 楼 user-2 的回复:] 这直接从你给的数据上看不出来吧 我现在怀疑踩内存了，出问题那 一段数据，我有了，然后在另外一个地方发现，差不多的一段数据，我现在需要知道那个内存分给那个变量了， 然后对着代码看是不是因为这个变量踩了别人的内存。  赵老师出来指点一下啊[/quote] 我2楼已经指点过了。[/quote] 老师这不可行啊， 我是抓的很多数据作为输入，现在不知道是那个数据引起的问题，有时候是1天，有时候是好几天，只能是长跑，出现问题了，通过core看问题的。

引用 3 楼 zifeiyuuuu 的回复:[quote=引用 1 楼 user-2 的回复:] 这直接从你给的数据上看不出来吧 我现在怀疑踩内存了，出问题那 一段数据，我有了，然后在另外一个地方发现，差不多的一段数据，我现在需要知道那个内存分给那个变量了， 然后对着代码看是不是因为这个变量踩了别人的内存。  赵老师出来指点一下啊[/quote] 我2楼已经指点过了。

引用 1 楼 user-2 的回复:这直接从你给的数据上看不出来吧 我现在怀疑踩内存了，出问题那 一段数据，我有了，然后在另外一个地方发现，差不多的一段数据，我现在需要知道那个内存分给那个变量了， 然后对着代码看是不是因为这个变量踩了别人的内存。  赵老师出来指点一下啊

watch 表达式：设置一个监视点，一旦被监视的“表达式”的值改变，gdb将强行终止正在被调试的程序。如： watch a 2. 设置观察点(WatchPoint) 观察点一般用来观察某个表达式(变量也是一种表达式)的值是否变化了。如果有变化，马上停住程序。有下面的几种方法来设置观察点： watch <expr> 为表达式(变量)expr设置一个观察点。一旦表达式值有变化时，马上停住程序。 rwatch <expr> 当表达式(变量)expr被读时，停住程序。 awatch <expr> 当表达式(变量)的值被读或被写时，停住程序。 info watchpoints 列出当前设置的所有观察点。

这直接从你给的数据上看不出来吧


Question: 询问万能的坛友一个C语言算法的名字

映射

引用 3 楼 adusuccessfully 的回复:[quote=引用 1 楼 lqbk1 的回复:] #include<stdio.h>    signed char myScale(int v){ 	return -128 + ((255*v/100) + 0.5); }    int main()   {    	printf("%d -> %d\n%d -> %d\n%d -> %d\n",0, myScale(0), 50, myScale(50), 100, myScale(100)); 	return 0;   }    一楼挺给力，提供了一个非常好的思路。但我试了下，还是有点问题，这样double转unsigned char 都是向下取整了：  -128+（255*0/100+0.5）是-127.5，输出是-127； -128+（255*50/100+0.5）是-0.5，输出是0； -128+（255*0/100+0.5）是127.5，输出是127；[/quote]  多谢提醒，做个调整也是很简单的事情  #include<stdio.h>    signed char myScale(int v){ 	return -128 + (int)((255.0*v/100) + 0.5); }    int main()   {    	printf("%d -> %d\n%d -> %d\n%d -> %d\n",0, myScale(0), 50, myScale(50), 100, myScale(100)); 	return 0;   }

引用 1 楼 lqbk1 的回复:#include<stdio.h>    signed char myScale(int v){ 	return -128 + ((255*v/100) + 0.5); }    int main()   {    	printf("%d -> %d\n%d -> %d\n%d -> %d\n",0, myScale(0), 50, myScale(50), 100, myScale(100)); 	return 0;   }  思路是对的，谢谢了

引用 1 楼 lqbk1 的回复:#include<stdio.h>    signed char myScale(int v){ 	return -128 + ((255*v/100) + 0.5); }    int main()   {    	printf("%d -> %d\n%d -> %d\n%d -> %d\n",0, myScale(0), 50, myScale(50), 100, myScale(100)); 	return 0;   }    一楼挺给力，提供了一个非常好的思路。但我试了下，还是有点问题，这样double转unsigned char 都是向下取整了：  -128+（255*0/100+0.5）是-127.5，输出是-127； -128+（255*50/100+0.5）是-0.5，输出是0； -128+（255*0/100+0.5）是127.5，输出是127；

引用 1 楼 lqbk1 的回复:#include<stdio.h>    signed char myScale(int v){ 	return -128 + ((255*v/100) + 0.5); }    int main()   {    	printf("%d -> %d\n%d -> %d\n%d -> %d\n",0, myScale(0), 50, myScale(50), 100, myScale(100)); 	return 0;   }  这么晚了，好给力，我先研究研究，到时候给分


Question: 手机棋盘加密算法（急！！！）

引用 7 楼 zhao4zhong1 的回复:[quote=引用 5 楼 qq423399099 的回复:] 哈哈，只有放在C++小版里才会404  http://bbs.csdn.net/topics/391853986 规则越多越严格的论坛，死得越早越快。个人意见。[/quote] 对的，我在VB版就见到一个圣母，为社区一点力都没出，还要求删除他不满意的贴子，贴子都删了，谁还来你csdn。

这叫对数组不熟么，分明是不会编程，检测输入，定位数组元素，，，

等待这个帖子404中……

引用 8 楼 zhao4zhong1 的回复:“仅供参考”四个字已经被赵4老师锤炼成一句比“芝麻开门”还灵验的咒语了！

“仅供参考”四个字已经被赵4老师锤炼成一句比“芝麻开门”还灵验的咒语了！

引用 5 楼 qq423399099 的回复:哈哈，只有放在C++小版里才会404  http://bbs.csdn.net/topics/391853986 规则越多越严格的论坛，死得越早越快。个人意见。

//http://bbs.csdn.net/topics/391962021 //  1 2 3 4 //1 //2 A B C //3 D E F //4 G H I //5 J K L //6 M N O //7 P Q R S //8 T U V //9 W X Y Z //如上 //要求是 //1,：解密：当输入42 21 71 71 93时，会输出HAPPY //2,：加密：当输入HAPPY时，会输出42 21 71 71 93 //附加要求：如果可以，每行之间做互换，如果输入1321，就表示第1行和第3行互换，然后第2行再和第1行互换，当然也可以输入987867这样，进行3轮互换。 #include <stdio.h> #include <string.h> int main() {     char mi[10][5]={         {0, 0 , 0 , 0 , 0 },         {0,' ',' ',' ',' '},         {0,'A','B','C',' '},         {0,'D','E','F',' '},         {0,'G','H','I',' '},         {0,'J','K','L',' '},         {0,'M','N','O',' '},         {0,'P','Q','R','S'},         {0,'T','U','V',' '},         {0,'W','X','Y','Z'},     };     char ln[80];     char s[80];     char *p,c;     int i;     int L;     int n;     int y;     int x;      fgets(ln,80,stdin);     if ('\n'==ln[0]) return 1;//直接输入回车，退出     L=strlen(ln);     if ('\n'==ln[L-1]) ln[L-1]=0;//去掉行尾的'\n'(如果有)     p=ln;     while (1) {         if (1!=sscanf(p,"%79s%n",s,&n)) break;         if (2==strlen(s) && '1'<=s[0] && s[0]<='9' && '1'<=s[1] && s[1]<='4') {             printf("%c",mi[s[0]-'0'][s[1]-'0']);         } else {             L=strlen(s);             for (i=0;i<L;i++) if (!('A'<=s[i] && s[i]<='Z')) break;             if (i>=L) {//全部由'A'到'Z'组成                 for (i=0;i<L;i++) {                     for (y=1;y<=9;y++) {                         for (x=1;x<=4;x++) {                             if (mi[y][x]==s[i]) {                                 if (i==L-1) {                                     printf("%d%d",y,x);                                 } else {                                     printf("%d%d ",y,x);                                 }                                 goto NC;                             }                         }                     }                     NC:;                 }             } else {                 L=strlen(s);                 if (L>=4 && 0==L%2) {                     for (i=0;i<L;i+=2) {                         if (!('1'<=s[i] && s[i]<='9' && '1'<=s[i+1] && s[i+1]<='9')) break;                     }                     if (i>=L) {//符合行互换语法                         for (i=0;i<L;i+=2) {                             if (s[i]!=s[i+1]) {                                 for (x=1;x<=4;x++) {c=mi[s[i]-'0'][x];mi[s[i]-'0'][x]=mi[s[i+1]-'0'][x];mi[s[i+1]-'0'][x]=c;} //                              printf("\n%c<=>%c\n",s[i],s[i+1]); //                              for (y=1;y<=9;y++) { //                                  printf("%d ",y); //                                  for (x=1;x<=4;x++) { //                                      printf("%c",mi[y][x]); //                                  } //                                  printf("\n"); //                              }                             }                         }                     }                 }             }         }         p+=n;     }     return 0; } //输入：42 21 71 71 93 HAPPY 1321 987867 HAPPY //输出：HAPPY42 21 71 71 9342 11 81 81 63

哈哈，只有放在C++小版里才会404

咦？竟然还没404

仅供参考. #include <stdio.h>  void mima(void) { 	char mi[10][5]={ 		{0}, 		{0}, 		{0,'A','B','C',0}, 		{0,'D','E','F',0}, 		{0,'G','H','I',0}, 		{0,'J','K','L',0}, 		{0,'M','N','O',0}, 		{0,'P','Q','R','S'}, 		{0,'T','U','V',0}, 		{0,'W','X','Y','Z'} 	}; 	char s; 	int f=0,i,j,z,st=1; 	while(st!=0) 	{ 		printf("功能 1 : 加密   2 : 解密\n"); 		scanf("%d",&f); 		switch(f){ 		case 1: 			printf("加密\n"); 			rewind(stdin); 			while((s=getchar())!='\n') 			{ 				for(i=1;i<10;i++) 				{ 					for(j=1;j<5;j++) 					{ 						if(s==mi[i][j]) 							printf("%.1d%.1d\t",i,j); 					} 				} 			} 			break; 		case 2: 			printf("解密\n"); 			while(scanf("%d",&z)) 			{ 				printf("%c",mi[z/10][z%10]); 				if('\n'==getchar()) 					break; 			} 			break; 		default: 			break; 	} 	rewind(stdin); 	printf("\n0:退出1:继续\t"); 	scanf("%d",&st); 	} }  int main(void) { 	mima(); 	return 0; } 效果:


Question: C语言，字符合并

作为一个C程序员，对  scanf,sscanf,fscanf  printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离手，曲不离口”的。

#include <stdio.h> #include <string.h> void main() { int i,k; unsigned char str[4][10]={"MAC","TIME","MARK","SSID"};  printf("("); for(i=0;i<4;i++){ 	printf("'"); 	printf("%s",str[i]); 	printf("'"); if(i!=3){ 		printf(","); 	} } printf(")");   }

1、strcat字符连接 注意控制格式，可以批量处理 2、sprintf这个比较直接，固定格式

sprintf  "（'%s','%s','%s','%s'）"  http://en.cppreference.com/w/c/io/fprintf

sprintf


Question: C语言又一个函数不知道哪里错了

修改方法：   for(i=0;i<3;i++) 		for(j=i;j<3;j++)

原因很简单，你交换的时候，比如 i = 1, j = 0的时候，你把array[0][1]与array[1][0]交换了一次，当i=0，j=1的时候，你又将它们交换一次，这样又换回原来的了

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

#include<stdio.h> void zhuanzhi(int array[][3]) {  	int t,i,j; for(i=0;i<3;i++) {  for(j=i;j<3;j++) { t=array[i][j];     array[i][j]=array[j][i]; array[j][i]=t; } } for(i=0;i<3;i++) for(j=0;j<3;j++) printf("%d ",array[i][j]); } int main() {   int array[3][3];   int m,n;     for(m=0;m<3;m++)  for(n=0;n<3;n++)     scanf("%d",&array[m][n]);      zhuanzhi(array);  printf("\n"); return 0; } 注意那个条件


Question: c语言怎么把字符串0x123转换成16进制的0x123?

int v; sscanf("0x123","%i",&v); printf("0x%x",v); 这样应该就可以

BOOL HexStringToUnShort(const char *pInHexString,unsigned short &nOut) { 	if(pInHexString==NULL) 	{ 		return FALSE; 	}  	char szBuf[16] = "\0"; 	strcpy(szBuf, pInHexString + 2);  	try 	{ 		nOut=0; 		BYTE nData; 		for(int i=0;i<2;++i) 		{ 			nData=szBuf[i]; 			switch(nData) 			{ 			case '0': 			case '1': 			case '2': 			case '3': 			case '4': 			case '5': 			case '6': 			case '7': 			case '8': 			case '9': 				nData=nData-'0'; 				nOut +=nData<< ((3-i)*4); 				break;  			case 'A': 			case 'B': 			case 'C': 			case 'D': 			case 'E': 			case 'F': 				nData=nData-'A' + 10; 				nOut +=nData<< ((3-i)*4); 				break;  			case 'a': 			case 'b': 			case 'c': 			case 'd': 			case 'e': 			case 'f': 				nData=nData-'a' + 10; 				nOut +=nData<< ((3-i)*4); 				break;	  			default: 				return FALSE; 			} 		} 	} 	catch(...) 	{ 		return FALSE; 	} 	return TRUE; }

char* p = "0x123";           char* str;           long i = strtol(p, &str, 16);     printf("%d", i);

atoi遇到第一个数字就取出来，sscanf要对格式。

有个函数叫sscanf

十进制和十六进制的数的内存表现形式是一样的，所以转换为十进制就可以了，具体方法可以参考我的这篇文章 http://blog.csdn.net/cyfcsd/article/details/51381605


Question: c语言指针排序问题

引用 5楼我是你的主体 的回复:[quote=引用 2 楼 qq423399099 的回复:] inv函数里问题很多： 1.p是啥？i是啥？ 2.t1=arr+k;//t1是int,而arr+k是int *指针 3.arr+k和arr+n-1也不能作为左值  参考别人的选择排序：  /* 版本一 */ #include<stdio.h> #include<stdlib.h>   void swap(int*a,int*b) {     int temp;     temp=*a;     *a=*b;     *b=temp; } void select_sort(int A[],int n) {     register int i,j,min,m;     for(i=0;i<n-1;i++)     {         min=i;//查找最小值         for(j=i+1;j<n;j++)         {             if(A[min]>A[j])             {                 min=j;             }         }         if(min!=i)         {             swap(&A[min],&A[i]);             printf("第%d趟排序结果为:\n",i+1);             for(m=0;m<n;m++)             {                 if(m>0)                 {                     printf("");                 }                 printf("%d",A[m]);             }             printf("\n");         }     } } int main(void) {     int n;     while(scanf("%d",&n)!=EOF)    /* VS2013等版本中需使用scanf_s()，VC6.0中使用scanf() */     {         int i;         int*A=(int*)malloc(sizeof(int)*n);         for(i=0;i<n;i++)         {             scanf("%d",&A[i]);         }         select_sort(A,n);         printf("最终排序结果为:\n");         for(i=0;i<n;i++)         {             if(i>0){                 printf("");             }             printf("%d",A[i]);         }         printf("\n");     }     return 0; }       /* 版本二 */ #include <stdio.h> #include <math.h>   #define MAX_SIZE 101 #define SWAP(x, y, t)  ((t) = (x), (x) = (y), (y) = (t))   void sort(int[], int);      /* selection sort */   void main(void) {     int i, n;     int list[MAX_SIZE];     printf("Enter the number of numbers to generate: ");     scanf_s("%d", &n);     if (n < 1 || n > MAX_SIZE){         fprintf(stderr, "Improper value of n\n");         exit(1);     }     for (i = 0; i < n; i++){    /* randomly generate numbers */         list[i] = rand() * 1000;         printf("%d ", list[i]);     }     sort(list, n);     printf("\n Sorted array:\n");     for (i = 0; i < n; i++)    /* print out sorted numbers */         printf("%d ", list[i]);     printf("\n"); }     void sort(int list[], int n) {     int i, j, min, temp;     for (i = 0; i < n - 1; i++){         min = i;         for (j = i + 1; j < n; j++)         if (list[j] < list[min])             min = j;         SWAP(list[i], list[min], temp);     } }     #include<stdio.h> int main() { 	void inv(int *arr,int n); 	int i,a[10],*p=a; 	printf("请输入十个数\n"); 	for(i=0;i<10;i++,p++) 		scanf("%d",p); 	printf("\n"); 	p=a; 	inv(a,10); 	for(p=a;p<a+10;p++) 		printf("%d ",*p); 	printf("\n"); } void inv(int *arr,int n) { 	int t1,t2,*max,*min,*p; 	max=min=arr; 	for(p=arr+1;p<arr+n;p++) 	{ 		if(*max<*p) 		{ 			max=p; 		} 		if(*min>*p) 		{ 			min=p; 		} 	} 	t1=arr[0]; 	arr[0]=*min; 	*min=t1; 	t2=arr[n-1];     arr[n-1]=*max;     *max=t2; } 我改好了  你看看这样行不行[/quote]测试了下结果没啥问题

引用 2 楼 qq423399099 的回复:inv函数里问题很多： 1.p是啥？i是啥？ 2.t1=arr+k;//t1是int,而arr+k是int *指针 3.arr+k和arr+n-1也不能作为左值  参考别人的选择排序：  /* 版本一 */ #include<stdio.h> #include<stdlib.h>   void swap(int*a,int*b) {     int temp;     temp=*a;     *a=*b;     *b=temp; } void select_sort(int A[],int n) {     register int i,j,min,m;     for(i=0;i<n-1;i++)     {         min=i;//查找最小值         for(j=i+1;j<n;j++)         {             if(A[min]>A[j])             {                 min=j;             }         }         if(min!=i)         {             swap(&A[min],&A[i]);             printf("第%d趟排序结果为:\n",i+1);             for(m=0;m<n;m++)             {                 if(m>0)                 {                     printf("");                 }                 printf("%d",A[m]);             }             printf("\n");         }     } } int main(void) {     int n;     while(scanf("%d",&n)!=EOF)    /* VS2013等版本中需使用scanf_s()，VC6.0中使用scanf() */     {         int i;         int*A=(int*)malloc(sizeof(int)*n);         for(i=0;i<n;i++)         {             scanf("%d",&A[i]);         }         select_sort(A,n);         printf("最终排序结果为:\n");         for(i=0;i<n;i++)         {             if(i>0){                 printf("");             }             printf("%d",A[i]);         }         printf("\n");     }     return 0; }       /* 版本二 */ #include <stdio.h> #include <math.h>   #define MAX_SIZE 101 #define SWAP(x, y, t)  ((t) = (x), (x) = (y), (y) = (t))   void sort(int[], int);      /* selection sort */   void main(void) {     int i, n;     int list[MAX_SIZE];     printf("Enter the number of numbers to generate: ");     scanf_s("%d", &n);     if (n < 1 || n > MAX_SIZE){         fprintf(stderr, "Improper value of n\n");         exit(1);     }     for (i = 0; i < n; i++){    /* randomly generate numbers */         list[i] = rand() * 1000;         printf("%d ", list[i]);     }     sort(list, n);     printf("\n Sorted array:\n");     for (i = 0; i < n; i++)    /* print out sorted numbers */         printf("%d ", list[i]);     printf("\n"); }     void sort(int list[], int n) {     int i, j, min, temp;     for (i = 0; i < n - 1; i++){         min = i;         for (j = i + 1; j < n; j++)         if (list[j] < list[min])             min = j;         SWAP(list[i], list[min], temp);     } }     #include<stdio.h> int main() { 	void inv(int *arr,int n); 	int i,a[10],*p=a; 	printf("请输入十个数\n"); 	for(i=0;i<10;i++,p++) 		scanf("%d",p); 	printf("\n"); 	p=a; 	inv(a,10); 	for(p=a;p<a+10;p++) 		printf("%d ",*p); 	printf("\n"); } void inv(int *arr,int n) { 	int t1,t2,*max,*min,*p; 	max=min=arr; 	for(p=arr+1;p<arr+n;p++) 	{ 		if(*max<*p) 		{ 			max=p; 		} 		if(*min>*p) 		{ 			min=p; 		} 	} 	t1=arr[0]; 	arr[0]=*min; 	*min=t1; 	t2=arr[n-1];     arr[n-1]=*max;     *max=t2; } 我改好了  你看看这样行不行

引用 1 楼 user-3 的回复:#include <stdio.h> #include <stdlib.h>  int main() { int array[5]; int i,j,*p,temp; p=array; printf("please input some integer:\n"); for(i=0;i<5;i++) { scanf("%d",p++); } p=array; printf("排序前为：\n"); for(i=0;i<5;i++) { printf("%-5d",*p++); } p=array;  for(i=0;i<4;i++) { for(j=0;j<4-i;j++) { if(*(p+j)>*(p+j+1)) //用指针去引用数组中的元素并进行比较 { temp=*(p+j);  *(p+j)=*(p+j+1); *(p+j+1)=temp; } } } printf("排序之后：\n"); for(i=0;i<5;i++) { printf("%-5d",*p++); } return 0; } 这是冒泡排序，不过建议还是自己写写吧，从你的代码中可以看出，你对 C 的基础都不清楚呢~   恩 对啊，指针还没有学完呢。。我现在是各种混乱。。

回答的都很很六！！


Question: hdu 1002  A + B Problem II  菜鸟求助

仅供参考：#include <stdio.h> #include <string.h> #define MAXLEN 1000 char a1[MAXLEN]; char a2[MAXLEN]; static int v1[MAXLEN]; static int v2[MAXLEN]; static int v3[MAXLEN]; int i,j,n,L,z; void main(void) {     scanf("%d",&n);     for (j=0;j<n;j++) {         scanf("%s%s",a1,a2);          L=strlen(a1);         for (i=0;i<L;i++) v1[i]=a1[L-1-i]-'0';          L=strlen(a2);         for (i=0;i<L;i++) v2[i]=a2[L-1-i]-'0';          for (i=0;i<MAXLEN;i++) v3[i]=v1[i]+v2[i];          for (i=0;i<MAXLEN;i++) {             if (v3[i]>=10) {                 v3[i+1]+=v3[i]/10;                 v3[i]=v3[i]%10;             }         }          printf("Case %d:\n", j+1);         printf("%s + %s = ", a1, a2);          z=0;         for (i=MAXLEN-1;i>=0;i--) {             if (z==0) {                 if (v3[i]!=0) {                     printf("%d",v3[i]);                     z=1;                 }             } else {                 printf("%d",v3[i]);             }         }         if (z==0) printf("0");          printf("\n");     } } //Sample Input //3 //0 0 //1 2 //112233445566778899 998877665544332211 // //Sample Output //Case 1: //0 + 0 = 0 //Case 2: //1 + 2 = 3 //Case 3: //112233445566778899 + 998877665544332211 = 1111111111111111110

参考:  /*  * hdu-1002  * mike-w  * 2012-5-21  */ #include<stdio.h> #include<stdlib.h> #include<string.h>  #define ONLINE_JUDGE  #ifndef ONLINE_JUDGE #include<assert.h> #endif  #define MAX_NUM_LEN 1234 #define BASE 10000 #define WIDTH 4 #define min(a,b) ((a)>(b)?(b):(a))  int conv(char *buf, int *s) { 	int len=strlen(buf); 	int weight=1,pos=MAX_NUM_LEN-1; 	int i; 	memset(s,0,sizeof(int)*MAX_NUM_LEN); 	for(i=1;i<=len;i++) 	{ 		s[pos]+=(buf[len-i]-'0')*weight; 		weight*=10; 		if(weight==BASE) 			weight=1, pos--; 	} 	s[0]=pos; 	return 0; }  int add(int *a1, int *a2, int *s) { 	memset(s,0,sizeof(int)*MAX_NUM_LEN); 	int end=min(a1[0], a2[0]); 	int carry=0,i; 	for(i=MAX_NUM_LEN-1;i>=end;i--) 	{ 		s[i]=a1[i]+a2[i]+carry; 		carry=s[i]/BASE; 		s[i]%=BASE; 	} 	if(carry) 		s[i]=carry,s[0]=i; 	else 		s[0]=i+1; 	return 0; }  int disp(int *s) { 	int i=s[0]; 	while(i<MAX_NUM_LEN && s[i]==0) 		i++; 	if(i==MAX_NUM_LEN) 		putchar('0'); 	else 		printf("%d",s[i]); 	for(i++;i<MAX_NUM_LEN;i++) 		printf("%0*d",WIDTH,s[i]); 	return 0; }  int read_num(int *s) { 	char buf[MAX_NUM_LEN]; 	memset(s,0,sizeof(int)*MAX_NUM_LEN); 	scanf("%s",buf); 	conv(buf,s); 	return 0; }  int main(void) { #ifndef ONLINE_JUDGE 	assert(freopen("in","r",stdin)); #endif 	int ncase,ccase; 	int n1[MAX_NUM_LEN]; 	int n2[MAX_NUM_LEN]; 	int s[MAX_NUM_LEN]; 	scanf("%d",&ncase); 	for(ccase=1;ccase<=ncase;ccase++) 	{ 		if(ccase>1) 			putchar('\n'); 		printf("Case %d:\n",ccase); 		read_num(n1); 		read_num(n2); 		add(n1, n2, s); 		disp(n1) 		printf(" + "); 		disp(n2); 		printf(" = "); 		disp(s); 		printf("\n"); 	} 	return 0; } /*  * extra words:  * 我的存储大数的方法：  * char* -> int*  * 数字在数组中与尾部对齐——不倒序存储！  * 数组的首位标示了数字可能开始的位置，有可能比实际开始位置  * 提前。  * 输出的过程中注意过滤掉数组前面的0  */

ACM初学者见谅..试了很多数据都对，可是还是wrong answer


Question: 关于Iso C中有些语句不会翻译

相由心生。 说是一物即不中。 搜“盲人摸太阳”。

感觉我见过的实现好像都没有填充位 ...  引用 7 楼 Zxy0918520 的回复:[quote=引用 6 楼 user-2 的回复:] 对于有符号整数，对象表示中的位可以分为三部分：数值位，填充位，符号位。 填充位可以不出现; signed char 不能含有填充位。符号位只能占用1位。 数值位中的每一位的所代表的数值，与改类型对应的无符号整数类型的对象表示中的对应位是一致的 (如果有符号类型有M个数值位，无符号类型有N个数值位，那么 M ≤ N) 如果符号位为0，符号位不影响结果值。 如果符号位为1，结果值必须经历以下几种修改之一： — 对数值位所表示的值取反 (符号与绝对值表示；原码); — 数值位表示的值 −(2^M) (补码); — 数值位表示的值 −(2^M − 1) (反码). 具体使用哪一种方案由实现定义。对前两种表示，符号位为1，数值位全为0时，以及对最后一种表示，符号位与数值位全为1时，是否一个正常的数值也有实现定义。对于原码与反码，如果前述的表示是一个正常值，它将被称作负零。感谢 请问一下 什么是填充位。。是不是 十进制3 用二进制00000011表示，除符号位以外00000011红色部分是填充位[/quote]

目的就是让三部分的总长度凑够8的倍数。因为每字节8位。

引用 6 楼 user-2 的回复:对于有符号整数，对象表示中的位可以分为三部分：数值位，填充位，符号位。 填充位可以不出现; signed char 不能含有填充位。符号位只能占用1位。 数值位中的每一位的所代表的数值，与改类型对应的无符号整数类型的对象表示中的对应位是一致的 (如果有符号类型有M个数值位，无符号类型有N个数值位，那么 M ≤ N) 如果符号位为0，符号位不影响结果值。 如果符号位为1，结果值必须经历以下几种修改之一： — 对数值位所表示的值取反 (符号与绝对值表示；原码); — 数值位表示的值 −(2^M) (补码); — 数值位表示的值 −(2^M − 1) (反码). 具体使用哪一种方案由实现定义。对前两种表示，符号位为1，数值位全为0时，以及对最后一种表示，符号位与数值位全为1时，是否一个正常的数值也有实现定义。对于原码与反码，如果前述的表示是一个正常值，它将被称作负零。感谢 请问一下 什么是填充位。。是不是 十进制3 用二进制00000011表示，除符号位以外00000011红色部分是填充位

浮点数格式 http://bbs.csdn.net/topics/390676437

有人么。。padding value又指的是什么

红色部分的 不知道什么意思 自己翻译的很拗口 ，难懂。。


Question: 采用哈夫曼编码进行文件压缩

百度搜“C源代码 哈夫曼 文件”

求源代码~~~


Question: return 下出现说明：应输入声明。

引用 15 楼 qcx1221 的回复:[quote=引用 14 楼 zhao4zhong1 的回复:]  “找到问题出现的症状和解决问题” 都不如 学习和练习如何 “找到问题出现的症状和解决问题” 重要。  我发现通过C-free能够通过运行并能正确显示结果。 这个代表编译器使用的标准不同吗？[/quote]

引用 14 楼 zhao4zhong1 的回复: “找到问题出现的症状和解决问题” 都不如 学习和练习如何 “找到问题出现的症状和解决问题” 重要。  我发现通过C-free能够通过运行并能正确显示结果。 这个代表编译器使用的标准不同吗？

用了另一款C-free编译器，居然能够通过。 疑问依然在。

引用 10 楼 Atom2004 的回复:我印象中下面这种写法只是某些特殊版本的编译器才能识别吧，应该不属于标准C的语法吧。  pt1 = (int [2]){10.20};  研究别人的写法，我觉得没有任何问题。但自己写代码的时候最好采用通熟易懂的写法。  这个不是别人的写法，而是C primer plus 书上的例题写法。 1、首先这个例题，我是在怀疑自己是不是有些许错误。 2、例题写法如果有问题，是错在哪个部分，他为什么这样写？ 3、还是想要追根究底。 4、既然楼上各位都对此写法有疑问，而我google了暂也没发现有这类疑问搜索到。

10.20 应该改成10, 20  另外没刚过这种用法

引用 8 楼 qq423399099 的回复:不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  实在话！ 但，初学者，就是因为这些疑问，在寻找问题的症状。

引用 6 楼 zhao4zhong1 的回复:偶遇到类似问题都是用 “每次用/*...*/注释掉不同部分再重新编译，直到定位到具体语法出错的位置。” 的方法解决的。  学习了！ 不过为什么出现的这个问题还是弄不明白。  数组定义方式按：     int temp_1[2] = {10, 20};     int temp_2[2][4] = {{1,2,3,-9},{4,5,6,-8}};     int temp_3[6] = {4,4,4,5,5,5};     pt1 = temp_1;     pt2 = temp_2; 是较容易理解的。  但是例题中：     pt1 = (int [2]){10.20};     pt2 = (int [2][COLS]){{1,2,3,-9},{4,5,6,-8}};       total1 = sum(pt1,2);     total2 = sum2d(pt2,2);     total3 = sum((int []){4,4,4,5,5,5},6); 这种定义方式却行不通？

引用 4 楼 user-5 的回复:我觉得 return 0有问题  return 0 处没问题，只是前面有个符号错了。 而更改之后17\18\19及return处问题均没有了，但还是有2楼的问题。

我觉得 return 0有问题

引用 2 楼 qq423399099 的回复: #include <stdio.h> #define COLS 4 int sum2d(int ar[][COLS], int rows); int sum(int ar[],int n); int main(void) { 	int total1, total2,total3; 	int * pt1; 	int (*pt2)[COLS];  	int temp_1[2] = {10, 20}; 	int temp_2[2][4] = {{1,2,3,-9},{4,5,6,-8}}; 	int temp_3[6] = {4,4,4,5,5,5}; 	pt1 = temp_1; 	pt2 = temp_2;  	total1 = sum(pt1,2); 	total2 = sum2d(pt2,2); 	total3 = sum(temp_3,6); 	printf("total1 = %d\n", total1); 	printf("total2 = %d\n", total2); 	printf("total3 = %d\n", total3);  	return 0; }  int sum(int ar[], int n) { 	int i; 	int total = 0; 	for(i=0;i<n;i++) 		total += ar[i]; 	return total; }  int sum2d(int ar[][COLS], int rows) { 	int r; 	int c; 	int tot = 0; 	for(r=0;r<rows;r++) 		for(c=0;c<COLS;c++) 			tot += ar[r][c]; 	return tot; }   这种方法定义数组是没问题。 而书上例题所在的定义数组方式却无法运行，这个是何问题？ 例题所在目录：10.9 复合文字  程序清单10.19

更新： #include <stdio.h> #define COLS 4 int sum2d(int ar[][COLS], int rows); int sum(int ar[],int n); int main(void) { 	int total1, total2,total3; 	int * pt1; 	int (*pt2)[COLS];  	pt1 = (int [2]){10.20}; 	pt2 = (int [2][COLS]){{1,2,3,-9},{4,5,6,-8}};  	total1 = sum(pt1,2); 	total2 = sum2d(pt2,2); 	total3 = sum((int []){4,4,4,5,5,5},6); 	printf("total1 = %d\n", total1); 	printf("total2 = %d\n", total2); 	printf("total3 = %d\n", total3);  	return 0; }  int sum(int ar[], int n) { 	int i; 	int total = 0; 	for(i=0;i<n;i++) 		total += ar[i]; 	return total; }  int sum2d(int ar[][COLS], int rows) { 	int r; 	int c; 	int tot = 0; 	for(r=0;r<rows;r++) 		for(c=0;c<COLS;c++) 			tot += ar[r][c]; 	return tot; }   自己找到一处小错误，第4点错误没有了！


Question: perror和strerror的问题

补充一点，perror 是打到 stderr 上的，不是 stdout 。它们会有独立的缓冲。

在每个最后不带\n的printf后面加fflush(stdout);

perror是无缓冲:无缓冲指的是标准的IO库不对字符进行缓冲存储 printf是行缓冲: 在这种情况下，标准的IO在输入和输出中遇到换行符执行IO操作；注意，当流涉及终端时，都使用行缓冲．


Question: 后缀子串排序

scanf返回值是接收到的变量值的个数 而EOF一般是-1

引用 2 楼 paschen的回复:while((gets(str))!=EOF){ 这句  gets返回值是char*，而 EOF是整数类型，不能这样比较  http://en.cppreference.com/w/c/io/gets 改成scanf也不对。。。

字斟句酌， 边界条件。


Question: 关于打开外部exe文件的问题

引用 7 楼 060的回复:你不行，总的有个现象吧？现象是什么，这样大家才好帮你解决问题。 抱歉！ 代码已经贴出。

#include <stdio.h>  #include <windows.h>  int main(int argc,char *argv[]) {  	WinExec("C:/Users/ZGHMVP/Desktop/SD_Setup.exe",SW_SHOW);//无法打开 	printf("%d\n",GetLastError()); 	WinExec("C:/Users/ZGHMVP/Desktop/SD1.4.0.553_CN.exe",SW_SHOW);//正常打开 	printf("%d\n",GetLastError()); 	system("pause"); 	return 0;  }  打印输出 ///////////////// 0 0 请按任意键继续. . . ////////////////////

system 或者exec ？ 这俩函数行不。

你不行，总的有个现象吧？现象是什么，这样大家才好帮你解决问题。

贴出你的代码，让大家帮你看看

GetLastError

检查函数返回值，并参照MSDN解释，判断失败原因

自己的程序和系统自带的程序不一样，要用完整的路径

试过用管理员权限运行你的程序吗？


Question: 谢谢大神指导

也就是*s1=s2改成*s1=*s2 另外char*p 改成char p[] 结果将是1711717

引用 9 楼 小灸舞的回复:你这个不是要逆序输出？ 蒽蒽，我懂了，谢谢指导

这样改：   #include<stdio.h> #include<string.h> void fun(char *w, int n) { 	char t, *s1, *s2; 	s1 = w, s2 = w + n - 1; 	while(s1 < s2) 	{ 		t = *s1++; 		*s1 = *s2; 		*s2 = t; 	} } main() { 	char p[] = "1234567"; 	fun(p, strlen(p)); 	puts(p); }

你这个不是要逆序输出？

引用 7 楼 小灸舞的回复:我第三条讲了，不要将--和++写在一个语句里，否则的话你进行之后的赋值替换的时候，指针已经指到下一个字符了 初始：1234567（s1指向1，s2指向7） t = *s1++;//t为1，然后s1++指向了2 *s1 = *s2--;//*s2为7，将7赋给s1指向的位置!!!!(此时s1是指向2的，你将2替换成了7)，字符串变成了1734567 *s2 = t;//s2已经--过了，所以指向的是6，然后用1替换掉6，字符串变成了1734517  楼主应该明白了吧.................. 不对的，按你这个改顺序是7654321，可是你按我的那个打一次结果是1711717，而且标准答案就是1711717

引用 4 楼 小灸舞的回复:有3个错误： 1.p = "1234567";代表p指向的是常量区的常量字符串"1234567"，该区域一般是禁止进行写操作的 2.楼主没有让s2-- 3.逻辑上也有问题，不要将--和++写在一个语句里，否则的话你进行之后的赋值替换的时候，指针已经指到下一个字符了  #include<stdio.h> #include<string.h> void fun(char *w, int n) { 	char t, *s1, *s2; 	s1 = w, s2 = w + n - 1; 	while(s1 < s2) 	{ 		t = *s1; 		*s1 = *s2; 		*s2 = t; 		s1++; 		s2--; 	} }  void main() { 	char p[] = "1234567"; 	fun(p, strlen(p)); 	puts(p); }  结果为什么是1711717，能指导一下吗

4楼正解

引用 1 楼 user-4的回复:char *p; p = "1234567"; =================== 改为：char p[] = "1234567"; 对了，那个循环中条件是*s1≡s2--,可是结果为什么是1711717，还有那个你说的字符改法有什么区别

引用 1 楼 user-4的回复:char *p; p = "1234567"; =================== 改为：char p[] = "1234567"; 可是这样修改程序是没错了，可结果是乱码


Question: c语言编译错误求助

引用 4 楼 ghx287524027 的回复:#include"stdio.h" float max(float a[]) {     float *p=a,*i=a;     for(;p<p+9;p++)         if(*a<*(p+1))         {             *a=*(p+1);             i=(p+1);         }     printf("这个最大的数是数组的第%d位元素",i-a);     return *a; }       int main() {     float a[10],*p=a,maxnum;     for(;p<p+10;p++)         scanf("%f",p);     maxnum=max(a);     printf(":%f",maxnum); 	return 0; } 建议你也跟着楼主一起改行。

#include <stdio.h> float max(float a[]) {     float *p=a,*i=a;     for(;p<&a[9];p++)         if(*a<*(p+1))         {             *a=*(p+1);             i=p+1;         }     printf("这个最大的数是数组的第%d（从0开始）个元素",i-&a[0]);     return *a; }  int main() {     float a[10],*p=a,maxnum;     for(;p<&a[10];p++)         scanf("%f",p);     maxnum=max(a);     printf(":%f",maxnum);     return 0; }  建议楼主趁早改行。

maxnum=max(a[10]);  改成  maxnum=max(a);   另外建议把max函数换个名字，否则可能与max宏重名

1.编译错误： 传参写错了，a[10]代表a数组第11个元素，直接传数组名就行了 maxnum=max(a[10]);改为maxnum=max(a); 2.逻辑错误： main和max函数里for循环里p<p+10都是不对的，这个恒满足，应该改成p<a+10  #include"stdio.h" float max(float a[]) { 	float *p=a,*i=a; 	for(;p<a+9;p++) 		if(*a<*(p+1)) 		{ 			*a=*(p+1); 			i=(p+1); 		} 		printf("这个最大的数是数组的第%d位元素",i-a); 		return *a; }  void main() { 	float a[10],*p=a,maxnum; 	for(;p<a+10;p++) 		scanf("%f",p); 	maxnum=max(a); 	printf(":%f",maxnum); }


Question: 请教一个函数局部变量生命周期问题

要是想在函数内部创建一个在全局可用的变量，可以用new操作符。

栈中的变量通常包括函数参数和函数里声明的临时变量。 栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。 而栈中的类变量退出其作用域时，会自动执行其析构函数，……

有效最多能说明运气好，调用prinft后无效因为printf函数参数以及内部变量需要在栈上开辟空间，将你之前的值覆盖了

房东租给你了一间房子，配了一把钥匙给你，结果到期了，你还占着房子以为是你的，结果房东找到了新租客，你的东西全被房东扔了，然后你还理直气壮的拿着钥匙问为什么。

行为未定义，anything is possible

在调用了int *test(int a)函数之后，内存被释放，但是此处，虽然*p指向已经被释放区域，但是此处内存可能没有被覆盖，等到第二次打印的时候也许此处内存被覆盖了，所以打印会出现任意情况

test函数返回后局部变量销毁，但是仍然有指针指向这块内存，这块内存随时有可能被修改成不同的内容，所以得到了不确定的结果

所以如果换一个编译环境的话结果可能完全不一样是吗？

本来就是一个未定义的行为，发生什么结果都不奇怪。 毕竟你让p指向了一个形参的地址（局部变量）


Question: 请教：这种情形下，不写return有没有问题？

尝试运行了一下是没问题

第一种写法有的编译器无法通过，即使通过了也会出现未定义行为。

楼主第一种方法是想通过f1内的EAX寄存器里值作为返回值？ PS：暂且不说第一种方式在有的编译器里编译都过不去。

凡是有返回值的函数，他的每条路径，都应该有返回值。

如果不需要取g函数都返回值 没return也没关系 需要去g函数都返回值就必须有return

本质上是不一样的  不过凑巧的话，可能是一样的


Question: 提示错误error C2143: syntax error : missing ';' before '{'

[quote=引用 19 楼 wyyy2088511 的回复:] {{}，{}}这里要加的是逗号而不是分号 恩，明白，谢谢啦！

{{}，{}}这里要加的是逗号而不是分号

引用 17 楼 jianwen0529 的回复:[quote=引用 16 楼 D_vcp 的回复:] 难道初始化应该是： int zifu={ {1, 1, 1, 1, 1, 0, 0, 0};{0, 1, 1, 0, 1, 1, 0, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 1, 1, 0, 0};{1, 1, 1, 1, 1, 0, 0, 0}}; 赋值时是： zifu={ {1, 1, 1, 1, 1, 0, 0, 0};{0, 1, 1, 0, 1, 1, 0, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 1, 1, 0, 0};{1, 1, 1, 1, 1, 0, 0, 0}}; 是这样的吗？ （去年的问题，其实有点记不清了；现在又有了新的解决思路） 你一年还没搞清楚这个问题，初始化全部用逗号 赋值只能一个个元素进行赋值 你的两种方式都是语法不允许的错误  //定义并初始化 int a[2][2] = { {1, 2}, {3, 4} };   int a[2][2]; a[0][1] = 1; a[1][0] = 3; [/quote]  ……中间有段时间没有继续学习，谢谢你的提示！

引用 16 楼 D_vcp 的回复:难道初始化应该是： int zifu={ {1, 1, 1, 1, 1, 0, 0, 0};{0, 1, 1, 0, 1, 1, 0, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 1, 1, 0, 0};{1, 1, 1, 1, 1, 0, 0, 0}}; 赋值时是： zifu={ {1, 1, 1, 1, 1, 0, 0, 0};{0, 1, 1, 0, 1, 1, 0, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 1, 1, 0, 0};{1, 1, 1, 1, 1, 0, 0, 0}}; 是这样的吗？ （去年的问题，其实有点记不清了；现在又有了新的解决思路） 你一年还没搞清楚这个问题，初始化全部用逗号 赋值只能一个个元素进行赋值 你的两种方式都是语法不允许的错误  //定义并初始化 int a[2][2] = { {1, 2}, {3, 4} };   int a[2][2]; a[0][1] = 1; a[1][0] = 3;

你的那种写法只能在声明时初始化，赋值是不能那样写。

引用 12 楼 赵4老师的回复:[quote=引用 11 楼 D_vcp 的回复:] 用注释法，错误好多，心累 目前还没有更好的办法。要不楼主想个更好的办法。[/quote] 果断放弃治疗，让我静静

用注释法，错误好多，心累

我直接在在构造函数里初始化的 还需要放到构造函数初始化列表里吗？

偶遇到类似问题都是用 “每次用/*...*/注释掉不同部分再重新编译，直到定位到具体语法出错的位置。” 的方法解决的。

“变量赋值”和“变量初始化”不是一回事！ “变量赋值”发生在运行期，其写法遵循赋值语法规定。 “变量初始化”发生在编译期或运行期，其写法遵循初始化列表语法规定。

你要在构造函数时初始需要放到构造函数初始化列表里

把分号改成逗号，又出现如下错误： error C2143: syntax error : missing ';' before ','

头文件代码如是： class CDrawDianZhenView : public CView { protected: // create from serialization only 	CDrawDianZhenView(); 	DECLARE_DYNCREATE(CDrawDianZhenView)  // Attributes public: 	CDrawDianZhenDoc* GetDocument();     int zifu[8][8];  //定义了一个点阵数组，进行图形演示 // Operations  Cpp代码如是： CDrawDianZhenView::CDrawDianZhenView() { 	// TODO: add construction code here 	//zifu={ {1, 1, 1, 1, 1, 0, 0, 0};{0, 1, 1, 0, 1, 1, 0, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 0, 1, 1, 0};{0, 1, 1, 0, 1, 1, 0, 0};{1, 1, 1, 1, 1, 0, 0, 0}};  	zifu[0]={1, 1, 1, 1, 1, 0, 0, 0}; 	zifu[1]={0, 1, 1, 0, 1, 1, 0, 0}; 	zifu[2]={0, 1, 1, 0, 0, 1, 1, 0}; 	zifu[3]={0, 1, 1, 0, 0, 1, 1, 0}; 	zifu[4]={0, 1, 1, 0, 0, 1, 1, 0}; 	zifu[5]={0, 1, 1, 0, 0, 1, 1, 0}; 	zifu[6]={0, 1, 1, 0, 1, 1, 0, 0}; 	zifu[7]={1, 1, 1, 1, 1, 0, 0, 0};  	//并且分别用每行首字符地址来初始化也不行？？ };

大概是两种方式，一，定义的时候初始化，参考上楼。第二，先定义，然后利用循环初始化；还没见过你这么写的……

char zifu[8][8]={  	{1, 1, 1, 1, 1, 0, 0,1}, 	{0, 1, 1, 0, 1, 1, 0,1}, 	{0, 1, 1, 0, 0, 1, 1,1}, 	{0, 1, 1, 0, 0, 1, 1,1}, 	{0, 1, 1, 0, 0, 1, 1,1}, 	{0, 1, 1, 0, 0, 1, 1,1}, 	{0, 1, 1, 0, 1, 1, 0,1}, 	{1, 1, 1, 1, 1, 0, 0,1} };

多贴点代码。 方法1每个元素中间的分号至少也应该改为, 参考：C++11的统一初始化

引用 11 楼 D_vcp 的回复:用注释法，错误好多，心累 目前还没有更好的办法。要不楼主想个更好的办法。


Question: 代码段（.text）在内存中的地址为什么比数据段的要大？

这个应该是局部变量，存放在栈中的，地址应该是大的啊

引用 8 楼 spiritmg 的回复:[quote=引用 7 楼 zhao4zhong1 的回复:] 这个问题要回到当初ROM中烧代码，RAM中存数据的那个年代了…… 这么说来就远了，估计得搞个单片机来测试下。不纠结了先这样吧。[/quote] ROM的地址一般总比RAM的地址大。

引用 6 楼 paschen 的回复:请参看PE文件结构，各个块之间并没有顺序要求  恩，确实是。 我估计段在内存中的位置可能与PE loader的实现有关。暂时先不纠结这个问题了。windows总是给人意外的惊喜，linux就比较按规矩来。

引用 7 楼 zhao4zhong1 的回复:这个问题要回到当初ROM中烧代码，RAM中存数据的那个年代了…… 这么说来就远了，估计得搞个单片机来测试下。不纠结了先这样吧。

这个问题要回到当初ROM中烧代码，RAM中存数据的那个年代了……

请参看PE文件结构，各个块之间并没有顺序要求

引用 4 楼 spiritmg 的回复:[quote=引用 3 楼 akirya 的回复:] [quote=引用 2 楼 spiritmg 的回复:] [quote=引用 1 楼 qq423399099 的回复:] DEBUG模式变量周围需要存放调试信息，所以相差的距离大于4个字节。 楼主改成RELEASE就会发现两者相差4字节了  多谢版主，确实是这样的，改为release后就是4个字节了。  第1个问题，还是不懂，请大神们赐教。  [/quote] 这个没有为什么吧，没有规定的事情。[/quote]  从我网上查的资料看，程序在内存中的映射应该是有一定规律的，我把工程->属性中改为固定基地址，每次运行程序中各个变量的地址就不变了。而且对于Linux系统来说，代码段的基地址永远是0x08048000。[/quote] 得有明确的规定才能说不符合的是错的，规律不能证明什么。

引用 3 楼 akirya 的回复:[quote=引用 2 楼 spiritmg 的回复:] [quote=引用 1 楼 qq423399099 的回复:] DEBUG模式变量周围需要存放调试信息，所以相差的距离大于4个字节。 楼主改成RELEASE就会发现两者相差4字节了  多谢版主，确实是这样的，改为release后就是4个字节了。  第1个问题，还是不懂，请大神们赐教。  [/quote] 这个没有为什么吧，没有规定的事情。[/quote]  从我网上查的资料看，程序在内存中的映射应该是有一定规律的，我把工程->属性中改为固定基地址，每次运行程序中各个变量的地址就不变了。而且对于Linux系统来说，代码段的基地址永远是0x08048000。

引用 2 楼 spiritmg 的回复:[quote=引用 1 楼 qq423399099 的回复:] DEBUG模式变量周围需要存放调试信息，所以相差的距离大于4个字节。 楼主改成RELEASE就会发现两者相差4字节了  多谢版主，确实是这样的，改为release后就是4个字节了。  第1个问题，还是不懂，请大神们赐教。  [/quote] 这个没有为什么吧，没有规定的事情。

引用 1 楼 qq423399099 的回复:DEBUG模式变量周围需要存放调试信息，所以相差的距离大于4个字节。 楼主改成RELEASE就会发现两者相差4字节了  多谢版主，确实是这样的，改为release后就是4个字节了。  第1个问题，还是不懂，请大神们赐教。

引用 9 楼 spiritmg 的回复:[quote=引用 6 楼 paschen 的回复:] 请参看PE文件结构，各个块之间并没有顺序要求  恩，确实是。 我估计段在内存中的位置可能与PE loader的实现有关。暂时先不纠结这个问题了。windows总是给人意外的惊喜，linux就比较按规矩来。[/quote]  你看的规矩是不是都是根据 Linux 写的 ..


Question: 新人求助

引用 11 楼 qq423399099 的回复:else putchar(m);表示如果输入的字符不是s里面的字符就原样输出 如果输入的字符是s里面的字符，输出的其实是s数组里和m字符相同的前一个字符  这个明白 我的意思是按题目的意思 怎么会输入除s之外的字符

引用 9 楼 k1287447887 的回复:[quote=引用 8 楼 firmbank 的回复:] s[i]&&s[i]!=m 这个s[I] 是为了读到s结尾时退出循环，防止内存溢出。 引用 8 楼 firmbank 的回复:s[i]&&s[i]!=m 这个s[I] 是为了读到s结尾时退出循环，防止内存溢出。          else putchar(m);这句话有什么用吗 我实在想不到输入什么会用到这句话[/quote] 这个是当m在s[]中未曾出现时将你输入都字符输出来。

引用 8 楼 firmbank 的回复:s[i]&&s[i]!=m 这个s[I] 是为了读到s结尾时退出循环，防止内存溢出。 引用 8 楼 firmbank 的回复:s[i]&&s[i]!=m 这个s[I] 是为了读到s结尾时退出循环，防止内存溢出。          else putchar(m);这句话有什么用吗 我实在想不到输入什么会用到这句话

引用 4 楼 qq423399099 的回复:1.s[i]&&s[i]!=m表示既要保证字符数组s没有循环到末尾，同时也要满足s[i]!=m 2.if(s[i])表示判断是不是由于s循环到末尾才跳出的for循环  1. 如果不加s[i]，而只有s[i]!=m这一个条件为什么不行呢  2.有一个新问题 else那句话有什么用吗   题目是这样的：输入一个错位后敲出的字符串（所有字母均大写），输出打字员本来想打出的句子。输入保证合法，即一定是错位之后的字符串。例如输入中不会出现大写字母A。

如果循环到字符数组末尾了那么s[i]将等于'\0' 此时if(s[i])将是false

引用 3 楼 k1287447887 的回复:[quote=引用 1 楼 user-3 的回复:] 1、意思是要同时满足s[i] 与 s[i]!=m 两个条件才执行 2、s[i] 不为0时执行if，否则不执行   不懂怎么回帖= =我这么回的话你是不是能看到   1.  s[i]这个条件指的是什么 2.  为啥要s[i]不为0啊 这个0指的是数组s里面那个0吗[/quote]  1、 s[i]这个条件已经在你上面第二个问题里回复你了 2、是字符数组 s的索引为 i 的字符不是'\0'

引用 1 楼 user-3 的回复:1、意思是要同时满足s[i] 与 s[i]!=m 两个条件才执行 2、s[i] 不为0时执行if，否则不执行   不懂怎么回帖= =我这么回的话你是不是能看到   1.  s[i]这个条件指的是什么 2.  为啥要s[i]不为0啊 这个0指的是数组s里面那个0吗


Question: struct 结构体初始化问题。

引用 8 楼 xiaozi5230 的回复:[quote=引用 4 楼 qq423399099 的回复:] 用_tcscpy赋值 用_stprintf打印 定义了UNICODE，TCHAR就是wchar_t。 没定义UNICODE,TCHAR就是char  我是想就是说，定义了对象以后直接用里面成员，不需要在初始化了，前提是在结构体那里构造函数的时候初始化 [/quote]  malloc / calloc申请内存，当用malloc的时候用 memset 初始化内存空间，calloc本身包含初始化的作用

引用 4 楼 qq423399099 的回复:用_tcscpy赋值 用_stprintf打印 定义了UNICODE，TCHAR就是wchar_t。 没定义UNICODE,TCHAR就是char  我是想就是说，定义了对象以后直接用里面成员，不需要在初始化了，前提是在结构体那里构造函数的时候初始化

引用 6 楼 paschen 的回复:其次，构造函数初始列表初始化的是成员变量，而不是其他，所以你只能这样写：   struct bRegAccount { 	int Number; 	TCHAR ID[30]; 	TCHAR PassWord[30]; 	TCHAR PassWordOK[30]; 	TCHAR TwoPassWord[30];  public: 	bRegAccount() :Number(0),ID(""),PassWord(""),PassWordOK(""),TwoPassWord(""){} };  我在VS这样试还是不行的

首先说一下，你结构体里的数组有效索引只是0-29，这种语句PassWord[30] = '\0';已经越界了

引用 1 楼 user-5 的回复:ID[30] = '\0'; PassWord[30] = '\0'; PassWordOK[30] = '\0'; TwoPassWord[30] = '\0'; lz你这是在玩火....这几行是什么意思....  请问是不是错了。正确如何写，初始化

引用 1 楼 user-5 的回复:ID[30] = '\0'; PassWord[30] = '\0'; PassWordOK[30] = '\0'; TwoPassWord[30] = '\0'; lz你这是在玩火....这几行是什么意思....  初始化啊


Question: 求助贴。。最近老师叫做课程设计，然而遇到点问题，请大神指导一下

已解决，谢谢1楼

请那些喜欢将数组作为函数参数传来传去的码农思考一下为什么不把整个互联网内容当作函数参数传来传去呢？

楼上大大已经给代码了我还是混个回答，个人想法是返回数组或者指针

1.函数调用传参的时候不需要写类型 2.函数声明的时候需要写类型 3.你的paixu函数里不需要再调用shuzua函数了 4.paixu函数里出现了把两个a写成了b  #include <stdio.h> #include <stdlib.h>                            // 包含rand()函数说明 #include <time.h>  void shuzua(int*a,int i);  void paixu(int*a,int i);  void shuzua(int*a,int i) {    	int j, tmp;           	srand((unsigned)time( NULL ) );//用当前时间种子重置随机数生成器，使每次运行生成不同的随机数 	for(i=0;i<100;i++)                          // 生成100个数 	{ 		while(1)                             //生成1个数 		{ 			tmp=100 *rand()/ RAND_MAX +1;   // 产生随机数 			for(j=0;j<i;j++)                  //判断是否重复 				if( tmp==a[j] ) 					break; 			if(j==i)                     // 找到1个数 			{ 				a[i]=tmp;            //入队列 				break;                 // 开始下一轮 			} 		}  	}   } void paixu(int*a,int i)//冒泡排序 {  	int m,n,temp; 	//shuzua(); 	//	strcpy(char*b,char*a);   	for(m=0;m<100-1;m++)//冒泡排序 	{ 		for(n=0;n<100-1-m;n++) 		{ 			if(a[n]<a[n+1]) 			{ 				temp=a[n]; 				a[n]=a[n+1]; 				a[n+1]=temp; 			} 		}  	} 	for(i=0;i<100;i++) 	{ 		printf("%d\t",a[i]); 	}   } void main() { 	int a[100],i; 	shuzua(a,i); 	paixu(a,i); }


Question: 异或算法、除数、模数，看题。

这不是通联支付的KEY吗

大胆假设，小心求证。

引用 6 楼 ForestDB 的回复:[quote=引用 5 楼 afdlig 的回复:] [quote=引用 2 楼 ForestDB 的回复:] 将除数与模数......  将‘商’与‘余数’......  如果不是LZ打错的话。。。。我没打错，这是原话。我只是怀疑错了。那你将你所说的'商'与'余数'亦或之后得出那个结果了么。。。我来试试[/quote] 3L... [/quote]嗯，没错。是商与余数。一直被套在这里。谢谢啦~

引用 5 楼 afdlig 的回复:[quote=引用 2 楼 ForestDB 的回复:] 将除数与模数......  将‘商’与‘余数’......  如果不是LZ打错的话。。。。我没打错，这是原话。我只是怀疑错了。那你将你所说的'商'与'余数'亦或之后得出那个结果了么。。。我来试试[/quote] 3L...

引用 2 楼 ForestDB 的回复:将除数与模数......  将‘商’与‘余数’......  如果不是LZ打错的话。。。。我没打错，这是原话。我只是怀疑错了。那你将你所说的'商'与'余数'亦或之后得出那个结果了么。。。我来试试

第一步：将56781234变为35 36 37 38 31 32 33 34 第二步：将第一步转化的结果分别与CD A8 C1 AA D0 C2 D0 CB进行异或操作 第三步：分别用第二步的结果除以9得到商，模9得到余数，将商和余数进行异或操作得到最后结果

‘5’ == 0x35  0x35 ^ 0xCD == 0xF8  0xF8 / 0x09 == 0x1B  0xF8 % 0x09 == 0x05  0x1B ^ 0x05 == 0x1E

35 36 37 38 31 32 33 34 CD A8 C1 AA D0 C2 D0 CB八字节亦或得 F8 9E F6 92 E1 F0 E3 FF


Question: 求请教。。。。不知道哪里写错了

谢谢

#include <stdio.h> int main() {     int a[10],max,min,i,t,y;     printf("please enter 10 numbers:");fflush(stdout);     for(i=0;i<10;i++)         scanf("%d",&a[i]);     y=0;     max=a[y];     for(i=1;i<10;i++) {         if (a[i]>max) {             y=i;             max=a[y];         }     }     t=a[y];a[y]=a[0];a[0]=t;     y=1;     min=a[y];     for(i=2;i<10;i++) {         if(a[i]<min) {             y=i;             min=a[y];         }     }     t=a[y];a[y]=a[9];a[9]=t;     for(i=0;i<10;i++)         printf("%d ",a[i]);     return 0; }

逻辑有点问题： 1.下标初始化放在for循环之前 2.保存最大值和最小值的下标才对 3.交换数值应该放在for循环之后 4.打印的时候两个数之间加上空格  #include<stdio.h> int main() { 	int a[10],max,min,i,t,y; 	printf("please enter 10 numbers:"); 	for(i=0;i<10;i++) 		scanf("%d",&a[i]); 	max=0; 	for(i=1;i<10;i++) 	{ 		if(a[i]>a[max]) 			max=i; 	} 	t=a[max];a[max]=a[0];a[0]=t; 	min=0; 	for(i=1;i<10;i++) 	{ 	if(a[i]<a[min]) 		min=i; 	} 	y=a[min];a[min]=a[9];a[9]=y;  	for(i=0;i<10;i++) 		printf("%d ",a[i]); 	return 0; }   代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

最大值能对换，但是最小值不行，怎么解决哦。。。

找个调试工具跟一下试试


Question: C语言新手程序求帮助，程序里生成不了文件，有个文件无法输出

在占用内存空间较大的局部数组声明的前面加static将其从堆栈数据段挪到全局数据段即可避开因局部数组大小超过默认堆栈大小1MB造成程序不能正常运行的问题。

这程序我这都编不过去，而且好多地方写的都比较乱。先自己调试一下吧。另外，char function() 返回的是字符，char *function() 返回的是字符串


Question: 死循环中如何跳出stitch

PHP中可以用 break n跳出n重循环，但是C++貌似没有这种语法。

java、javascript、python、php、pascal、c#、……能做到类似6楼代码的功能吗？

引用 12 楼 wzxq123 的回复:PHP中可以用 break n跳出n重循环，但是C++貌似没有这种语法。 6楼代码演示的不是多重循环，是多层函数调用。 C++版，请欣赏：#include <iostream> using namespace std; struct MyStruct {     int Nodedata;     MyStruct *pLeft;     MyStruct *pRight; } s1,s2,s3,s4,s5,s6,s7,s8; void ashow(MyStruct * p) {     if (p != nullptr) {         ashow(p->pLeft);         ashow(p->pRight);         cout << p->Nodedata << endl;         if (p->Nodedata == 4) {             throw 1;//退出递归.直接返回.         }     } } int main() {     MyStruct *pRoot;//根      pRoot = &s1;     s1.Nodedata = 1;     s2.Nodedata = 2;     s3.Nodedata = 3;     s4.Nodedata = 4;     s5.Nodedata = 5;     s6.Nodedata = 6;     s7.Nodedata = 7;     s8.Nodedata = 8;      s1.pLeft = &s2;     s1.pRight = &s3;      s2.pLeft = &s4;     s2.pRight = &s5;      s3.pLeft = &s6;     s3.pRight = &s7;     try {         ashow(pRoot);     } catch (int err) {         cout<<"catch err "<<err<<endl;     }     return 0; } //4 //catch err 1 //

让你输入case的值，你输个0加回车就退了呀

用goto吧，或者在每次循环最后用个变量判断是否退出循环，而这个变量在switch中根据不同要求进行变化

在switch外面,判断输入的sel,然后break;如果在switch中可以考虑使用flag, 在switch外面判断flag退出,或者使用goto但不建议使用最后一个~

引用 6 楼 zhao4zhong1 的回复:需要我在这里炫一下怎么退出多层函数吗？ #include <stdio.h> #include <setjmp.h> jmp_buf mark; int i=0; void c() {     printf( "c in\n");     if (1==i%2) longjmp( mark, i );     printf( "c out\n"); } void b() {     printf( "b in\n");     c();     printf( "b out\n"); } void a() {     printf( "a in\n");     b();     printf( "a out\n"); } void main( void ) {    int jmpret;    jmpret = setjmp( mark );    printf( "Start %d\n",jmpret);    if( jmpret == 0 ) {        printf( "First\n");        a();        i++;        a();    } else {        printf( "Second\n");    } } //Start 0 //First //a in //b in //c in //c out //b out //a out //a in //b in //c in //Start 1 //Second //  不需要吗？

goto 或者设置标志吧 这是C 语言设置的一个小小缺陷  switch 和 循环嵌套，谁在内部，break 的目标就是谁的外部 break,goto,return，continue 都属于 直接跳转类关键字 if,switch  属于条件跳转 函数调用也是跳转 循环也是条件跳转  switch 内部的break 不能跳出循环 反之循环内部的break 也不能跳出 switch

楼主 你标题里的 switch  你拼写错了！

方法太多了，最通用的就是设一个标志变量f，default设置f=0，while里判断f==0就break

退出多层循环可以采用这样的形式或goto  for(int i=0;i<100;i++) {     for(int k=0;k<100;k++)     {         if(i+k>100 && k<30)         {             cout<<i<<" "<<k<<endl;             i=k=200;//退出多层循环可以采用这样的形式或goto         }     } }


Question: 一个关于c语言结构体及其调用的问题

引用 2 楼 qq423399099 的回复: #include<stdio.h> struct fish { 	const char *name; 	const char *species; 	int teeth; 	int age; } ;  void catalog(struct fish f) { 	printf("%s is a %s with %i teeth. He is %i.\n", f.name, f.species, f.teeth, f.age); }  void label(struct fish f) { 	printf("Name: %s\nSpecies: %s\n%i years old,\n%i teeth\n", f.name, f.species, f.teeth, f.age); }   int main() { 	struct fish snappy = {"Snappy", "Piraha", 69, 4}; 	catalog(snappy); 	label(snappy); 	return 0; }   这个代码是怎么添加的啊，好神奇，嗷嗷嗷~~~

引用 1 楼 user-2 的回复:void catalog(struct fish f) { printf("%s is a %s with %i teeth. He is %i.\n", f,name, f.species, f.teeth, f.age); }  其余的类似 谢谢，谢谢~


Question: fwrite成功后，fread出现问题，总是少一字节？

gdata.data = 12;  你把12 改成别的试试，比如14.

#include <stdio.h> #include <unistd.h> #include <string.h>  typedef struct { 	int data; } data_t;  data_t gdata; int main() { 	FILE *file; 	int size = 0, size_1 = 0; 	int len = 0, len_1 = 0; 	 	data_t local_data;  	memset((void *)&gdata, 0, sizeof(gdata)); 	gdata.data = 12; 	 	file = fopen("data.ini", "wb+"); 	if(file == NULL){ 		printf("fopen file ERROR"); 	} 	 	size = sizeof(gdata); 	fprintf(file, "%d\n", size); 	 	if((len = fwrite(&gdata, 1, size, file)) < size)    	{     	printf("fwrite error");     	fclose(file);     	return -1;     } 	printf("len %d write %d bytes finished.\n", len, size); 	printf("ftel result: %d\n", ftell(file)); 	fclose(file);  	getchar();  	 	file = fopen("data.ini", "rb"); 	if(file == NULL){ 		printf("fopen file ERROR"); 	} 	 	fscanf(file, "%d\n", &size_1); //	fseek(file, 2, SEEK_SET);			// 不加这行，读取不成功总是少读取一个字节		 	printf("read ftell: %d\n", ftell(file)); 	if((len_1 = fread(&local_data, 1, size_1, file)) < size_1){ 		printf("read ftell end: %d\n", ftell(file)); 		printf("fread failed, size:%d, len :%d!\n", size_1, len_1);         fclose(file);         return -1; 	} 	printf("read ftell end: %d\n", ftell(file)); 	printf("read %d bytes finished.\n", len_1); 	 	fclose(file);  	printf("%d\n", local_data.data); 	 	return 1; 	 }     不加  fseek(file, 2, SEEK_SET); 结果为： len 4 write 4 bytes finished. ftel result: 6  read ftell: 3 read ftell end: 6 fread failed, size:4, len :3!  加完之后结果正常： len 4 write 4 bytes finished. ftel result: 6  read ftell: 2 read ftell end: 6 read 4 bytes finished. 12 为什么会是这样的结果哦？

为什么不用ftell函数看看当前读到哪儿了呢？

电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。

还不是很懂 ~~~~(>_<)~~~~ 这是读取失败的写文件后的二进制文件： [root@localhost samba]# hexdump data.ini  0000000 0a34 000c 0000                          0000006 [root@localhost samba]#   如果在结构中加一个字段则能读取成功，很是不解   #include <stdio.h> #include <unistd.h> #include <string.h>  typedef struct { 	char ch;	// 如果加上ch字段，读取文件成功 	int data; } data_t;  data_t gdata; int main() { 	FILE *file; 	int size = 0, size_1 = 0; 	int len = 0, len_1 = 0; 	 	data_t local_data;  	memset((void *)&gdata, 0, sizeof(gdata)); 	gdata.data = 12; 	gdata.ch = '8'; 	 	file = fopen("data.ini", "wb+"); 	if(file == NULL){ 		printf("fopen file ERROR"); 	} 	 	size = sizeof(gdata); 	fprintf(file, "%d\n", size); 	 	if((len = fwrite(&gdata, 1, size, file)) < size)    	{     	printf("fwrite error");     	fclose(file);     	return -1;     } 	printf("len %d write %d bytes finished.\n", len, size); 	printf("ftel result: %d\n", ftell(file)); 	fclose(file);  	getchar();  	 	file = fopen("data.ini", "rb"); 	if(file == NULL){ 		printf("fopen file ERROR"); 	} 	 	fscanf(file, "%d\n", &size_1); //	fseek(file, 2, SEEK_SET);			// 删除该行，在结构体中加字段	 	printf("read ftell: %d\n", ftell(file)); 	if((len_1 = fread(&local_data, 1, size_1, file)) < size_1){ 		printf("read ftell end: %d\n", ftell(file)); 		printf("fread failed, size:%d, len :%d!\n", size_1, len_1);         fclose(file);         return -1; 	} 	printf("read ftell end: %d\n", ftell(file)); 	printf("read %d bytes finished.\n", len_1); 	 	fclose(file);  	printf("data: %d\n", local_data.data); 	printf("ch: %c\n", local_data.ch); 	 	return 1; 	 }     这行结果如下：  len 8 write 8 bytes finished. ftel result: 10  read ftell: 2 read ftell end: 10 read 8 bytes finished. data: 12        ch: 8 [root@localhost samba]#  [root@localhost samba]#  二进制文件内容为： [root@localhost samba]# hexdump data.ini  0000000 0a38 0038 0000 000c 0000                000000a [root@localhost samba]#   这里的0a38 具体指什么意思呀？

Format Specification Fields: scanf and wscanf Functions A format specification has the following form:  % [width] [{h | l | I64 | L}]type  The format argument specifies the interpretation of the input and can contain one or more of the following:   White-space characters: blank (' '); tab ('\t'); or newline ('\n'). A white-space character causes scanf to read, but not store, all consecutive white-space characters in the input up to the next non–white-space character. One white-space character in the format matches any number (including 0) and combination of white-space characters in the input.   Non–white-space characters, except for the percent sign (%). A non–white-space character causes scanf to read, but not store, a matching non–white-space character. If the next character in stdin does not match, scanf terminates.   Format specifications, introduced by the percent sign (%). A format specification causes scanf to read and convert characters in the input into values of a specified type. The value is assigned to an argument in the argument list.  The format is read from left to right. Characters outside format specifications are expected to match the sequence of characters in stdin; the matching characters in stdin are scanned but not stored. If a character in stdin conflicts with the format specification, scanf terminates, and the character is left in stdin as if it had not been read.  When the first format specification is encountered, the value of the first input field is converted according to this specification and stored in the location that is specified by the first argument. The second format specification causes the second input field to be converted and stored in the second argument, and so on through the end of the format string.  An input field is defined as all characters up to the first white-space character (space, tab, or newline), or up to the first character that cannot be converted according to the format specification, or until the field width (if specified) is reached. If there are too many arguments for the given specifications, the extra arguments are evaluated but ignored. The results are unpredictable if there are not enough arguments for the format specification.  Each field of the format specification is a single character or a number signifying a particular format option. The type character, which appears after the last optional format field, determines whether the input field is interpreted as a character, a string, or a number.   The simplest format specification contains only the percent sign and a type character (for example, %s). If a percent sign (%) is followed by a character that has no meaning as a format-control character, that character and the following characters (up to the next percent sign) are treated as an ordinary sequence of characters, that is, a sequence of characters that must match the input. For example, to specify that a percent-sign character is to be input, use %%.  An asterisk (*) following the percent sign suppresses assignment of the next input field, which is interpreted as a field of the specified type. The field is scanned but not stored.

你以为 47:      fscanf(file, "%d\n", &size_1); 之后ftell应该为2；而显然实际为3    不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了


Question: 为什么出现了乱码

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

if(b[i]>=0&&b[i]<=9) c[k-1-i]=b[i]-'0'; 转化有问题

楼主把这两句想清楚：c[k-1-i]=b[i]-'0';  c[k-1-i]=b[i]-10+'A'; 要把整数数字转换为对应字符数字，应该是用+  下面是帮你改的：   #include<stdio.h> void main() { 	int a,k=0; 	scanf("%d",&a); 	int t=a; 	while(a!=0) 	{    		a=a/16; 		k++; 	} 	int b[100]; 	for(int i=0;i<k;i++) 	{ 		b[i]=t%16; 		t=t/16; 	} 	char c[100]; 	for(int i=0;i<k;i++) 	{ 		if(b[i]>=0&&b[i]<=9)  			c[k-1-i]=b[i]+'0'; 		else  			c[k-1-i]=b[i]+10+'0'; 	} 	c[k]='\0'; 	printf("%s",c); }


Question: c语言例题

引用 2 楼 github_27756899 的回复:前面错了          leap=0表示m不是素数。   正解

根据你程序推断为判断素数的一个标记

leap用于标识是否为素数，h是每行的素数个数，按代码的意思是每行输出10个然后换行。

leap只是一个标志位而已，用来标记哪些是素数哪些不是，最后根据标志位的状态确定是不是输出该数

leap是用来判断是否是素数的标志位，判断每个数前先置为1，一旦能够整除任意一个for循环中的数，就置为0 循环结束后，如果leap是1就输出该数（说明它是素数）。  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！  单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

前面错了          leap=0表示m不是素数。

leap是素数的标志，即leap=1表示m是素数，leap=1表示m不是素数。 if(leap){printf("%-4d",m);   //如果leap=1输出素数m。


Question: C语言中malloc的问题

引用 10 楼 github_27756899 的回复:free(counter); 完后加 counter=NULL; 就不容易错了。  谢谢大神指导

简单点说就是counter分配了内存(未free)。

引用 楼主 robin_Xu_shuai 的回复:int i; 	int j; 	char filename[200]; 	FILE* fread; 				 	Item* item_1;		/* 				   Item有两个域，第一个域dimension_1是用来存放数据 				   		 第二个域clusterID,现在被用来存放相同的数据出现的个数 				*/	 	//test 	for( i = 1; i <= cluster_count; i++ ) 		printf("the size of cluster %d is %d\n", i, counter[i]); 	//test END  	for( i = 1; i <= 1; i++ ) 	{ 		printf("@@@@@@@@%d\n", counter[i]); 		sprintf(filename, ".//ClusterProcess_1dimension//round%d_cluster%d.data", count, i); 		if( NULL == (fread = fopen(filename, "r"))) 		{ 			printf("open file(%s) error!\n"); 			exit(0); 		} 		item_1 = (Item*)malloc(sizeof(struct Item) * (counter[i] + 1)); 		/* 		if( !item_1 ) 		{ 			printf("item malloc error %d\n", i); 			exit(0); 		} 		*/ 		printf("@@@@@@@@%d\n", counter[i]); 		/* 		for( j = 1; j <= counter[i]; j++ ) 		{ 			if( 1 != fscanf(fread, "%d ", &item_1[j].dimension_1)) 			{ 				printf("scanf error: %s : %d", filename, j); 				exit(0); 			} 			printf("cluster_center : %d --- %d \n", i, j); 		} 		*/ 		free(item_1); 		//fclose(fread); 	} 为什么第32行和第17行的输出结果不一致，出现了乱码，如果去掉24行则正常。 其中调用	//test 	for( i = 1; i <= cluster_count; i++ ) 		printf("the size of cluster %d is %d\n", i, counter[i]); 	//test END 之前应该 counter = (int *) malloc(size);  即 //test counter = (int *) malloc(sizeof(int)*(cluster_count+1));  	for( i = 1; i <= cluster_count; i++ ) 		printf("the size of cluster %d is %d\n", i, counter[i]); 	//test END

引用 6 楼 github_27756899 的回复:之前调用函数中的 free(counter); 这句删除。  您能解释一下吗，之前那个函数是循环调用了多次的，所以我用了free，并且之前也是没有错的（没有我问题中说的那个函数之前） 谢谢

之前调用函数中的 free(counter); 这句删除。

引用 4 楼 robin_Xu_shuai 的回复:[quote=引用 3 楼 github_27756899 的回复:] counter = (int *) malloc(size);  free(counter); //其它函数有没有调用?  有调用，但是是在之前，这个函数是最后的函数。请您指教这样有什么问题吗[/quote] /*  * 重新计算新的cluster center  * */ void calculate_clusterCenter(int round){					 	int i; 	double* new_X_Y;	/* 				   用来计算和保存新的cluster center的值，同样的，0号元素不用。1,2号元素分别用来 				   存放第一个聚类的所有的项的x和y的累加和。3,4号元素分别用来存放第二个聚类的所有 				   的项的x和y的累加和...... 				*/ 	new_X_Y = (double*)malloc(sizeof(double) * (cluster_count + 1)); 	if( !new_X_Y ) 	{ 		printf("malloc error: new_X_Y!\n"); 		exit(0); 	} 	//初始化为0 	for( i = 1; i <= cluster_count; i++ ) 		new_X_Y[i] = 0.0;  	counter = (int*)malloc(sizeof(int) * (cluster_count + 1)); 	if( !counter ) 	{ 		printf("malloc error: counter\n"); 		exit(0); 	} 	//初始化为0 	for( i = 1; i <= cluster_count; i++ ) 		counter[i] = 0;  	for( i = 1; i <= data_size; i++ ) 	{ 		new_X_Y[data[i].clusterID] += data[i].dimension_1;	//统计每个聚类中的项的和 		counter[data[i].clusterID]++;				//统计每个聚类中的项的个数 	}  	//test 	for( i = 1; i <= cluster_count; i++ ) 		printf("%f\t", new_X_Y[i]); 	printf("\n"); 	for( i = 1; i <= cluster_count; i++ ) 		printf("%d\t", counter[i]); 	printf("\n"); 	//testEND  	for( i = 1; i <= cluster_count; i++ ) 	{ 		new_X_Y[i] = new_X_Y[i] / (double)(counter[i]); 	}  	//test 	/* 	printf("new cluster center:\n"); 	for( i = 1; i <= 2 * cluster_count; i++ ) 		printf("%f\t", new_X_Y[i]); 	printf("\n"); 	*/ 	//testEND 	 	//要将cluster center的值保存在文件中，后续作图 	writeClusterCenterToFile(round); 	 	/* 	 * 在这里比较一下新的和旧的cluster center值的差别。如果是相等的，则停止K-means算法。 	 * */ 	compareNew_OldClusterCenter(new_X_Y);  	//将新的cluster center的值放入cluster_center_new 	for( i = 1; i <= cluster_count; i++ ) 	{ 		cluster_center_new[i].dimension_1 = new_X_Y[i]; 		cluster_center_new[i].clusterID = i; 	} 	free(new_X_Y); 	free(counter);  	//在重新计算了新的cluster center之后，意味着我们要重新来为每一个Item进行聚类，所以data中用于表示聚类ID的clusterID 	//要都重新置为0。 	for( i = 1; i <= data_size; i++ ) 	{ 		data[i].clusterID = 0; 	} }

引用 3 楼 github_27756899 的回复:counter = (int *) malloc(size);  free(counter); //其它函数有没有调用?  有调用，但是是在之前，这个函数是最后的函数。请您指教这样有什么问题吗

引用 1 楼 github_27756899 的回复:counter[i] 的声明?  是动态的数组，在另外一个函数中使用malloc分配的，不可以吗

counter[i] 的声明?


Question: 怎么把我的程序改为多文件格式？？

是的，我不知道该如何分开存放，哪一部分放哪些东西呢？

什么叫多文件格式？是指把你这个程序的内容放在多个文件吗？你可以利用头文件与源文件分开存放的方法，这样可以将很长的代码分成多个文件存储和修改。


Question: 毫无头绪报错error C2143

好蠢啊，谢谢

大括号不对称，楼主把代码写规范了自然就看出来了

语法错误,仔细检查错误的行数~

k++;后面多了一个}

偶遇到类似问题都是用 “每次用/*...*/注释掉不同部分再重新编译，直到定位到具体语法出错的位置。” 的方法解决的。  关于自己是否适合编程的很简单的测试： 在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案：  A里面有10处以上文字或标点错误 B里面没有文字或标点错误并敢为此跟人打赌 C里面没有文字或标点错误并且字体和排版完全与原稿一致 D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感  A不适合编程（理由：打字准确度偏低、粗心大意） B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念） C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证） D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！）  如果想从A变成B的话，到我的资源http://download.csdn.net/detail/zhao4zhong1/4084259里面下载“适合程序员的键盘练习”

k++ 后面有两个花括号

#include<stdio.h> void main() { 	int a,k=0; 	scanf("%d",&a); 	int t=a; 	while(a!=0) 	{    		a=a/16; 		k++; 	} 	int b[100]; }

k++;} }这2个大括号，删除一个就好了

int b上边那个}删了


Question: 关于 fgets 的一个疑问，小白求大神！！

让str指向的内存空间是可写的。 方式1：  char buffer[24]; char *str = buffer;  方式2：  char *str = (char *)malloc(24 * sizeof(char));

引用 1 楼 qq423399099 的回复:你第一种方式： char *str; str = NULL; 意味着str指向了地址为0的区域（该区域禁止写操作） 然后你fgets(str, 1024, stdin);试图向地址为0的区域写入读到的数据，肯定报错了  而第二种方式char str[24];是在栈上分配的空间，可以写入  这样，那我知道了，另外就是如果就想通过第一种方式做可以怎么做？

其实电脑开机后物理内存的每个字节都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。

fget的第一个参数虽然是一个指针，但不能是空指针

第一个方法里的str是NULL   NULL是0,那么0地址是系统保护地址是不容许读写内容的！

C 语言保证 0 （NULL）不是有效的数据地址，即值为 NULL的指针不会指向任何数据内容，因此你不可以向它写入任何内容。

指针接收的是首地址，数组接收的是值，那么问题来了，你第一种写法数据保存在那里？


Question: 【链表】一元多项式乘法, 乘法运行错误，想不通哪里的问题，求大神帮助

仅供参考：//不带表头结点的单向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> #include <locale.h> struct NODE {     int          data;     struct NODE *next; } *head,*p,*q,*s,*p1,*p2,*q1,**ta; int i,k,n,t,m,v,N=10; int main() {     setlocale(LC_ALL,"chs");     srand(time(NULL));      head=NULL;      printf("创建%d个节点的单链表:",N);//创建N个节点的单链表     p=head;     for (i=0;i<N;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) exit(1);         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         if (NULL==p) {             head=q;             p=head;         } else {             p->next=q;             p=q;         }     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      k=3;     v=5;     printf("将值为%d的结点插入到单链表的第%d个结点前:",v,k);//将值为v的结点插入到单链表的第k个结点前     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) exit(1);             q->data=v;             q->next=head;             head=q;             break;         } else {             if (k-1==n) {                 q=(struct NODE *)malloc(sizeof(struct NODE));                 if (NULL==q) exit(1);                 q->data=v;                 q->next=p->next;                 p->next=q;                 break;             }         }         p=p->next;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      k=5;     printf("删除第%d个节点:",k);//删除第k个节点     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=head;             head=head->next;             free(q);             break;         } else {             if (k-1==n) {                 q=p->next;                 if (q) {                     p->next=q->next;                     free(q);                 }                 break;             }         }         p=p->next;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      printf("从小到大排序:");//从小到大排序     for (p=head,p1=NULL;p!=NULL;p1=p,p=p->next) {         for (q=p->next,q1=p;q!=NULL;q1=q,q=q->next) {             if (p->data > q->data) {                  //交换data //              printf("swap %02d %02d\n",p->data,q->data); //              t=p->data;p->data=q->data;q->data=t;                  //或者                  //交换next //              printf("swap %02d %02d\n",p->data,q->data);                 if (p==head) {//p是头                     if (p->next==q) {//pq挨着                         head=q;                         p->next=q->next;                         q->next=p;                         q=p;                         p=head;                     } else {//pq不挨着                         head=q;                         p2=p->next;                         p->next=q->next;                         q->next=p2;                         q1->next=p;                         q=p;                         p=head;                     }                 } else {//p不是头                     if (p->next==q) {//pq挨着                         p1->next=q;                         p->next=q->next;                         q->next=p;                         q=p;                         p=p1->next;                     } else {//pq不挨着                         p1->next=q;                         p2=p->next;                         p->next=q->next;                         q->next=p2;                         q1->next=p;                         q=p;                         p=p1->next;                     }                 }                  //输出整个单链表 //              s=head; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d->",s->data); //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个单链表并计算链表长度n     n=0;     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         n++;         s=s->next;     }      printf("将整个链表逆序:");//将整个链表逆序     if (n>=2) {         p=head;         q=p->next;         p->next=NULL;         while (1) {             q1=q->next;             q->next=p;             p=q;             q=q1;             if (NULL==q) break;         }         head=p;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      m=4;     n=6;     printf("将单链表中前%d个结点和后%d个结点进行互换:",m,n);//将单链表中前m个结点和后n个结点进行互换,m+n为链表总长     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m==k) {             q=p;         }         s=p;         p=p->next;     }     q1=head;     head=q->next;     s->next=q1;     q->next=NULL;      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //释放所有节点     p=head;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //创建10个节点的单链表:08->74->07->23->03->99->31->56->88->16-> //将值为5的结点插入到单链表的第3个结点前:08->74->05->07->23->03->99->31->56->88->16-> //删除第5个节点:08->74->05->07->03->99->31->56->88->16-> //从小到大排序:03->05->07->08->16->31->56->74->88->99-> //将整个链表逆序:99->88->74->56->31->16->08->07->05->03-> //将单链表中前4个结点和后6个结点进行互换:31->16->08->07->05->03->99->88->74->56-> //

三个链表中，可能有两个链表是互相纠缠的，二者尾部是相同的 一个为和链表 一个为加数链表   其实，乘法采用插入排序的方式插入乘积，就可以做到合并同类项和 升幂，或者降幂排列的目的了  实际上，鉴于多项式是升幂或者降幂排列的 插入数据的时候，应该进行插入排序， 这样才能保证多项式是有序的  这比靠记忆，或者有序输入做到，容易得多

//两个链表相加 List add(List a_list, List b_list)  的逻辑是混乱的 混合了，创新式产插入和直接插入两种方式 结果是 三个链表中，可能有个链表是互相纠缠的，二者尾部是相同的  形成如下结构                                 sum-> ----------------------->    P  ------------------------- >NULL                                        ^                                        | i 或者 j -->------------------>  至于乘法倒是没有这个问题，只是忽略了需要降幂（或者升幂）排列的事实 同时也没有进行合并同类项的操作。 这里，忽略了多项式乘法的数学意义。 暂时就发现这么多

不带有节点的缺点，你没避开吧 之所以单链表通常会有头结点 是因为，不带空头结点的单链表  头结点数据的插入，删除等等。 需要特殊处理  添加一个空的（非数据）头结点。 所有数据节点的处理方式就一致了，避免了特殊处理的麻烦。

谢谢，我的思路是正确的，可能在语言层面上有问题，我写的那个链表是不带头结点的，您能帮我看看乘函数哪里有问题吗

仅供参考：//链表实现一元多项式的加法减法乘法 #include <stdio.h> #include <stdlib.h> typedef struct node {     float coef;   //系数     int expn;     //指数     struct node *next; } PolyNode;      //多项式节点 polynomial node typedef PolyNode* Polynomial; Polynomial createPolynomial() {  //创建多项式     PolyNode *p, *q, *head = (PolyNode *)malloc(sizeof(PolyNode));   //头节点     head->next = NULL;     float coef;     int expn;     printf("输入该多项式每一项的系数和指数，每项一行，输入0 0结束！\n");     while (scanf("%f %d", &coef, &expn) && coef) {   // 默认，按指数递减排列         if (head->next) {             p = head;             while (p->next && expn < p->next->expn)                 p = p->next;             if (p->next) {                 if (expn == p->next->expn) { //有相同指数的直接把系数加到原多项式                     p->next->coef += coef;                     if (p->next->coef > -0.000001 && p->next->coef < 0.000001) { //若是相加后系数为0，则舍弃该节点                         q = p->next;                         p->next = q->next;                         free(q);                     }                 } else {                     q = (PolyNode*)malloc(sizeof(PolyNode));                     q->coef = coef;                     q->expn = expn;                     q->next = p->next;                     p->next = q;                 }             } else {                 p->next = (PolyNode*)malloc(sizeof(PolyNode));                 p = p->next;                 p->coef = coef;                 p->expn = expn;                 p->next = NULL;             }         } else {             head->next = (PolyNode*)malloc(sizeof(PolyNode));             head->next->coef = coef;             head->next->expn = expn;             head->next->next = NULL;         }     }     return head; } Polynomial multiply(Polynomial poly, float coef, int expn) {  //多项式与指定单项式相乘，该单项式为 coefx^expn     PolyNode *p, *q, *Poly = (PolyNode*)malloc(sizeof(PolyNode));     p = Poly;     q = poly->next;     while (q) {         p->next = (PolyNode*)malloc(sizeof(PolyNode));         p = p->next;         p->coef = (q->coef*coef);         p->expn = (q->expn + expn);         q = q->next;     }     p->next = NULL;     return Poly; } void add(Polynomial poly1, Polynomial poly2) {  //把 poly2 加到 poly1 上     PolyNode *p, *q, *r;     r = poly1;     p = poly1->next;  //指向第一个节点     q = poly2->next;     poly2->next = NULL;     while (p && q) {         if (p->expn > q->expn) {             r->next = p;             p = p->next;             r = r->next;         } else if (p->expn < q->expn) {             r->next = q;             q = q->next;             r = r->next;         } else {             PolyNode *t;             p->coef += q->coef;             if (!(p->coef > -0.000001 && p->coef < 0.000001)) //系数不为0             {                 r->next = p;                 r = r->next;                 p = p->next;             } else {                 t = p;                 p = p->next;                 free(t);             }             t = q;             q = q->next;             free(t);         }     }     if (p)         r->next = p;     if (q)         r->next = q; } Polynomial polySubtract(Polynomial poly1, Polynomial poly2) {  //多项式减法 poly1-poly2形成一个新的多项式     //把poly2的系数取相反数，形成一个新的多项式     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode)); //构造头节点     PolyNode *p, *q;     p = poly;     q = poly2->next;     while (q) {         p->next = (PolyNode*)malloc(sizeof(PolyNode));         p = p->next;         p->coef = -(q->coef);  //系数取反         p->expn = q->expn;         q = q->next;     }     p->next = NULL;     add(poly, poly1);  //利用加法     return poly; } Polynomial polyAdd(Polynomial poly1, Polynomial poly2) { //多项式相加 poly1+poly2形成一个新的多项式     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode));  //和多项式的头节点     poly->next = NULL;     PolyNode *p, *q, *r;     r = poly;     p = poly1->next;     q = poly2->next;     while (p&&q) {         if (p->expn > q->expn) {             r->next = (PolyNode*)malloc(sizeof(PolyNode));             r = r->next;             r->coef = p->coef;             r->expn = p->expn;             p = p->next;         } else if (p->expn < q->expn) {             r->next = (PolyNode*)malloc(sizeof(PolyNode));             r = r->next;             r->coef = q->coef;             r->expn = q->expn;             q = q->next;         } else {             float m = p->coef + q->coef;             if (!(m > -0.000001 && m < 0.000001)) {                 r->next = (PolyNode*)malloc(sizeof(PolyNode));                 r = r->next;                 r->coef = m;                 r->expn = p->expn;             }             q = q->next;             p = p->next;         }     }     while (p) {         r->next = (PolyNode*)malloc(sizeof(PolyNode));         r = r->next;         r->coef = p->coef;         r->expn = p->expn;         p = p->next;     }     while (q) {         r->next = (PolyNode*)malloc(sizeof(PolyNode));         r = r->next;         r->coef = q->coef;         r->expn = q->expn;         q = q->next;     }     r->next = NULL;     return poly; } Polynomial polyMultiply(Polynomial poly1, Polynomial poly2) {  //多项式相乘     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode));  //创建多项式和的头节点     poly->next = NULL;     PolyNode *p;     p = poly2->next;     while (p) {         add(poly, multiply(poly1, p->coef, p->expn));         p = p->next;     }     return poly; } void printPoly(Polynomial poly) {  //打印多项式     if (poly && poly->next) {         PolyNode *p = poly->next;  //p指向第一个节点         while (p->next) {             printf("%gx^%d", p->coef, p->expn);             p = p->next;             if (p && (p->coef > 0))                 printf("+");         }         if (p->expn == 0)             printf("%g", p->coef);   //打印常数项         else             printf("%gx^%d", p->coef, p->expn);         printf("\n");     } } void freePoly(Polynomial poly) {  //释放内存     if (poly && poly->next) {         PolyNode *p, *q;         p = poly;         while (p) {             q = p->next;             free(p);             p = q;         }     }     poly = NULL; } int main() {     printf("用链表实现多项式的加减法\n");     Polynomial poly1, poly2, poly3;     printf("创建多项式一\n");     poly1 = createPolynomial();     printf("多项式一：\n");     printPoly(poly1);     printf("创建多项式二\n");     poly2 = createPolynomial();     printf("多项式二：\n");     printPoly(poly2);     printf("两多项式相加，和为：\n");     poly3 = polyAdd(poly1, poly2);     printPoly(poly3);     freePoly(poly3);     printf("两个多项式相乘，积为：\n");     poly3 = polyMultiply(poly1, poly2);     printPoly(poly3);     freePoly(poly3);     printf("两多项式相减，差为：\n");     poly3 = polySubtract(poly1, poly2);     printPoly(poly3);     freePoly(poly1);     freePoly(poly2);     freePoly(poly3);     system("pause");     return 0; }  窃代码不叫偷！


Question: 询问一个C++的问题

//Student.h class Student { private: 	 char num[20]; 	 char name[60]; 	 char address[60]; 	 Student *next; public: 	 Student* Create(); }; int n; //Student.cpp Student* Student::Create()//定义函数。此函数返回一个指向链表头的指针 { 		struct Student *head; 		struct Student *p1,*p2; 		n=0; 		p1=p2=new Student(); 		printf("请依次输入学生的信息，输入学号为零时退出。\n"); 		printf("学号\t姓名\t地址\n"); 		scanf("%s%s%s",p1->name,p1->address);     head=NULL;     while(p1->num[0]!='0')//当学号是0时，退出 		{ 				n=n+1; 				if(n==1) 					head=p1; 				else 					p2->next=p1; 				p2=p1; 				p1=new Student();//开辟动态存储区，把起始地址付给p1 				printf("学号\t姓名\t地址\n"); 				scanf("%s%s%s",p1->num,p1->name,p1->address); 		} 		p2->next=NULL;      return(head); }

把结构体改为类型？是指改为class么？

什么叫“将结构体改为类型”？是想少打struct吗？  struct student; typedef student* pstudent;  struct student {    char num[20];    char name[60];    char address[60];    pstudent next; }; int n;//n为全局变量，本文件模块中各函数均可使用它 pstudent creat()//定义函数。此函数返回一个指向链表头的指针 {     pstudent head;     pstudent p1,p2;     ... } 这样子？


Question: 单链表逆转问题

for 中的next 赋值问题

搞清楚单链表的操作~

next没有赋初值。 参考：http://www.cnblogs.com/pianoid/archive/2011/05/03/reverse-a-singly-linked-list.html


Question: 请问cmd界面下运行这个程序

引用 7 楼 BEE_HY 的回复:[quote=引用 4 楼 zhao4zhong1 的回复:] 计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  我说的也是控制台环境。 程序员个人发展路线？ [/quote] IT专业科班生成长历程。

引用 4 楼 zhao4zhong1 的回复:计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  我说的也是控制台环境。 程序员个人发展路线？

引用 4 楼 zhao4zhong1 的回复:计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  我说的也是控制台环境。  好吧，我错了。我用了windows开发的习惯思维！

引用 1 楼 user-5 的回复:lz太叼，居然用DOS，膜拜  楼主说的应该是控制台环境吧？

比如你的exe文件名为MYPROG.EXE，在D:\MYDIR目录下 D: CD \MYDIR MYPROG IN   将在当前目录下生成一个文件IN.RED IN.RED内容为IN中每三个字符留一个字符的内容

lz太叼，居然用DOS，膜拜


Question: 在下小白，希望大家帮忙把下面一段程序，画成流程图

难道大家不是先画流程图然后才写代码么？

引用 2 楼 C0909 的回复:难道大家不是先画流程图然后才写代码么？ 至少我不是。

看代码理解不了，看对应的流程图更理解不了！  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。


Question: 各位大神们，帮忙用c语言写一个程序！！！谢谢啦！！！

仅供参考：#include <afxdisp.h> #include <stdio.h> #include <stdlib.h> int main(int argc, TCHAR* argv[]) {     COleDateTime t;     COleDateTimeSpan ts;     CString s,fmt;     int nYear;     int nMonth;     int nDay;     int nHour;     int nMin;     int nSec;     int lDays;     int nHours;     int nMins;     int nSecs;     int i,N;     // initialize MFC and print and error on failure     if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0)) {         printf("Fatal Error: MFC initialization failed\n");         return 1;     }     if (argc<13) {         printf("Usage:%s sYYYY sMM sDD shh smm sss pDD phh pmm pss n {SQL|YYYY|YY}\n",argv[0]);         return 2;     }     if (stricmp(argv[12],"SQL")==0) fmt="%Y-%m-%d %H:%M:%S";     else if (stricmp(argv[12],"YYYY")==0) fmt="%Y%m%d %H%M%S";     else if (stricmp(argv[12],"YY")==0) fmt="%y%m%d %H%M%S";     else {         printf("Usage:%s sYYYY sMM sDD shh smm sss pDD phh pmm pss n {SQL|YYYY|YY}\n",argv[0]);         return 3;     }     nYear =atoi(argv[ 1]);     nMonth=atoi(argv[ 2]);     nDay  =atoi(argv[ 3]);     nHour =atoi(argv[ 4]);     nMin  =atoi(argv[ 5]);     nSec  =atoi(argv[ 6]);     lDays =atoi(argv[ 7]);     nHours=atoi(argv[ 8]);     nMins =atoi(argv[ 9]);     nSecs =atoi(argv[10]);     N     =atoi(argv[11]);     if (N<=0) {         printf("Usage:%s sYYYY sMM sDD shh smm sss pDD phh pmm pss n {SQL|YYYY|YY}\n",argv[0]);         return 4;     }     t=COleDateTime( nYear, nMonth, nDay, nHour, nMin, nSec);     ts=COleDateTimeSpan( lDays, nHours, nMins, nSecs );     for (i=1;i<=N;i++) {         s=t.Format(fmt);         printf("%08d %s\n",i,s);         t=t+ts;     }     return 0; }

#include<stdio.h> void main() { 	int year,month,day; 	int leapyear=0;//闰年时使用  	int daytime=0; 	int sum; 	static int month_date[12]={31,28,31,30,31,30,31,31,30,31,30,31}; 	printf("请输入日期:(例如:2010 5 27)"); 	scanf("%d%d%d",&year,&month,&day);  	if(year<=0||month>12||month<1)//判断输入是否正确  	{ 		printf("Error!\n"); 		return; 	} 	if(year%400==0||(year%4==0&&year%100!=0))//判断是否为闰年  		leapyear=1;//是就加1 	if(month==2)//判断日是否输入正确，2月是特殊的因为分闰年和平年  	{  		if((month_date[month-1]+leapyear)<day||day<=0) 	{ 		printf("Error!\n"); 		return; 	} 	}  	if(month!=2)//当输入不是2月时，判断输入  	{ 		if(month_date[month-1]<day||day<=0) 		{ 			printf("Error!\n"); 			return; 		} 	} 	printf("\n请输入天数："); 	scanf("%d",&daytime);//输入第N天后  	if(daytime<0) 	{ 		printf("Error!\n"); 		return; 	} 	sum=daytime+day;//当前日期与N天相加 	do 	{ 		if(month==2)//判断当月是不是二月份  			month_date[month-1]+=leapyear; 		if(sum>month_date[month-1]) 		{ 			sum-=month_date[month-1]; 			month++;//超过当月天数，加一个月  			if(month==13)//当月份超过12月时，重新返到1月  			{ 				year++;//加一年  				if(year%400==0||(year%4==0&&year%100!=0))//判断加一年后是不是闰年  					leapyear=1; 				else 					leapyear=0;//不是闰年则为0  				month=1;//因为12月的下一个月是1月  			} 		} 	}while(sum>month_date[month-1]);//当加起来的天数少于当月的天数就停止循环  	day=sum; 	printf("\n第%d天后是%d %d %d\n",daytime,year,month,day);//输出  }


Question: 一个计算第一个单词长度的函数

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

建议自己进行调试，逐步查看变量和内存的变化，发现问题比直接解决问题更有意义~


Question: 关于访问1048 ＊ 2000 的数组时出现的奇怪的内存错误

数组已占用整个栈，当给其它局部变量分配栈空间时就溢出了

太大的数组不要放在栈上，请使用动态分配内存，否则会导致栈溢出

在占用内存空间较大的局部数组声明的前面加static将其从堆栈数据段挪到全局数据段即可避开因局部数组大小超过默认堆栈大小1MB造成程序不能正常运行的问题。

堆栈溢出了~

栈溢出了吧，一般栈空间只有几m

栈溢出了吧？ 你这个a数组已经有1048*2000*4字节了。  把这个变量申请成静态的或者全局变量就好了。

编译器在这种情况下至少应该给个警告，我觉得。


Question: 新手自编一段代码输出结果不对，求指教

1   #include <stdio.h>                                                                                1 int main()     2 {              3     int a,b,c,d,x;   4     char e;    5     scanf("%c",&e);   6     x = e - 'a'+1;   7     for(a=0;a<=x;a++)   8     {   9     |   for(b=0; b<x-a; b++)  10     |   |   printf(" ");  11     |   for(c=0; c<=x-b; c++)  12     |   |   printf("%c",'A' + c);  13     |   for(d=0; d < c-1; d++)  14     |   |   printf("%c",'A' + d);     15     |   printf("\n");  16     }         17     return 0;  18 }   找到行数和字母的规律吧,另外建议注意编写格式和变量命名: 1   #include <stdio.h>                                                                                1                2 int main()     3 {              4     int i, j, k, m, x;     5     int ch; >>  6     scanf("%c",&ch);     7     x = ch - 'a'+1;     8     //printf("%d\n", x);     9     for(i = 0; i < x; i++) {    10     |   for(j = 0; j < x-i; j++)    11     |   |   printf(" ");    12     |   for(k=0; k <= x-j; k++)    13     |   |   //printf("%c",'A'+x-j);    14     |   |   printf("%c", 'A'+k);    15     |   for(m = 0; m < k-1; m++)    16     |   |   printf("%c",'A'+m);    17     |   printf("\n");    18     }         19     return 0;    20 }

#include <stdio.h> int main() { 	int a,b,c,d,x; 	char XX; 	scanf("%c",&XX); 	x=XX-'A'; 	for(a=0;a<=x;a++) 	{ 		for(b=0;b<x-a;b++) printf(" "); 		for(c=0;c<=x-b;c++) printf("%c",'A'+c); 		for(d=c-1;d>0;d--) printf("%c",'A'+d-1); 		printf("\n"); 	} 	return 0;    }


Question: 打印5*5螺旋方阵问题

引用 2 楼 flora1203315558 的回复:[quote=引用 1 楼 qq423399099 的回复:] 参考  #include <stdio.h>  int main(int argc, char* argv[]) { 	int a, b, c, d, i, n, num = 1, array[20][20];  	scanf("%d", &n);  	/* a, b, c, d分别为上、下、左、右边界，a、b为行号，c、d为列号 */ 	for (a = 0, b = n - 1, c = 0, d = n - 1; a <= b; a ++, b --, c ++, d --) { 		for (i = c; i <= d; i ++) array[a][i] = num ++; 		for (i = a + 1; i < b; i ++) array[i][d] = num ++; 		for (i = d; i > c; i --) array[b][i] = num ++; 		for (i = b; i > a; i --) array[i][c] = num ++; 	}  	for (i = 0; i < n; i ++) { 		for (a = 0; a < n; a ++) printf("%5d", array[i][a]); 		printf("\n"); 	}  	return 0; }  小妹拜服！我那个哪里错啦？[/quote]  建议单步调试观察你数组a的变化

void main() { int a[10][10],i,j,m,n,k=0; printf("enter n\n"); scanf("%d",&n);      if (n%2==0) m=n/2;     else m=(n+1)/2;      for(i=0;i<m;i++) 	{											//少个大括号         for(j=i;j<n-i;j++) a[i][j]=++k;         for(j=i+1;j<=n-i-1;j++) a[j][n-i-1]=++k;//j<=n-i-1少个等号         for(j=n-i-2;j>=i;j--) a[n-i-1][j]=++k;         for(j=n-i-2;j>=i+1;j--) a[j][i]=++k; 	}   for(i=0;i<n;i++)   { 	  for(j=0;j<n;j++) 		  printf("%d\t",a[i][j]);     printf("\n");   } }

for(i=0;i<m;i++)         for(j=i;j<n-i;j++) a[i][j]=++k;         for(j=i+1;j<n-i-1;j++) a[j][n-i-1]=++k;         for(j=n-i-2;j>=i;j--) a[n-i-1][j]=++k;         for(j=n-i-2;j>=i+1;j--) a[j][i]=++k;  这是楼主的代码。。我个人建议for循环和if判断之后加{}，不知道这里是复制过来的时候出现了问题还是你原来代码就是这样，计算机识别的时候你不加{}，他认为你 for(i=0;i<m;i++)中只有   for(j=i;j<n-i;j++) a[i][j]=++k; [code=c] for(i=0;i<m;i++)         for(j=i;j<n-i;j++) a[i][j]=++k;和      for(j=i+1;j<n-i-1;j++) a[j][n-i-1]=++k;         for(j=n-i-2;j>=i;j--) a[n-i-1][j]=++k;         for(j=n-i-2;j>=i+1;j--) a[j][i]=++k;是两部分

Do not let me think! #include <stdio.h> #define MAXN 100 int m[MAXN+2][MAXN+2]; char d; int x,y,k,n,w; char str[10]; void main() {     while (1) {         printf("Input n(1..%d):",MAXN);         fflush(stdout);         rewind(stdin);         if (1==scanf("%d",&n)) {             if (1<=n && n<=MAXN) break;         }     }     y=0  ;for (x=0;x<=n+1;x++) m[y][x]=1;     y=n+1;for (x=0;x<=n+1;x++) m[y][x]=1;     x=0  ;for (y=0;y<=n+1;y++) m[y][x]=1;     x=n+1;for (y=0;y<=n+1;y++) m[y][x]=1;     for (y=1;y<=n;y++) {         for (x=1;x<=n;x++) {             m[y][x]=0;         }     }     x=1;     y=1;     k=0;     d='D';     while (1) {         k++;         if (k>n*n) break;         m[y][x]=k;         switch (d) {             case 'D':                 if (0==m[y+1][x])  y++;                 else              {x++;d='R';}             break;             case 'R':                 if (0==m[y][x+1])  x++;                 else              {y--;d='U';}             break;             case 'U':                 if (0==m[y-1][x])  y--;                 else              {x--;d='L';}             break;             case 'L':                 if (0==m[y][x-1])  x--;                 else              {y++;d='D';}             break;         }     }     w=sprintf(str,"%d",n*n);     for (y=1;y<=n;y++) {         for (x=1;x<=n;x++) {             printf(" %0*d",w,m[y][x]);         }         printf("\n");     } }

引用 2 楼 flora1203315558 的回复:[quote=引用 1 楼 qq423399099 的回复:] 参考  #include <stdio.h>  int main(int argc, char* argv[]) { 	int a, b, c, d, i, n, num = 1, array[20][20];  	scanf("%d", &n);  	/* a, b, c, d分别为上、下、左、右边界，a、b为行号，c、d为列号 */ 	for (a = 0, b = n - 1, c = 0, d = n - 1; a <= b; a ++, b --, c ++, d --) { 		for (i = c; i <= d; i ++) array[a][i] = num ++; 		for (i = a + 1; i < b; i ++) array[i][d] = num ++; 		for (i = d; i > c; i --) array[b][i] = num ++; 		for (i = b; i > a; i --) array[i][c] = num ++; 	}  	for (i = 0; i < n; i ++) { 		for (a = 0; a < n; a ++) printf("%5d", array[i][a]); 		printf("\n"); 	}  	return 0; }  小妹拜服！我那个哪里错啦？[/quote]哥也很是服

引用 1 楼 qq423399099 的回复:参考  #include <stdio.h>  int main(int argc, char* argv[]) { 	int a, b, c, d, i, n, num = 1, array[20][20];  	scanf("%d", &n);  	/* a, b, c, d分别为上、下、左、右边界，a、b为行号，c、d为列号 */ 	for (a = 0, b = n - 1, c = 0, d = n - 1; a <= b; a ++, b --, c ++, d --) { 		for (i = c; i <= d; i ++) array[a][i] = num ++; 		for (i = a + 1; i < b; i ++) array[i][d] = num ++; 		for (i = d; i > c; i --) array[b][i] = num ++; 		for (i = b; i > a; i --) array[i][c] = num ++; 	}  	for (i = 0; i < n; i ++) { 		for (a = 0; a < n; a ++) printf("%5d", array[i][a]); 		printf("\n"); 	}  	return 0; }  小妹拜服！我那个哪里错啦？


Question: nodejs+socket.io做的服务器，怎么用C语言实现客户端来与服务器通讯，因为socketio客户端没有c语言版本的

socket 虽然用法不一样,但是效果是一样的

建议楼主先学会使用抓包软件比如wireshark

引用 2 楼 u012880683 的回复:[quote=引用 1 楼 user-3 的回复:] 当然可以了，试下  怎么试呢？ 你对socket.io有研究吗，有大体思路吗[/quote]没有，但这应该有样例，写一个简单的应该可以的

引用 1 楼 user-3 的回复:当然可以了，试下  怎么试呢？ 你对socket.io有研究吗，有大体思路吗

当然可以了，试下


Question: 子函数线性顺序表的建立、插入和删除与主函数之间怎么实现参数的传递

buil中m没有初始化就使用了，主函数中m,n,i,b都没有初始化就使用

buil函数完全不对。 m没有初始化，直接malloc了m*sizeof(int)的空间 而且函数也没有return 给n赋值成0也毫无意义，根本不会影响到main函数里的n

这个书上和网上都有现成的吧~感觉你都没理解了什么是顺序表，以及顺序表的操作原理~

参数传递是不是正确单步调试到子函数里看一下就知道了。  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！  单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

除了没有初始化以及子函数buil没有return之外，主函数与另外那两个子函数之间的参数传递有问题吗？


Question: 请问如何大端编译c code

-march=                   Generate code for given CPU ？

没见过大端序的 x86 ...

这命令干嘛用的？


Question: 求教为啥写进程字符串无法写入

具体原因有很多的啊， 端口设置错误，传值错误，还有就是速率不匹配。可以通过返回值或者GetLastError来具体分析。  建议这类的代码还是不要自己造轮子，网上下一个吧。


Question: 求二叉树的层次遍历，把这个补全。

仅供参考：#include <iostream> #include <stack> #include <queue> #include <locale.h> using namespace std; typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int CreateBiTree(BiTree &T) {//按先序序列创建二叉树     char data;     scanf("%c",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         T = NULL;     } else {         T = (BiTree)malloc(sizeof(BiTNode));         T->data = data;         //生成根结点         CreateBiTree(T->lchild);//构造左子树         CreateBiTree(T->rchild);//构造右子树     }     return 0; } void Visit(BiTree T) {//输出     if (T->data != '#') {         printf("%c ",T->data);     } } void PreOrder(BiTree T) {//先序遍历     if (T != NULL) {         Visit(T);               //访问根节点         PreOrder(T->lchild);    //访问左子结点         PreOrder(T->rchild);    //访问右子结点     } } void InOrder(BiTree T) {//中序遍历     if (T != NULL) {         InOrder(T->lchild);     //访问左子结点         Visit(T);               //访问根节点         InOrder(T->rchild);     //访问右子结点     } } void PostOrder(BiTree T) {//后序遍历     if (T != NULL) {         PostOrder(T->lchild);   //访问左子结点         PostOrder(T->rchild);   //访问右子结点         Visit(T);               //访问根节点     } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。     stack<BiTree> stack;     BiTree p = T;//p是遍历指针     while (p || !stack.empty()) {   //栈不空或者p不空时循环         if (p != NULL) {             stack.push(p);          //存入栈中             printf("%c ",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             p = stack.top();        //退栈             stack.pop();             p = p->rchild;          //访问右子树         }     } } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     stack<BiTree> stack;     BiTree p = T;//p是遍历指针     while (p || !stack.empty()) {   //栈不空或者p不空时循环         if (p != NULL) {             stack.push(p);          //存入栈中             p = p->lchild;          //遍历左子树         } else {             p = stack.top();        //退栈，访问根节点             printf("%c ",p->data);             stack.pop();             p = p->rchild;          //访问右子树         }     } }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     stack<BiTreePost> stack;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || !stack.empty()) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack.push(BT);             p = p->lchild;         }         while (!stack.empty() && (stack.top())->tag == 'R') {//左右子树访问完毕访问根节点             BT = stack.top();             stack.pop();//退栈             printf("%c ",BT->biTree->data);         }         if (!stack.empty()) {//遍历右子树             BT = stack.top();             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     } }  void LevelOrder(BiTree T) {//层次遍历     if (T == NULL) return;     BiTree p = T;     queue<BiTree> queue;//队列     queue.push(p);//根节点入队     while (!queue.empty()) {    //队列不空循环         p = queue.front();      //对头元素出队         printf("%c ",p->data);  //访问p指向的结点         queue.pop();            //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue.push(p->lchild);         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue.push(p->rchild);         }     } } int main() {     BiTree T;      setlocale(LC_ALL,"chs");     CreateBiTree(T);      printf("先序遍历        ：");PreOrder  (T);printf("\n");     printf("先序遍历(非递归)：");PreOrder2 (T);printf("\n");                                                printf("\n");     printf("中序遍历        ：");InOrder   (T);printf("\n");     printf("中序遍历(非递归)：");InOrder2  (T);printf("\n");                                                printf("\n");     printf("后序遍历        ：");PostOrder (T);printf("\n");     printf("后序遍历(非递归)：");PostOrder2(T);printf("\n");                                                printf("\n");     printf("层次遍历        ：");LevelOrder(T);printf("\n");      return 0; } //ABC##DE#G##F### //先序遍历        ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历        ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历        ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历        ：A B C D E F G //  ///       A ///      / ///     B ///    / \ ///   C   D ///      / \ ///     E   F ///      \ ///       G


Question: 用循环嵌套语句输出九九乘法表出错

#include <stdio.h> int main (void) {     int i;     int j;     int n;      for(i=1;i<10;i++)     {          for(j=1;j<=i;j++)          {                n=i*j;                printf("%d*%d=%d ",i,j,n);           }          printf("\n");       }      return 0; }

j不是在开头已经置1了吗，为什么下面还需要

3个错误： 1.printf("4d\n",i*j);改为printf("%4d\n",i*j); 2.while(i<10)后面多了分号 3.j应该在每次while循环都重新置为1  #include<stdio.h> void main() { 	int i,j; 	i=1; 	while(i<10) 	{ 		j=1; 		do{ 			if(j==9) 				printf("%4d\n",i*j); 			else 				printf("%4d",i*j); 			j++; 		}while(j<10); 		i++; 	} }

printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。  在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 int c; scanf("%c",&c); //时，都改为 char s[2]; int c; scanf("%1s",s); c=s[0];  关于自己是否适合编程的很简单的测试： 在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案：  A里面有10处以上文字或标点错误 B里面没有文字或标点错误并敢为此跟人打赌 C里面没有文字或标点错误并且字体和排版完全与原稿一致 D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感  A不适合编程（理由：打字准确度偏低、粗心大意） B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念） C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证） D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！）  如果想从A变成B的话，到我的资源http://download.csdn.net/detail/zhao4zhong1/4084259里面下载“适合程序员的键盘练习”


Question: 关于程序内存问题

你看看编译有没警告什么的

通过调用堆栈来判断出错位置

引用没代码没真相……  main还没进去？ 那可能是某个全局或者静态变量要初始化，楼主在构造函数里想new好大好大好大好大的内存，比方说10g，你机器内存没那么多，爆了 根本就没有用到new

引用你看看编译有没警告什么的 有，和警告有关系？

引用崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 怎么进入，不太懂

引用main函数怎么写的？进调试看看 第一句打了断点都没有进去

main函数怎么写的？进调试看看


Question: 为什么t2非要加绝对值以后，结果才会正确呢？不加pi=1，π=4，t2不是个正数吗？加与不加为什么有这么大的差别？

问题解决了记得结帖

谢谢！你说的太对了，怎么没有初始化呢？自己看了半天都看不出来，一语惊醒梦中人啊！ 引用 1 楼 qq423399099 的回复:你的t2都没初始化过，里面可能存了一个垃圾值（极有可能是个负数） 在VS下值是-9.2559631349317831e061（是个负数） 所以不满足while循环，直接就输出结果了 PS:加了绝对值的话就会进入while循环，建议可以初始化成1.0


Question: 求使用win 32进行串口通信多线程的例子，希望能进行字符串传输

去codeproject上找吧，非常的多。 还有事例，代码也很成熟。

百度搜“C源代码 串口通信 多线程”


Question: C语言输入函数scanf()和gets()，gets函数输入的次数比输入的n少一次，这是为什么？

谢谢，问题已经解决了，我刚学C语言，大概知道是输入的n的占了一次，但是不知道要怎么解决。函数是fflush()，不是flush()

scanf("%d",&n);在输入时候你会按3，回车，然后scanf取到了3，回车保留在了缓冲区里，当你用gets(name)的时候,name获取到了一个回车，可以用fflush(stdin);清空缓冲区，放在get（name）前。 我是那么理解的

你for循环之前的scanf("%d",&n);会有遗留下来的回车符在输入缓冲区 gets可以读入回车符而跳过第一次for循环，而scanf不行 你在scanf("%d",&n);后面加上flush(stdin);清空输入缓冲区两者就一样了


Question: 为啥会乱码啊！！！！

for(p=a;p<(p+8);p++)这句写的不对 你的p<(p+8)恒成立，直到程序越界崩溃 应该改成for(p=a;p<(a+8);p++)


Question: 这一段c代码功能如下，现要求每4位间隔空格显示在屏幕上输出。如何改法更优？

参考《编译原理》中的词法分析和有限状态自动机。


Question: 十个整数  把最小的和第一个数互换 最大和最后互换 如果把*(a+9)=*max*去掉 就提示左值 求详解

《牛肉干》 C语言上机课，某女同学偷偷吃起牛肉干。 有一粒牛肉干掉到了键盘上，卡在7和8键之间。 女同学就在键盘上抠啊、抠啊、抠啊…… 程序里一行代码变成这个样子： int *pa=&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&a; 后来的结局是 ————程序顺利通过编译，运行结果正确！

引用 3 楼 qq_35109846 的回复:[quote=引用 1 楼 paschen 的回复:] a=number;    这句语法上没问题  max=(a+i);        加*是解引指针，而你这里只是做指针运算，所以不用加*  (a+9)=max;  因为a+9是一个右值（临时的值），你不能对他进行赋值那为什么加上*就可以赋值[/quote]  *(a+9)是解引该地址的值，是左值，但a+9是个右值

a=number; 不用加 * ，这句话的意思是让 a 指向 number指向的内存，在这里也就是传进来的数组的首地址。如果改为 *a = *number; 的话，那只是将 a 所指向的内存初始化为number[0] ，也就会导致之后的程序无法通过  a 引用到数组中的值。  max=(a+i);   同理，也是为了达到交换指向的目的，如果变为单纯的值赋值的话，是没有什么意义的。  关于左右值得问题，参考楼上的就可以了，实在不行就从网上找找相关的资料，c语言的指针确实容易让人迷惑，但是一旦要是理解了也就会豁然开朗的~

引用 4 楼 qq_35109846 的回复:[quote=引用 2 楼 qq423399099 的回复:] *max加上*并且作为左值，表示你对max指针所指向的值要进行赋值操作 而你的max指针只是要找到最大的值，并且指向它就可以了  左值：能代表一个“容器”的就是一个左值。 一般来说，左值都是有地址的，但是寄存器变量是没有地址的max为什么不是右值 而a+i是 ，麻烦说详细点[/quote] max不是不能作为右值，而是此处应当作为左值，才能指向值最大的元素 PS：建议看下指针的基础

引用 2 楼 qq423399099 的回复:*max加上*并且作为左值，表示你对max指针所指向的值要进行赋值操作 而你的max指针只是要找到最大的值，并且指向它就可以了  左值：能代表一个“容器”的就是一个左值。 一般来说，左值都是有地址的，但是寄存器变量是没有地址的max为什么不是右值 而a+i是 ，麻烦说详细点

引用 1 楼 paschen 的回复:a=number;    这句语法上没问题  max=(a+i);        加*是解引指针，而你这里只是做指针运算，所以不用加*  (a+9)=max;  因为a+9是一个右值（临时的值），你不能对他进行赋值那为什么加上*就可以赋值


Question: 求解答

数组名不允许做左值,可以考虑是用strcpy/strncpy/memcpy代替赋值；

数组是不允许 直接赋值的 你可以使用copy系统函数或使用下标方式赋值

str不是指针类型，而是数组类型  数组类型不允许被赋值

数组一旦定义就会被分配一片连续的空间，因此数组的首地址是不变的，因此可以说数组名是一个常量指针，一旦定义就不能再被赋值了。 数组名它永远是右值。 http://blog.csdn.net/weiwenhp/article/details/8002942

const char*, const是很重要的一个关键字，不要漏了


Question: C语言问题

结果与楼主所述不符啊

结果与楼主所述不符啊

最后的输出不会是 1  0

a 数组大小怎么没传给f 函数，你f 函数里while循环的结束条件呢？？？你a[]数组里全都是<=10的，如果size=sizeof(a); a[size]<= 10呢？？

楼主截个图看看

楼主截个图看看


Question: 我的这本教材我怎么感觉好多错的地方呢？这段代码又编译不了。

换书，并且换编译器，vc6.0太老了

strcat那里改成(pFun)strcat  同理strcpy那句

变量名和函数名重名,就近原则编译器认为你输入的是第三个参数是变量而不是函数了

建议楼主换这个： C语言教程（附带C语言100例）http://download.csdn.net/detail/zhao4zhong1/8830817

反正我是没见过哪本教材里面的代码有把函数原型写在函数内部的。

引用 7 楼 qq423399099 的回复:strcat和strcpy在string.h头文件里，你没include当然就是undeclared identifier 哦

引用 8 楼 zhao4zhong1 的回复:反正我是没见过哪本教材里面的代码有把函数原型写在函数内部的。 赵老师好啊，我又回来了。 那两句 的确是我自己写进去的。 教材里这段代码  它的原文 的确没有 #include <string.h> 书名 叫 零基础学C语言  第三版。 作者是个叫 康莉的人。  我想应该是印刷错误吧。

#include <string.h>

还有，s是source的缩写，d是destination的缩写，两者顺序不宜搞错了。

引用 3 楼 qq423399099 的回复:你变量名和函数名取名一样。。。 敢不敢换个名字。 教材要是真取这样的变量名的话也是牛   what?      char strcat[40]="\0" char strcpy[40]="\0 这两句真是我添的。函数名？ 那是C风格字符串的变量名。 函数名 fun这个才是？ 我为啥要自作主张添 这两句请看下图 错误提示：  那两个单词是不是 未声明变量的意思？ 去了我添的两句还是编译不了嘛

char strcat[40]="\0" char strcpy[40]="\0" 这两句注释掉试试，strcat和strcpy应该是函数名，作为fun()函数的参数。

什么书，这么牛？你确定是书上的代码？不是你自己写的？