Question: linux C 互斥量问题

仅供参考：//循环向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; }

可能是机制没有处理好吧

感觉是谁抢到了就是谁的。


Question: 算法问题 排序和输出

#include<stdio.h>  #define N 200  int main() {     int number[N];     int n;     int i=0, j;     int k;      scanf("%d\n",&n);      for (i = 0; i < n; i++)         scanf("%2d",&number[i]);      for(j = 0; j < n; j++)         for(i = 0; i < n-1-j; i++)             if(number[i] > number[i+1])             {                 k = number[i];                 number[i] = number[i+1];                 number[i+1] = k;             }      for(i = 0; i < n; i++)         printf("%2d", number[i]);     putchar(10);      return 0; } 有多少个实际数据，就对多少个实际数据进行排序～

排序算法有错误啦： for(int j=0;j<n;j++) for(int i=0;i<n-j-1;i++) if(number[i] > number[i+1]) { k=number[i]; number[i] = number[i+1]; number[i+1] = k; } 由于你只是要求对5个数组元素排序，可是你的算法却是对10个数组元素排序，这样当然有问题啦 PS：排版能好点吗，至少要像楼上那样啦

return 0; }

#include<stdio.h> #define N 200  int main() { 	int number[N]; 	int n,k; 	scanf("%d",&n); 	for(int i=0;i<n;i++) 		scanf("%d",&number[i]);  	for(int j=0;j<n-1;j++) 		for(int i=0;i<n-1;i++) 			if(number[i] > number[i+1]) 			{ 				k=number[i]; 				number[i] = number[i+1]; 				number[i+1] = k; 			} 	for(int i=0;i<n;i++) 		printf("%2d",number[i]); 	r


Question: 强制转换

引用 4 楼 hswshya 的回复:[quote=引用 3 楼 qq_36409192 的回复:] x为什么会转换为float型？？？ （float） x ；  不是就把x转换成了float类型吗。。 初学，谢谢[/quote] 这是强制类型转换；是将x的值强制转换为float类型，但是x还是int类型。 第二个初始想法应该是(float *)&x吧， 第二个是将转换为float类型的指针。一般这些表达式都是要赋值给某些变量的；即作为赋值号的右边；

第二个应该是把一个指针  转换成float型

引用 3 楼 qq_36409192 的回复:x为什么会转换为float型？？？ （float） x ；  不是就把x转换成了float类型吗。。 初学，谢谢

x为什么会转换为float型？？？

不同吧，指针转换跟数据类型转换不同吧。关注一下，互相学习。

(flat *)&x 才是转换指针


Question: 22行，m的表达式值看不懂？？？

int m = (n - 1) / 2; n是传入的形参

对数组进行倒序，以中间元素为“标杆”，交换的次数就是(n-1)/2,没问题

在定义变量的时候给出初值，这叫初始化。 初始化给出的值必须在编译的时候就能确定。 这里的int m=(n-1)是初始化，但是n也是变量，编译时无法确定值，所以肯定报错。

22行定义了temp  i  j   m  这几个变量  并让m初始化为 (n-1) / 2的值


Question: 一个指针的问题，通过编译器调用正常，直接运行报错（增加问题描述）

引用 2 楼 zzmlake 的回复:*tptr1= xxx;// 这句出错  估计是tptr1指向的地址不可访问，非法。 建议你用printf("%p\n", tptr1);输出地址看看。  你这代码不全，没法明确判断 rval = (ldouble *)calloc( size * size, sizeof( ldouble));    if( rval)    tptr1 = rval; 这3行是说明这个地址应该没有问题。  刚刚测试了半天出现更加诡异的问题。 在调用该函数前的一段代码加上调试语句 printf("1\n"); 一段代码 printf("2\n"); 一段代码 printf("3\n"); *tptr1= xxx; printf("4\n"); 运行程序出现 1 2 3 崩溃  如果把 printf("1\n"); printf("2\n"); 全部删掉，则直接崩溃， 3这行也看不到，就是说理论上完全没有用的printf("1\n");也会影响程序是否出错，我猜是某些随机操作，比如分配内存之类的出现问题，但是我没有办法调试。 目前能想到的解决办法是下午换个编译器试试。

刚刚增加了测试数据，经过测试，发现无论是通过编译器调用还是通过cmd窗口运行，一样在*tptr1= xxx;会出错，有没有人有经验，在这种情况出错的原因是什么？

引用 5 楼 zhao4zhong1 的回复:崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 尝试了一下，出现这个 线程 'Win32 线程' (0x2854) 已退出，返回值为 0 (0x0)。 gauss_devcpp.exe 中的 0x00435193 处未处理的异常: 0xC0000005: 读取位置 0xffffffff 时发生访问冲突 还是完全看不懂。  我刚刚找了一个codeblock，重新编译了一下，这次很顺利的把程序跑完了，没有出现那个奇怪的问题。 编译器devcpp背锅了吧

重点看你那一大段代码有没有对temp直接或间接的内存指向重新修改  printf()是可能对崩溃点造成影响的 经典的情况是在一个函数内打印，然后返回局部的指针或者引用，最后在调用处打印返回结果，那么就可能并不会崩溃


Question: 求助，初学C语言，请问strcasestr究竟该如何使用？

#include <string.h>         char *strstr(const char *haystack, const char *needle);         #define _GNU_SOURCE         /* See feature_test_macros(7) */         #include <string.h>         char *strcasestr(const char *haystack, const char *needle);  DESCRIPTION        The strstr() function finds the first occurrence of the substring needle in the string haystack.  The terminating null bytes ('\0') are not compared.         The strcasestr() function is like strstr(), but ignores the case of both arguments.  RETURN VALUE        These functions return a pointer to the beginning of the located substring, or NULL if the substring is not found.

strcasestr 比 strstr 多了一个忽略大小写的功能吧，怎么用strstr就怎么用strcasestr  char *strcasestr(const char *str1, const char *str2) {   char *cp = (char *) str1;   char *s1, *s2;    if (!*str2) return (char *) str1;    while (*cp) {     s1 = cp;     s2 = (char *) str2;      while (*s1 && *s2 && !(tolower(*s1) - tolower(*s2))) s1++, s2++;     if (!*s2) return cp;     cp++;   }    return NULL; }

strcasestr函数         #define _GNU_SOURCE         #include <string.h>         char *strcasestr(const char *haystack, const char *needle);          用于在c串haystack中查找c串needle，忽略大小写。如果找到则返回needle串在haystack串中第一次出现的位置的char指针          在实际的应用中如果只加上头文件，当编译时会出现  warning: assignment makes pointer from integer without a cast         这是因为函数的声明在调用之后。未经声明的函数默认返回int型。         因此要在#include所有头文件之前加  #define _GNU_SOURCE  ，以此解决此问题。

这种东西难得用上，没必要纠结。

不是标准的C，必须在linux上，在include前面还要加#define _GNU_SOURCE  参考：http://stackoverflow.com/questions/9935642/how-do-i-use-strcasestr https://linux.die.net/man/3/strcasestr

引用 1 楼 user-6 的回复:你哪里查到有strcasestr这个函数？  我是在浙江大学的mooc上学习的，其中老师提到了一句：   课程链接：http://www.icourse163.org/course/ZJU-1001614008#/info 在字符串一课，9.2》字符串搜索函数。  后来我也查询了这个函数：http://blog.csdn.net/huanggang982/article/details/37901937  但貌似相关资料比较有限

你哪里查到有strcasestr这个函数？


Question: C语言  吃掉换行符问题  求指教！！

仅供参考：void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%08x -",i+addr);             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]:'.');             }             printf("%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]:'.');         }         printf("%s\n",binstr);     } }

好像不行啊   还是把换行符写入文件里了

