Question: 怎么在一个char*字符串中截取出两个指定子串的中间部分？

仅供参考：#include <ctype.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAXN  40 #define MAX2N 80 FILE *fi,*fo; char sn[_MAX_PATH],dn[_MAX_PATH],f[MAX2N],bw[MAXN],bf[MAXN+sizeof(int)-1],bx[MAXN],br[MAXN+sizeof(int)-1],bb[MAXN]; char *ag[MAXN]; int L,i,j,k,lenf,lenr,find,match; __int64 off; void FR() {     printf("\n");     printf("Src : %s\n",sn);     if (find==0) {         printf("Dest: %s\n",dn);     }     for (i=0;i<lenf;i++) {         bb[i]=fgetc(fi);     }     off=0i64;     while (1) {         match=1;         for (j=0;j<lenf;j++) {             if (bw[j]==0&&bf[j]==bb[j]) continue;             if (bw[j]==1) continue;             match=0;             break;//         }         if (match==1) {             printf("%016I64X\n",off);             if (find==0) {                 for (j=0;j<lenf;j++) {                     if (bx[j]==0) fputc(br[j],fo);                     else fputc(bb[j],fo);                 }             }             for (i=0;i<lenf;i++) {                 bb[i]=fgetc(fi);                 if (feof(fi)) break;//             }             if (feof(fi)&&find==0) {                 for (j=0;j<i;j++) fputc(bb[j],fo);                 break;//             }             if (feof(fi)) break;//             else off+=(__int64)lenf;         } else {             if (find==0) {                 fputc(bb[0],fo);             }             memmove(bb,bb+1,lenf-1);             bb[lenf-1]=fgetc(fi);             off++;             if (feof(fi)) {                 if (find==0) {                     for (j=0;j<lenf-1;j++) fputc(bb[j],fo);                 }                 break;//             }         }     } } int main() {     while (1) {         printf("Find & Replace, designed by zhao4zhong1@163.com\n");         printf("Src  file name:");         fflush(stdout);         fgets(sn,_MAX_PATH,stdin);         if ('\n'==sn[0]) break;//         L=strlen(sn);if ('\n'==sn[L-1]) sn[L-1]=0;         if ((fi=fopen(sn,"rb"))==NULL) {             printf("Can not open %s!",sn);             break;//         }         while (1) {             printf("Dest file name:");             fflush(stdout);             fgets(dn,_MAX_PATH,stdin);             if ('\n'==dn[0]) break;//             L=strlen(dn);if ('\n'==dn[L-1]) dn[L-1]=0;             if (strcmpi(sn,dn)==0) printf("Error: Src file name[%s] == Dest file name[%s]!\n",sn,dn);             else if ((fo=fopen(dn,"rb"))!=NULL) {                 fclose(fo);                 printf("Error: Dest file already exists!\n");             } else break;//         }         printf("Find   :");         fflush(stdout);         fgets(f,MAX2N,stdin);         L=strlen(f);if ('\n'==f[L-1]) f[L-1]=0;         if (f[0]=='\'') {             lenf=strlen(f)-1;             for (j=0;j<lenf;j++) {                 if (f[j+1]=='?') bw[j]=1;                 else {                     bw[j]=0;                     bf[j]=f[j+1];                 }             }         } else {             i=0;             for (j=0;j<MAXN;j++) {                 if (f[i]==0x0D||f[i]==0x0A||f[i]==0x1A||f[i]==0) {                     f[i]=0;                     break;//                 }                 while (f[i]==' '||f[i]==9) {                     f[i]=0;                     i++;                 }                 ag[j]=f+i;                 while (f[i]!=9&&f[i]!=' '&&f[i]!=0x0D&&f[i]!=0x0A&&f[i]!=0x00) i++;             }             lenf=j;             for (i=0;i<lenf;i++) {                 if (isxdigit(ag[i][0])) {                     bw[i]=0;                     sscanf(ag[i],"%2x",&bf[i]);                 } else {                     bw[i]=1;                 }             }         }         printf("Replace:");         fflush(stdout);         fgets(f,MAX2N,stdin);         L=strlen(f);if ('\n'==f[L-1]) f[L-1]=0;         if (f[0]==0 || '\n'==dn[0]) find=1;         else {             if (f[0]=='\'') {                 lenr=strlen(f)-1;                 if (lenr!=lenf) {                     printf("Error: Find len != Replace len");                     fclose(fi);                     break;//                 }                 find=0;                 fo=fopen(dn,"wb");                 for (j=0;j<lenr;j++) {                     if (f[j+1]=='?') bx[j]=1;                     else {                         bx[j]=0;                         br[j]=f[j+1];                     }                 }             } else {                 i=0;                 for (j=0;j<MAXN;j++) {                     if (f[i]==0x0D||f[i]==0x0A||f[i]==0x1A||f[i]==0) {                         f[i]=0;                         break;//                     }                     while (f[i]==' '||f[i]==9) {                         f[i]=0;                         i++;                     }                     ag[j]=f+i;                     while (f[i]!=9&&f[i]!=' '&&f[i]!=0x0D&&f[i]!=0x0A&&f[i]!=0x00) i++;                 }                 lenr=j;                 if (lenr!=lenf) {                     printf("Error: Find len != Replace len");                     fclose(fi);                     break;//                 }                 find=0;                 fo=fopen(dn,"wb");                 for (i=0;i<lenr;i++) {                     if (isxdigit(ag[i][0])) {                         bx[i]=0;                         sscanf(ag[i],"%2x",&br[i]);                     } else {                         bx[i]=1;                     }                 }             }         }         if (lenf<=0) break;//         FR();         fcloseall();     }     return 0; }

使用strstr是对字符串而言的，若该文件里的数据遇到'\0'，就不会继续寻找；有可能是infoData里的数据在遇到“over”之前先遇到了'\0',那么就不会向后执行了。 建议先去确定一下是否这种情况出现； 对于若出现上面的情况，可以考虑这么做：  char *str = infoData; while (str < infoData + fileLen) {     p = strstr(str, "over");     if (!p) {         str += 1;     } else {         writefile.     } }

1 char* infoData = new  char[fileLen]——>char* infoData = new  char[fileLen+1]; 2 每一次strstr(A,B)后要计算返回的地址和A的地址的偏移,下一次的时候传入进去的就不是A了而是偏移后的A'',这样才能逐步前进往前找 3 应该是循环查找直到strstr返回NULL为止

用 strstr 函数寻找到你的两个指定字符串  然后strcpyn复制出来，起始位置为第一个子串的strstr返回值，长度为两次strstr的值的差


Question: 新人求教C++的文件输入输出流问题

outdata.open("score.txt",ios_base::out|ios_base::app);


Question: 初学，一个很简单的C程序编译通过但是执行的时候总不对

现在的码农竟然99%都不会在cmd窗口中输入cd命令设置当前目录为程序所在目录，输入程序名运行程序了！

程序没有问题，起码在Linux编译和运行都没有问题；程序可以肯定的没有问题，建议你检查一下你的编译和运行环境，或者将同样的代码放到其他人的环境里进行编译和运行，查看结果是否一样。

windows看你是怎么运行，你如果直接双击这个程序，那就是你现在的效果。 你如果先打开一个cmd窗口，再去运行程序，那就和你linux差不多，所以，这为什么叫执行的时候总不对？？这个程序执行没有任何问题 你在linux shell里面执行这个程序，这个程序一样是自动退出的，只不过它的输出会留在shell窗口上而已。

引用 7 楼 qwqwqw408 的回复:按照4楼说的去做吧，你都不加个等待，就算有输出，你看得到吗，那3个printf调用显示不过是数毫秒而已，你眼睛都没反应过来，程序就正常退出了，这是正常退出，并不是什么异常，不要自己把自己搞晕了。 这个主要是看编译和运行环境，在Linux下没有这些问题，加不加getchar();都是可以。加了，还得在敲一下回车。 如果楼主是在windows下使用专门软件操作的，建议可以考虑一下上面的建议

#include <stdio.h> int main(void) { float num; printf("Enter a floating-point value: "); scanf("%f", &num); printf("fixed-point notation: %f\n", num); printf("exponential notation: %e\n", num); printf("p notation: %a\n", num); getchar(); //等待用户输入才结束程序，或者“菜单-调试-开始执行（不调试）”，快捷键Ctrl+F5 return 0; }

引用 1 楼 qq_30348181 的回复:要么去掉return或void  自己选 试过了，都不行

试过了。都不行

要么去掉return或void  自己选


Question: C语言怎么让图片跟着鼠标走

BeginBatchDraw http://tieba.baidu.com/p/2014559854


Question: 最近在自己做一个射击游戏，很多地方都不懂 希望大神指教


Question: 最近在自己做一个射击游戏，很多地方都不懂 希望大神指教


你的fp定义为指针，后面又加取地址干嘛

引用 3楼自信男孩 的回复:是不是node.csv文件格式不是格式化的？ fscanf是格式化的读取。这个我也不懂… 是老师给的 那应该是没问题的吧…

引用 5楼versatts 的回复:以文本方式打开试试也不行…

引用 4楼赵4老师 的回复:请判断fscanf函数的返回值。判断了fscanf==-1 break 这样不可以吗…

以文本方式打开试试

请判断fscanf函数的返回值。

是不是node.csv文件格式不是格式化的？ fscanf是格式化的读取。

引用 1楼user-5 的回复:F://datastructure//data//node.csv => F:\\datastructure\\data\\node.csv好像不是这个原因… 改了也不行

注意文件编码： In Visual C++ 2005, fopen supports Unicode file streams. A flag specifying the desired encoding may be passed to fopen when opening a new file or overwriting an existing file, like this:  fopen("newfile.txt", "rw, ccs=<encoding>");  Allowed values of the encoding include UNICODE, UTF-8, and UTF16-LE. If the file is already in existence and is opened for reading or appending, the Byte Order Mark (BOM) is used to determine the correct encoding. It is not necessary to specify the encoding with a flag. In fact, the flag will be ignored if it conflicts with the type of the file as indicated by the BOM. The flag is only used when no BOM is present or if the file is a new file. The following table summarizes the modes used in for various flags given to fopen and Byte Order Marks used in the file.  Encodings Used Based on Flag and BOM Flag  No BOM (or new file)  BOM: UTF-8  BOM: UTF-16   UNICODE  ANSI  UTF-8  UTF-16LE   UTF-8  UTF-8  UTF-8  UTF-16LE   UTF-16LE  UTF-16LE  UTF-8  UTF-16LE


Question: 求大神解答！！！

#include <stdio.h> #include <stdlib.h>  int main() {     int i,a[200],n,k,j,p=0,u=0,sum=0;     char b[200];     scanf("%d",&n);     getchar();     while(n--) {         gets(b);         for(i=0;i<13;i++)             a[i]=b[i]-'0';         k=0;         j=0;         for(i=0;i<13;i++) {             if(i%2==0)                 k+=a[i];             else                 j+=a[i]; //          printf("%d",a[i]);         }         sum=j*3+k;         p=sum%10;         if((10-p)==10)             u=0;         else             u=10-p;         if(u==a[12])             printf("Yes\n");         else             printf("No\n");      }     return 0; }

#include <stdio.h> #include <stdlib.h>  int main() {     int i,a[200],n,k=0,j=0,p=0,u=0,sum=0;     char b[200];      scanf("%d",&n);     getchar();     while(n--)     {         gets(b);         for(i=0;i<13;i++)             a[i]=b[i]-'0';         for(i=0;i<13;i++)         {             if(i%2==0)                 k+=a[i];             else                 j+=a[i];             printf("%d",a[i]);         }         sum=j*3+k-a[12];         p=sum%10;         if((10-p)==10)             u = 0;         else             u = 10 - p;         printf("%u = %d, a[12] = %d\n", u, a[12]);         if(u==a[12])             printf("Yes\n");         else             printf("No\n");        /*为了不影响下一次的使用，先将这三个值重新初始化*/         u = 0;         j = 0;         k = 0;      }     return 0; } 原因，就是u, i, k没有重新初始化，没有重新初始化，他们都会带着上一次的计算结果，继续下次的判定和运算

#include <stdio.h> #include <stdlib.h>  int main() {     int i,a[200],n,k,j,p=0,u=0,sum=0;     char b[200];     scanf("%d",&n);     getchar();     while(n--) {         gets(b);         for(i=0;i<13;i++)             a[i]=b[i]-'0';         k=0;         j=0;         for(i=0;i<13;i++) {             if(i%2==0)                 k+=a[i];             else                 j+=a[i]; //          printf("%d",a[i]);         }         sum=j*3+k-a[12];         p=sum%10;         if((10-p)==10)             u=0;         else             u=10-p;         if(u==a[12])             printf("Yes\n");         else             printf("No\n");      }     return 0; }

样例输入 3 6901234567892 0101092900016 0101092900015 样例输出 Yes No Yes


Question: 文章编辑问题（用顺序表）

#include<stdio.h> #include<string.h> #include<stdlib.h>  #define N 3//文章的行数  char str[N][80]; int len[N];   int intput(int i) {     int len;     printf("请输入第 %d 行文字\n",i+1);     fgets(str[i], 80, stdin);     len = strlen(str[i]);     str[i][len-1] = 0;      return len - 1; }   void output() {     int i;     for(i=0;i<N;i++)     {         puts(str[i]);     } }   void count() {     int i,j;     int a,b,c,d;     a=0;     b=0;     c=0;     d=0;     for(i=0;i<N;i++)     {         for(j=0;j<len[i];j++)         {             if(str[i][j]>='a' && str[i][j]<='z')                 a++; //统计小写字母             if(str[i][j]>='A' && str[i][j]<='Z')                 b++; //统计大写字母             if(str[i][j]>='0' && str[i][j]<='9')                 c++; //统计数字             if(str[i][j]==' ')                 d++; //统计空格         }     }     printf("文章中的字母个数为：%d \n",a+b);     printf("数字个数为：%d \n",c);     printf("空格个数为：%d \n",d);     printf("文章总字数为：%d \n",a+b+c+d); }   void checkstring() //统计指定字符串个数函数 {     char cstr[20];     char *p1,*p2;     int i;     int e=0;      printf("请输入需要统计的字符串:\n");     fgets(cstr, 20, stdin);     cstr[strlen(cstr) - 1] = 0;     p2 = cstr;     for(i=0;i<N;i++)     {         p1=str[i];         while(strstr(p1,p2)!=NULL) {             e++;             p1 += strlen(p2);         }     }     printf("字符串：%s 在文章中出现的次数为：%d \n",cstr,e); }  void outputdelstr() {     int i;     char cstr[20];     char *p,*p1,*p2;     int len;     printf("请输入要删除的字符串:");     fgets(cstr, 20, stdin);     cstr[strlen(cstr) - 1] = 0;     len=strlen(cstr);     p2 = cstr;     for(i=0;i<N;i++)     {         p1=str[i];         while(strstr(p1,p2)!=NULL)         {             p=p1=strstr(p1,p2);             while(*(p+len-1))             {                 *p=*(p+len);                 p++;             }         }     }     printf("删除字符串：%s 后文章为： \n",cstr);     output(); }  void menu() {     printf("**********************\n");     printf("*        菜单        *\n");     printf("**********************\n");     printf("*   1---统计字符串   *\n");     printf("*   2---删除字符串   *\n");     printf("*   0---退出系统     *\n");     printf("**********************\n"); }  int main() {     int i;     int key, t;     printf("**************************\n");     printf("* 计算机1602      666 *\n");     printf("**************************\n");      for(i=0;i<N;i++)     {         len[i] = intput(i);     }     while(1)     {         printf("**************************\n");         printf("* 计算机1602      666 *\n");         printf("**************************\n");         printf("\n");         printf("您输入的文章为：\n");         output();         printf("\n");         count();         printf("\n");         menu();         printf("\n");         printf("请输入操作：");         key=getchar();         printf("\n");         switch(key)         {             case '1':                 {                     //fflush(stdin);//功能:清空输入缓冲区，确保不影响后面的数据读取                     getchar();                     checkstring();                 }                 break;             case '2':                 {                     //fflush(stdin);                     getchar();                     outputdelstr();                 }                 break;             case '0':                 exit(0);             default:                 {                     printf("此菜单不存在！\n");                 }                 break;         }         t=getchar();  //接收回车         system("pause");     }     system("pause");     return 0; } gets不安全，建议使用fgets代替gets;  参考一下上面的代码，注意： 1。 全局变量len你没有赋值，后面直接使用，那么数组len的值都为0； 2。 查找函数，请对比上面的函数。 3。 fflush对stdin的操作是未定义的，对stdout是有效的，所以用getchar替换。

百度上是用链表来做的，要用c++来运行。我想要用顺序表来写，c语言运行！

百度搜相关关键字。


Question: 二叉排序树也可以用顺序存储模式吗？

百度搜相关关键字。


Question: 求大神帮忙C语言实现3*3图片的卷积

不要做A语言代码修改为B语言代码的无用功。 也不要做用A语言代码直接调用B语言代码库这样复杂、这样容易出错的傻事。 只需让A、B语言代码的输入输出重定向到文本文件，或修改A、B语言代码让其通过文本文件输入输出。 即可很方便地让A、B两种语言之间协调工作。 比如： A将请求数据写到文件a.txt，写完后改名为aa.txt B发现aa.txt存在时，读取其内容，调用相应功能，将结果写到文件b.txt，写完后删除aa.txt，改名为bb.txt A发现bb.txt存在时，读取其内容，读完后删除bb.txt 以上A可以替换为任何一种开发语言或开发环境，B可以替换为任何一种与A不同的开发语言或开发环境。 除非A或B不支持判断文件是否存在、文件读写和文件更名。 但是谁又能举出不支持判断文件是否存在、文件读写和文件更名的开发语言或开发环境呢？ 可以将临时文件放在RamDisk上提高效率减少磨损磁盘。 数据的结构很复杂的话，文本文件的格式问题可参考json或xml  共享临时文本文件这种进程之间的通讯方法相比其它方法的优点有很多，下面仅列出我现在能想到的： ·进程之间松耦合 ·进程可在同一台机器上，也可跨机，跨操作系统，跨硬件平台，甚至跨国。 ·方便调试和监视，只需让第三方或人工查看该临时文本文件即可。 ·方便在线开关服务，只需删除或创建该临时文本文件即可。 ·方便实现分布式和负载均衡。 ·方便队列化提供服务，而且几乎不可能发生队列满的情况（除非硬盘空间满） ·……  “跨语言、跨机，跨操作系统，跨硬件平台，跨国，跨*.*的”苦海无边， 回头是“使用共享纯文本文件进行信息交流”的岸！


Question: va_arg 使用问题

c89 6.3.15小节清楚的说明了这个转换， c99/c11继续沿用

应该不可能，建议从生成的汇编代码中去看究竟

逻辑短路？ 编译器优化掉了？ 使用gdb查看每句C/C++语句对应的汇编指令。

引用 6 楼 xsklld 的回复:问题不在va_arg，而在条件表达式。 C/C++里的表达式在编译时就需要确定类型，条件表达式也不例外。当条件表达式后两个子表达式类型不一致时会实施类型转化，在这里即前面的int会转换成unsigned int，所以看上去就像无论怎样都会执行false分支。  正解。这里num在编译时既被确定使用unsigned int类型。因为编译器不知道会进true还是false，而num需要确定的类型，所以做了隐含类型转换。但是在32位unsigned类型转64位的过程中，符号位被丢掉了。

引用 4楼我是你的主体 的回复:问题找到了，两种写法确实是有区别的。为什么呢？

问题找到了，两种写法确实是有区别的。

优化没开，汇编还没跟，直接运行的结果很诡异所以直接贴上来问问。 如果把代码改成 num = sign ? (int)va_arg(args, int) : 123; 那么sign=1, 传入参数是-1时， num能得到-1. 原始代码sign=1,传入参数是-1时，num的值是0xffffffff，而num是unsigned long long，这个值就不是-1了


Question: 热烈庆祝本人受关注人数即将突破13000大关！散分！！+为什么机器每隔约一个多月就假死一次重启后就好了？

赵老师帮过一次忙，受益匪浅

大牛啊，不知道为什么，每次我遇到问题的时候，搜出来的帖子，总能看到赵老师的身影，果断关注！

还有分吗，赵老师

接分接分，外带恭喜赵老师

就是来赚点积分好下载的。。。

接分接分，外带恭喜赵老师

赵老师牛逼了！！

引用 44 楼 pre_fection 的回复:赵老师新粉 可惜这一波没分了。

赵老师新粉

因为它累了。

恭喜老师！！！

散多少分啊？

我来接分了，记得给我多些啊

关注一下，靠赵老师解决过不少问题


Question: 机房管理系统运行process returned -1073741819(0xC0000005)内存分配问题

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


Question: C语言 显示功能小问题

解决了，是文件读取问题，谢了

引用 7 楼 cfjtaishan 的回复:[quote=引用 6 楼 qiangshu6990 的回复:] [quote=引用 5 楼 cfjtaishan 的回复:] 改一下create函数里这句： fscanf(fp, "%s%s%d", stu[j].id, stu[j].name, &stu[j].balance); 改成  fscanf(fp, "%s%s%d\n", stu[j].id, stu[j].name, &stu[j].balance); 加一个'\n'，因为看到你的每次写入都加了'\n'，所以读取时，也要加上。这样做到格式统一 嗯，改了之后就解决了，谢谢！不过现在出现续钱后就会消失某个档案，求解[/quote] 消失那个档案，最后一个还是中间某个？可以先确认一下文件里是否有该档案，如果有，那么应该是读文件时出现的问题，可以单读查文件[/quote] 我建立六个档案，帮第二个续钱，结果第二，第四，第六都没了，我再帮第一个续，第三个又没了

打印结构体，最好用fread和fwrite函数，可以参考一下这个资料 http://blog.csdn.net/libing403?viewmode=contents

引用 6 楼 qiangshu6990 的回复:[quote=引用 5 楼 cfjtaishan 的回复:] 改一下create函数里这句： fscanf(fp, "%s%s%d", stu[j].id, stu[j].name, &stu[j].balance); 改成  fscanf(fp, "%s%s%d\n", stu[j].id, stu[j].name, &stu[j].balance); 加一个'\n'，因为看到你的每次写入都加了'\n'，所以读取时，也要加上。这样做到格式统一 嗯，改了之后就解决了，谢谢！不过现在出现续钱后就会消失某个档案，求解[/quote] 消失那个档案，最后一个还是中间某个？可以先确认一下文件里是否有该档案，如果有，那么应该是读文件时出现的问题，可以单读查文件

引用 5 楼 cfjtaishan 的回复:改一下create函数里这句： fscanf(fp, "%s%s%d", stu[j].id, stu[j].name, &stu[j].balance); 改成  fscanf(fp, "%s%s%d\n", stu[j].id, stu[j].name, &stu[j].balance); 加一个'\n'，因为看到你的每次写入都加了'\n'，所以读取时，也要加上。这样做到格式统一 嗯，改了之后就解决了，谢谢！不过现在出现续钱后就会消失某个档案，求解