if (member_name[0] != ‘\0') {  fprintf(...); }  member_name[0] != '\n'  这个判不判断都可以  gets  不存储换行符的，即 '\n' fgets 存储换行符


Question: 求一个程序，输入一个整数，依次输出它的每位数的英文单词，（看到精华帖的问题，自己学着编的），

修改版：参考一下吧！ #include <stdio.h>  void Switch(int j) { 	switch(j) 	{ 		case 0:printf("zero ");break; 		case 1:printf("one ");break; 		case 2:printf("two ");break; 		case 3:printf("three ");break; 		case 4:printf("four ");break; 		case 5:printf("five ");break; 		case 6:printf("six ");break; 		case 7:printf("seven ");break; 		case 8:printf("eight ");break; 		case 9:printf("nine ");break; 		default:printf("error!\n"); 	} }  int main() { 	int num,i=1,n=1,h,j; 	int temp; 	printf("please input the number:\n"); 	scanf("%d",&num); 	temp=num; 	while(temp>9) 	{ 		temp=temp/10; 		i++; 		n=n*10;	 	} 	 	for(h=0;h<i;h++) 	{ 		temp=num; 		j=(temp/n)%10; 		n=n/10; 		Switch(j); 	} 		  	 	return 0; }

#include <stdio.h>  void Switch(int j) { 	switch(j) 	{ 		case 1:printf("one");break; 		case 2:printf("two");break; 		case 3:printf("three");break; 		case 4:printf("four");break; 		case 5:printf("five");break; 		case 6:printf("six");break; 		case 7:printf("seven");break; 		case 8:printf("eight");break; 		case 9:printf("nine");break; 		default:printf("error!"); 	} }  int main() { 	int num,i=1,n=1,h,j; 	int temp; 	printf("please input the number:\n"); 	scanf("%d",&num); 	temp=num; 	while(temp>10) 	{ 		temp=temp/10; 		i++; 		n=n*10;	 	} 	 	for(h=0;h<i;h++) 	{ 		temp=num; 		j=(temp/n)%10; 		n=n/10; 		Switch(j); 	} 		  	 	return 0; }

#include <stdio.h> #include <stdlib.h>  #define  MAX_LEN    10  void reverse(int *bits, int len); int get_bits(int *bits, int num); int main() {     char *p[10] = {"zero", "one", "two", "three",         "four", "five", "six", "seven", "eight", "nine"};      long int num;     int cnt, bits[MAX_LEN], i;      printf("Please input a interger: ");     scanf("%ld", &num);      cnt = get_bits(bits, num);      printf("bits list are: \n");     for (i = 0; i < cnt; i++) {         printf("%s ", p[bits[i]]);     }     putchar(10);      /*     long n,m;     int i,j;     scanf("%ld",&n);     for(j=0;n>=0;j++)     {         m=n;         for(i=0;m>=10;i++)         {             m=m/10;         }         if(n>=10)         {             n=n-m*(pow(10,i));             printf("%s\n",p[m]);             if(n<pow(10,i-1)&&n>0)             {                 printf("%s\n",p[0]);             }         }         if(n<10&&n>=0)         {             printf("%s\n",p[n]);             break;         }     }     */     system("pause");     return 0; }  int get_bits(int *bits, int num) {     int i = 0;      if (num == 0) {         bits[i] = 0;         return 0;     }     if (num < 0)         num = abs(num);      while (num) {         bits[i++] = num % 10;         num /= 10;     }     reverse(bits, i);     return i; }  void reverse(int *bits, int len) {     int i, tmp;      for (i = 0; i < len/2; i++) {         tmp = bits[len-1-i];         bits[len-1-i] = bits[i];         bits[i] = tmp;     } }  作为一个参考吧～

谢谢，自己在家学的，还没有深入，确实要多花功夫

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

引用 1 楼 user-4的回复:char *p[10]={"zero","one","two","three","four","five","six","seven","eight","nine","ten"}; 数组大小为11 这个问题挺多的，不止一处，现在还在更正摸索。


Question: 一个内存分配的问题？

空数组不占用任何内存空间，标准是说结构的最后一个元素可以是空数组，情形2这种情况是不是属于不确定的情况啊  C99的原文： As a special case, the last element of a structure with more than one named member may have an incomplete array type; this is called a flexible array member. With two exceptions, the flexible array member is ignored. First, the size of the structure shall be equal to the offset of the last element of an otherwise identical structure that replaces the flexible array member with an array of unspecified length. Second, when a . (or ->) operator has a left operand that is (a pointer to) a structure with a flexible array member and the right operand names that member, it behaves as if that member were replaced with the longest array (with the same element type) that would not make the structure larger than the object being accessed; the offset of the array shall remain that of the flexible array member, even if this would differ from that of the replacement array. If this array would have no elements, it behaves as if it had one element but the behavior is undefined if any attempt is made to access that element or to generate a pointer.

http://blog.csdn.net/u013165704/article/details/53733412  最后一个成员是大小为0的数组才不占用空间

还有就是值为0 是为什么？  是编译器的原因 还是？  其他？  麻烦详细解答下。。。我写的程序因为这个困扰。。。。


Question: Uva1225 想利用itoa（）函数来解

引用 6 楼 yangyangsnr 的回复:[quote=引用 4 楼 yangyangsnr 的回复:] 用itoa的话应该再用一个字符串存储转换的数字，然后合并到s中，itoa本身不会智能的在原字符串末尾继续添加 或者说不组合了，直接判断数字  #include <stdio.h> int main() {     int n;     int a[10];     for( int i = 0; i != 10; i++ )         a[i] = 0;      scanf( "%d", &n );          for( int i = 0; i <= n; i++ )     {         int t = i;         while( t!= 0 )         {               a[t % 10]++;                     t /= 10;         }         }              for( int i = 0; i != 10; i++ )         printf( "%d:%d\n", i, a[i] );              getchar();     getchar();     return 0; }  [/quote]先谢谢你啦！我先看看

for循环嵌套,第二个for里的循环变量不能用i,换一个 否则是死循环

引用 9 楼 lgbxyz 的回复:case的值也错了,应该是字符 '0' ~ '9''嗯嗯，确实这里有问题，谢谢你，这个case不加break结果也是一样的，都能跑出来

引用 5 楼 user-3 的回复:for(i=1; i <= n; i++) {    itoa(i, s, 10);      for(j=0;  s[j]; j++)     {        a[s[j] - '0'] ++;    } }谢谢你，加上你这个内循环，以及综合其他几位大神提的建议，结果正确了，能解释下内循环吗，谢谢！

case后面都没加break

case的值也错了,应该是字符 '0' ~ '9''

itoa 第一个参数错了,应该是i

引用 2 楼 lgbxyz 的回复:把第二个for循环拿到第一个for循环里面 放进去之后输入n一直没结果出来，好像程序一直在跑，可是再怎么也不会跑那么久吧

引用 4 楼 yangyangsnr 的回复:用itoa的话应该再用一个字符串存储转换的数字，然后合并到s中，itoa本身不会智能的在原字符串末尾继续添加 或者说不组合了，直接判断数字  #include <stdio.h> int main() {     int n;     int a[10];     for( int i = 0; i != 10; i++ )         a[i] = 0;      scanf( "%d", &n );          for( int i = 0; i <= n; i++ )     {         int t = i;         while( t!= 0 )         {               a[t % 10]++;                     t /= 10;         }         }              for( int i = 0; i != 10; i++ )         printf( "%d:%d\n", i, a[i] );              getchar();     getchar();     return 0; }

引用 1 楼 user-3 的回复:for(……) {   itoa(i, a, 10);   stract_s(s, a); }  switch (s[i])   设置断点 单步 调试， 看看结果是否是按自己的思路走的vc++6.0好像不能使用这个函数，我用dev编译，这个函数也出现 [Error] 'stract_s' was not declared in this scope

把第二个for循环拿到第一个for循环里面


Question: 非循环双链表逆向输出的问题!

#include "stdafx.h" #include <stdio.h> #include <stdlib.h> #include <string.h>   typedef struct List {     int ldata;        //数据域     List* pier;        //前驱节点     List* pnext;        //后继节点  }*plist,list;  plist lcreate() {     list* lhead, *lend, *lnew;     int num,data;     int icount;     lhead = (list*)malloc(sizeof(list));     if (lhead == NULL)     {         printf("内存申请失败!\n");         exit(-1);     }     lhead->pnext = NULL;     lhead->pier = NULL; /* note: init pier */     lend = lhead;     lend->pnext = NULL;     printf("需要输入多少位数据:");     scanf_s("%d",&num);     for (icount = 0; icount < num; icount++)     {          printf("输入数据:");         scanf_s("%d", &data);         lnew = (list*)malloc(sizeof(list));         if (lnew == NULL)         {             printf("内存申请失败!\n");             exit(-1);         }          lnew->ldata = data;         lnew->pnext = lend->pnext;         lnew->pier = lend;         lend->pnext = lnew;         lend = lnew;      }     lend->pnext = NULL;     return lhead; } //在第i个节点前添加数据 plist inserchlist(list* head,int data,int num) {     list* p,*pnew;     int findnum;     p = head->pnext;     for (findnum = 1; findnum < num; findnum++)     {         p = p->pnext;     }     pnew = (list*)malloc(sizeof(list));     pnew->ldata = data;      pnew->pier = p->pier;     pnew->pnext = p;     p->pier->pnext = pnew;     p->pier = pnew;      return head; } //在第i个节点后插入数据 plist nextinserch(list* head, int data, int num) {     list* p, *nnext;     p = head->pnext;     int findnum;     for (findnum = 1; findnum < num; findnum++)     {         p = p->pnext;     }      nnext = (list*)malloc(sizeof(list));     nnext->ldata = data;     if (p->pnext!=NULL)     {         p = p->pnext;         nnext->pier = p->pier;         nnext->pnext = p;         p->pier->pnext = nnext;         p->pier = nnext;     }     else     {         nnext->pier = p;         nnext->pnext = p;         p->pnext = nnext;         p->pnext->pier = NULL;         p = nnext;         p->pnext = NULL;     }     return head; } //顺序输出数据 void prit(list* head) {     list* p;     p = head->pnext;     if (head == NULL)     {         printf("空链表!\n");         exit(-1);     }     while (p!=NULL)     {          printf("数据为:%d\n",p->ldata);         p = p->pnext;     }  } //逆置输出数据 void pierpirt(list* head) {     list* p;     p = head->pnext;      //while (p != NULL)     while (p->pnext != NULL)     {         printf("顺序打印,节点元数为:%d\n",p->ldata);          p = p->pnext;         //这个循环体中，p是正常的，断点调试，看到p的next都有值，在每个next的上面pier（即前驱节点也有值）。      }     //上面的循环之后，p应该到链尾。断点调试在p循环出来之后，p却是内存无法读取。     if (p == NULL)     {         printf("前驱为空!\n");         exit(-1);     }      //while (p->pier != head)     while (p->pier != NULL)     {         printf("逆向输出的数据为:%d\n",p->ldata);         p = p->pier;     } }  int _tmain(int argc, _TCHAR* argv[]) {     list* temp;     int tdata,tnum;     int lastdata, lastnum;     temp = lcreate();     prit(temp);     //在第i个节点前添加数据     printf("输入要添加的数据:");     scanf_s("%d",&tdata);     printf("输入要添加的节点:");     scanf_s("%d", &tnum);     temp=inserchlist(temp, tdata, tnum);     prit(temp);      //在第i个节点后添加数据     printf("输入要添加的数据:");     scanf_s("%d", &lastdata);     printf("输入要添加的节点:");     scanf_s("%d", &lastnum);     temp=nextinserch(temp, lastdata,lastnum);     /*prit(temp);*/     //逆置输出数据     pierpirt(temp);     return 0; } 逆向输出问题解决了，对比看一下；改了2句，加了一句。加的一句是在创建双向链表时，初始化了头节点的前置指针。

因为你是while (p != NULL)，当结束while循环时p是NULL，所以你判断if (p == NULL)就是true了，就exit了 两个问题： 1.你的顺序打印中，应该判断改成这样while (p->pnext != NULL)，然后先p = p->pnext;才行 2.你的逆序打印中，判断应该是while (p != head)才对  #include "stdafx.h" #include <stdio.h> #include <stdlib.h> #include <string.h>  typedef struct List { 	int ldata;        //数据域 	List* pier;        //前驱节点    	List* pnext;        //后继节点  }*plist, list;  plist lcreate() { 	list* lhead, *lend, *lnew; 	int num, data; 	int icount; 	lhead = (list*)malloc(sizeof(list)); 	if (lhead == NULL) 	{ 		printf("内存申请失败!\n"); 		exit(-1); 	} 	lhead->pnext = NULL; 	lend = lhead; 	lend->pnext = NULL; 	printf("需要输入多少位数据:"); 	scanf_s("%d", &num); 	for (icount = 0; icount < num; icount++) 	{  		printf("输入数据:"); 		scanf_s("%d", &data); 		lnew = (list*)malloc(sizeof(list)); 		if (lnew == NULL) 		{ 			printf("内存申请失败!\n"); 			exit(-1); 		}  		lnew->ldata = data; 		lnew->pnext = lend->pnext; 		lnew->pier = lend; 		lend->pnext = lnew; 		lend = lnew;  	} 	lend->pnext = NULL; 	return lhead; } //在第i个节点前添加数据 plist inserchlist(list* head, int data, int num) { 	list* p, *pnew; 	int findnum; 	p = head->pnext; 	for (findnum = 1; findnum < num; findnum++) 	{ 		p = p->pnext; 	} 	pnew = (list*)malloc(sizeof(list)); 	pnew->ldata = data;  	pnew->pier = p->pier; 	pnew->pnext = p; 	p->pier->pnext = pnew; 	p->pier = pnew;  	return head; } //在第i个节点后插入数据 plist nextinserch(list* head, int data, int num) { 	list* p, *nnext; 	p = head->pnext; 	int findnum; 	for (findnum = 1; findnum < num; findnum++) 	{ 		p = p->pnext; 	}  	nnext = (list*)malloc(sizeof(list)); 	nnext->ldata = data; 	if (p->pnext != NULL) 	{ 		p = p->pnext; 		nnext->pier = p->pier; 		nnext->pnext = p; 		p->pier->pnext = nnext; 		p->pier = nnext; 	} 	else 	{ 		nnext->pier = p; 		nnext->pnext = p; 		p->pnext = nnext; 		p->pnext->pier = NULL; 		p = nnext; 		p->pnext = NULL; 	} 	return head; } //顺序输出数据 void prit(list* head) { 	list* p; 	p = head->pnext; 	if (head == NULL) 	{ 		printf("空链表!\n"); 		exit(-1); 	} 	while (p != NULL) 	{  		printf("数据为:%d\n", p->ldata); 		p = p->pnext; 	}  } //逆置输出数据 void pierpirt(list* head) { 	list* p; 	p = head;  	while (p->pnext != NULL) 	{ 		p = p->pnext; 		printf("顺序打印,节点元数为:%d ", p->ldata);  		 		//这个循环体中，p是正常的，断点调试，看到p的next都有值，在每个next的上面pier（即前驱节点也有值）。  	} 	//上面的循环之后，p应该到链尾。断点调试在p循环出来之后，p却是内存无法读取。 	if (p == NULL) 	{ 		printf("前驱为空!\n"); 		exit(-1); 	} 	printf("\n"); 	while (p != head) 	{ 		printf("逆向输出的数据为:%d\n", p->ldata); 		p = p->pier; 	} }  int _tmain(int argc, _TCHAR* argv[]) { 	list* temp; 	int tdata, tnum; 	int lastdata, lastnum; 	temp = lcreate(); 	prit(temp);  	//在第i个节点前添加数据 	printf("输入要添加的数据:"); 	scanf_s("%d", &tdata); 	printf("输入要添加的节点:"); 	scanf_s("%d", &tnum); 	temp = inserchlist(temp, tdata, tnum); 	prit(temp);  	//在第i个节点后添加数据 	printf("输入要添加的数据:"); 	scanf_s("%d", &lastdata); 	printf("输入要添加的节点:"); 	scanf_s("%d", &lastnum); 	temp = nextinserch(temp, lastdata, lastnum); 	/*prit(temp);*/  	//逆置输出数据 	pierpirt(temp); 	return 0; }

谢谢各位前辈。


Question: 菜鸟关于在vs2015上遇到的一个小问题

引用 2 楼 jianwen0529 的回复:你两个程序不一样的地方 一个用的是 scanf_s 一个用的是 scanf  前者要求传入一个指定大小的参数 我用vs2015 scanf不能用  他会叫我用scanf_s替换。这是为什么？

引用 1 楼 heyuhang112 的回复:scanf_s("%s", a);改成scanf_s("%s", &a, 20); 多谢，问题以解决。

http://blog.csdn.net/silleyj/article/details/8545408 scanf_s缺少参数。

引用 6 楼 jianwen0529 的回复:[quote=引用 5 楼 c_vs_noob 的回复:] [quote=引用 2 楼 jianwen0529 的回复:] 你两个程序不一样的地方 一个用的是 scanf_s 一个用的是 scanf  前者要求传入一个指定大小的参数 我用vs2015 scanf不能用  他会叫我用scanf_s替换。这是为什么？[/quote]  工程配置 -- C/C++ -- 常规 -- SDL checks 设置为No[/quote] 非常感谢！问题解决了！

引用 5 楼 c_vs_noob 的回复:[quote=引用 2 楼 jianwen0529 的回复:] 你两个程序不一样的地方 一个用的是 scanf_s 一个用的是 scanf  前者要求传入一个指定大小的参数 我用vs2015 scanf不能用  他会叫我用scanf_s替换。这是为什么？[/quote]  工程配置 -- C/C++ -- 常规 -- SDL checks 设置为No


Question: C# 提示当前上下文中不存在名称Dcommission

谢谢了。。跑错地方了

你的Dcommission定义在if里面，所以它的的作用域只在if里面，改成下面这样   double Dcommission = 0.0; if (tkSpecialCampaignIdRateMap.Trim() != "null") {           Dcommission = sdx(pid); //返回比例 }  还有，C#的问题最好到C#板块去问


Question: 问一个关于c语言的入门问题

((mount-m-n)/8.0) 计算后的值是5.5， 返回后变成5 printf打印转换成浮点型也就成5.0

你这个test函数返回的是int类型，即使函数内计算出来是5.500000，返回时会转换为int类型，返回5，然后这个返回值赋值给b，由于b是float型，会把int类型的5转变为float类型的5.000000赋值给b

改一下test返回值类型即可，改成float或者double。test的返回值为int类型，是现将float类型取整得5，然后又强制类型转换float给b，所以会得到5.00000; 这中间有两次类型转换，如果返回值直接是float或double就不会有中间的取整环节了。

注意test函数返回值类型

非常感谢大家! 我明白了(主要是点醒了我 之前也是知道函数前面的修饰符 修饰返回值类型 只是一叶障目 只记得return类型) (其实之前一直用js的) 今天看书还觉得自己发现问题 就是打印的时候%d之间加上修饰宽度/精度的值(比如%0.1就是宽度没有最小值 精度保留小数点后一位)没想到还是没想到点上 谢谢大家!  同时 6楼的朋友 我的理解是 函数前面的修饰符权重大于return的类型 或者说是强制转换为修饰符的类型 这应该是c和其他语言的不同(因为比如js都没有函数前的修饰符啊)

int test(float a[10])改为float test(float a[10])函数返回也存在类型转换

看了您的问题我也是不太理解为什么test返回的是int类型，感觉 return ((mount-m-n)/8.0);这里应该是返回至少是浮点数类型。 如果题主明白了，再帮我解答下可好，多谢


Question: C语言小白问一个关于printf函数的问题

明白了，我忘记替换的字符串也带有换行符，谢谢你！

"%s!C is cool!\n"   上面红色字符被替换成了："%s!C is cool!\n"  所以得到你图片的结果，因为后面是换行符，所以显示成了两行


Question: 编译traffic server 时怎样静态编译openssl

traffic server没用过, 最简单的方法是先把libcrypto.so libssl.so移动到别的地方, 这样编译的时候,编译器找不到动态库,就会去找静态库.


Question: dos下面调用程序出错！求大神解答

1.看看CPU等硬件的区别 2.有些品牌机有保护机制,不允许访问敏感区域数据

引用 3 楼 littlebeat123 的回复:运行脚本的时候有切换到脚本所在的目录吗？ 脚本所在目录已经是在环境变量里面了，这个关系应该不大，因为他报的错和直接调用报的错都是一样的

引用 2 楼 zhao4zhong1 的回复:需要在DosBox下运行？ 不是在DosBox下运行的，就是用ＰＸＥ启动进入的ＤＯＳ

引用 1 楼 lgbxyz 的回复:没太明白, 一个C程序中用system函数执行一个程序, DJGPP编译后的exe在DOS中执行,报OOM错误,BC编译后在DOS中能正确执行 ? excel调用的是DJGPP编译后的exe? 用system和execl调用的是一个外部程序，这个程序不知道是用什么编译器写的，这个程序叫image for dos，但是有一点很奇怪，就是如果不能调用的话在所有机器上都应该不能调用，但是有些机型能够调用，有些机型不能调用，试了几台机子过后，发现联想的笔记本基本都不能这样调用，而用其他笔记本是可以成功调用的，而且台式机和一体机也各试过一台，也是能够调用的。

运行脚本的时候有切换到脚本所在的目录吗？

需要在DosBox下运行？


Question: 求浮点值下溢实例

double d = 4.9406564584124654418e-324;   printf("%0.15f\n", d / 2.0);

（在C Primer Plus中说，以十进制为例，把一个有4位有效数字的数（如，0.1234E-10）除以10，得到的结果是0.0123E-10）  计算机里用的是二进制。 这个不是“实际”计算机里的例子。

可以理解成精度丧失, 不用太钻研这种没有的技巧,只要知道有这么一回事就行了   float toosmall = 0.1234E-43 / 10;  printf("%e\n", toosmall);


Question: C语言经典问题之哨兵难度提升

一楼的idx[k++]=i确实是精髓所在，但是不知道是不是我编译器问题 运行结果不一致啊

引用 1 楼 cfjtaishan 的回复:#include <stdio.h> #include <string.h>  #define     MAX_SIZE 10   int search_idx(const int *v, int *idx, int key, int n);  int main(void) {     int array[MAX_SIZE] = { 1, 7, 5, 7, 2, 4, 7};     int idx[MAX_SIZE], cnt, i;      memset(idx, -1, sizeof(idx));      cnt = search_idx(array, idx, 7, MAX_SIZE);      printf("total number: %d\n", cnt);     printf("idx list is:\n");     for (i = 0; i < MAX_SIZE; i++) {         if (idx[i] != -1)             printf("%d ", idx[i]);     }     putchar(10);      return 0; }  int search_idx(const int *v, int *idx, int key, int n) {     int i, k = 0;      for (i = 0; i < n; i++) {         if (v[i] == key)             idx[k++] = i;     }      return k; }楼主果然是厉害啊，这道题目最难的地方就在于正确储存idx数组的值，说白了这里最重要的一行代码就是idx[k++],这实在是太精彩了，感谢各位层主的大力支持

难度太大了，写不来。

#include <stdio.h> #include <stdlib.h>   int search_idx(const int v[] ,int** idx ,int key,int n); int main() { 	int j=0; 	int v[]={1,31,34,3,2,3,7}; 	int len=sizeof(v)/sizeof(int); 	int *p=NULL;     int i=0; 	j=search_idx(v,&p,3,len);  	for(i=0;i<j;i++) 	{ 		printf("p[%d]=%d",i,p[i]);  	}  	printf("hello..."); 	system("pause"); 	return 0; }  int search_idx(const int v[] ,int** idx ,int key,int n) { 	int* tmp=NULL; 	int count=0; 	int i=0; 	for(i=0;i<n;i++) 	{ 		if(v[i]==key) 		{ 			count++; 		} 	}  	if(count==0) 		return count; 	tmp=(int*)malloc(sizeof(int)*count); 	*idx=tmp;  for(i=0;i<n;i++) { 	if(v[i]==key) 	{ 		*tmp=i; 		tmp++; 	} } return count;  }


Question: memcpy内存复制

引用 8 楼 Armin_ 的回复:[quote=引用 7 楼 jianwen0529 的回复:] [quote=引用 4 楼 Armin_ 的回复:] 目的是通过socket send()发送出去，然后在另一端再解析。 有复杂的原因我必须这样先转化然后再解析。我的目的就是想把他们变成一段连续的内存。  sprintf(buf, "%d", c); //socket.send(buf) //socket.revc(buf) int i = atoi(buf);  这样子使用会不会好一些？  或者如同6L的，不要用strlen，依据revc参数中接收到的字节数判断[/quote] 我用strlen只是想判断一下有多少个字节数。 突然又发现一个问题。 如果这样char buf[1024]; strlen(buf) 为什么结果是1呢。[/quote]  一个int变量4个字节，值为1，二进制是0x00000001，小端字节序，在内存中反过来存储：0x01 0x00 0x00 0x00,用strlen去判断，结果是1

引用 10 楼 user-4 的回复:strlen是检测到0为止  所以你要看这些数据在内存二进制是什么，然后就知原因了 恩恩 找到原因了谢谢！

引用 7 楼 jianwen0529 的回复:[quote=引用 4 楼 Armin_ 的回复:] 目的是通过socket send()发送出去，然后在另一端再解析。 有复杂的原因我必须这样先转化然后再解析。我的目的就是想把他们变成一段连续的内存。  sprintf(buf, "%d", c); //socket.send(buf) //socket.revc(buf) int i = atoi(buf);  这样子使用会不会好一些？  或者如同6L的，不要用strlen，依据revc参数中接收到的字节数判断[/quote] 我用strlen只是想判断一下有多少个字节数。 突然又发现一个问题。 如果这样char buf[1024]; strlen(buf) 为什么结果是1呢。

引用 4 楼 Armin_ 的回复:目的是通过socket send()发送出去，然后在另一端再解析。 有复杂的原因我必须这样先转化然后再解析。我的目的就是想把他们变成一段连续的内存。  sprintf(buf, "%d", c); //socket.send(buf) //socket.revc(buf) int i = atoi(buf);  这样子使用会不会好一些？  或者如同6L的，不要用strlen，依据revc参数中接收到的字节数判断

strlen使用对象是字符串，对其他类型的使用结果不一定相同； 另外， 如果想把其他类型的数据拷贝到buf(char类型），直接memcpy即可，如果将buf的数据换回其他类型，直接反向memcpy，即将memcpy的前两个参数互换一下；或者直接类型转换，如下： #include <stdio.h> #include <string.h>  int main(void) {     int num = 5, tmp, num2;     char buf[32];      memcpy(buf, &num, sizeof(num));      memcpy(&tmp, buf, sizeof(tmp));     num2 = *(int *)buf;     printf("tmp = %d\n", tmp);     printf("num2 = %d\n", num2);      return 0; }

strlen是针对字符串的函数 在发送端是怎么序列化的，接收端就怎么反序列化。

引用 3 楼 jianwen0529 的回复:[quote=引用 2 楼 Armin_ 的回复:] [quote=引用 1 楼 jianwen0529 的回复:] int float double 的存储结构导致的  int的存储的是 0x00000001 那么复制到buf就是 1000 sizeof(int) 大小，这里假定是4字节  strlen是依据 '\0' 结束的，那么计算出来就是1了  至于float double（3.0,5.0）第一个byte就是 0 了，那么长度自然是 0 平台不懂，存储的结构并不一致，不便多讨论，你换个数字可能就不一样的结果了  memcpy是按字节拷贝的，所以你以上的用法是有明显缺陷的，不建议这样子使用 尽量只对一块整体的内存或者char*使用 谢谢！ 那我应该怎样将这这几种数据类型拷贝到char[]中？[/quote]  首先你拷贝到char[]的目的是什么？ 知道目的，才能设计过程。 这种法子不是不行，只是得看你这样子做的目的了[/quote]  目的是通过socket send()发送出去，然后在另一端再解析。 有复杂的原因我必须这样先转化然后再解析。我的目的就是想把他们变成一段连续的内存。

引用 2 楼 Armin_ 的回复:[quote=引用 1 楼 jianwen0529 的回复:] int float double 的存储结构导致的  int的存储的是 0x00000001 那么复制到buf就是 1000 sizeof(int) 大小，这里假定是4字节  strlen是依据 '\0' 结束的，那么计算出来就是1了  至于float double（3.0,5.0）第一个byte就是 0 了，那么长度自然是 0 平台不懂，存储的结构并不一致，不便多讨论，你换个数字可能就不一样的结果了  memcpy是按字节拷贝的，所以你以上的用法是有明显缺陷的，不建议这样子使用 尽量只对一块整体的内存或者char*使用 谢谢！ 那我应该怎样将这这几种数据类型拷贝到char[]中？[/quote]  首先你拷贝到char[]的目的是什么？ 知道目的，才能设计过程。 这种法子不是不行，只是得看你这样子做的目的了

引用 1 楼 jianwen0529 的回复:int float double 的存储结构导致的  int的存储的是 0x00000001 那么复制到buf就是 1000 sizeof(int) 大小，这里假定是4字节  strlen是依据 '\0' 结束的，那么计算出来就是1了  至于float double（3.0,5.0）第一个byte就是 0 了，那么长度自然是 0 平台不懂，存储的结构并不一致，不便多讨论，你换个数字可能就不一样的结果了  memcpy是按字节拷贝的，所以你以上的用法是有明显缺陷的，不建议这样子使用 尽量只对一块整体的内存或者char*使用 谢谢！ 那我应该怎样将这这几种数据类型拷贝到char[]中？


Question: HC-05蓝牙串口接收数据丢失问题

不懂你的问题,但是有点建议 1.输出数据的最大速率是多少 2串口的波特率是多少,能否满足输出的要求 3.输入端处理的最小速率是多少,能否满足处理全部输入数据


Question: C语言中fread和fcanf从文件读取数据的区别

fwrite和fread是以整体作为单位进行读取/写入，一般是一次读取/写入一个结构体大小的块； fscanf和fprintf是格式化的读写；类型printf/scanf，读写的都是基本类型数据，所以对于一个结构体，一次需要按照类型分别读取其中的元素；  另外，对于文件末尾判定；fscanf是以EOF作为判定， fread使用feof函数判定。

先看x,假定CPU是32位，这是int长度就是4字节。x的存放是这样的：（x86）  06 00 00 00 01 00 00 00 02 00 00 00..... 你用fwrite写文件，写入了3个int，也就是写入12个字节。完成后你看txt文件大小是12字节。 fread读一个int，把06 00 00 00读了出来。 这个txt文件是二进制文件，你type test.txt看到的是乱码。  fprintf写文件的话是按ASCII字符写的，写入文件的实际内容是“612”字符串，这个test.txt文件是type看到的。scanf取int时，碰到第一个非数字字符结束，然后将字符串转换为int因此是612。 你把fprintf中的%d之间加个空格，就可以看到scanf读一个int，应该也读到6，而不是612。

前者是整块内容读入 后者是格式化读入，一般处理文本


Question: posix多线程程序设计 第一个小程序

谢谢！！！你们都完美解决了。。。

http://www.360doc.com/content/12/0807/17/8006573_228871199.shtml 仿照这个err_exit写，或者直接改一下名，err_exit改成err_abort

引用 2 楼 cfjtaishan 的回复:该文件看看是否在书的最后面，看看书的目录？如果没有，建议从网上找一下。 最简单的方法就是自定义err_abort,然后把头文件errors.h引用去掉。 类似这样的： void err_abort(int status, const char *msg, ...) {   va_list ap;   va_start(ap, msg); #if HAVE_VSYSLOG   if(_syslog) {             vsyslog(LOG_ERR, msg, ap);     } else #endif           vprintf(msg, ap);   va_end(ap);   exit(1); } 缺点是我没有对status参数处理。 另外，记着加上头文件#include <stdarg.h>

这个是书上自定义的头文件，你可能需要去下载


Question: 顺序栈的创建

稍微修改了下，你试试  void create(Stack *S, int stacksize) {     S->base = (int*)malloc((stacksize+1)*sizeof(int)); //多分配一个空间     if (!S->base)         exit(0);     S->top = S->base; //base中不放置栈元素，用于判断空栈等     S->size = stacksize; }  void push(Stack *S, int elem) {     if (S->top - S->base >= S->size)     {         S->base = (int*)realloc(S->base, (S->size + 1 + 10)*sizeof(int)); //多分配一个空间         if (!S->base)             exit(0);         S->top = S->base + S->size;         S->size += 10;     }     *(++S->top) = elem; }  void pop(Stack *S) {     int popnum;     if (S->top == S->base)     {         printf("栈空");         return;     }     popnum = *(S->top--);     printf("%d", popnum); }

好多问题  1：  void push(Stack*S,int elem) { if(S->top - S->base>=S->size) {        S->base=(int*)realloc(S->base,(S->size+10)*sizeof(int));    if(!S->base)    exit(0);    S->top=S->base+S->size;    S->size+=10; } *S->top++ = elem; //你的栈顶永远指向真实栈顶的下一个地方 }  2： void push(Stack*S,int elem) { if(S->top - S->base>=S->size) //这个判断，除非发生在你数组已经越界的情况下 {        S->base=(int*)realloc(S->base,(S->size+10)*sizeof(int));    if(!S->base)    exit(0);    S->top=S->base+S->size;    S->size+=10; }  3：  void show(Stack*S) {    printf("The stack is:");    while(S->top!=S->base)    {    printf("%d  ",*S->top--); //你循环打印一遍，top一直减到栈顶，下一次你还怎么取得栈顶元素？    }    printf("\n");  }

#include <stdio.h> #include<stdlib.h>  #define MAXSIZE 10  typedef struct stack {     int *top;     int *base;     int size; }Stack;  enum {     PUSH = 1,     POP,     EXIT };  Stack *create(void) {     Stack *s = (Stack *)malloc(sizeof(Stack));     if (!s) {         fprintf(stderr, "%d, %smalloc error!\n", __LINE__, __func__);         return NULL;     }     s->base = NULL;     s->top = NULL;     s->size = 0;      return s; } int is_empty(Stack *s) {     if (s->size == 0)         return 1;     else         return 0; } int is_full(Stack *s) {     if (s->size >= MAXSIZE)         return 1;     else         return 0; }  void push(Stack *s, int elem) {     if (is_full(s)) {         fprintf(stdout, "stack is full!\n");         return;     }     s->base = (int *)realloc(s->base, (s->size +1) * sizeof(int));     if (!(s->base)) {         fprintf(stderr, "%d, %smalloc error!\n", __LINE__, __func__);         return;     }     //printf("s->size = %d\n", s->size);     //printf("s->base = %p\n", s->base);     *(s->base + s->size) = elem;     s->top = s->base + s->size+1;     //printf("len = %lu\n", (s->size+1)*sizeof(int));     //printf("s->top = %p, s->base = %p\n", s->top, s->base);     s->size += 1; }  void pop(Stack *s, int *elem) {     if (is_empty(s)) {         fprintf(stdout, "stack is empty!\n");         return;     }     *elem = *(s->top - 1);     s->top -= 1;     s->size--; }  void show(Stack *s) {     printf("stack list: \n");     while (s->base != s->top - 1) {         printf("%d\t", *(s->top - 1));         s->top -= 1;     }     printf("%d\n", *(s->base)); } static void menu(void) {         printf("-----------------------------------------------\n");         printf("                main     menu                  \n");         printf("             1    ---   入栈（Update）         \n");         printf("             2    ---   出栈（Delete）         \n");         printf("             3    ---   退出（ exit ）         \n");         printf("-----------------------------------------------\n");         printf("请输入所要进行的操作序号:  "); }  int main(void) {     Stack *s = NULL;     int num;     int ch;      s = create(); #if 0     while (1) {         menu();         scanf("%d", &ch);         switch (ch) {             case PUSH:                 printf("Please input a number: ");                 scanf("%d", &num);                 push(s, num);                 break;              case POP:                 pop(s, &num);                 printf("num = %d\n", num);                 break;              case EXIT:                 exit(0);                 break;              default:                 fprintf(stdout, "Error input!\n");                 break;         }     }  #else     while (scanf("%d", &num) && num > 0) {         push(s, num);     }     while (!is_empty(s)) {         pop(s, &num);         printf("num = %d\n", num);     } #endif     return 0; }  /* void create(Stack *S, int stacksize) {     S->base = (int*)malloc(stacksize*sizeof(int));     if(!S->base)         exit(0);     S->top = S->base;     S->size = stacksize; } void push(Stack *S, int elem) {     if(S->top - S->base >= S->size)     {         S->base=(int*)realloc(S->base,(S->size+10)*sizeof(int));         if(!S->base)             exit(0);         S->top = S->base + S->size;         S->size+=10;     }     *S->top++ = elem; } void pop(Stack*S) {     int popnum;     if(S->top == S->base) {         printf("栈空");         return;     }     popnum= *(--S->top);     printf("%d",popnum);  } void show(Stack*S) {     printf("The stack is:");     while(S->top!=S->base)     {         printf("%d  ",*S->top--);     }     printf("\n");  } int main() {     Stack SS;     //create(&SS,MAXSIZE);     int j;     do     {         printf("       -----------------------------------------------\n");      //显示一个简易菜单         printf("                       main     menu                  \n");         printf("                     1      ---     创建（Insert）     \n");         printf("                    2      ---     入栈（Update）     \n");         printf("                     3      ---     出栈（Delete）     \n");         printf("                     4      ---     退出（ Show ）     \n");         printf("        ---------------------------------------------\n");         printf("请输入所要进行的操作序号:  ");          scanf("%d",&j);         switch(j)         {             case 1:                 {                     create(&SS, MAXSIZE);                     printf("创建成功；");                     break;                 }             case 2:                 {                     printf("请输入要入栈的值:");                     int pushnum;                     scanf("%d",&pushnum);                     //printf("%d",popnum);                     push(&SS,pushnum);                     show(&SS);                     break;                 }             case 3:                 {                     pop(&SS);                     show(&SS);                     break;                 }             case 4:                 {                     break;                 }         }     } while(j!=4);      return 0; } */  另一种实现方法，建议去搜一下栈的类型，栈可以分为不同类型，基本上分为：空递增，满递增，空递减，满递减。 作为一个参考吧

单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。

初学者 ，请大家多赐教。。。


Question: c语言语法问题

引用 2 楼 jianwen0529 的回复:警告而已 你这样子写 char p[] = "XXXXXXXXXXXXXXXXXXXX"; const *p = "XXXXXXXXXXXXXXXXXXX"; 是const char *p = "XXXXXXXXXXXXXXXXXXX";

先把文件扩展名改成c再说。人家编译器是按c++处理的。


Question: 报错提示类型不兼容，为什么错了啊

形式参数是DataType，实际参数是StudentType，二者不同


Question: 关于数组的问题，各位大神指点迷津

在一楼的基础上进行的修改 #include<stdio.h> int main(void) { 	int ss[3]; 	int STR[9]; 	int i, count;  	for (i = 0, count = 0; i == count; i++)//判断用户输入的字符个数 	{ 		scanf_s("%d", &ss[i]); 		 		if (getchar() == ' ') 			count++;  	} 	count++;//count表示用户输入有几个数字 	 	for (i = 0; i < 3; i++)//由用户输入的值给STR赋值 	{ 		switch (ss[i]) 		{ 		case 1:   			STR[i * 3 ] = 'A'; 			STR[i * 3 + 1] = 'B'; 			STR[i * 3 + 2] = 'C'; 			break; 		case 2: 			STR[i * 3 ] = 'D'; 			STR[i * 3 + 1] = 'E'; 			STR[i * 3 + 2] = 'F'; 			break; 		case 3: 			STR[i * 3 ] = 'H'; 			STR[i * 3 + 1] = 'J'; 			STR[i * 3 + 2] = 'K'; 			break; 		default: 			break;  		} 		  	}  	for (i = 0; i < 3 * count; i++)//输出 		printf("%c ", STR[i]); 	 }

#include <stdio.h> #include <time.h> #include <stdlib.h>  #define ROW 3 #define COL 3   void init_str(char (*pstr)[COL], int row, int col); void show_str(char (*pstr)[COL], int row, int col);  int main(void) {     char str[ROW][COL];     int num[ROW], i, j;      init_str(str, ROW, COL);      srand(time(NULL));     for (i = 0; i < ROW; i++) {         num[i] = rand() % ROW;     }     for (i = 0; i < ROW; i++) {         if (num[i] <= 0)             continue;         printf("num = %d\t: ", num[i]);         for (j = 0; j < COL; j++)             printf("%c ", str[num[i]-1][j]);         putchar(10);     }      return 0; }  void init_str(char (*pstr)[COL], int row, int col) {     int i, j;     int ch = 'A';      for (i = 0; i < row; i++)         for (j = 0; j < col; j++)             pstr[i][j] = ch++; }  void show_str(char (*pstr)[COL], int row, int col) {     int i, j;      for (i = 0; i < row; i++) {         for (j = 0; j < col; j++)             printf("%c ", pstr[i][j]);         putchar(10);     }     putchar(10); }  作为一个参考吧

#include <stdio.h>  #define SIZE_ARRAY 9  int main()  {     int SS[] = { 2, 1, 3 };     int nSize = sizeof(SS) / sizeof(int);      int STR[SIZE_ARRAY] = { 0 };     for (int i = 0; i < nSize; i++)     {         switch (SS[i])         {         case 1:             STR[i * 3] = 'A';             STR[i * 3+1] = 'B';             STR[i * 3+2] = 'C';             break;         case 2:             STR[i * 3] = 'D';             STR[i * 3 + 1] = 'E';             STR[i * 3 + 2] = 'F';             break;         case 3:             STR[i * 3] = 'G';             STR[i * 3 + 1] = 'H';             STR[i * 3 + 2] = 'I';             break;         default:             break;         }     }      for (int i = 0; i < nSize ; i++)     {         printf("%c %c %c\n", STR[i * 3], STR[i * 3 + 1], STR[i * 3 + 2]);     }      return 0; }


Question: C语言程序 关于ABRACADABRA language 麻烦大家帮忙写一写！！！谢谢

#include <stdio.h> #include <stdlib.h> #include <string.h>  int encrypt_word(char* in, char* out, char* key) { 	int i = 0, j = 0;  	for (j = 0; j < strlen(in); j++) { 		switch (in[j]) { 		case 'a': 			out[i++] = key[0]; 			break; 		case 'b': 			out[i++] = key[1]; 			break; 		case 'c': 			out[i++] = key[2]; 			break; 		case 'd': 			out[i++] = key[3]; 			break; 		case 'r': 			out[i++] = key[4]; 			break; 		default: 			return -1; 		} 	}  	return 0; }  int main(int argc, char *argv[]) { 	 	char key[8]; 	char word[8] = {0}; 	char encrpt_word[8] = {0}; 	 	printf("Enter key: "); 	scanf("%s", key); 	//verfiy key 	 	printf("Enter word: "); 	scanf("%s", word); 	if (strlen(word) != 7) {//The word should consist of seven letters 		printf("You did not speak in ABRACADABRA to me!\n"); 		return 127; 	}		 	if (encrypt_word(word, encrpt_word, key) != 0) { 		printf("You did not speak in ABRACADABRA to me!\n"); 		return 127; 	} 	else { 		printf("Encrypted word: %s\n", encrpt_word); 	} 	return 0;


Question: C语言程序设计

所有的条件都要成立才行啊，又不是一个满足就行了，多交流，我也是学C的。http://m.blog.csdn.net/article/details?id=55061737

条件用的不对，应该是没弄清楚逻辑符号。

if(x%5==1 && x%6==5 && x%7==4 &&x%11==10)判断条件是否为真，&&若x%5==1为真，还需要判断后面的表达式是否为真，很明显x%6==5为假，所以不会输出1； 若改成||，则输出1，  if(x%5==1 || x%6==5 || x%7==4 || x%11==10)

不知道楼主为什么觉得会输出1 第一个满足x % 5 == 1 && x % 6 == 5 && x % 7 == 4 && x % 11 == 10的数是2111 因为还会在进行一次++，所以输出的是2112 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。


Question: syntax error : identifier 'income'

编译错误，查阅源代码

#include "wallet.h"  检查下看你这个文件在那放着

wallet income(wallet w) {     int i, year;    /*少个逗号*/     wallet salary=0;      printf("choose type of job\n1.easy \2.nnormal\n3.advance\n");     scanf("%d",&i);     printf("how many years do you want stay?");     scanf("%d", &year);    /*少个分号*/     while(salary==0){         switch(i){             case 1:salary=100;break;             case 2:salary=200;break;             case 3:salary=300;break;             default:printf("you idiot!there are only 3 kinds of job ,choose again!");         }     }     w=w+salary*year;     return w; }  另外，应该在头文件里有一个typedef int wallet;的语句； 基本C语言语法还需要加强一下；

你这个根本不是个程序

wallet是什么？前面有typedef walley xxx; 吗？应该有才对

e:\课程资料\2015年春大一下\c语言程序设计\题目\4  关于头文件的使用\money\earnmoney.h(3) : error C2061: syntax error : identifier 'income' e:\课程资料\2015年春大一下\c语言程序设计\题目\4  关于头文件的使用\money\earnmoney.h(3) : error C2059: syntax error : ';' e:\课程资料\2015年春大一下\c语言程序设计\题目\4  关于头文件的使用\money\earnmoney.h(3) : error C2146: syntax error : missing ')' before identifier 'w' e:\课程资料\2015年春大一下\c语言程序设计\题目\4  关于头文件的使用\money\earnmoney.h(3) : error C2061: syntax error : identifier 'w' e:\课程资料\2015年春大一下\c语言程序设计\题目\4  关于头文件的使用\money\earnmoney.h(3) : error C2059: syntax error : ')' E:\课程资料\2015年春大一下\C语言程序设计\题目\4  关于头文件的使用\money\earnMoney.c(3) : error C2061: syntax error : identifier 'income' E:\课程资料\2015年春大一下\C语言程序设计\题目\4  关于头文件的使用\money\earnMoney.c(3) : error C2059: syntax error : ';' E:\课程资料\2015年春大一下\C语言程序设计\题目\4  关于头文件的使用\money\earnMoney.c(3) : error C2146: syntax error : missing ')' before identifier 'w' E:\课程资料\2015年春大一下\C语言程序设计\题目\4  关于头文件的使用\money\earnMoney.c(3) : error C2061: syntax error : identifier 'w' E:\课程资料\2015年春大一下\C语言程序设计\题目\4  关于头文件的使用\money\earnMoney.c(3) : error C2059: syntax error : ')' E:\课程资料\2015年春大一下\C语言程序设计\题目\4  关于头文件的使用\money\earnMoney.c(4) : error C2449: found '{' at file scope (missing function header?) E:\课程资料\2015年春大一下\C语言程序设计\题目\4  关于头文件的使用\money\earnMoney.c(18) : error C2059: syntax error : '}' 执行 cl.exe 时出错.


Question: 矩阵转置出现的问题

非常感谢两位,问题已解决!

#include<stdio.h> #include<malloc.h>  int * tranverse(int * p,int row,int col) {     int i, j;      int *s=(int *)malloc(row*col*sizeof(int));      for(i=0;i<col;i++)         for(j=0;j<row;j++)             *(s+i*row+j)=*(p+j*col+i);     return s;  }  void print_matrix(int *arr, int row, int col) {     int i, j;      for(i = 0; i < row; i++) {         for(j = 0; j < col; j++)             printf("%d ", *(arr+i*col+j));         printf("\n");     }     printf("\n"); }  int main(void) {     int i,j;     int row = 2, col = 3;      int *p = (int *)malloc(row*col*sizeof(int));     if (!p) {         fprintf(stderr, "malloc error!\n");         return -1;     }     printf("请输入矩阵数据\n");     for(i = 0; i < row; i++)         for(j = 0; j < col; j++)             scanf("%d", p+i*col+j);      printf("输入的矩阵为:\n");     print_matrix(p, row, col);      int *s;     s = tranverse(p,row,col);     printf("转置后的矩阵为:\n");     print_matrix(s, col, row);      printf("\n");     free(p);     free(s);     return 0; }  显示输入的矩阵时，打印的是错误的。因为换行的条件出错了；你输入的是2行3列，所以输出的也应该是2行3列。 转置没有问题，输出时也是需要注意，行和列对换；申请的空间记着释放。 最后，建议注意一下代码风格。

1.转置后输出的应该是printf("%d ", *(s + i*row + j)); 2.你的tranverse或者是你输出的循环有问题，自己再看看 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。


Question: c 结构体中包含同类结构体

感谢回复！

因为第一种的声明实际上是一个无限循环，分配内存的时候会无限嵌套，无法确定大小，所以是错的，但可以包含指向这种类型结构体的指针

引用 1 楼 qq423399099 的回复:sss属于不完整的类型。 定义对象之前，编译器必须看到完整的类定义  （1）使用不完整类型的话，我们也就只能使用指向该不完整类型的指针了，因为指针类型是平台相关的，即在特定的平台上指针变量的大小是已知的。 （2）在不完整类型还没有完整之前，sizeof操作符是获取不了该类型的大小的。 （3）头文件中我们也是不可以使用inline函数的，因为类型是不完整的，在inline函数中如果访问成员的话，编译器会报错。 赞成楼主，第一种写法属于自己不知道自己长什么样子

结构体内不能包含自己本身，如果包含的话编译器不知道变量体的变量，可以包含自身的指针，指针占4个字节。

指针类型在声明变量时，不会为变量对象分配空间，只会检查类型  实体类型，分配空间，所以出错

struct sss {     int key;     sss LLLL;     sss RRRR; };这种声明是错误的，因为这种声明实际上是一个无限循环，成员A是一个结构体，A的内部还会有成员是结构体，依次下去，无线循环。在分配内存的时候，由于无限嵌套，也无法确定这个结构体的长度，所以这种方式是非法的。 struct sss {     int key;     sss* LLLL;     sss* RRRR; }; 由于指针的长度是确定的（在32位机器上指针长度为4），所以编译器能够确定该结构体的长度。


Question: 为什么在codeblock里找不到project了

左下角的小黑三角试试


Question: 奇怪的C语法， 有谁见过这样写函数形参的吗？

引用 17 楼 fefe82 的回复:[quote=引用 14 楼 lin5161678 的回复:] [quote=引用 12 楼 fefe82 的回复:] 这确实是一种非常古老的写法，但是即使是在 C11 ，这也是一种标准支持的合法的写法。  ========================= C++ 没有这种写法。  C11 支持这个写法吗? 我好像没看到 写在哪?[/quote]  ISO/IEC 9899 2011 6.9.1 Function definitions Syntax 1 function-definition: declaration-specifiers declarator declaration-list(opt) compound-statement declaration-list: declaration declaration-list declaration Constraints 2 The identifier declared in a function definition (which is the name of the function) shall have a function type, as specified by the declarator portion of the function definition.162) 3 The return type of a function shall be void or a complete object type other than array type. 4 The storage-class specifier, if any, in the declaration specifiers shall be either extern or static. 5 If the declarator includes a parameter type list, the declaration of each parameter shall include an identifier, except for the special case of a parameter list consisting of a single parameter of type void, in which case there shall not be an identifier. No declaration list shall follow. 6 If the declarator includes an identifier list, each declaration in the declaration list shall have at least one declarator, those declarators shall declare only identifiers from the identifier list, and every identifier in the identifier list shall be declared. An identifier declared as a typedef name shall not be redeclared as a parameter. The declarations in the declaration list shall contain no storage-class specifier other than register and no initializations.   13 EXAMPLE 1 In the following: extern int max(int a, int b) { return a > b ? a : b; } extern is the storage-class specifier and int is the type specifier; max(int a, int b) is the function declarator; and { return a > b ? a : b; } is the function body. The following similar definition uses the identifier-list form for the parameter declarations: extern int max(a, b) int a, b; { return a > b ? a : b; } Here int a, b; is the declaration list for the parameters. The difference between these two definitions is that the first form acts as a prototype declaration that forces conversion of the arguments of subsequent calls to the function, whereas the second form does not.[/quote] 多谢  学习了

引用 9 楼 lin5161678 的回复:[quote=引用 5 楼 zhu339111520 的回复:] 编译不报错，逗么 然而真的可能不报错 比较古老的写法 已经废弃 但还有一些比较古老的编译器能看懂[/quote]确实是这样的，所以才纳闷，我都写了好几年的代码，都没看过这种写法

引用 14 楼 lin5161678 的回复:[quote=引用 12 楼 fefe82 的回复:] 这确实是一种非常古老的写法，但是即使是在 C11 ，这也是一种标准支持的合法的写法。  ========================= C++ 没有这种写法。  C11 支持这个写法吗? 我好像没看到 写在哪?[/quote]  ISO/IEC 9899 2011 6.9.1 Function definitions Syntax 1 function-definition: declaration-specifiers declarator declaration-list(opt) compound-statement declaration-list: declaration declaration-list declaration Constraints 2 The identifier declared in a function definition (which is the name of the function) shall have a function type, as specified by the declarator portion of the function definition.162) 3 The return type of a function shall be void or a complete object type other than array type. 4 The storage-class specifier, if any, in the declaration specifiers shall be either extern or static. 5 If the declarator includes a parameter type list, the declaration of each parameter shall include an identifier, except for the special case of a parameter list consisting of a single parameter of type void, in which case there shall not be an identifier. No declaration list shall follow. 6 If the declarator includes an identifier list, each declaration in the declaration list shall have at least one declarator, those declarators shall declare only identifiers from the identifier list, and every identifier in the identifier list shall be declared. An identifier declared as a typedef name shall not be redeclared as a parameter. The declarations in the declaration list shall contain no storage-class specifier other than register and no initializations.   13 EXAMPLE 1 In the following: extern int max(int a, int b) { return a > b ? a : b; } extern is the storage-class specifier and int is the type specifier; max(int a, int b) is the function declarator; and { return a > b ? a : b; } is the function body. The following similar definition uses the identifier-list form for the parameter declarations: extern int max(a, b) int a, b; { return a > b ? a : b; } Here int a, b; is the declaration list for the parameters. The difference between these two definitions is that the first form acts as a prototype declaration that forces conversion of the arguments of subsequent calls to the function, whereas the second form does not.

不要用不常用的写法，否则移植可能会出问题

引用 12 楼 fefe82 的回复:这确实是一种非常古老的写法，但是即使是在 C11 ，这也是一种标准支持的合法的写法。  ========================= C++ 没有这种写法。  C11 支持这个写法吗? 我好像没看到 写在哪?

老式C语言写法

哈哈~我还这么写过。。。不过我可不老~你的教材可以扔掉了~

老式的 c 语法，比大部分这里回帖的都老。

引用 5 楼 zhu339111520 的回复:编译不报错，逗么 然而真的可能不报错 比较古老的写法 已经废弃 但还有一些比较古老的编译器能看懂

这不是标准的c++

因为C语言没有函数重载，所以函数形参可以放在外面，但这不是标准的C

const char * inet_ntop(int af, const void* src, char* dst, size_t size) { 	switch (af) { 	case AF_INET: 		return (inet_ntop4(src, dst, size)); 	case AF_INET6: 		return (inet_ntop6(src, dst, size)); 	default: 		errno = EAFNOSUPPORT; 		return (NULL); 	} 	/* NOTREACHED */ }   这才是c语法

编译不报错，逗么

可读性还是需要考虑的

不好理解的代码；建议不要学，更不要写；因为自己写出来的代码如果都读不懂，如何让别人阅读。

K&R C Style

扔了你那些资料，应该超30年了。 C语言标准出来之前的语法。


Question: 打开文件并输出数据出现乱码怎么破

楼主对文件的概念还要加强。用文本编辑器编写的是ascii文件，比如看到的是数字1001，实际存放的是ascii码值，0x31 0x30 0x30 0x31。 而用fread往buf里读的话是按数据文件方式读的。 楼主试下把fread改成fscanf，类似：  fscanf(fp, "%s%d%d%s",  stud[i].name, &stud[i].nun, &stud[i].age, stud[i].addr  另外stud结构中的num和age为什么是数组？一个学生难道有5个年龄？name也短了点吧。地址也太短了。

楼上说的有道理，你的num和age不需要定义成数组形式，name和addr又定义的太小，越界可能覆盖到一些别的信息，导致输出结果不对

楼上说的都对，我也是学C的，多交流。http://m.blog.csdn.net/article/details?id=55061737

数据结构中name和addr定义的长度太小；文件中的name和addr已经越界；另外，文件中age和num都是一个值； 建议使用fscanf和fprintf对文件进行读写；fread和fwrite是二进制形式的读写   #define    MAX_NAME_LEN    32 #define    MAX_ADDR_LEN    32  struct student_type {     char name[MAX_NAME_LEN];     int num;     int age;     char addr[MAX_ADDR_LEN]; };

引用 楼主 baidu_37516993 的回复:我想打开一个文件，输出其中的数据  这是我要打开的文件  运行之后出现乱码  请问要怎么修改      问题不在于乱码,而是你那个结构体的定义,你每次对文件进行seek操作,但是你内容的实际大小并没有那么大,或者加上空格之后已经远超这个限制,导致内存错乱,字符就乱了,你可以先实现readline功能,给你一个demo    #include <stdlib.h> #include <stdio.h>  char* readline(FILE* f) {     char* line = (char*) calloc(1, sizeof(char) );;     char c;     int len = 0;          while ( (c = fgetc(f) ) != EOF && c != '/n')     {         line = (char*) realloc(line, sizeof(char) * (len + 2) );         line[len++] = c;         line[len] = '/0';     }       return line; }


Question: 求助：两个一样的上锁函数会存在什么问题？

按不同顺序加锁有导致死锁的风险..

锁这个名字没觉得起的很好么，  你给你自行车上了两把锁，有什么毛病么

注意上锁和开锁的顺序，尤其是在锁嵌套的时候； 你的两个函数里只写的加锁，没有释放锁的操作呢

引用 楼主 l00110228 的回复:void lock_1(char * A, char * B) { mutux_lock(A); mutux_lock(B); }  void lock_2(char * A, char * B) { mutux_lock(B); mutux_lock(A); }  这两个函数在锁顺序上有不同，这两个函数如果调用不当，会有影响吗？  多谢。  没有影响,两个锁相互独立,没有依赖关系


Question: 找不到错误啊syntax error : missing ';' before 'type'

注意括号匹配，可以找个自动对齐的ide

#include <stdio.h>  int my_factorial(int i); double my_power(double x, int y);  int my_factorial(int i) {     int ans = 1, k;      if(i == 0) {         ans = 1;     } else {         for(k=1;k<=i;k++)             ans=ans*k;     }//阶乘      return ans; } double my_power(double x, int y) {     int i, ans = 1;      for(i = 1; i <= y; i++)         ans=ans*x;      return(ans); }  double my_expTaylor(double x, unsigned int n) {     double ans = 0,i;      for(i = 0; i <= n; i++)         ans = ans + my_power(x,i) / my_factorial(i);      return(ans); } int main() {     float x = 2.0, n;      for(n = 0; n <= 9; n++) {         printf("%lf\n", my_expTaylor(x,n));     }     return 0; }  少一个}，在第一个函数里对应else； 出现这样的错误跟代码风格我感觉有一定的关系；所以建议养成一个良好的代码风格，不要把代码写的太紧凑，改换行的还是要换行。代码写出来更多是让自己和别人读的。 另外，main函数里的回车符是\n，不是/n，也一并改了。

括号在使用的时候最好{ } 一起打出来。。。然后再在中间编写代码～ 而且注意换行，，

#include <stdio.h> int my_factorial(int i) { int ans=1,k; if(i==0){ans=1;} else {for(k=1;k<=i;k++) {ans=ans*k;} return(ans); }//阶乘 少了一个}   所以要注意代码格式  #include <stdio.h> int my_factorial(int i) { int ans=1,k; if(i==0) {     ans=1; } else  {     for(k=1;k<=i;k++)     {         ans=ans*k;     } }//这里少了 return(ans); }//阶乘

int my_factorial(int i) {   int ans=1,k;   if(i==0)   {     ans=1;   }   else {     for(k=1;k<=i;k++)       {       ans=ans*k;        }       return(ans);       }//阶乘  看吧，函数结尾是不是少了}  编码习惯要好好培养一下啊

#include <stdio.h>  int my_factorial(int i) {     int ans=1,k;     if(i==0){         ans=1;     }     else {         for(k=1;k<=i;k++){             ans=ans*k;         }     }     return(ans); }//阶乘 double my_power(double x,int y) {     int i,ans=1;     for(i=1;i<=y;i++){         ans=ans*x;     }     return(ans); }  double my_expTaylor(double x,unsigned int n) {     int my_factorial(int i);     double my_power(double x,int y);     double ans=0,i;     for(i=0;i<=n;i++){         ans=ans+my_power(x,i)/my_factorial(i);     }     return(ans); } int main() {     float x=2.0,n;     for(n=0;n<=9;n++){         printf("%f/n",my_expTaylor(x,n));     }     return 0; }


Question: 用c语言操作文件，损坏了文件，是什么原因？

感觉这个文档格式就不对吧。

读WORD不能用fopen http://msdn.microsoft.com/en-us/library/Aa155776 http://book.51cto.com/art/200806/76629.htm

在Linux下运行你的程序没有问题，输出123 456，这跟系统还是有关系的。因为Windwos和Linux的回车格式不同。 建议你先创建好文件，然后去读试试。

直接用C语言操作word文档可能不行，你换成txt试一试

首先，doc是微软的一种文档格式，里面存储的格式并不是简单的TXT格式  如果你需要读写doc，那你需要使用专门的接口或者组件

你这样创建的 啦啦.docx 并不是一个WORD格式文档，用WORD打开肯定提示格式不对或文件损坏。


Question: 关于c语言auto求简单的能理解的代码

C++ 98标准/C++03标准： 同C语言的意思完全一样：auto被解释为一个自动存储变量的关键字，也就是申明一块临时的变量内存。  C++ 11标准： 在C++11标准的语法中，auto被定义为自动推断变量的类型。例如： auto x=5.2;//这里的x被auto推断为double类型 map<int,int>m; for(auto it=m.begin();//这里it被auto推断为map<int,int>::iterator类型 it!=m.end();++it) { //.... } 不过C++11的auto关键字时有一个限定条件，那就是必须给申明的变量赋予一个初始值，否则编译器在编译阶段将会报错。

看看这个的讲解吧http://www.jb51.net/article/37689.htm

不知道你问的是哪个auto 在以前的标准中，auto关键字是为了编译器方便给出的，它告诉编译器将其作为自动存储的变量，在实际使用中没啥用，基本可以忽略，这在C和C++中都是一样的 C++新标准（C++11）将其作为自动推断变量类型，即编译器根据初始值决定auto后面的变量是什么类型

由编译器自动推导类型 在定义变量的时候，必须指明数据类型，那么此时此刻就可以使用auto替代 不过有一个前提是：必须初始化，因为只有初始化编译器才能推导出类型


Question: c语言语法问题

end是什么鬼？自己定义的宏吗？

! = 改成 !=  不能有空格

!=是一体的，中间不能有空格； 另外，不清楚你的End是指什么？或者是否是一个宏？ 如果要和EOF，文件结束标志比较，一定要把c变量定义为int类型。因为EOF是int类型的。char类型不能接收EOF。另外，不论是否和EOF比较，都要把getchar()的返回值赋值给一个int类型的变量。

END是什么？？？

第一个程序定义了End = ‘！’ 所以直接直接比较，你的第二个程序并没有类似的定义

EOF 不是End


Question: 是否所有球余数都可以使用移位方法来呢？？？？？

6%4   ->   6&3

对于移位，注意被移位的是有符号数还是无符号数，有无符号，对于移位是不一样的。

http://codepad.org/E9vl7wdM  #include <stdio.h> int main() { 	int a = -2; unsigned b = 0xfffffffe; 	printf ("before: \n"); 	printf ("a = %d,%#x\n", a, a); 	printf ("b = %d,%#x\n", b, b); 	a >>= 1; b >>= 1; 	printf ("after shift: \n"); 	printf ("a = %d,%#x\n", a, a); 	printf ("b = %d,%#x\n", b, b); 	  	return 0; }  输出：  before:  a = -2,0xfffffffe b = -2,0xfffffffe after shift:  a = -1,0xffffffff b = 2147483647,0x7fffffff

只有2的N次方的才可以。 有符号数为算术右移，无符号数为逻辑右移


Question: c语言中的小小问题

楼上说的都对，0为假，非0为真，余数就算是2,3,4之类的，也当做真处理

0和非0，一起交流吧，我也是学C的。关注我。http://m.blog.csdn.net/article/details?id=55061737

if判断的机制是判断条件是否为真，为真则执行，否则的话就执行else中的语句（如果没有else则直接跳过了）

非0为真，0为假

不为0都当做真处理，对于if的条件，只区分0和非0，0为假，非0为真


Question: Windows编程，按老师一步一步写的运行的窗口不能关闭，不能移动，不能拉大拉小

我也是这个问题，多了个；号

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

引用 2 楼 phelps_pass的回复:消息循环有问题，陷入了死循环，去掉后面分号即可 while(GetMessage(&msg,NULL,0,0)); //分号！！！！！！ { TranslateMessage(&msg);//翻译消息 DispatchMessage(&msg);//转发消息到窗口过程WndProc  } 谢谢！就是这个问题！


Question: 从键盘上输入数组，再输出就不一样了，为什么

谢谢大家了，是我zz了

引用 2 楼 cyfcsd 的回复:这个程序能编译通过了？！你用的什么编译器啊 int row,col,i,j,m,n;  scanf("%d%d",&row,&col);  int b[col][row]; 这几句不能通过吧 C语言键盘输入的时候确实是这样的

int b[col][row]; 写反了，就这么简单。。。。 int b[row][col];

引用 4 楼 wang0635 的回复:int b[col][row]; ==>  int b[row][col];  C99开始，允许VLA（变长数组）。标准已经多少年了 奥奥 是我错了，一直在用C++，不知道C语言已经支持这种语法了


Question: 一个奇怪的程序

void main() {     int a;     create_flat();     while(1)     {         printf("\n");         printf("/********************************************************\\\n");         printf("*                                                    *\n");         printf("*                城市小区管理信息系统                *\n");         printf("*                      主菜单                        *\n");         printf("*                                                    *\n");         printf("*                    1.录入(增加)信息                *\n");         printf("*                    2.删除信息                      *\n");         printf("*                    3.输出信息                      *\n");         printf("*                    4.查找信息                      *\n");         printf("*                    5.修改信息                      *\n");         printf("*                    6.小区总面积排序                *\n");         printf("*                    7.退出系统                      *\n");         printf("*                                                    *\n");         printf("/********************************************************\\\n");         printf("请输入选择项(1-7):");         scanf("%d", &a);         printf("\n\n\n\n");         if(a>0 && a<=7)         {             switch(a)             {                 case 1:xq_input();break;                 case 2:xq_delete();break;                 case 3:xq_listout();break;                 case 4:xq_search();break;                 case 5:xq_change();break;                 case 6:xq_order();break;                 case 7:exit(0);             }         }         else         {             printf("***************************************************************\n");             printf("*                                                    *\n");             printf("*                   按任意键                         *\n");             printf("*                     退出!                          *\n");             printf("*                                                    *\n");             printf("***************************************************************\n");             break;         }     } }  这是主函数； 改了一些我感觉不合适的地方。判断是否在链表中，建议是使用局部变量，全局变量使用完之后需要注意初始化为0。建议还是使用局部变量。 其他地方也做了一些修改，你可以查看一下对比一下。

#include<stdio.h> #include<stdlib.h> #include<string.h> //#include<windows.h>  #define len sizeof(struct flat)  struct flat {      char add[100];     char name[100];     float total_area;     int total_num;     struct flat *next; };  typedef struct flat flat;  int n=0, xl[100];  flat *head=NULL;   void create_flat() {     FILE *fp;     int b=0;     long Size;     flat *p1,*p2;     head=(flat *)malloc(sizeof(flat));     memset(head->add,'\0',sizeof(head->add));     memset(head->name,'\0',sizeof(head->name));     head->next=NULL;     if((fp=fopen("xqfile.dat","rb"))==NULL)     {         printf("这是一个新的链表\n");         return;     }     fseek(fp,0L,2);     Size =ftell(fp);     if(!Size)     {         printf("这是一个空链表\n");         return;     }     rewind(fp);     p1=(flat *)malloc(sizeof(flat));     memset(p1->add,'\0',sizeof(p1->add));     memset(p1->name,'\0',sizeof(p1->name));     while(1)     {         if(fread(p1,len,1,fp)==1)         {             p1->next=NULL;             if(head->next==NULL)                 head->next=p1;             else                 p2->next=p1;             p2=p1;             n++;             xl[b]=n;             b++;             p1=(flat *)malloc(sizeof(flat));             memset(p1->add,'\0',sizeof(p1->add));             memset(p1->name,'\0',sizeof(p1->name));         }         else         {             free(p1);             return;         }     }     p2->next=NULL;     fclose(fp); }   void save() {     flat *p=NULL;     FILE *fp;     if((fp=fopen("xqfile.dat","wb"))==NULL)     {         printf("\n打不开文件!\n");         return;     }     if(head->next == NULL)     {         printf("\n信息为空!\n");         return;     }     else     {         p = head->next;     }     while(p!=NULL)     {          fwrite(p,len,1,fp);         p = p->next;     }     printf("保存完毕!\n");     fclose(fp); }    void xq_input() {     struct flat *p1=NULL,*p2=NULL;     char a;     while(1)     {         fflush(stdin);         printf("按q或Q结束录入:");         getchar();         scanf("%c",&a);         getchar();         if(a=='q'||a=='Q')         {             return;         }         else         {             p1=(flat *)malloc(len);             memset(p1->add,'\0',sizeof(p1->add));             memset(p1->name,'\0',sizeof(p1->name));             printf("\n\r请输入地址(字符型):");             scanf("%s",p1->add);             printf("\n\r请输入开发商名(字符型):");             scanf("%s",p1->name);             printf("\n\r请输入总面积:");             scanf("%f",&(p1->total_area));             printf("\n\r请输入总套数:");             scanf("%d",&(p1->total_num));             n++;             xl[n-1]=n;             if(head->next==NULL)             {                 head->next=p1;             }             else             {                 for(p2=head;p2->next!=NULL;p2=p2->next);                 p2->next=p1;             }             p1->next=NULL;             save();         }     } }       void xq_delete() {     flat *p = NULL;     char str[100];     int flag = 0;      if(head->next == NULL)     {         printf("文档中无记录!\n");         return;     }     fflush(stdin);     printf("请输入要删除小区的地址:");     scanf("%s", str);     for(p=head;p->next!=NULL;p=p->next)     {         if(!strcmp(p->next->add,str))         {             flag = 1;             printf("***************************************************************\n");             printf("    小区列表\n");             printf("---------------------------------------------------------------\n");             printf("    地址   开发商名  总套数  总面积    \n");             printf("---------------------------------------------------------------\n");             printf("%8s%8s%8d%10.2f\n", p->next->add,p->next->name,p->next->total_num,p->next->total_area);             printf("---------------------------------------------------------------\n");             printf("***************************************************************\n");             printf("\n");             if(p->next->next)                 p->next=p->next->next;             else                 p->next=NULL;             n--;             save();             printf("删除成功！\n");             //return;             break;         }     }     if(!flag)     {         printf("无该小区信息!请查证!");         return;     } }     void xq_change() {     flat *p=NULL;     char str[100];     int flag = 0;      if(head==NULL)     {         printf("文档中无记录!\n");         return;     }     printf("请输入要修改小区的地址:");     scanf("%s",str);     for(p=head;p!=NULL;p=p->next)     {         if(!strcmp(p->add,str))         {             flag = 1;             printf("***************************************************************\n");             printf("    小区列表\n");             printf("---------------------------------------------------------------\n");             printf("    地址   开发商名  总套数  总面积    \n");             printf("---------------------------------------------------------------\n");             printf("%8s%8s%8d%10.2f\n",p->add,p->name,p->total_num,p->total_area);             printf("---------------------------------------------------------------\n");             printf("***************************************************************\n");             printf("\n");             printf("***************************************************************\n");             printf("\n请输入修改小区的地址:");             scanf("%s",p->add);             printf("\n请输入修改小区的开发商名:");             scanf("%s",p->name);             printf("\n请输入修改小区的总面积:");             scanf("%f",&p->total_area);             printf("\n请输入修改小区的总套数:");             scanf("%d",&p->total_num);             printf("\n");             save();             printf("修改成功！\n");         }     }     if(!flag)     {         printf("无该小区信息!请查证!");     }  }    void xq_listout() {      flat *p=NULL;     int b;     if(head->next==NULL)     {         printf("文档中无记录！\n");         return;     }     printf("***************************************************************\n");     printf("    小区列表:\n");     printf("---------------------------------------------------------------\n");     printf("     序列    地址  开发商名  总套数  总面积    \n");     printf("---------------------------------------------------------------\n");     for(p=head->next,b=0;p!=NULL;p=p->next,b++)     {          printf("%8d%8s%8s%8d%10.2f\n",xl[b],p->add,p->name,p->total_num,p->total_area);     }     printf("---------------------------------------------------------------\n"); }    void xq_search() {     flat *p=NULL;     char str[100];     int flag = 0;      if(head->next==NULL)     {         printf("文档中无记录！\n");         return;     }     printf("请输入要查找的小区地址:");     scanf("%s",str);     printf("***************************************************************\n");     printf("   查询的结果:\n");     printf("---------------------------------------------------------------\n");     printf("    地址   开发商名  总套数  总面积    \n");     printf("---------------------------------------------------------------\n");     for(p=head->next;p!=NULL;p=p->next)     {         if(!strcmp(p->add,str)) {             flag = 1;             printf("%8s%8s%8d%10.2f\n",p->add,p->name,p->total_num,p->total_area);         }     }     if(!flag)     {         printf("无该小区信息!请查证!\n");     }     printf("---------------------------------------------------------------\n");     printf("***************************************************************\n"); }  void xq_order() {     flat *first,*t,*p,*q,*head1;     int b;     head1=head->next;     if(head1==NULL)     {         printf("文档中无记录！\n");         return;     }     first=head1->next;     head1->next=NULL;     while(first != NULL)     {         for(t=first,q=head1;((q!=NULL)&&(q->total_area > t->total_area));p=q,q=q->next);         first=first->next;         if(q==head1)         {             head1=t;         }         else         {             p->next=t;         }         t->next=q;     }     head->next=head1;     printf("***************************************************************\n");     printf("    小区列表:\n");     printf("---------------------------------------------------------------\n");     printf("     序列    地址  开发商名  总套数  总面积    \n");     printf("---------------------------------------------------------------\n");     for(p=head->next,b=0;p!=NULL;p=p->next,b++)     {          printf("%8d%8s%8s%8d%10.2f\n",xl[b],p->add,p->name,p->total_num,p->total_area);     }     printf("---------------------------------------------------------------\n"); }

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

没有发现你说的错误啊，只是一些提示语句的位置不对而已

你是学生？还是小区管理人员？

这是程序： #include<stdio.h> #include<stdlib.h> #include<string.h> #include<windows.h>  #define len sizeof(struct flat)   struct flat {  	char add[100]; 	char name[100]; 	float total_area; 	int total_num; 	struct flat *next; };    typedef struct flat flat; int n=0,i=0,xl[100]; flat *head=NULL;   void create_flat() { 	FILE *fp; 	int b=0; 	long Size; 	flat *p1,*p2; 	head=(flat *)malloc(sizeof(flat)); 	memset(head->add,'\0',sizeof(head->add));     memset(head->name,'\0',sizeof(head->name)); 	head->next=NULL; 	if((fp=fopen("xqfile.dat","rb"))==NULL)     { 		printf("这是一个新的链表\n"); 		return; 	} 	fseek(fp,0L,2); 	Size =ftell(fp); 	if(!Size) 	{        printf("这是一个空链表\n"); 	   return; 	}     rewind(fp); 	p1=(flat *)malloc(sizeof(flat));     memset(p1->add,'\0',sizeof(p1->add)); 	memset(p1->name,'\0',sizeof(p1->name)); 	while(1) 	{ 		if(fread(p1,len,1,fp)==1) 		{ 		p1->next=NULL; 		if(head->next==NULL) 			head->next=p1; 		else 			p2->next=p1; 		p2=p1;         n++; 		xl[b]=n; 		b++; 		p1=(flat *)malloc(sizeof(flat));      	memset(p1->add,'\0',sizeof(p1->add)); 	    memset(p1->name,'\0',sizeof(p1->name));         } 		else 		{ 			free(p1); 			return; 		} 	} 	p2->next=NULL; 	fclose(fp); }                 void save()  { 	 flat *p=NULL; 	 FILE *fp; 	 if((fp=fopen("xqfile.dat","wb"))==NULL) 	 { 		 printf("\n打不开文件!\n"); 		 return; 	 } 	 if(head->next==NULL) 	 { 		 printf("\n信息为空!\n"); 		 return; 	 } 	 else 		 p=head->next; 	 while(p!=NULL) 	 {  		 fwrite(p,len,1,fp); 		 p=p->next; 	 } 	 printf("保存完毕!\n"); 	 fclose(fp);  }                         void xq_input() {       struct flat *p1=NULL,*p2=NULL; 	char a; 	while(1) 	{ 	fflush(stdin); 	printf("按q或Q结束录入:"); 	scanf("%c",&a); 	if(a=='q'||a=='Q') 	{ 		return; 	} 	else 	{     p1=(flat *)malloc(len);  	memset(p1->add,'\0',sizeof(p1->add)); 	memset(p1->name,'\0',sizeof(p1->name)); 	printf("\n\r请输入地址(字符型):"); 	scanf("%s",p1->add); 	printf("\n\r请输入开发商名(字符型):"); 	scanf("%s",p1->name);	 	printf("\n\r请输入总面积:"); 	scanf("%f",&(p1->total_area));			 	printf("\n\r请输入总套数:"); 	scanf("%d",&(p1->total_num)); 	n++; 	xl[n-1]=n; 	if(head->next==NULL) 	{ 	    head->next=p1; 	} 	else 	{ 	    for(p2=head;p2->next!=NULL;p2=p2->next); 		p2->next=p1; 	} 	p1->next=NULL;			     save(); 	} 	} }       void xq_delete() { 	flat *p=NULL; 	char str[100]; 		if(head->next==NULL) 	{ 		printf("文档中无记录!\n"); 		return; 	}     fflush(stdin); 	printf("请输入要删除小区的地址:"); 	scanf("%s",str); 	for(p=head;p->next!=NULL;p=p->next) 	{ 		if(!strcmp(p->next->add,str)) 		{ 			i=1; 			printf("***************************************************************\n");            	printf("    小区列表\n"); 			printf("---------------------------------------------------------------\n"); 		    printf("    地址   开发商名  总套数  总面积    \n"); 			printf("---------------------------------------------------------------\n"); 	        printf("%8s%8s%8d%10.2f\n",p->next->add,p->next->name,p->next->total_num,p->next->total_area);             printf("---------------------------------------------------------------\n"); 	 	    printf("***************************************************************\n"); 			printf("\n");             if(p->next->next) 				p->next=p->next->next; 			else 				p->next=NULL; 			n--; 			save(); 			printf("删除成功！\n"); 			return; 		}            if(i!=1) 		   { 			   printf("无该小区信息!请查证!"); 			   return; 		   } 	} }     void xq_change() { 	flat *p=NULL; 	char str[100]; 	if(head==NULL) 	{ 		printf("文档中无记录!\n"); 		return; 	} 	printf("请输入要修改小区的地址:"); 	scanf("%s",str); 	for(p=head;p!=NULL;p=p->next) 	{ 		if(!strcmp(p->add,str)) 		{ 		 			printf("***************************************************************\n");            	printf("    小区列表\n"); 			printf("---------------------------------------------------------------\n"); 		    printf("    地址   开发商名  总套数  总面积    \n"); 			printf("---------------------------------------------------------------\n"); 	        printf("%8s%8s%8d%10.2f\n",p->add,p->name,p->total_num,p->total_area);             printf("---------------------------------------------------------------\n"); 	 	    printf("***************************************************************\n"); 			printf("\n"); 			i=1;             printf("***************************************************************\n"); 			printf("\n请输入修改小区的地址:"); 			scanf("%s",p->add); 			printf("\n请输入修改小区的开发商名:"); 			scanf("%s",p->name); 			printf("\n请输入修改小区的总面积:"); 			scanf("%f",&p->total_area); 			printf("\n请输入修改小区的总套数:"); 			scanf("%d",&p->total_num); 			printf("\n"); 			save(); 			printf("修改成功！\n"); 		} 	} 	if(!i) 	{ 		printf("无该小区信息!请查证!"); 	}     }    void xq_listout() { 	 	flat *p=NULL; 	int b; 	if(head->next==NULL) 	{ 		printf("文档中无记录！\n"); 		return; 	} 	printf("***************************************************************\n"); 	printf("    小区列表:\n"); 	printf("---------------------------------------------------------------\n");     printf("     序列    地址  开发商名  总套数  总面积    \n");     printf("---------------------------------------------------------------\n"); 	for(p=head->next,b=0;p!=NULL;p=p->next,b++) 	{                  printf("%8d%8s%8s%8d%10.2f\n",xl[b],p->add,p->name,p->total_num,p->total_area); 	}     printf("---------------------------------------------------------------\n"); }    void xq_search() { 	flat *p=NULL; 	char str[100];     if(head->next==NULL) 	{ 		printf("文档中无记录！\n"); 		return; 	} 	printf("请输入要查找的小区地址:"); 	scanf("%s",str);     printf("***************************************************************\n"); 	printf("   查询的结果:\n"); 	printf("---------------------------------------------------------------\n");     printf("    地址   开发商名  总套数  总面积    \n");     printf("---------------------------------------------------------------\n");     for(p=head->next;p!=NULL;p=p->next) 	{ 		if(!strcmp(p->add,str)) 		{ 			i=1; 			printf("%8s%8s%8d%10.2f\n",p->add,p->name,p->total_num,p->total_area); 		} 	} 	if(!i) 	{ 		printf("无该小区信息!请查证!"); 	}        printf("---------------------------------------------------------------\n"); 	   printf("***************************************************************\n"); }  void xq_order() { 	flat *first,*t,*p,*q,*head1; 	int b; 	head1=head->next; 		if(head1==NULL) 	{ 		printf("文档中无记录！\n"); 		return; 	} 	first=head1->next; 	head1->next=NULL; 	while(first != NULL) 	{ 		for(t=first,q=head1;((q!=NULL)&&(q->total_area > t->total_area));p=q,q=q->next);         first=first->next; 		if(q==head1) 		{ 			head1=t; 		} 		else 		{ 			p->next=t; 		} 		t->next=q; 	}      head->next=head1; 	printf("***************************************************************\n"); 	printf("    小区列表:\n"); 	printf("---------------------------------------------------------------\n");     printf("     序列    地址  开发商名  总套数  总面积    \n");     printf("---------------------------------------------------------------\n"); 		for(p=head->next,b=0;p!=NULL;p=p->next,b++) 	{                  printf("%8d%8s%8s%8d%10.2f\n",xl[b],p->add,p->name,p->total_num,p->total_area); 	}     printf("---------------------------------------------------------------\n"); }    void main() { 	int a; 	create_flat(); 	while(1) 	{ 		printf("\n"); 		printf("/********************************************************\\\n"); 		printf("*                                                    *\n"); 	    printf("*                城市小区管理信息系统                *\n"); 		printf("*                      主菜单                        *\n"); 	    printf("*                                                    *\n"); 		printf("*                    1.录入(增加)信息                *\n"); 	    printf("*                    2.删除信息                      *\n"); 		printf("*                    3.输出信息                      *\n"); 		printf("*                    4.查找信息                      *\n"); 		printf("*                    5.修改信息                      *\n"); 		printf("*                    6.小区总面积排序                *\n");      	printf("*                    7.退出系统                      *\n");         printf("*                                                    *\n"); 		printf("/********************************************************\\\n"); 		printf("请输入选择项(1-7):"); 		scanf("%d",&a); 		printf("\n\n\n\n"); 		if(a>0 && a<=7) 		{ 			switch(a) 			{ 			case 1:xq_input();break; 			case 2:xq_delete();break; 			case 3:xq_listout();break; 			case 4:xq_search();break; 			case 5:xq_change();break;             case 6:xq_order();break; 			case 7:exit(0); 			} 		} 		else 		{              printf("***************************************************************\n"); 			 printf("*                                                    *\n"); 		     printf("*                   按任意键                         *\n"); 			 printf("*                     退出!                          *\n"); 			 printf("*                                                    *\n"); 			 printf("***************************************************************\n");              break;    		} 	} }


Question: 一个算法关于递归

引用 8 楼 zilaishuichina 的回复:如果一个质数是某个数的因数，那么就说这个质数是这个数的质因数  先说思路：  n = 0时，没有质因数，可以拿的糖果数为0 n = 1时，没有质因数，可以拿的糖果数为0 n = 2时，质因数为2，不大于√2的质因数没有，可以拿的糖果数为0 n = 3时，质因数为3，不大于√3的质因数没有，可以拿的糖果数为0 n = 4时，质因数为2，不大于√4的质因数为2，可以拿的糖果数为2 n = 5时，质因数为5，不大于√5的质因数没有，可以拿的糖果数为0 n = 6时，质因数为2，3，不大于√6的质因数为2，可以拿的糖果数为2 n = 7时，质因数为7，不大于√7的质因数没有，可以拿的糖果数为0  n = 8时，质因数为2，不大于√8的质因数为2，可以拿的糖果数为 2 加上  n=(8-2*2)时可以拿到的糖果的最大数2 n = 9时，质因数为3，不大于√9的质因数为3，可以拿的糖果数为 3 加上  n=(9-2*3)时可以拿到的糖果的最大数0 n = 10时，质因数为2，5，不大于√10的质因数为2，可以拿的糖果数为 2 加上  n=(10-2*2)时可以拿到的糖果的最大数2  即： 已知数字num的所有不大于√num的质因子为a1,a2,...,ai,...,an 则num个糖果中，最大可以拿的糖果数为： a1 + (num - a1 * 2)个糖果中最大可以拿的个数 a2 + (num - a2 * 2)个糖果中最大可以拿的个数 ... ai + (num - ai * 2)个糖果中最大可以拿的个数 ... an + (num - an * 2)个糖果中最大可以拿的个数 以上各行的和的最大值  则，当需要求num个糖果中，最大可以拿的糖果数，将0～（num-1）分别能拿多少个求出来，num有多少个不大于√num的质因数求出来，最大可以拿的糖果数就可以得到  贴代码  //判断n是否为质数  bool IsPrime(unsigned int n) { 	bool isPrime = true; 	for (unsigned int i = 2; i * i <= n; i++) 	{ 		if (n%i == 0) 		{ 			isPrime = false; 			break; 		} 	} 	return isPrime; } //计算√100000以内的所有质数，存入g_primes备用 //（实际有65个） unsigned int g_primes[100]; unsigned int g_count_primes = 0; void GetPrimes() { 	memset(g_primes, 0x00, sizeof(unsigned int)* 100); 	g_count_primes = 0; 	for (unsigned int i = 2; i * i <= 100000; i++) 	{ 		if (IsPrime(i)) 		{ 			g_primes[g_count_primes] = i; 			g_count_primes++; 		} 	} } //计算0～√num之间，num的质因数，存入g_primes_of_num //（√100000以内的所有质数最多65个，所以num的质因数最多65个） unsigned int g_primes_of_num[100]; unsigned int g_count_primes_of_num = 0; void GetPrimesOfNum(unsigned int num) { 	memset(g_primes_of_num, 0x00, sizeof(unsigned int)* 100); 	g_count_primes_of_num = 0;  	//试除法： 	//0～√num之间，用每一个质数g_primes[i]试除num 	//能除尽，则该质数g_primes[i]是num的一个不大于√num的质因数 	for (unsigned int i = 0; i < g_count_primes; i++) 	{ 		if (g_primes[i] * g_primes[i] <= num) 		{ 			if (num % g_primes[i] == 0) 			{ 				g_primes_of_num[g_count_primes_of_num] = g_primes[i]; 				g_count_primes_of_num++;  				//若g_primes[i]是num的一个不大于√num的质因数 				//将num中所有为g_primes[i]的质因子全部去掉 				while (num % g_primes[i] == 0) 				{ 					num = num / g_primes[i]; 				} 			} 		} 		else 		{ 			break; 		} 	} } //计算n = num时，最多可以拿多少个糖果，存入g_max_candy_of_num //（题目约定n<=100000） //已知数字num的所有不大于√num的质因子为a1,a2,...,ai,...,an //则num个糖果中，最大可以拿的糖果数candy为： //a1 + (num - a1 * 2)个糖果中最大可以拿的个数 //a2 + (num - a2 * 2)个糖果中最大可以拿的个数 //... //ai + (num - ai * 2)个糖果中最大可以拿的个数 //... //an + (num - an * 2)个糖果中最大可以拿的个数 //以上各行的和的最大值 unsigned int g_max_candy_of_num[100001]; void GetMaxCandy(unsigned int num) { 	GetPrimesOfNum(num);  	unsigned int max_candy = 0; 	for (unsigned int i = 0; i < g_count_primes_of_num; i++) 	{ 		unsigned int candy = g_primes_of_num[i] + g_max_candy_of_num[num - g_primes_of_num[i] * 2]; 		if (candy > max_candy) 		{ 			max_candy = candy; 		} 	} 	g_max_candy_of_num[num] = max_candy; } //分别计算糖果数为0-n时，各最多可以拿多少个糖果 unsigned int GetCandies(unsigned int n) { 	g_max_candy_of_num[0] = 0; // n = 0时，可以拿的糖果数为0 	g_max_candy_of_num[1] = 0; // n = 1时，可以拿的糖果数为0 	g_max_candy_of_num[2] = 0; // n = 2时，可以拿的糖果数为0 	g_max_candy_of_num[3] = 0; // n = 3时，可以拿的糖果数为0 	for (unsigned int i = 4; i <= n; i++) 	{ 		GetMaxCandy(i); 	} 	return g_max_candy_of_num[n]; }  int main(int argc, char* argv[]) { 	//预算质数数组 	GetPrimes();  	//求糖果数 	unsigned int num = 15; 	printf("n = %u, candy = %u\n", num, GetCandies(num)); 	num = 100; 	printf("n = %u, candy = %u\n", num, GetCandies(num)); 	num = 1000; 	printf("n = %u, candy = %u\n", num, GetCandies(num)); 	num = 68467; 	printf("n = %u, candy = %u\n", num, GetCandies(num));  	return 0; }   输出 n = 15, candy = 6 n = 100, candy = 50 n = 1000, candy = 500 n = 68467, candy = 34232  谢谢啊很详细明白了

引用 6 楼 qq_36151474 的回复:[quote=引用 5 楼 user-3的回复:]恩，算法应该是对的，但这是穷举法，所以时间复杂度不能满足需要 这个题应该可以利用动态规划求解，因为在穷举过程中有很多数据是重复计算的，针对同一个数会调用getcandy很多次，可以想办法把这些中间结果保存起来，计算后面的数时直接利用前面的结果，具体的代码还没写好 谢谢了，我以为我用的就是动态规划分而治之把大往小化的思想，结果好像还真的又成了枚举，那麻烦你能不能根据我的这个策略改下然后贴出来想学习下谢谢了。[/quote] 前面3楼贴出来的代码就是用的枚举法啊，跟你的策略是一样的，只是你的算法有点儿小错误，我的就是根据你的改的，动态规划的算法还没想好，等想好了发你吧

引用 5 楼 user-3的回复:恩，算法应该是对的，但这是穷举法，所以时间复杂度不能满足需要 这个题应该可以利用动态规划求解，因为在穷举过程中有很多数据是重复计算的，针对同一个数会调用getcandy很多次，可以想办法把这些中间结果保存起来，计算后面的数时直接利用前面的结果，具体的代码还没写好 谢谢了，我以为我用的就是动态规划分而治之把大往小化的思想，结果好像还真的又成了枚举，那麻烦你能不能根据我的这个策略改下然后贴出来想学习下谢谢了。

引用 3 楼 user-3的回复:[quote=引用 2 楼 qq_36151474 的回复:] [quote=引用 1 楼 cyfcsd 的回复:] 你试试这个代码 #include<iostream> #include<cmath> using namespace std;   //判断是否为质数  bool judge(int n) {     for(int i=2;i*i<=n;i++)     {         if(n%i==0) 		{             return false;         }     }     return true; } int max1=-1; //递归求解  int getcandy(int m) {     //出口边界      if(m<4||judge(m))     {         return 0;     }     //把所有满足条件做比较取相对于全局最优解      for(int i=2;i*i<=m;i++)     { 		int b = 0;         if(m%i==0&&judge(i))         {             b=getcandy(m-i-i)+i;         } 		if(max1<b)         {              max1=b;         }     }     //得到最优的解      return max1; }   int main() {     int m;     cin>>m;     cout<<getcandy(m)<<endl; 	system("pause");     return 0; }  抱歉还是不对 输入100应该得50 我的代码结果内存不崩溃但是没有结果 你的代码有结果但是不正确[/quote]  引用 2 楼 qq_36151474 的回复:[quote=引用 1 楼 cyfcsd 的回复:] 你试试这个代码 #include<iostream> #include<cmath> using namespace std;   //判断是否为质数  bool judge(int n) {     for(int i=2;i*i<=n;i++)     {         if(n%i==0) 		{             return false;         }     }     return true; } int max1=-1; //递归求解  int getcandy(int m) {     //出口边界      if(m<4||judge(m))     {         return 0;     }     //把所有满足条件做比较取相对于全局最优解      for(int i=2;i*i<=m;i++)     { 		int b = 0;         if(m%i==0&&judge(i))         {             b=getcandy(m-i-i)+i;         } 		if(max1<b)         {              max1=b;         }     }     //得到最优的解      return max1; }   int main() {     int m;     cin>>m;     cout<<getcandy(m)<<endl; 	system("pause");     return 0; }  抱歉还是不对 输入100应该得50 我的代码结果内存不崩溃但是没有结果 你的代码有结果但是不正确[/quote] 奥奥，错了，你把那个max1的定义放到getcandy函数里面试试[/quote] 还是不对输入一些数字能够得出正确结果但是输入1000,68467等数字还是无法得出结果，内存不报错但就是不出结果。

引用 2 楼 qq_36151474 的回复:[quote=引用 1 楼 cyfcsd 的回复:] 你试试这个代码 #include<iostream> #include<cmath> using namespace std;   //判断是否为质数  bool judge(int n) {     for(int i=2;i*i<=n;i++)     {         if(n%i==0) 		{             return false;         }     }     return true; } int max1=-1; //递归求解  int getcandy(int m) {     //出口边界      if(m<4||judge(m))     {         return 0;     }     //把所有满足条件做比较取相对于全局最优解      for(int i=2;i*i<=m;i++)     { 		int b = 0;         if(m%i==0&&judge(i))         {             b=getcandy(m-i-i)+i;         } 		if(max1<b)         {              max1=b;         }     }     //得到最优的解      return max1; }   int main() {     int m;     cin>>m;     cout<<getcandy(m)<<endl; 	system("pause");     return 0; }  抱歉还是不对 输入100应该得50 我的代码结果内存不崩溃但是没有结果 你的代码有结果但是不正确[/quote]  引用 2 楼 qq_36151474 的回复:[quote=引用 1 楼 cyfcsd 的回复:] 你试试这个代码 #include<iostream> #include<cmath> using namespace std;   //判断是否为质数  bool judge(int n) {     for(int i=2;i*i<=n;i++)     {         if(n%i==0) 		{             return false;         }     }     return true; } int max1=-1; //递归求解  int getcandy(int m) {     //出口边界      if(m<4||judge(m))     {         return 0;     }     //把所有满足条件做比较取相对于全局最优解      for(int i=2;i*i<=m;i++)     { 		int b = 0;         if(m%i==0&&judge(i))         {             b=getcandy(m-i-i)+i;         } 		if(max1<b)         {              max1=b;         }     }     //得到最优的解      return max1; }   int main() {     int m;     cin>>m;     cout<<getcandy(m)<<endl; 	system("pause");     return 0; }  抱歉还是不对 输入100应该得50 我的代码结果内存不崩溃但是没有结果 你的代码有结果但是不正确[/quote] 奥奥，错了，你把那个max1的定义放到getcandy函数里面试试

引用 1 楼 cyfcsd 的回复:你试试这个代码 #include<iostream> #include<cmath> using namespace std;   //判断是否为质数  bool judge(int n) {     for(int i=2;i*i<=n;i++)     {         if(n%i==0) 		{             return false;         }     }     return true; } int max1=-1; //递归求解  int getcandy(int m) {     //出口边界      if(m<4||judge(m))     {         return 0;     }     //把所有满足条件做比较取相对于全局最优解      for(int i=2;i*i<=m;i++)     { 		int b = 0;         if(m%i==0&&judge(i))         {             b=getcandy(m-i-i)+i;         } 		if(max1<b)         {              max1=b;         }     }     //得到最优的解      return max1; }   int main() {     int m;     cin>>m;     cout<<getcandy(m)<<endl; 	system("pause");     return 0; }  抱歉还是不对 输入100应该得50 我的代码结果内存不崩溃但是没有结果 你的代码有结果但是不正确


Question: c语言指针初始化问题，自己检查不出错误，求教大家。

哦哦 知道了 谢谢大佬们

引用 12 楼 m0_37482591 的回复:自己顶一个，前几天的帖子了，大佬速来帮忙啊。已经要被折磨死了。 select 不会生成0，只会生成（j+1）-（n）的整数，而且这个错误不是每次都出现，运行很多很多次才会出现一次

简单来讲就是你的rand函数可能返回0.

快点顶上去让大佬看见。。。我中午再过来看下，去看论文了要，，

j=0且select在rand到0的时候，数组下标越界了，所以你的alloc[0]得到了一个很大的值。

自己顶一个，前几天的帖子了，大佬速来帮忙啊。已经要被折磨死了。

自己顶一个，前几天的帖子了，大佬速来帮忙啊。

我已经知道哪里出问题了，现在上代码描述问题。 自己写了3个随机函数 如下两图所示；最终目标是Randperm函数，也就是第二张图。   现在问题就是Randperm函数每运行很多很多次才会出现一次错误，比如生成一组1-7的随机数（也就是将1-7打乱）。出错误时的情况如下图所示，注意，永远是数组中的第0个元素出问题，但是检查了代码感觉没有问题啊。再次求助各位。

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

突然发现只有一步步调试的时候才会出现这个问题，直接运行倒没有这个问题，，，，

问题还没解决，打算一步步调试下看看，关键是时好时不好。检查了每个指针都赋值了。

检查方法： 1、指针是否存在多次释放 2、释放之后的指针是否再次被使用 3、如果是多线程，指针是否为全局变量  可以使用ibm purify，可以检查内存泄漏和变量初始化等

空说没用，直接上代码。

0xcccccccc代表的是你调用了未初始化的的指针。vs debug模式下为初始化的指针就是0xCCCCCCCC。

是不是用到了free函数。如果在malloc之后没有初始化，则free的时候很容易出错，free函数释放的区间必须以\0结束

断点调试  注释法调试

自己顶一个。


Question: 想学习：C语言在不同指令集构架下的实现  推荐书籍

参考 Tiny C Compiler 或 gcc 源代码相关片断。

建议看一些嵌入式方面的书籍，因为嵌入式会涉及到各种平台，尤其是在ARM平台上使用是比较广的～

http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素 http://edu.csdn.net/course/detail/2455 C语言指针与汇编内存地址-二.函数 http://edu.csdn.net/course/detail/2516 C语言指针与汇编内存地址-三.数组和二维数组 http://edu.csdn.net/course/detail/2517 C语言指针与汇编内存地址-四.三维数组


Question: 【求救】一个编程题求解答

#include <stdio.h>  int main() { 	char a,b,c; 	printf("Enter a first and last name:"); 	a=getchar(); 	while((b=getchar())>='A'&&(b=getchar())<='Z') 	{ 		putchar(b); 		break; 	}  	while((c=getchar())!='\n') 		putchar(c); 	printf(",%c.",a); 	return 0; 	 } 输出是vd Fosdick,L. 想知道是哪里错了- -

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

#include<stdio.h>  main(){     char first_name[10];//名     char last_name[10];//姓     int i = 0;     printf("Enter a first and last name :");     for(i=0; i<9; i++){         scanf("%c",&last_name[i]);         if(last_name[i] == '\n')             break;     }        for(i=0; i<9; i++){         scanf("%c",&first_name[i]);         if(last_name[i] == '\n')             break;     }      i=0;     while(last_name[i] != '\n'){         printf("%c",last_name[i]);         i++;     }        printf(",%c.",first_name[0]); }  测试用例: lon boo  测试结果: lon,b.  我也是初学者，希望能够互相交流,共同进步!

#include <stdio.h>  int main()  {     char firstname[32], lastname[32], fullname[64];      printf("Please input name:");     if (scanf("%s %s", firstname, lastname) != 2)     {         printf("Input name error.\n");         return 0;     }      sprintf(fullname, "%s.%c\n", lastname, firstname[0]);     printf(fullname);      return 0; }


Question: C语言输出语句可不可以放在子函数中，而不用放在主函数

#include<stdio.h>   double sphere(double r,double*v)  {  double area;  area=3.14*4*r*r;  *v=4.0/3*3.14*r*r*r;  printf("表面积=%lf",area);  printf("体积=%lf",*v);  return area;  }   int main()  {  double r,m;  printf("r=",r);  scanf("%lf",&r);  sphere(r,&m);  return 0;  }


Question: c语言，int 按位转字符型，加上打印信息就能正确输出，否则出错

@幻夢之葉    答的太好了，非常感谢！

未定义行为  你返回局部变量，返回之后就被系统回收了。你打印语句，恰好导致那块内存没有被重写！ 请使用参数返回char数组，或者动态内存返回  还有一个问题就是赋值的问题，你把一个unsigned int的值强制转为unsigned char，会导致数据的损失  abyte[2] = (unsigned char)(0xff00 & i); 改为 abyte[2] = (unsigned char)((0xff00 & i) >> 8);  后面两个赋值分别左移 16，24


Question: 请大家帮我看看这个错误，新手

引用 3 楼 cfjtaishan 的回复: printf("line: %d, function: %s\n", __LINE__, __func__);  __func__宏是前后两个下划线哦 谢谢了，编译通过了

引用 2 楼 jianwen0529 的回复:错误说了 _func_ 这个变量或者宏找不到它的声明 知道错误，不知道怎么修改！ 新手，请谅解

引用 1 楼 user-3 的回复:_func_ 没有定义  你要写的是不是 f 不是，是输出当前函数的名字 3楼帮我找出错误了，是两个下划线

错误说了 _func_ 这个变量或者宏找不到它的声明

_func_ 没有定义  你要写的是不是 f