引用 2 楼 cfjtaishan 的回复:在create函数里为什么有两个fscanf，while(!feof(fp))和for里都有fscanf，理论上while(!feof(fp))退出循环就已经读到文件末尾了吧 之前改的时候忘记注释，不过现在改了还是不行 void Create()   //创新功能——显示所有学生信息 {     struct Student stu[150] = {0};     int j = 0;     char ch;     if((fp = fopen("duli16.3.dat", "a+")) == NULL)     {         printf("打开文件失败！\n");         exit(0);     }     while(!feof(fp))     {         fscanf(fp, "%s%s%d", stu[j].id, stu[j].name, &stu[j].balance);         j++;     }      printf("学号\t\t\t名字\t\t\t余额\n");     for(int i = 0; i < j; i++)     {         //fscanf(fp, "%15s%15s%10d", stu[i].id, stu[i].name, stu[i].balance);         //printf("%15s%15s%10d\n", stu[i].id, stu[i].name, stu[i].balance);         printf("%s\t\t\t", stu[i].id);         printf("%s\t\t\t", stu[i].name);         printf("%d\n", stu[i].balance);     }     //while((ch = fgetc(fp)) != EOF)         //printf("%c",ch);      fclose(fp);     system("pause");     system("cls"); }

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h>  struct Student {     char id[15];     char name[10];     int balance;   //余额 }stu; time_t start, end; FILE *fp;  void Build()   //建立上机档案 {     struct Student stu = {0};     int i = 1;      if((fp=fopen("duli16.3.dat", "a+")) == NULL)     {         printf("打开文件失败！\n");         exit(0);     }     while(i == 1)     {         printf("请输入学号：");         scanf("%s", stu.id);         printf("姓名：");         scanf("%s", stu.name);         printf("金额：");         scanf("%d", &stu.balance);         fprintf(fp, "%15s%15s%10d\n", stu.id, stu.name, stu.balance);         printf("是否继续？（1-是   2-否）\n");         scanf("%d", &i);     }     fclose(fp);     system("pause");     system("cls"); } void Online()   //开始上机 {     struct Student stu[150] = {0};     char s[15];     int i, j, k;     k = -1;     i = j = 0;      if((fp = fopen("duli16.3.dat", "r")) == NULL)     {         printf("打开文件失败！\n");         exit(0);     }     while(!feof(fp))     {         fscanf(fp, "%s%s%d", stu[j].id, stu[j].name, &stu[j].balance);         j++;     }     fclose(fp);      printf("请输入上机学生学号：");     scanf("%s", s);     for(i = 0; i <= j; i++)     {         if(strcmp(stu[i].id, s) == 0)         {             k = i;             break;         }     }     if(k == -1)     {         printf("查无此人，请重新输入！\n");         Online();     }     if(stu[i].balance < 6)         printf("余额不够，请续钱！\n");     else     {         start = time(NULL);         printf("学号：%15s     姓名：%15s     余额：%15d\n", stu[i].id, stu[i].name, stu[i].balance);     }     system("pause");     system("cls"); } void Offline()   //离开机房 {     struct Student stu[150] = {0};     int dif, hour, minute, second, money, j, k, i = 0;     char s[15];     end = time(NULL);     dif = (int) difftime(end, start);     hour = dif / 3600;     minute = dif%3600 / 60;     second = dif % 60;      if(minute > 30)         hour++;     else if(minute > 0)         minute = 1;     money = hour*2 + minute;      fopen("duli16.3.dat", "r");     while(!feof(fp))     {         fscanf(fp, "%s%s%d", stu[i].id, stu[i].name, &stu[i].balance);         i++;     }     printf("请输入下机学生学号：");     scanf("%s", s);     for(k = 0; k <= i; k++)         if(strcmp(stu[k].id, s) == 0)             break;     fclose(fp);     j = stu[k].balance;     stu[k].balance -= money;     printf("上机前的金额：%d     上机后的金额：%d\n", j, stu[k].balance);      fp = fopen("duli16.3.dat", "a+");     for(k = 0; k < i; k++)         fprintf(fp, "%15s%15s%10d\n", stu[k].id, stu[k].name, stu[k].balance);     fclose(fp);     system("pause");     system("cls"); } void Add()   //添加新档案 {     struct Student stu[150] = {0};     int j = 0;      if((fp = fopen("duli16.3.dat", "a+")) == NULL)     {         printf("打开文件失败！\n");         exit(0);     }     while(!feof(fp))     {         fscanf(fp, "%s%s%d", stu[j].id, stu[j].name, &stu[j].balance);         j++;     }      printf("请输入学号：");     scanf("%s", stu[j+1].id);     for(int i = 0; i <= j; i++)     {         if(strcmp(stu[i].id, stu[j+1].id) == 0)         {             printf("该学号已存在，请重新输入！\n");             Add();         }     }     printf("姓名：");     scanf("%s", stu[j+1].name);     printf("金额：");     scanf("%d", &stu[j+1].balance);     fprintf(fp, "%15s%15s%10d\n", stu[j+1].id, stu[j+1].name, stu[j+1].balance);     fclose(fp);     system("pause");     system("cls"); } void Logout()   //注销旧档案 {     struct Student stu[150] = {0};     int j, i, l, flag;     char s[15];     j = flag = 0;      if((fp = fopen("duli16.3.dat", "a+")) == NULL)     {         printf("打开文件失败！\n");         exit(0);     }     while(!feof(fp))     {         fscanf(fp, "%s%s%d", stu[j].id, stu[j].name, &stu[j].balance);         j++;     }     fclose(fp);      printf("请输入要注销的学号：");     scanf("%s", s);     printf("确认注销此学号？（1-确认 2-重新输入）\n");     scanf("%d", &l);     if(l == 2)         Logout();     else     {         for(i = 0; i < j; i++)             if(strcmp(stu[i].id, s) == 0)                 break;         for(; i < j; i++)             stu[i] = stu[i+1];          fp = fopen("duli16.3.dat", "w");         for(i = 0; i < j-1; i++)             fprintf(fp, "%15s%15s%10d\n", stu[i].id, stu[i].name, stu[i].balance);         fclose(fp);         system("pause");         system("cls");     } } void Renew()   //续钱 {     struct Student stu[150] = {0};     int money, flag, k, j, i;     char s[15];     flag = -1;     j = 0;      if((fp = fopen("duli16.3.dat", "a+")) == NULL)     {         printf("打开文件失败！\n");         exit(0);     }     while(!feof(fp))     {         fscanf(fp, "%s%s%d", stu[j].id, stu[j].name, &stu[j].balance);         j++;     }     fclose(fp);      printf("请输入学号：");     scanf("%s", s);     printf("续钱额：");     scanf("%d", &money);     for(i = 0; i <= j; i++)     {         if(strcmp(stu[i].id ,s) == 0)         {             k = stu[i].balance + money;             flag++;             printf("续钱成功！续钱前金额：%d     续钱后金额：%d\n", stu[i].balance, k);             stu[i].balance = k;             break;         }     }     if(flag == -1)     {         printf("查无此人，请重新输入！\n");         Renew();     }      fp = fopen("duli16.3.dat", "w");     for(int i = 0; i < j; i++)     {         fprintf(fp, "%15s%15s%10d\n", stu[i].id, stu[i].name, stu[i].balance);         i++;     }     fclose(fp);     system("pause");     system("cls"); } void Create()   //创新功能——显示所有学生信息 {     struct Student stu[150] = {0};     int j = 0;     char ch;     if((fp = fopen("duli16.3.dat", "a+")) == NULL)     {         printf("打开文件失败！\n");         exit(0);     }     while(!feof(fp))     {         fscanf(fp, "%s%s%d", stu[j].id, stu[j].name, &stu[j].balance);         j++;     }      //printf("学号\t\t\t名字\t\t\t余额\n");     for(int i = 0; i < j; i++)     {         fscanf(fp, "%15s%15s%10d", stu[i].id, stu[i].name, stu[i].balance);         printf("%15s%15s%10d\n", stu[i].id, stu[i].name, stu[i].balance);         //printf("%s\t\t\t", stu[i].id);         //printf("%s\t\t\t", stu[i].name);         //printf("%d\n", stu[i].balance);     }     //while((ch = fgetc(fp)) != EOF)         //printf("%c",ch);      fclose(fp);     system("pause");     system("cls"); } int main() {     int i;     while(1)     {         printf("…………………………………………………….\n");         printf(".请输入选项编号（0~7）：\n");         printf(". 1——建立上机档案.\n");         printf(". 2——开始上机.\n");         printf(". 3——离开机房.\n");         printf(". 4——添加新档案.\n");         printf(". 5——注销旧档案.\n");         printf(". 6——续钱.\n");         printf(". 7——创新功能.\n");         printf(". 0——退出系统.\n");         printf("…………………………………………………….\n");         scanf("%d", &i);          switch(i)         {             case 1:                 Build();                 break;             case 2:                 Online();                 break;             case 3:                 Offline();                 break;             case 4:                 Add();                 break;             case 5:                 Logout();                 break;             case 6:                 Renew();                 break;             case 7:                 Create();                 break;             case 0:                 printf("感谢使用本软件！已成功退出，按任意键结束。\n");                 exit(0);             default:                 ;         }     } }


Question: 刚学习linux c网络编程，对IO多路复用的疑惑

引用 3 楼 cfjtaishan 的回复:若每个连接需要处理的逻辑不复杂，可以在一个线程里处理，否则要交给其他线程；这样有更多的时间给其他连接； 好的，多谢分享

引用 1 楼 lgbxyz 的回复:IO多路复用 指的的是使用 select/poll/epoll/kqueen 等函数实现的事件驱动机制, 链接处理的时间长短是不可控的,socket有超时机制,也可以用socketopt指定超时时间. 死循环那是bug不在考虑范围内,IO复用通常是在一个进程内, 具体处理可以使用线程池. 详细了解的话,百度一大堆, 具体可以参考nginx源码 引用 1 楼 lgbxyz 的回复:IO多路复用 指的的是使用 select/poll/epoll/kqueen 等函数实现的事件驱动机制, 链接处理的时间长短是不可控的,socket有超时机制,也可以用socketopt指定超时时间. 死循环那是bug不在考虑范围内,IO复用通常是在一个进程内, 具体处理可以使用线程池. 详细了解的话,百度一大堆, 具体可以参考nginx源码 好的，非常感谢，现在有点思路了，IO复用加线程池确实效率要高，业务处理也更合理点。


Question: 新人

如果一道计算题放在不用函数我会解决 用函数就不知道怎么下手

上图，还是建议你去看下基础书籍，这个还是基础的东西。

函数就是实现复杂的逻辑关系的集合。比如你要显示屏间隔2秒显示一次信息。你自己手动的话就比较麻烦，用函数就可以自动定时2秒显示了


Question: 一个小小的算法

需要将hello.c和sort.c都放入项目树的源文件目录下。

引用 2 楼 赵4老师的回复:代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。 老师，请教个问题，我用的是ubuntu ，安装了个基本c/c++开发环境 我写了两个文件sort.c和hello.c并且在hello.c中调用了sort.c   头文件中也引入了，但是提示找不到 sort.c 这个是不是需要安装什么插件？

引用 1 楼 paschen的回复:最好的解释也比不上你 单步跟踪程序运行，观察每一步变量的变化情况 嗯，好的，多谢， 顺便再请教一个

题目都错了，数组6，你初始化7个数据

最好的解释也比不上你 单步跟踪程序运行，观察每一步变量的变化情况

题目话都说不清楚

仅供参考  #include <stdio.h> #include <stdlib.h>   #define GAME_CNT 7   int calc_min_fine(int endTime[], int fine[], int count, int timeLeft, int total_fine);   int main(int argc, char* argv[]) {  	int endTime[GAME_CNT] = {4, 2, 4, 3, 1, 4, 6}; 	int fine[GAME_CNT]	  = {70,60,50,40,30,20,10}; 	int bouty = 10000; 	 	int min_fine = 0; 	int n = 5;  	if (argc == 2) n = atoi(argv[1]);  	printf("total time is %d\n", n);	 	min_fine = calc_min_fine(endTime, fine, GAME_CNT, n, 0); 	printf("MAX=%d\n", bouty - min_fine);  	return 0; }  int calc_min_fine(int endTime[], int fine[], int count, int timeLeft, int total_fine) { 	int i = 0; 	int index = -1; 	int min = total_fine; 	int sum = 0; 	int front_fine = 0; 	 	for (i = 0; i < count; i++) { 		 		if (timeLeft < endTime[i]) { 			front_fine += fine[i]; 			continue; 		}  		sum = calc_min_fine(endTime+i+1, fine+i+1, count-i-1,  				timeLeft-endTime[i], total_fine + front_fine); 		 		if (index < 0) { 			min = sum; 			index = i; 		} 		 		if (sum < min) { 			min = sum; 			index = i; 		} 		 		front_fine += fine[i]; 	}  	if (index < 0) { 		min += front_fine; 	}  	return min;  }


Question: 新人求助一个关于函数调用和全局静态变量的问题（C语言）

你这个是涉及存储类别的问题，请参考这里http://blog.csdn.net/libing403/article/details/72934528

1. 所有函数都是加载到内存里运行的，每隔函数都有自己在内存的首地址，所以调用函数其实是跳转到某个内存地址去执行； 2. static定义的变量有其作用域，在文件里定义的static变量其作用域是本文件内可见，其他文件不能使用，也是未定义和未可见的。 在函数内定义的static变量，起作用域是其所在函数。 3. 能否编译通过，最好的办法是自己尝试一下，这个也不麻烦。验证的结果，应该是能编译通过的，static变量是在函数里使用了，你明白函数调用的原理，这个问题理解起来也会不难了。 4. static定义的变量和全局变量的生命周期是一样的，因为它们都是在数据段上申请的空间，作用域是整个程序开始到结束； 所以，若是多次调用某个函数（函数内有静态变量的读写），那么这个static定义的变量的值可能是变化了，比如若在你说的那个函数里对这个static的变量进行了修改，那么下次再调用该函数，那么它的值就是被修改之后的。  所以的猜测或者理论都是想象中的，没有经过实践的验证理论也只是理论；所以，建议将自己的问题去实践中验证，然后再去理解，这样可能效果更好！

1楼回答的无问题，也不多说了

1：每一个编译单元被编译成可执行的链接对象，所以你说的进入这个文件是不对的说法。 2：其他地方都看不到这个变量怎么可能用？就比如我都不知道你姓甚名啥，我喂的一声你知道我叫你么 PS：static 表示该变量是文件内可见，所以在头文件进行声明它并在其他地方使用是不应该的（是否报错还需验证） 3：（1）当然是可以的，你可以测试下。（2）你怎么样修改它，它就是什么值。


Question: 程序输入第一个数字的时候是对NULL地址进行操作，为什么对NULL地址操作不报错呢？

引用 9 楼 paschen 的回复:不是有分配内存吗，第一次输入时data不是NULL啊  楼主可单步跟踪程序运行，观察变量变化情况 没注意，capacity初始值为0

引用 7 楼 coverlo 的回复:[quote=引用 2 楼 versatts 的回复:]  capacity += CAPACITY_INCREMENT;        // Create new array of pointers        if(!(temp = (double*)realloc(data, capacity*sizeof(double))))        {          printf("Error allocating memory for data values.\n");          exit(1);        }        data = temp; 这里不是分配了内存么 最后没有释放temp，算不算瑕疵[/quote] data和temp指向同一地址，free一个就行了。

引用 2 楼 versatts 的回复:capacity += CAPACITY_INCREMENT;        // Create new array of pointers        if(!(temp = (double*)realloc(data, capacity*sizeof(double))))        {          printf("Error allocating memory for data values.\n");          exit(1);        }        data = temp; 这里不是分配了内存么 最后没有释放temp，算不算瑕疵

引用 4 楼 Cy_Chance 的回复:讲道理如果data如果真的是null是有问题的，但是问题并不是啊 。data后面是做过复制处理的！为了稳妥起见，可以在使用之前确认下是否是null 看错了，如果capacity初始值不为0的话，就会对NULL进行操作 这里capacity初始值为0

引用 2 楼 versatts 的回复:capacity += CAPACITY_INCREMENT;        // Create new array of pointers        if(!(temp = (double*)realloc(data, capacity*sizeof(double))))        {          printf("Error allocating memory for data values.\n");          exit(1);        }        data = temp; 这里不是分配了内存么 这。。。 没看到一开始capacity变量定义为0，所以if语句是满足条件的，一开始要分配 我大意了

强制类型转换

scanf_s(" %lf", data + count++); 第一次输入一个double型的数据，会写入data指针所指的地址 但是data不是指向NULL吗？ 对NULL操作不会报错吗？


Question: 求助 C语言中如何往txt文件增加数据

引用 9 楼 cfjtaishan 的回复:[quote=引用 6 楼 leoJD 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 对于修改，对于普通文件还没有什么捷径直接修改文件里的某行数据，甚至是某个数据（要做到这些，需要专门的软件），只能是将所有数据读出来，在内存里修改，然后在重新写入文件中；  对于增加数据，如果是在文件末尾增加，可以在打开文件时，以追加的形式打开；若在某行数据之后增加，也只能读到内存里，然后在增加。 我在运行这个程序的时候 用修改再重新输出就是修改后的 但如果重新运行的时候 就不对了，txt文件里也会出现乱码，这要如何解决啊 谢谢[/quote] 看到你的写入用fwrite，但是读取用fscanf，读和写的函数不匹配呢。fscanf是格式化的，一个元素一个元素读取，而fwrite是整个结构体进行写的，建议若用fwrite写，那么就要用fread读吧；注意读写函数要匹配[/quote]好的 谢谢了

引用 6 楼 leoJD 的回复:[quote=引用 3 楼 cfjtaishan 的回复:] 对于修改，对于普通文件还没有什么捷径直接修改文件里的某行数据，甚至是某个数据（要做到这些，需要专门的软件），只能是将所有数据读出来，在内存里修改，然后在重新写入文件中；  对于增加数据，如果是在文件末尾增加，可以在打开文件时，以追加的形式打开；若在某行数据之后增加，也只能读到内存里，然后在增加。 我在运行这个程序的时候 用修改再重新输出就是修改后的 但如果重新运行的时候 就不对了，txt文件里也会出现乱码，这要如何解决啊 谢谢[/quote] 看到你的写入用fwrite，但是读取用fscanf，读和写的函数不匹配呢。fscanf是格式化的，一个元素一个元素读取，而fwrite是整个结构体进行写的，建议若用fwrite写，那么就要用fread读吧；注意读写函数要匹配

引用 7 楼 libing403 的回复:关于c语言对文件的操作，以及输入输出，你可以参考一下这个资料 http://blog.csdn.net/libing403 哦 好的谢谢！

引用 3 楼 cfjtaishan 的回复:对于修改，对于普通文件还没有什么捷径直接修改文件里的某行数据，甚至是某个数据（要做到这些，需要专门的软件），只能是将所有数据读出来，在内存里修改，然后在重新写入文件中；  对于增加数据，如果是在文件末尾增加，可以在打开文件时，以追加的形式打开；若在某行数据之后增加，也只能读到内存里，然后在增加。 我在运行这个程序的时候 用修改再重新输出就是修改后的 但如果重新运行的时候 就不对了，txt文件里也会出现乱码，这要如何解决啊 谢谢

引用 2 楼 js_gary 的回复:建议用数据库做这类题目，数据不多可以用access之类的小型DB。 往文件追加数据可以以"a"方式打开文件，然后中fwrite. 谢了但目前只学了C

引用 1 楼 jianwen0529 的回复:fp=fopen("e:\\1.txt","a") //a 模式是追加写入，不清楚内容并且从最后位置写入数据 谢谢


Question: 求助！九度oj1013,runtime error

边界条件 输入输出格式 ……  变量声明都挪到前面？


Question: 求各位大神帮忙看看这程序怎么了，新手求帮忙

程序很长，除了调试，你可以针对疑惑的地方查一下资料，可以看看这里的资料 http://blog.csdn.net/libing403?viewmode=contents

就算你去医院难道你对医生说：我身体不舒服 然后你让医生一遍遍猜你哪里不舒服或者怎么不舒服吗

同问，你的程序怎么了，建议对于较长的代码先把问题提出来~

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


Question: 编写unix网络编程出现问题

1楼回答比较专业！

库函数写的有很多问题,下载作者提供的源码 http://pix.cs.olemiss.edu/csci561/unpv13e.tar.gz ./configure cd ./unpv13e/lib make  然后使用 其下的lib/unp.h 和 libunp.a 编程


Question: 在没有任何数据时进行无效的读取尝试

try { // string mm = ...; } catch(InvalidOperationException e) { //捕获异常，在这里处理 }  或者判断strReader['密码']的返回值是否为null？  PS：还有这是C#吧，有专门的版块

就是我在输入数据库中没有的账号密码时， 就会出现这个问题。  我想在我输入无效的用户名密码时，返回用户名错误的提示


Question: 求大佬教我怎么把构造有向图中所输入的数据保存到txt文件中

不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了


Question: 链表问题

上帖我画的这两幅图完全可以上教科书了！我觉得。

单步跟踪程序运行，观察变量变化情况，分析原因

建议楼主提供更详细的code，可以参考以下代码： #include <stdio.h> #include <stdlib.h>  typedef int ElementType; typedef struct Node *PtrToNode;  struct Node {     ElementType Data;     PtrToNode   Next; }; typedef PtrToNode List;  List create_list(void); void Print(List L); List Merge(List L1, List L2);  int main(void) {     List L1, L2, L;      L1 = create_list();     L2 = create_list();     Print(L1);     Print(L2);      L = Merge(L1, L2);     Print(L);     return 0; }   List create_list(void) {     List phead, pcur, pnew;     int a, i = 0;      phead = (List)malloc(sizeof(struct Node));     if (!phead) {         fprintf(stderr, "malloc error!\n");         exit(1);     }     phead->Next = NULL;     pcur = phead;     scanf("%d", &a);      for(i = 0; i < a; i++) {         pnew = (List)malloc(sizeof(struct Node));         if (!pnew) {         fprintf(stderr, "malloc error!\n");         exit(1);         }         scanf("%d", &(pnew->Data));         pcur->Next = pnew;         pcur = pcur->Next;     }     pcur->Next = NULL;      return phead; }  List Merge( List L1, List L2 ) {     List L3, q, p, s, t;      L3 = (List)malloc(sizeof(struct Node));     if (!L3) {         fprintf(stderr, "malloc error!\n");         exit(1);     }     L3->Next = NULL;      q = L1->Next;     p = L2->Next;     s = L3;       while (p && q) {         if (p->Data >= q->Data) {            t = q->Next;            s->Next = q;            s = q;            q = t;         } else {            t = p->Next;            s->Next = p;            s = p;            p = t;         }     }      while (p) {         t = p->Next;         s->Next = p;         s = p;         p = t;     }      while (q) {         t = q->Next;         s->Next = q;         s = q;         q = t;     }      return L3; }  void Print(List L) {     List p = L->Next;      while (p) {             printf("%d ", p->Data);             p = p->Next;     }     putchar(10); }

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


Question: 九度oj 1013 runtime error

边界条件 输入输出格式 ……

另外,时间比较 直接比较字符串即可

流程有问题吧, 是先输入后输出, 你的是边输入边输出, 另外这个9度看起来挺差,这么多线上ACM怎么就选了这么个玩意

引用 2 楼 Cy_Chance 的回复:建议你变量声明的时候做好初始化。 例如：char num[15]={0},ear_num[15]={0},late_num[15]={0};

建议你变量声明的时候做好初始化。


Question: 一个windows的窗口，老是出现如下错误，求人帮忙看下，万分感激

项目、属性、链接器、输入、附加依赖项：填写附加依赖库的名字.lib 空格或分号间隔多项

怎么把这个引进去？就是说去哪里引？谢谢

在项目设置里，将winmm.lib引入到工程中

在源程序开头加上:      #include<mmsystem.h>      #pragma comment(lib,"winmm.lib")

在库依赖里面加上 Winmm.lib


typedef unsigned long int pthread_t少一个分号；因为typedef是一条完整的语句，而不是宏定义。 typedef unsigned long int pthread_t; 这句话的意思是，unsigned int别名是pthread_t，可以用pthread_t定义的变量，就相当与unsigned int定义的变量一样。

引用 9楼paschen 的回复:[quote=引用 4 楼 mark_qzh 的回复:] [quote=引用 1 楼 paschen 的回复:] 相当于pthread_t实际是个unsigned long int，只不过用pthread_t表示线程ID 那unsigned long int是个什么类型？无符号长整型？[/quote]  是的，就是long int的无符号型，现在的机器上占4字节[/quote]嗯，我被搞晕了，我在看apue，线程那章节写道实现的时候可用一个结构来代表pthread_t数据类型，所以可移植的操作系统实现不能把它作为整型处理，是不是不同的系统定义不一样？

以前有的机器int 占2个字节,因此要表示 4个字节的int 用long int 类似于64位下的 long long

引用 4 楼 mark_qzh 的回复:[quote=引用 1 楼 paschen 的回复:] 相当于pthread_t实际是个unsigned long int，只不过用pthread_t表示线程ID 那unsigned long int是个什么类型？无符号长整型？[/quote]  是的，就是long int的无符号型，现在的机器上占4字节

sizeof(long int)，应该清楚了

//char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf("typeid(x).name() is %s\n",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]

typedef typedef type-declaration synonym;  The typedef keyword defines a synonym for the specified type-declaration. The identifier in the type-declaration becomes another name for the type, instead of naming an instance of the type. You cannot use the typedef specifier inside a function definition.  A typedef declaration introduces a name that, within its scope, becomes a synonym for the type given by the decl-specifiers portion of the declaration. In contrast to the class, struct, union, and enum declarations, typedef declarations do not introduce new types — they introduce new names for existing types.  Example  // Example of the typedef keyword typedef unsigned long ulong;  ulong ul;     // Equivalent to "unsigned long ul;"  typedef struct mystructtag {    int   i;    float f;    char  c; } mystruct;  mystruct ms;   // Equivalent to "struct mystructtag ms;"  typedef int (*funcptr)();  // funcptr is synonym for "pointer                            //    to function returning int"  funcptr table[10];   // Equivalent to "int (*table[10])();"

unsigned long int  == unsigned long   0-(2^64)-1

引用 1 楼 paschen 的回复:相当于pthread_t实际是个unsigned long int，只不过用pthread_t表示线程ID 那unsigned long int是个什么类型？无符号长整型？

引用 2 楼 weixin_31656265 的回复:typedef 前面有#？  没有的，白纸上写就不淡定了 哈哈

typedef 前面有#？


Question: samba配置文件读取

引用 3楼LubinLew 的回复:最省时省力的方法就是使用xml作为配置文件嗯，以前做过用xml作为配置文件的项目，但是那时候只是修修改改xml文件，没具体研究过，好像要用到libxml的吧

最省时省力的方法就是使用xml作为配置文件

引用 1楼user-2 的回复:samba 是Linux下的文件共享服务程序 ，读取smb.conf本身不是他的亮点吧？！难道是想解决，samba下访问权限的问题么?!不是，我就是想看看它的方法是不是高效点，我也准备写一个读配置的接口函数


Question: 两个多项式相加的程序，数据结构，看看有没有人能解决

引用 4楼kugeniha 的回复:#include<stdio.h> #include<malloc.h>  typedef struct node   /*定义节点*/ { 	float coef;		/*多项式的系数*/ 	int exp;		/*多项式的指数*/ 	struct node * next; }listnode;  listnode * head; listnode * p; listnode * q; listnode * r; listnode * head1; listnode * head2; int head_num = 0; listnode* point[2];  void input()    /*输入的多项式系数和指数*/ { 	int j = 0; 	float coef;	/*节点中存放的多项式的系数*/ 	int exp;	/*节点中存放的多项式的指数*/ 	head = (listnode *)malloc(sizeof(listnode));		/* malloc 分配内存单元空间给头指针*/ 	head->next = NULL;	/*使头指针指向空，为空链表状态*/ start: printf("请输入系数和指数："); 	scanf_s("%f%d", &coef, &exp); 	if (coef == 0)//////////////系数为0退出 		goto next; 	p = (listnode *)malloc(sizeof(listnode));/*malloc 分配内存单元给指针p，通过p去预存输入的系数和指数*/ 	j++; 	p->coef = coef;	/*用p节点存储系数*/ 	p->exp = exp;		/*存储指数*/ 	p->next = head->next;	/*将下一个头指针分配给p，连接*/ 	head->next = p; 	goto start; next: head->exp = j; 	point[head_num] = head;	/*为了创建两个单链表*/ 	head_num++; }  int bubble_sort(listnode * myhead)/*用冒泡排序去将多项式的指数从高到低排序*/ { 	int i, j,num; 	listnode * swap;	/*用来交换节点*/ 	listnode * real_myhead;/*将每个多项式排序传递*/ 	real_myhead = myhead; 	num = myhead->exp; 	if (num == 1 || num == 0) 		goto next; 	for (i = 0; i<num - 1; i++) 	{ 		myhead = real_myhead; 		for (j = 0; j<num - 1; j++) /*将所有的多项式进行扫描*/ 		{ 			if ((myhead->next->exp)<(myhead->next->next->exp)) 			{ 				swap = (listnode *)malloc(sizeof(listnode)); 				swap->exp = myhead->next->exp;	/*将指数小的项传递给swap指针，存储*/ 				swap->coef = myhead->next->coef; 				myhead->next->exp = myhead->next->next->exp;/*将指数大的项排前*/ 				myhead->next->coef = myhead->next->next->coef; 				myhead->next->next->exp = swap->exp; 				myhead->next->next->coef = swap->coef; 				free(swap); 			} 			myhead = myhead->next; 		} 	}  next:return 0; }  void myprintf(listnode * node)//函数的表现形式 { 	listnode * mynode; 	mynode = (listnode *)malloc(sizeof(listnode)); 	mynode->coef = node->coef; 	mynode->exp = node->exp; 	if ((mynode->coef == 1) && (mynode->exp == 1))     //当系数为1，指数为1，输出X 		printf("x"); 	else if ((mynode->coef == 1) && (mynode->exp != 1)  		&& (mynode->exp != 0))                        //当系数为1，指数不为1和不为0，就输出X^exp 		printf("x^%d", mynode->exp); 	else if ((mynode->coef != 1) && (mynode->exp == 1))//系数不为1，指数为1时，输出 coef X 		printf("%.2fx", mynode->coef); 	else if ((mynode->coef != 0) && (mynode->exp == 0))//系数不为0，指数为0，那么X^exp为0，直接输出 coef 		printf("%.f", mynode->coef); 	else                                                //其他情况下，输出    coef X^exp 		printf("%.2fx^%d", mynode->coef, mynode->exp); 	free(mynode); }  int output(listnode * output)    /*输出函数,将多项式输出，还有两个多项式相加的结果输出*/ { 	if (output->exp == 0) 	{ 		printf("0\n"); 		return 0; 	} 	p = output->next; 	if (p->coef>0) 	{ 		myprintf(p); 		p = p->next; 	} 	for (;output->exp>1&&p; p = p->next) 	{ 		if (p->coef>=0) 			printf("+"); 		myprintf(p); 	} 	printf("\n"); 	return 0; }  void plus() { 	int i=0,m=point[0]->exp+point[1]->exp; 	listnode *p=point[0]; 	listnode *tmp; 	point[0]->exp=m; 	//连接两个链表 	for(;p->next;p=p->next); 	p->next=point[1]->next; 	//连接后整体排序 	bubble_sort(point[0]); 	//合并,多余的清0 	for(p=point[0]->next;p->next;p=p->next) 	{ 		if(p->exp==p->next->exp) 		{ 			p->next->coef=p->coef+p->next->coef; 			p->coef=0; 		} 	} 	//消除0系数结点 	for(p=point[0];p->next;) 		if(p->next->coef==0) 		{ 			tmp=p->next; 			p->next=p->next->next; 			free(tmp); 		} 		else p=p->next; }  int main() { 	printf("请输入第一个多项式的各个项的系数和指数(当系数为0时结束输入）\n"); 	input(); 	printf("请输入第二个多项式的各个项的系数和指数(当系数为0时结束输入）\n"); 	input(); 	bubble_sort(point[0]); 	bubble_sort(point[1]); 	printf("第一个多项式为："); 	output(point[0]); 	printf("第二个多项式为："); 	output(point[1]); 	printf("多项式1+多项式2=："); 	plus(); 	output(point[0]); 	printf("Press any key to exit"); 	getchar(); 	getchar(); 	return 0; }挺好的，完美运行哈哈

引用 5楼kugeniha 的回复: #include<stdio.h> #include<malloc.h>  typedef struct node   /*定义节点*/ { 	float coef;		/*多项式的系数*/ 	int exp;		/*多项式的指数*/ 	struct node * next; }listnode;  listnode * head; listnode * p; listnode * q; listnode * r; listnode * head1; listnode * head2; int head_num = 0; listnode* point[2];  void input()    /*输入的多项式系数和指数*/ { 	int j = 0; 	float coef;	/*节点中存放的多项式的系数*/ 	int exp;	/*节点中存放的多项式的指数*/ 	head = (listnode *)malloc(sizeof(listnode));		/* malloc 分配内存单元空间给头指针*/ 	head->next = NULL;	/*使头指针指向空，为空链表状态*/ start: printf("请输入系数和指数："); 	scanf_s("%f%d", &coef, &exp); 	if (coef == 0)//////////////系数为0退出 		goto next; 	p = (listnode *)malloc(sizeof(listnode));/*malloc 分配内存单元给指针p，通过p去预存输入的系数和指数*/ 	j++; 	p->coef = coef;	/*用p节点存储系数*/ 	p->exp = exp;		/*存储指数*/ 	p->next = head->next;	/*将下一个头指针分配给p，连接*/ 	head->next = p; 	goto start; next: head->exp = j; 	point[head_num] = head;	/*为了创建两个单链表*/ 	head_num++; }  int bubble_sort(listnode * myhead)/*用冒泡排序去将多项式的指数从高到低排序*/ { 	int i, j,num; 	listnode * swap;	/*用来交换节点*/ 	listnode * real_myhead;/*将每个多项式排序传递*/ 	real_myhead = myhead; 	num = myhead->exp; 	if (num == 1 || num == 0) 		goto next; 	for (i = 0; i<num - 1; i++) 	{ 		myhead = real_myhead; 		for (j = 0; j<num - 1; j++) /*将所有的多项式进行扫描*/ 		{ 			if ((myhead->next->exp)<(myhead->next->next->exp)) 			{ 				swap = (listnode *)malloc(sizeof(listnode)); 				swap->exp = myhead->next->exp;	/*将指数小的项传递给swap指针，存储*/ 				swap->coef = myhead->next->coef; 				myhead->next->exp = myhead->next->next->exp;/*将指数大的项排前*/ 				myhead->next->coef = myhead->next->next->coef; 				myhead->next->next->exp = swap->exp; 				myhead->next->next->coef = swap->coef; 				free(swap); 			} 			myhead = myhead->next; 		} 	}  next:return 0; }  void myprintf(listnode * node)//函数的表现形式 { 	listnode * mynode; 	mynode = (listnode *)malloc(sizeof(listnode)); 	mynode->coef = node->coef; 	mynode->exp = node->exp; 	if ((mynode->coef == 1) && (mynode->exp == 1))     //当系数为1，指数为1，输出X 		printf("x"); 	else if ((mynode->coef == 1) && (mynode->exp != 1)  		&& (mynode->exp != 0))                        //当系数为1，指数不为1和不为0，就输出X^exp 		printf("x^%d", mynode->exp); 	else if ((mynode->coef != 1) && (mynode->exp == 1))//系数不为1，指数为1时，输出 coef X 		printf("%.2fx", mynode->coef); 	else if ((mynode->coef != 0) && (mynode->exp == 0))//系数不为0，指数为0，那么X^exp为0，直接输出 coef 		printf("%.f", mynode->coef); 	else                                                //其他情况下，输出    coef X^exp 		printf("%.2fx^%d", mynode->coef, mynode->exp); 	free(mynode); }  int output(listnode * output)    /*输出函数,将多项式输出，还有两个多项式相加的结果输出*/ { 	if (output->exp == 0) 	{ 		printf("0\n"); 		return 0; 	} 	p = output->next; 	if (p->coef>0) 	{ 		myprintf(p); 		p = p->next; 	} 	for (;output->exp>1&&p; p = p->next) 	{ 		if (p->coef>=0) 			printf("+"); 		myprintf(p); 	} 	printf("\n"); 	return 0; }  void plus() { 	int i=0,m=point[0]->exp+point[1]->exp; 	listnode *p=point[0]; 	listnode *tmp; 	point[0]->exp=m; 	//连接两个链表 	for(;p->next;p=p->next); 	p->next=point[1]->next; 	//连接后整体排序 	bubble_sort(point[0]); 	//合并,多余的清0 	for(p=point[0]->next;p->next;p=p->next) 	{ 		if(p->exp==p->next->exp) 		{ 			p->next->coef=p->coef+p->next->coef; 			p->coef=0; 		} 	} 	//消除0系数结点 	for(p=point[0];p->next;) 		if(p->next->coef==0) 		{ 			tmp=p->next; 			p->next=p->next->next; 			free(tmp); 		} 		else p=p->next; }  int main() { 	printf("请输入第一个多项式的各个项的系数和指数(当系数为0时结束输入）\n"); 	input(); 	printf("请输入第二个多项式的各个项的系数和指数(当系数为0时结束输入）\n"); 	input(); 	bubble_sort(point[0]); 	bubble_sort(point[1]); 	printf("第一个多项式为："); 	output(point[0]); 	printf("第二个多项式为："); 	output(point[1]); 	printf("多项式1+多项式2=："); 	plus(); 	output(point[0]); 	printf("Press any key to exit"); 	getchar(); 	getchar(); 	return 0; } 挺好的

单步跟踪程序运行，看每一步执行结果与你期望的是否一致，这样容易找到BUG原因

排序问题，建议先判断排序是否正确了，再进行多项式的加法运算。

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


Question: 最近写C问题越来越多啊啊。

引用 5 楼 cfjtaishan 的回复:scanf("%s%d %c", x[i].name, &x[i].num, &x[i].sex); 加一个空格即可，因为%c可以匹配空格，所以再输入num之后再输入sex时，你加了一个空格（这个是必要的），但是%c正好匹配到了这个空格，所以现在要在scanf中加一个空格，这样后面的输入就可以匹配%c了 谢谢，谢谢。

引用 6 楼 zhao4zhong1 的回复:在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 char c; scanf("%c",&c); //时，都改为 char s[2]; char c; scanf("%1s",s); c=s[0]; 能解释一下这样的用意吗？不是很懂。 萌新

引用 12 楼 zhao4zhong1 的回复:[quote=引用 7 楼 jtidni 的回复:] [quote=引用 6 楼 zhao4zhong1 的回复:] 在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 char c; scanf("%c",&c); //时，都改为 char s[2]; char c; scanf("%1s",s); c=s[0]; 能解释一下这样的用意吗？不是很懂。 萌新[/quote] 百度搜相关关键字。[/quote] 知道了，谢谢~

引用 10 楼 cfjtaishan 的回复:scanf中sex是字符串吧，既然用%s输入，就没有必要加&  fflush(stdout)和rewind(stdin)没必要加 sex临时改的，我输入的汉字，没用W女M男代替，之前定义的sex 然后%c输入汉字，出错了， 我才把定义成sex[10]的，后面忘改输入了，，哈哈。 谢谢了，我去改正确。 哦，那个不加fflush（stdout）和rewind（stdin）还是没法完成输入。我不知道那应该加，所以我全加了，然后就正确了

引用 7 楼 jtidni 的回复:[quote=引用 6 楼 zhao4zhong1 的回复:] 在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 char c; scanf("%c",&c); //时，都改为 char s[2]; char c; scanf("%1s",s); c=s[0]; 能解释一下这样的用意吗？不是很懂。 萌新[/quote] 百度搜相关关键字。

谢谢各位大佬，在各位的帮助下，已经调试完成了

知道了明天我试试，谢谢

不加空格， %c 就取到空格了

scanf("%s%d%c", x[i].name, &x[i].num, &x[i].sex); //改为（加上空格） scanf("%s %d %c", x[i].name, &x[i].num, &x[i].sex);

在这里谢谢了，谢谢各位大佬，我不想这么轻易就来论坛的，但确实找不到问题。感觉这两天写脑袋越来越昏。


Question: signal函数原型费解

返回的也是个函数指针，最后括号里的int是返回的函数的参数


Question: 总是有这三个错误，找不出来，那位帮看看，谢谢！

if (char a == '\b'||char a =='\t')  改成：  if (a == '\b' || a == '\t')  已经定义过变量，所以不用再写

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

太Low了吧！

这是基本语法，就好像：“你吃了吗？”  和  “你有没有吃了吗？”  这样的区别。。。。计算机无法识别啊亲，语法不对。

引用 10 楼 unswimmingfish 的回复:[quote=引用 9 楼 unswimmingfish的回复:]我感觉是函数只能定义一次 说错了，是变量只能定义一次[/quote] 函数也不能重复定义 相同作用域的变量只需要定义一次，不同作用域可以存储相同变量名

引用 9 楼 unswimmingfish的回复:我感觉是函数只能定义一次 说错了，是变量只能定义一次

我感觉是函数只能定义一次

第一次见这种写法

引用 2楼我是你的主体 的回复:谢谢！But why？C函数参数里的char a具有函数作用域，即函数结束调用以前都是存在的。而且，C里面的变量都是需要先申明再使用，所以，不能放在if语句里面。

那么vs2008是不是在瞎报警？

谢谢！But why？

把if (char a == '\b'||char a =='\t') 里面的两个 char 去掉 写成 if (a == '\b' || a =='\t')


Question: 写的C语言克鲁斯卡尔算法实现最小生成树 显示没错误但是实现不了 中途就退出了 求大神帮忙

《算法精解（C语言描述）》 ？


Question: strcpy函数出错

strcpy(head->number,p[0]);                 strcpy(head->name,p[1]);                 strcpy(head->sex,p[2]);                 strcpy(head->age,p[3]);                 strcpy(head->birthplace,p[4]);                 strcpy(head->GPA,p[5]); 建议判断一下p[0], p[1], p[2], p[3], p[4], p[5]是否为NULL， 现在怀疑p[0]~p[5]有为NULL或者为野指针的。 另外，也可以通过j的值来判定，即j的值若小于等于5，则strcpy就会有问题。

单步调试 估计要么是指针没有指向正确的地址，要么是你内存不足以拷贝源字符串

其实是由于局部变量的作用域的问题，把上面的 char *buf=new char【36】 调到 getline函数下面就解决了问题了。 但是最后出现“屯屯屯”的字样现在还没有解决 搞不懂他是什么时候被读进去的。

不会发图片 你试一下 这个代码就知道了 int m = 20;     printf("%p\n", &m);     {         int m = 30;         printf("%p\n", &m);     }

看下面这个图片

while 循环 当中 char  *buf=new char[36];  改为 buf=new char[36];


Question: 地址赋值指针加强制转换问题

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

因为野指针了, 出错是正常的吧.  char *tables[8];//此数组类型改不了 unsigned int *p = (unsigned int *)0x6800e008; table[0]=（char *）p;  你想要的是不是这个效果.

char *tables[8];//此数组类型改不了 unsigned int *p; *p=0x6800e008; //p指向哪里？ “0x6800e008”原本并不占有储存空间。 table[0]=（char *）p;

不能直接给指针赋值，p=0x6800e008 理论上也应该报错。

嗯那，犯了这么基础的错误，已改正，谢谢大家。

引用 3 楼 wang0635 的回复:p=0x6800e008; 不是 *p=0x6800e008; ++ *p=0x6800e008是对指针指向的内存空间（4个字节）赋值。 若是p = 0x6800e008，但是不能确定这个地址是否可以使用呢，建议使用malloc申请

引用 3楼wang0635 的回复:p=0x6800e008; 不是 *p=0x6800e008;对的，我在题目中打错了。马上修改。

p=0x6800e008; 不是 *p=0x6800e008;

移植魔方还原算法，它是先手动申请内存，然后遍历，将近20000条指令，为了节省时间，所以现在第一次申请完表格后就直接复制地址。

还有这种操作。。。不能直接手动分配地址，我记得


Question: 求一个 3×3矩阵两条对角线上元素之和（每个元素只加一次）。

引用 3 楼 cfjtaishan 的回复:既然是数组，那么中间的那个元素先判断是否为素数，若是素数，那么在总和里减去中间那个计算两次的素数 素数?

引用 4 楼 farmanlinuxer 的回复:[quote=引用 3 楼 cfjtaishan 的回复:] 既然是数组，那么中间的那个元素先判断是否为素数，若是素数，那么在总和里减去中间那个计算两次的素数 素数?[/quote] 嗯？不是要计算对角线上的素数之和吗？

第一种方法： 在计算之前，脑子里肯定已经知道了那个元素被重复计算了几次了，那么算完之后，再减去相应的次数。 第二种方法： 用一个nxm的（在你这题里是3x3）的bool数组，去标记已经把哪个元素计算过了，因为下标相同，所以很好操作，这样可以不用预先去思考哪些元素被重复加过。

这还不简单，计算完之后，如果N为奇数，再减一次a[N/2][N/2]，N为偶数不处理


Question: 纯小白求助

已经解决，今天打开Dev-c++时候提示说一个目录并不存在，不知道是不是这个的原因

引用 4 楼 幻夢之葉的回复:[quote=引用 2 楼 weixin_39116372 的回复:] [quote=引用 1 楼 好大一个土豆的回复:]这样输入试试  20,50,6 一开始就试过了，还是不行。[/quote] 你s输入是6,6/250 == 0 s乘以任何数都是0，结果没错[/quote] 但是一开始输入的是书上的100,20,300结果也是0

引用 4 楼 幻夢之葉的回复:[quote=引用 2 楼 weixin_39116372 的回复:] [quote=引用 1 楼 好大一个土豆的回复:]这样输入试试  20,50,6 一开始就试过了，还是不行。[/quote] 你s输入是6,6/250 == 0 s乘以任何数都是0，结果没错[/quote] 好的，我等会试试再看一下

scanf里面最好不要加,号（除非针对专门格式的输入），这样输入几个数的时候之间用空格就可以了。

scanf指定输入的数之间要用逗号隔开，所以输入时应该：20,50,6回车  20,50,6回车 f=      6000.0000  你输入方式如下： 20 50 6回车 f=         0.0000

引用 2 楼 weixin_39116372 的回复:[quote=引用 1 楼 好大一个土豆的回复:]这样输入试试  20,50,6 一开始就试过了，还是不行。[/quote] 你s输入是6,6/250 == 0 s乘以任何数都是0，结果没错

scanf 里带逗号，你输入的时候没有，那就只有第一个变量(p)赋值了,其他两个(w,s)并没有，是默认值0

引用 1 楼 好大一个土豆的回复:这样输入试试  20,50,6 一开始就试过了，还是不行。

这样输入试试  20,50,6


Question: c中乘法溢出的疑惑

http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

您的系统是32位系统，整形乘法溢出后只有低32位（只是简单的阶段了高位）：0x15e002c4即十进制：367002308 您在64位下应该是对的，或使用long long 类型

图发不出去…内容是 (2222222222×2222222222) mod 4294967296 = 367002308

如图(｢･ω･)｢嘿(｢･ω･)｢嘿

无符号整数超过最大值就会溢出到0，不断循环，最后结果就是你那个数。


Question: 小白求助，关于加密问题。

你要是从密文就能看出是des还是aes，那不牛逼上天了

要是这么容易解密，别个还加密干嘛

要知道如何解密，就需要先了解明文是如何加密的。 加密就是要掩盖明文的意思，通过加密让其他人不能理解和看到明文的意思； 加解密是相对的。

是base64编解码 而不是base64加解密！

这个需要专业的密码学知识吧，在这里问怕是难有结论

base64为了把一段二进制的流转为可以在互联网传输的明文字符串。并不是为了什么加密二用的，你把它解码回去，也就是一段二进制的byte数组。 看不懂是正常的。

从密文没办法推断加密方法的


Question: 请教高手，请问如何将两个txt文本中的字符进行比较？（C语言）

引用 6 楼 zanfeng 的回复:[quote=引用 5 楼 hdt 的回复:] 我觉得                                                                                那么长时间不回复的，然后突然回复一下，lz 一般不会结帖。h[/quote]  引用 6 楼 zanfeng 的回复:[quote=引用 5 楼 hdt 的回复:] 我觉得                                                                                那么长时间不回复的，然后突然回复一下，lz 一般不会结帖。h[/quote]  引用 6 楼 zanfeng 的回复:[quote=引用 5 楼 hdt 的回复:] 我觉得                                                                                那么长时间不回复的，然后突然回复一下，lz 一般不会结帖。h[/quote]  引用 6 楼 zanfeng 的回复:[quote=引用 5 楼 hdt 的回复:] 我觉得                                                                                那么长时间不回复的，然后突然回复一下，lz 一般不会结帖。h[/quote]  引用 6 楼 zanfeng 的回复:[quote=引用 5 楼 hdt 的回复:] 我觉得                                                                                那么长时间不回复的，然后突然回复一下，lz 一般不会结帖。h[/quote]t

引用 5 楼 hdt 的回复:我觉得                                                                                那么长时间不回复的，然后突然回复一下，lz 一般不会结帖。h

我觉得                                                                                那么长时间不回复的，然后突然回复一下，lz 一般不会结帖。

引用 2 楼 village_children 的回复:算   但是源代码怎么写呢？ 将两个文件里的内容先加载到内存（即打开文件，读文件），然后使用字符串比较和解析函数处理。

搜“编辑距离”

算   但是源代码怎么写呢？

StXRuYNvRuHoaBbvizXztNwRRuuNNP 这个算吗？


Question: 高水平的C都需要学那些课程

《The Intel 64 and IA-32 Architectures Software Developer's Manual》

C语言要学习，基础C和系统编程（线程，进程，文件操作，同步，socket编程等）

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语言指针与汇编内存地址-四.三维数组

APUE当做参考书多看看

编程的核心是算法和数据结构，C语言只是工具， 单论C语言的话，找几本书看看，关键是多练习，不懂得地方刨根问底搞清楚，逐渐积累。 C语言的工作方向太多了，每一个方向都肯能有其独立性的知识和技巧， 不光要多谢还要多读，有能力看看开源代码，你能发现各种方法和技巧。

估计又是一个基础的不肯干，高端的看不懂的好汉

我就不推荐书了，我觉得还是c基本的都了解了后，然后学习数据结构吧

C Primer Plus  C语言程序设计：现代方法：第2版(被誉为"近10年来最好的一部C语言著作") C和指针 或者谭浩强《C程序设计》 以上任选一本就差不多了，以下为参考书： 《深入理解C指针》 《C语言点滴》 《C陷阱与缺陷》 《C专家编程》 《C语言课程设计案例精编》 C语言程序开发范例宝典 C语言经典编程282例

首先，把编程语言基础学好，比如C语言，可以把它说成是一个工具，一个程序最终目标并不是每天敲代码，即码农，最终自己能够设计、理解业务。 当然，编程基本功是要有的，针对C的话，找一本基础的C书看一下，比如谭老师的，或国外的都可以，然后要以看一看高质量C编程相关的，另外，多练外还要多debug，这样才能加深理解。


Question: 小白求助，关于文件的写入后的读取

个人的建议是每次输入，都要和你的文件里的登录名都匹配一次，密码一样； 另外，这个也好定位，怎么定位呢，每次从文件里读取的和输入的文件名和密码都输出来。  你这个不匹配很可能是fgets导致，怎么说呢，fgets会将'\n'加入到缓存区里，即myusername缓存里实际上多了'\n',这是fgets本身读取时自动加上去的（前提是读取的字符串长度小于缓存的大小）。 只需要将读取的和输入的打印出来，对比一下就可以了。

fflush fclose  When the "r+", "w+", or "a+" access type is specified, both reading and writing are allowed (the file is said to be open for “update”). However, when you switch between reading and writing, there must be an intervening fflush, fsetpos, fseek, or rewind operation. The current position can be specified for the fsetpos or fseek operation, if desired.

这是我系统的注册和登陆部分，注册写入文本文件后，登陆系统就找不到用户名，求帮忙！


Question: 关于有位域的大小端求教

结贴, 结论是 大小端单个字节中的8位也是顺序相反的  struct tcphdr { 	__be16	source; 	__be16	dest; 	__be32	seq; 	__be32	ack_seq; #if defined(__LITTLE_ENDIAN_BITFIELD) 	__u16	res1:4, 		doff:4, 		fin:1, 		syn:1, 		rst:1, 		psh:1, 		ack:1, 		urg:1, 		ece:1, 		cwr:1; #elif defined(__BIG_ENDIAN_BITFIELD) 	__u16	doff:4, 		res1:4, 		cwr:1, 		ece:1, 		urg:1, 		ack:1, 		psh:1, 		rst:1, 		syn:1, 		fin:1; #else #error	"Adjust your <asm/byteorder.h> defines" #endif	 	__be16	window; 	__sum16	check; 	__be16	urg_ptr; };

不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！

在内存中，字节是最小的内存单位。位域是比字节更小，即一个字节8位，而位域的变量是占一个字节里的某几个位，或者一个变量的多个位（比如int类型的20位，总共32位）；位域也是有大小的，比如4位，那么它的范围就是一个字节的前4个位用于标识一个变量； test1_t类型的结构体，大小是1个字节，var1和var2占该字节的高4字节和低4字节。对于，那个是占高字节，那个占低字节，要看是大端系统还是小端系统；对于小端系统，var1占低4位，var2占高4位。

仅供参考：#include <stdio.h> #pragma pack(push,1) union U {     unsigned char byte;     struct BF {         unsigned int b0:1;//a         unsigned int b1:1;//b         unsigned int b2:1;//c     } bf; } u; #pragma pack(pop) unsigned char bt; int a,b,c; int main() {     for (bt=0;bt<8;bt++) {         u.byte=(unsigned char)bt;         a=u.bf.b0;         b=u.bf.b1;         c=u.bf.b2;         printf("byte 0x%02x -- c:%d b:%d a:%d\n",bt,c,b,a);     }     for (c=0;c<2;c++)     for (b=0;b<2;b++)     for (a=0;a<2;a++) {         u.bf.b0=a;         u.bf.b1=b;         u.bf.b2=c;         bt=u.byte;         printf("c:%d b:%d a:%d -- byte 0x%02x\n",c,b,a,bt);     }     return 0; } //byte 0x00 -- c:0 b:0 a:0 //byte 0x01 -- c:0 b:0 a:1 //byte 0x02 -- c:0 b:1 a:0 //byte 0x03 -- c:0 b:1 a:1 //byte 0x04 -- c:1 b:0 a:0 //byte 0x05 -- c:1 b:0 a:1 //byte 0x06 -- c:1 b:1 a:0 //byte 0x07 -- c:1 b:1 a:1 //c:0 b:0 a:0 -- byte 0x00 //c:0 b:0 a:1 -- byte 0x01 //c:0 b:1 a:0 -- byte 0x02 //c:0 b:1 a:1 -- byte 0x03 //c:1 b:0 a:0 -- byte 0x04 //c:1 b:0 a:1 -- byte 0x05 //c:1 b:1 a:0 -- byte 0x06 //c:1 b:1 a:1 -- byte 0x07

大神都哪去了


Question: 题目：删除文件中的注释：将C语言程序test.c中的注释删除后存入另一个文件new_test.c中；

for( i = 0; i < n; i++ ) i应该是从1开始，要不然s1[i-1]可能越界  还有诸如下面的形式，你的成员能正常跑出结果吗？  print("sdads//fdfmd");  int a/*, b*/, c;  /* Function: func Parameter: x */

最后再一个人的博客上看到了解释和解决方法 在读完文件的最后一个字符后，fp->flag仍然没有被置为_IOEOF，因而feof()仍然没有探测到文件结尾。直到再次调用fgetc()执行读操作，feof()才能探测到文件结尾。这样就多执行了一次。 对于feof()这个函数, 它是先读再判断是否到文件尾, 也就是说在它之前一定要读一次才能做出判断。 而我们经常这样把它使用在循环中： int c; while(!feof(fp)) { c = fgetc(fp); printf("%x\n",c); } 它是先判断==>再读(可能这时就是文件尾了, 读不出东西了) 所以正确的代码应该是 int c;  c = fgetc(fp); while(!feof(fp)) { printf("%x\n",c); c = fgetc(fp);  } 原博地址： http://blog.sina.com.cn/s/blog_a3e571160101irii.html

引用 2 楼 user-2 的回复:最后读到文件尾，会先写入，再判断循环条件是否成立。i=0时，i-1越界吧 那该怎么修改判断语句呢，我试了下用fscanf和fgets ！= EOF 不能解决问题

最后读到文件尾，会先写入，再判断循环条件是否成立。i=0时，i-1越界吧


Question: 如何将21位bmp图像转换成RGB888 和RGB565 存放起来

百度搜相关关键字。

说错了 是24位bmp图像


Question: c语言读取文件的时候，读出来的文本不一样

关于c语言的文件读写函数用法详解，可参考一下这个资料 http://blog.csdn.net/libing403

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

c的库函数中有一个现成的可以解析有规律的文件的函数，就是fscanf（）函数。 不需要自己写作无用功 可以参考： http://blog.csdn.net/liangxanhai/article/details/8026496

对于这样有格式的文本文件，建议使用fscanf/fprintf对文件进行读写； fscanf(fp, "%s %d %s\n", newStud[i].net_name,&newStud[i].distance, newStud[i].next_routing)  另外，scanf的参数net_name,和next_routing本身就是数组名，即地址。不需要前面在加&


Question: 批量处理，写分析完结果到txt

引用 3 楼 maychard1121 的回复:发现要是自己新建文件夹AAA就可行了，奇怪 file不是自动新建文件夹么 文件可以通过打开方式，比如w写的形式打开一个文件，若文件不存在自动创建；对于目录（文件夹）不能自动创建的，再说目录是不能直接存放数据的，目录下创建文件才可以存放数据的吧

引用 3 楼 maychard1121 的回复:发现要是自己新建文件夹AAA就可行了，奇怪 file不是自动新建文件夹么 谁告诉你的？

发现要是自己新建文件夹AAA就可行了，奇怪 file不是自动新建文件夹么

Error	2	fatal error C1057: unexpected end of file in macro expansion  这样必然不行呀

"e:\\AAA\" 最后一个斜杠去掉，后面需要加文件名或者路径的时候，在后续加上斜杠。你这样编译应该就会出问题的吧

CString FileSavePath = _T("e:\\AAA\");  改成：  CString FileSavePath = _T("e:\\AAA\\");


Question: c   中使用 minixml  出现   undefined reference to

如果是gcc的话 编译加上 -static 选项

可以参考： http://blog.csdn.net/shenwansangz/article/details/47155521

这些都是mxml的接口函数，应该是编译时没有加-lmxml，即编译时没有链接动态库。 了解更多，可以参考一下这个博主的文章： http://www.cnblogs.com/liunianshiwei/p/6086577.html


Question: 新手求助！我这个枚举法写的有关红绿灯程序是哪里出了问题？求指导

最后发现是main函数最后少了一个 “ } ”

暂没发现问题。运行了你的程序，没有发现问题。你是想要实现什么？

再供参考：#include <windows.h> #include <stdio.h>  void ConPrint(char *CharBuffer, int len); void ConPrintAt(int x, int y, char *CharBuffer, int len); void gotoXY(int x, int y); void ClearConsole(void); void ClearConsoleToColors(int ForgC, int BackC); void SetColorAndBackground(int ForgC, int BackC); void SetColor(int ForgC); void HideTheCursor(void); void ShowTheCursor(void);  int main(int argc, char* argv[]) {    HideTheCursor();    ClearConsoleToColors(15, 1);    ClearConsole();    gotoXY(1, 1);    SetColor(14);    printf("This is a test...\n");    Sleep(5000);    ShowTheCursor();    SetColorAndBackground(15, 12);    ConPrint("This is also a test...\n", 23);    SetColorAndBackground(1, 7);    ConPrintAt(22, 15, "This is also a test...\n", 23);    gotoXY(0, 24);    SetColorAndBackground(7, 1);    return 0; }  //This will clear the console while setting the forground and //background colors. void ClearConsoleToColors(int ForgC, int BackC) {    WORD wColor = ((BackC & 0x0F) << 4) + (ForgC & 0x0F);    //Get the handle to the current output buffer...    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    //This is used to reset the carat/cursor to the top left.    COORD coord = {0, 0};    //A return value... indicating how many chars were written    //not used but we need to capture this since it will be    //written anyway (passing NULL causes an access violation).    DWORD count;     //This is a structure containing all of the console info    // it is used here to find the size of the console.    CONSOLE_SCREEN_BUFFER_INFO csbi;    //Here we will set the current color    SetConsoleTextAttribute(hStdOut, wColor);    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //This fills the buffer with a given character (in this case 32=space).       FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);        FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       //This will set our cursor position for the next print statement.       SetConsoleCursorPosition(hStdOut, coord);    } }  //This will clear the console. void ClearConsole() {    //Get the handle to the current output buffer...    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    //This is used to reset the carat/cursor to the top left.    COORD coord = {0, 0};    //A return value... indicating how many chars were written    //   not used but we need to capture this since it will be    //   written anyway (passing NULL causes an access violation).    DWORD count;    //This is a structure containing all of the console info    // it is used here to find the size of the console.    CONSOLE_SCREEN_BUFFER_INFO csbi;    //Here we will set the current color    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //This fills the buffer with a given character (in this case 32=space).       FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       //This will set our cursor position for the next print statement.       SetConsoleCursorPosition(hStdOut, coord);    } }  //This will set the position of the cursor void gotoXY(int x, int y) {    //Initialize the coordinates    COORD coord = {x, y};    //Set the position    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord); }  //This will set the forground color for printing in a console window. void SetColor(int ForgC) {    WORD wColor;    //We will need this handle to get the current background attribute    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    CONSOLE_SCREEN_BUFFER_INFO csbi;     //We use csbi for the wAttributes word.    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //Mask out all but the background attribute, and add in the forgournd color       wColor = (csbi.wAttributes & 0xF0) + (ForgC & 0x0F);       SetConsoleTextAttribute(hStdOut, wColor);    } }  //This will set the forground and background color for printing in a console window. void SetColorAndBackground(int ForgC, int BackC) {    WORD wColor = ((BackC & 0x0F) << 4) + (ForgC & 0x0F);;    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), wColor); }  //Direct console output void ConPrint(char *CharBuffer, int len) {    DWORD count;    WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), CharBuffer, len, &count, NULL); }  //Direct Console output at a particular coordinate. void ConPrintAt(int x, int y, char *CharBuffer, int len) {    DWORD count;    COORD coord = {x, y};    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    SetConsoleCursorPosition(hStdOut, coord);    WriteConsole(hStdOut, CharBuffer, len, &count, NULL); }  //Hides the console cursor void HideTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = FALSE; 	  SetConsoleCursorInfo(hStdOut, &cciCursor);    } }  //Shows the console cursor void ShowTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = TRUE; 	  SetConsoleCursorInfo(hStdOut, &cciCursor);    } }

仅供参考：#include <conio.h> #include <windows.h>  void ConPrintAt(int x, int y, char *CharBuffer, int len) {    DWORD count;    COORD coord = {x, y};    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    SetConsoleCursorPosition(hStdOut, coord);    WriteConsole(hStdOut, CharBuffer, len, &count, NULL); } void HideTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = FALSE;       SetConsoleCursorInfo(hStdOut, &cciCursor);    } }  void ShowTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = TRUE;       SetConsoleCursorInfo(hStdOut, &cciCursor);    } } void GetWH(int *w,int *h) {     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     CONSOLE_SCREEN_BUFFER_INFO csbi;     if (GetConsoleScreenBufferInfo(hStdOut, &csbi)) {         *w=csbi.srWindow.Right;         *h=csbi.srWindow.Bottom;     } else {         *w=80;         *h=25;     } } void ClearConsole() {    //Get the handle to the current output buffer...    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    //This is used to reset the carat/cursor to the top left.    COORD coord = {0, 0};    //A return value... indicating how many chars were written    //   not used but we need to capture this since it will be    //   written anyway (passing NULL causes an access violation).    DWORD count;    //This is a structure containing all of the console info    // it is used here to find the size of the console.    CONSOLE_SCREEN_BUFFER_INFO csbi;    //Here we will set the current color    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //This fills the buffer with a given character (in this case 32=space).       FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       //This will set our cursor position for the next print statement.       SetConsoleCursorPosition(hStdOut, coord);    } }  int main() {     unsigned short k;     int x,y,w,h;     char d;      SetConsoleOutputCP(437);     ClearConsole();     GetWH(&w,&h);     x=w/2;y=h/2;     HideTheCursor();     ConPrintAt(x,y,"O",1);     d='o';     while (1) {         Sleep(50);         if (kbhit()) {             k=getch();             if (27==k) break;//按Esc键退出             if (0==k||0xe0==k) k|=getch()<<8;//非字符键             switch (k) {                 case 0x48e0:case 0x04800://上                     d='u';                     if (y>0) {                         ConPrintAt(x,y," ",1);                         y--;                         ConPrintAt(x,y,"O",1);                     }                 break;                 case 0x50e0:case 0x05000://下                     d='d';                     if (y<h) {                         ConPrintAt(x,y," ",1);                         y++;                         ConPrintAt(x,y,"O",1);                     }                 break;                 case 0x4be0:case 0x04b00://左                     d='l';                     if (x>0) {                         ConPrintAt(x,y," ",1);                         x--;                         ConPrintAt(x,y,"O",1);                     }                 break;                 case 0x4de0:case 0x04d00://右                     d='r';                     if (x<w-1) {                         ConPrintAt(x,y," ",1);                         x++;                         ConPrintAt(x,y,"O",1);                     }                 break;             } //          cprintf("%04x pressed.\r\n",k);         } else {             switch (d) {                 case 'u':                     if (y>0) {                         ConPrintAt(x,y," ",1);                         y--;                         ConPrintAt(x,y,"O",1);                     }                 break;                 case 'd':                     if (y<h) {                         ConPrintAt(x,y," ",1);                         y++;                         ConPrintAt(x,y,"O",1);                     }                 break;                 case 'l':                     if (x>0) {                         ConPrintAt(x,y," ",1);                         x--;                         ConPrintAt(x,y,"O",1);                     }                 break;                 case 'r':                     if (x<w-1) {                         ConPrintAt(x,y," ",1);                         x++;                         ConPrintAt(x,y,"O",1);                     }                 break;             }         }     }     ClearConsole();     ShowTheCursor();     return 0; }


Question: 求大神解答啊 错在哪里啊 程序运行报错

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

在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 char c; scanf("%c",&c); //时，都改为 char s[2]; char c; scanf("%1s",s); c=s[0];

char x; printf("输入你的结果:"); scanf_s("%s", &x);  x是char类型，因此不能用%s输入，需要用%c，并且在scanf_s之前，加getchar();用于吸收上面输入后残留在输入缓冲区里的回车符；  char x; printf("输入你的结果:"); getchar(); scanf_s("%c", &x);


Question: 二叉树递归和非递归遍历

#include <iostream> #include<string.h> #include<stack> #include <stdio.h> #include <stdio.h> #include <stdlib.h> using namespace std;  typedef struct node {     char data;     struct node *lchild,*rchild; }BinTree;  typedef struct node1 {     BinTree *btnode;     bool isFirst; }BTNode;   void creatBinTree(char *s,BinTree *&root)  //创建二叉树，s为形如A(B,C(D,E))形式的字符串  {     int i;     bool isRight=false;     stack<BinTree*> s1;          //存放结点      stack<char> s2;              //存放分隔符     BinTree *p,*temp;     root->data=s[0];     root->lchild=NULL;     root->rchild=NULL;     s1.push(root);     i=1;     while(i<strlen(s))     {         if(s[i]=='(')         {             s2.push(s[i]);             isRight=false;         }             else if(s[i]==',')             {             isRight=true;         }         else if(s[i]==')')         {             s1.pop();             s2.pop();         }         else if(isalpha(s[i]))         {             p=(BinTree *)malloc(sizeof(BinTree));             p->data=s[i];             p->lchild=NULL;             p->rchild=NULL;             temp=s1.top();             if(isRight==true)                 {                 temp->rchild=p;                 cout<<temp->data<<"的右孩子是"<<s[i]<<endl;             }             else             {                 temp->lchild=p;                 cout<<temp->data<<"的左孩子是"<<s[i]<<endl;             }             if(s[i+1]=='(')                 s1.push(p);         }         i++;     }     }  void display(BinTree *root)        //显示树形结构  {     if(root!=NULL)     {         cout<<root->data;         if(root->lchild!=NULL)         {             cout<<'(';             display(root->lchild);         }         if(root->rchild!=NULL)         {             cout<<',';             display(root->rchild);             cout<<')';         }     } }  void preOrder1(BinTree *root)     //递归前序遍历  {     if(root!=NULL)     {         cout<<root->data<<" ";         preOrder1(root->lchild);         preOrder1(root->rchild);     } }  void inOrder1(BinTree *root)      //递归中序遍历 {     if(root!=NULL)     {         inOrder1(root->lchild);         cout<<root->data<<" ";         inOrder1(root->rchild);     } }   void postOrder1(BinTree *root)    //递归后序遍历 {     if(root!=NULL)     {         postOrder1(root->lchild);         postOrder1(root->rchild);         cout<<root->data<<" ";     }     }   void preOrder2(BinTree *root)     //非递归前序遍历  {     stack<BinTree*> s;     BinTree *p=root;     while(p!=NULL||!s.empty())     {         while(p!=NULL)         {             cout<<p->data<<" ";             s.push(p);             p=p->lchild;         }         if(!s.empty())         {             p=s.top();             s.pop();             p=p->rchild;         }     } }  void inOrder2(BinTree *root)      //非递归中序遍历 {     stack<BinTree*> s;     BinTree *p=root;     while(p!=NULL||!s.empty())     {         while(p!=NULL)         {             s.push(p);             p=p->lchild;         }         if(!s.empty())         {             p=s.top();             cout<<p->data<<" ";             s.pop();             p=p->rchild;         }     }     }   void postOrder2(BinTree *root)    //非递归后序遍历 {     stack<BTNode*> s;     BinTree *p=root;     BTNode *temp;     while(p!=NULL||!s.empty())     {         while(p!=NULL)              //沿左子树一直往下搜索，直至出现没有左子树的结点           {             BTNode *btn=(BTNode *)malloc(sizeof(BTNode));             btn->btnode=p;             btn->isFirst=true;             s.push(btn);             p=p->lchild;         }         if(!s.empty())         {             temp=s.top();             s.pop();             if(temp->isFirst==true)     //表示是第一次出现在栈顶               {                 temp->isFirst=false;                 s.push(temp);                 p=temp->btnode->rchild;                 }             else                        //第二次出现在栈顶               {                 cout<<temp->btnode->data<<" ";                 p=NULL;             }         }     }     }   void postOrder3(BinTree *root)     //非递归后序遍历 {     stack<BinTree*> s;     BinTree *cur;                      //当前结点      BinTree *pre=NULL;                 //前一次访问的结点      s.push(root);     while(!s.empty())     {         cur=s.top();         if((cur->lchild==NULL&&cur->rchild==NULL)||            (pre!=NULL&&(pre==cur->lchild||pre==cur->rchild)))         {             cout<<cur->data<<" ";  //如果当前结点没有孩子结点或者孩子节点都已被访问过                s.pop();             pre=cur;          }         else         {             if(cur->rchild!=NULL)                 s.push(cur->rchild);             if(cur->lchild!=NULL)                     s.push(cur->lchild);         }     }     }   int main(int argc, char *argv[]) {     char s[100];     while(scanf("%s",s)==1)     {         BinTree *root=(BinTree *)malloc(sizeof(BinTree));         creatBinTree(s,root);         display(root);         cout<<endl;         preOrder2(root);         cout<<endl;          inOrder2(root);         cout<<endl;         postOrder2(root);         cout<<endl;         postOrder3(root);         cout<<endl;     }     return 0; }

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

typedef struct BiTNode{     char data; struct BiTNode *lchild, *rchild; }BiTNode;    /*少个分号*/ typedef BiTNode* BiTree;    /*少个分号*/

typedef struct BiTNode{     char data; struct BiTNode *lchild, *rchild; }BiTNode;    /*少个分号*/ typedef BiTNode* BiTree    /*少个分号*/ typedef不像宏定义，不需要分号。typedef是一条完整的语句，因此需要末尾的分号


Question: 求助！求大神找出错误3*4矩阵输入1~12后结果不对啊

引用 2 楼 战在春秋 的回复：for(j=0;j<4;j++);  // 多了一个分号，小心一些就好了    应该是：  for (i = 0; i < 3; i++) 		for (j = 0; j < 4; j++) 			scanf("%d", &a[i][j]); 用心回答每个问题，如果有帮助，请采纳答案好吗，谢谢~~~谢谢帮助两年后我已经转战python了

引用 3 楼 自信男孩 的回复：#include <stdio.h>  int main() {     int a[3][4];     int i,j,row,col,min;      for(i=0;i<3;i++)         for(j = 0;j<4;j++)             scanf("%d", &a[i][j]);      for(i=0;i<3;i++)     {         for(j=0;j<4;j++)             printf("%d ", a[i][j]);         printf("\n");     }      min = a[0][0];     row = 0;col=0;     for(i=0;i<3;i++)         for(j=0;j<4;j++)             if(min > a[i][j])             {                 min = a[i][j];                 row = i;                 col=j;             }     printf("min=%d,row=%d,col=%d",min,row,col); }  多了一个分号，另外，注意coding style.输出时，数据间加一个空格，会让输出结果更好的分析谢谢帮助两年后我已经转战python了

引用 1 楼 天糊土 的回复：逻辑是正确的，注意下细节谢谢帮助两年后我已经转战python了

逻辑是正确的，注意下细节


Question: C语言数据结构二叉树

#include "head.h" typedef  int DataType;  typedef struct tree{ 	DataType num; 	struct tree *left_child; 	struct tree *right_child; }node;  node * init_tree(void) { 	node *root = (node *)malloc(sizeof(node)); 	(node *)memset(root, 0x00, sizeof(node)); 	 	root->left_child = NULL; 	root->right_child = NULL; 	 	return root; }  void insert_tree(node **root) { 	static node *last_node = NULL; 	 	if(*root != NULL){ 		fprintf(stderr, "%s\012", "Here is not empty !"); 		return; 	} 	node *rt = (node *)calloc(1, sizeof(node)); 	*root = rt; 	if(!last_node){ 		system("color 0C"); 		fprintf(stderr, "%s\012", "\"The data inserted into the root node .\""); 		Sleep(2000); 		system("color 0A"); 	} 	printf("Enter to insert data :"); 	while(scanf("%d", &rt->num) == 0){ 		fflush(stdin); 		fprintf(stderr, "%s", "Illegal input and input again :"); 	} 	rt->left_child = NULL; 	rt->right_child = NULL; 	 	system("color 0C"); 	fprintf(stderr, "%s", "\n\t-----------------------------------------\n"); 	fprintf(stderr, "%s\n", "\t1.insert left_child  2.insert right_child\n\ 	3.insert brother     0.end_insert"); 	fprintf(stderr, "%s", "\t-----------------------------------------\n\n"); 	Sleep(3000); 	system("color 0A"); 	int choose; 	lb: fprintf(stderr, "%s", "Please select a :"); 	while(scanf("%d", &choose) == 0){ 		fflush(stdin); 		fprintf(stderr, "%s", "Illegal input and input again :"); 	} 	if(choose > 3 || choose < 0){ 		fprintf(stderr, "%s", "There is no this option.\012"); 		goto lb; 	}	 	 	switch(choose){ 		case 1:{ 			last_node = rt; 			insert_tree(&rt->left_child); 		}break; 		 		case 2:{ 			last_node = rt; 			insert_tree(&rt->right_child); 		}break; 		 		case 3:{ 			if(last_node != NULL){ 				if(last_node->left_child != NULL && last_node->right_child != NULL) 					fprintf(stderr, "%s", "Have no place to insert .\012"); 				 				else if(last_node->left_child == NULL) 					insert_tree(&last_node->left_child); 				 				else 					insert_tree(&last_node->right_child); 			} 	 		}break; 		case 4:{ 			 		}break; 		 		case 0: 			return; 	} 	 }  void preorder(node **p) { 	if(*p == NULL) 		return; 	fprintf(stderr, "%d ",(*p)->num); 	preorder(&(*p)->left_child); 	preorder(&(*p)->right_child); 	 }  void inorder(node **p) { 	if(*p == NULL) 		return; 	inorder(&(*p)->left_child); 	fprintf(stderr, "%d ",(*p)->num); 	inorder(&(*p)->right_child); 	 }  void postorder(node **p) { 	if(*p == NULL) 		return; 	inorder(&(*p)->left_child); 	inorder(&(*p)->right_child); 	fprintf(stderr, "%d ",(*p)->num); 	 }  void show(node **root) { 	node *p = *root; 	char order; 	fflush(stdin); 	lb2:system("color 0C"); 	fprintf(stderr, "%s", "\n\t--------------------------------------\n"); 	fprintf(stderr, "%s", "\tb:PreOrder i:Inorder a:PostOrder e:end\012"); 	fprintf(stderr, "%s", "\t--------------------------------------\n\n"); 	Sleep(3000); 	system("color 0A"); 	fprintf(stderr, "%s", "Choose the way to traverse :"); 	while(scanf("%c", &order) != '\n'){ 		fflush(stdin); 		switch(order){ 			case 'b': 				fprintf(stderr, "%s", "For the former sequence traversal results:"); 				preorder(&p); 				fprintf(stderr, "%c", '\012'); 				goto lb2; 				break; 		 			case 'i': 				fprintf(stderr, "%s", "In order to traverse the results :"); 				inorder(&p); 				fprintf(stderr, "%c", '\012'); 				goto lb2; 				break; 		 			case 'a': 				fprintf(stderr, "%s", "After the sequence traversal results for: \ "); 				postorder(&p); 				fprintf(stderr, "%c", '\012'); 				goto lb2; 				break; 				 			case 'e': 				return; 				 			default:{ 				fprintf(stderr, "%s", "There is no this option.\012"); 				goto lb2; 			} 		} 		 	}  }  node * creat_tree(void) { 	node *root = init_tree(); 	insert_tree(&root->left_child); 	show(&root->left_child); 	 	return root; }

无非是先序 中序 后序


Question: c语言中出现函数不接受 2 个参数

程序有至少两处错误： 1.调用QuickSort的实参个数少一个； 2. 第一个参数（实参）应直接传a.   #include <stdio.h> #include <stdlib.h>  #define N 6  int partition(int arr[], int low, int high) {     int key;      key = arr[low];     while(low<high) {         while(low <high && arr[high]>= key )             high--;         if(low<high)             arr[low++] = arr[high];         while( low<high && arr[low]<=key )             low++;         if(low<high)             arr[high--] = arr[low];     }     arr[low] = key;     return low; }  void quick_sort(int arr[], int start, int end) {     int pos;     if (start<end) {         pos = partition(arr, start, end);         quick_sort(arr,start,pos-1);         quick_sort(arr,pos+1,end);     }     return; }  int main(void) {     int i;     int arr[N]={32,12,7, 78, 23,45};     printf("排序前 \n");     for(i=0;i<N;i++)         printf("%d\t",arr[i]);     quick_sort(arr,0,N-1);     printf("\n 排序后 \n");     for(i=0; i<N; i++)         printf("%d\t", arr[i]);     printf ("\n");      return 0; } 参考一下这个快速排序算法；

QuickSort(a[], num); void QuickSort(int a[], int begin, int end)

#include <stdlib.h>         void qsort(void *base, size_t nmemb, size_t size,                   int (*compar)(const void *, const void *));


Question: error C2664 怎么处理？

引用 1 楼 user-1 的回复:要看你的那行代码了，给strcmp的第二个参数是什么类型？  谢谢您，大神。 我好想发现问题了，右括号位置弄错了。

引用 1 楼 user-1 的回复:要看你的那行代码了，给strcmp的第二个参数是什么类型？ #pragma warning(disable:4996) #include<stdio.h> #include<string.h> int main() { 	char *pstr[5], name[5][20];//这里的*pstr[5]其实就是一个二维指针，因为数组是用来存放指针的，指针前面在加一个 *  	char **p; 	int i; 	for (i = 0; i < 5; i++) 	{ 		pstr[i] = name[i]; 	} 	for (i = 0; i < 5; i++) 	{ 		scanf("%s", pstr[i]); 	} 	for (i = 0; i < 5; i++) 	{ 		printf("%s\n", pstr[i]); 	} 	return 0; 	void sort(char**p); 	p = pstr; 	sort(p); 	for (i = 0; i < 5; i++) 	{ 		printf("%s\n", *(p + i)); 	} 	return 0; } void sort(char**p) { 	int i, j; 	for (i = 0; i < 5-1; i++) 	{ 		int sign = i; 		for (j = i + 1; j < 5; j++) 		{ 			if (strcmp(*(p + i), *(p + j)>0))//错误。 				sign = j; 		} 		if (sign != i) 		{ 			char *temp; 			temp = *(p + i); 			*(p + i) = *(p + sign); 			*(p + sign) = temp; 		} 	} }

要看你的那行代码了，给strcmp的第二个参数是什么类型？


Question: 请教大神：C语言提取时间问题

谢谢各路大神！！学习了

百度搜索“C 格式化字符串”

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

char tm_str[16] = "00:02:14"; int hour, min, sec; sscanf(tm_str, "%d:%d:%d", &hour, &min, &sec); printf("%02d%02d%02d\n", hour, min, sec); snprintf(tm_str, 16, "%02d%02d%02d", hour, min, sec); puts(tm_str);  若在转回字符串，可以使用sprintf/snprintf

char tm_str[] = "00:02:14"; int hour, min, sec; sscanf(tm_str, "%d:%d:%d", &hour, &min, &sec); printf("%02d%02d%02d\n", hour, min, sec);


Question: 输出给定区间的随机偶数和随机奇数,当前区间为[0,9]，大家帮忙看一下

谢谢各位前辈们，看来我还需要多加强学习！

你可以查一下rand的使用说明。

注意2 * rand();的到值可能是一个负值，因为2 * rand();得到的值可能超过了int表示的范围。 所以，先对rand();的值做一个取余操作。

1.计算方法错误 ( 8 / (2 * rand())) 只有 在rand()返回1~3才不为0, rand()随机范围是int, 落再1~3的几率约等于0 2.未使用 srand()函数设置seed,每次rand返回值都是相同的,要想得到不同的随机值seed每次也不能一样 3.正确的程序  #include <stdio.h> #include <stdlib.h> #include <time.h>  /* 输出给定区间的随机偶数和随机奇数,当前区间为[0,9]*/ int main(void) { 	int even, odd; 	srand(time(NULL)); 	even = 2 * (rand() % 5); 	odd = 1 + 2 * (rand() % 5); 	printf("%d %d\n", even, odd); 	return 0; }

rand()返回值太大了，以至于 8 / (2 * rand()) 等于0


Question: 32位浮点数的表示问题

理解和讨论之前请先学会如何观察！  浮点数格式 http://bbs.csdn.net/topics/390676437

http://blog.csdn.net/biblereader/article/details/819428 参考一下别人的博客，浮点数的表示方法和int,char等等不一样，因为其有小数部分