Question: 数据结构，多项式加法，如何实现连续的输入，最后再连续的输出

引用 5 楼 qq_36212387 的回复:[quote=引用 4 楼 cfjtaishan 的回复:] [quote=引用 3 楼 qq_36212387 的回复:] [quote=引用 1 楼 cfjtaishan 的回复:] #include<stdio.h>  typedef struct{     int x;     int m; }List;  void select_sort(List *t, int n) {     int i, j, h, max;     List temp;      for(i = 0; i < n; i++)     {         h = i;         max = t[i].m;         for(j = i + 1; j < n; j++) {             if(t[j].m > max) {                 max = t[j].m;                 h = j;             }         }         if(h != i)         {             temp = t[i];             t[i] = t[h];             t[h] = temp;         }     } }   void print_list(List *l, int len) {     int i;      for (i = 0; i < len; i++)         printf("[%3d, %3d]\t", l[i].x, l[i].m);     putchar(10);  } int merge(List *a, List *b, List *c, int alen, int blen) {      int i = 0, j = 0, k, cnt = 0;      while(i < alen && j < blen &&(a[i].m >= 0 && b[j].m >= 0))     {         if(a[i].m > b[j].m) {             for (k = 0; k < cnt; k++)                 if (c[k].m == a[i].m) {                     c[k].x += a[i].x;                     i++;                     break;                 }              if (k >= cnt) {                 c[cnt] = a[i];                 i++;                 cnt++;             }         }         if(a[i].m < b[j].m) {             for (k = 0; k < cnt; k++)                 if (c[k].m == b[j].m) {                     c[k].x += b[j].x;                     j++;                     break;                 }             if (k >= cnt) {                 c[cnt] = b[j];                 j++;                 cnt++;             }         }         if(a[i].m == b[j].m) {             if(a[i].x + b[j].x == 0) {                 i++;                 j++;             } else {                 c[cnt].x = a[i].x + b[j].x;                 c[cnt++].m = a[i].m;                 i++;                 j++;             }          }     }     while(i < alen && a[i].m >= 0) {         c[cnt++] = a[i];         i++;     }     while(j < blen && b[j].m>=0) {         c[cnt++]=b[j];         j++;     }      return cnt; } int main() {     int n, i, j, d, k = 0, z = 0;     List a[300], b[300], c[600];      scanf("%d", &n);      while(n--)     {         for(i = 0; i < 300; i++)         {             scanf("%d%d", &a[i].x, &a[i].m);             if(a[i].m<0)                 break;             k++;         }         for(j = 0; j < 300; j++)         {             scanf("%d%d",&b[j].x, &b[j].m);             if(b[j].m<0)                 break;             z++;         }         select_sort(a, k);         printf("List one: ");         print_list(a, k);         select_sort(b, z);         printf("List two: ");         print_list(b, z);         d = merge(a, b, c, k, z);         for(i = 0; i < d; i++) {             printf("[%d %d] ",c[i].x,c[i].m);         }         printf("\n");         //print_list(c, d);         /*Initize*/         k = 0;         z = 0;     }     return 0; } 这道题怎么那么熟悉呢，前两天提过这个问题吧  前两天提的时候没注意输出的格式，今天提交发现输出的格式不对，另用一个while输出的话就只能输出第二组的数据，我用了一个for循环输出又发现没有输出结果，求改，谢谢[/quote] 需要什么样的格式？我的代码测试还有问题吗？[/quote]  代码的答案没有问题，我只是需要一个连续的输入，最后再连续的按照输入的顺序输出[/quote] 输出的格式是对的，但是测试出问题了 1 5 6 2 4 10 -1 2 3 7 8 1 -1 5 [ 7 8 ] [ 5 6 ] [ 2 4 ] [ 2 3 ] [ 11 -1 ] Press any key to continue 题目要求是不能输出幂为负的，这组数据输出了，然后那个数字5是我在那个merge函数里面加的一句输出，用来测试cnt的值，发现不对，不知道该怎么改了

引用 3 楼 qq_36212387 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] #include<stdio.h>  typedef struct{     int x;     int m; }List;  void select_sort(List *t, int n) {     int i, j, h, max;     List temp;      for(i = 0; i < n; i++)     {         h = i;         max = t[i].m;         for(j = i + 1; j < n; j++) {             if(t[j].m > max) {                 max = t[j].m;                 h = j;             }         }         if(h != i)         {             temp = t[i];             t[i] = t[h];             t[h] = temp;         }     } }   void print_list(List *l, int len) {     int i;      for (i = 0; i < len; i++)         printf("[%3d, %3d]\t", l[i].x, l[i].m);     putchar(10);  } int merge(List *a, List *b, List *c, int alen, int blen) {      int i = 0, j = 0, k, cnt = 0;      while(i < alen && j < blen &&(a[i].m >= 0 && b[j].m >= 0))     {         if(a[i].m > b[j].m) {             for (k = 0; k < cnt; k++)                 if (c[k].m == a[i].m) {                     c[k].x += a[i].x;                     i++;                     break;                 }              if (k >= cnt) {                 c[cnt] = a[i];                 i++;                 cnt++;             }         }         if(a[i].m < b[j].m) {             for (k = 0; k < cnt; k++)                 if (c[k].m == b[j].m) {                     c[k].x += b[j].x;                     j++;                     break;                 }             if (k >= cnt) {                 c[cnt] = b[j];                 j++;                 cnt++;             }         }         if(a[i].m == b[j].m) {             if(a[i].x + b[j].x == 0) {                 i++;                 j++;             } else {                 c[cnt].x = a[i].x + b[j].x;                 c[cnt++].m = a[i].m;                 i++;                 j++;             }          }     }     while(i < alen && a[i].m >= 0) {         c[cnt++] = a[i];         i++;     }     while(j < blen && b[j].m>=0) {         c[cnt++]=b[j];         j++;     }      return cnt; } int main() {     int n, i, j, d, k = 0, z = 0;     List a[300], b[300], c[600];      scanf("%d", &n);      while(n--)     {         for(i = 0; i < 300; i++)         {             scanf("%d%d", &a[i].x, &a[i].m);             if(a[i].m<0)                 break;             k++;         }         for(j = 0; j < 300; j++)         {             scanf("%d%d",&b[j].x, &b[j].m);             if(b[j].m<0)                 break;             z++;         }         select_sort(a, k);         printf("List one: ");         print_list(a, k);         select_sort(b, z);         printf("List two: ");         print_list(b, z);         d = merge(a, b, c, k, z);         for(i = 0; i < d; i++) {             printf("[%d %d] ",c[i].x,c[i].m);         }         printf("\n");         //print_list(c, d);         /*Initize*/         k = 0;         z = 0;     }     return 0; } 这道题怎么那么熟悉呢，前两天提过这个问题吧  前两天提的时候没注意输出的格式，今天提交发现输出的格式不对，另用一个while输出的话就只能输出第二组的数据，我用了一个for循环输出又发现没有输出结果，求改，谢谢[/quote] 需要什么样的格式？我的代码测试还有问题吗？

引用 4 楼 cfjtaishan 的回复:[quote=引用 3 楼 qq_36212387 的回复:] [quote=引用 1 楼 cfjtaishan 的回复:] #include<stdio.h>  typedef struct{     int x;     int m; }List;  void select_sort(List *t, int n) {     int i, j, h, max;     List temp;      for(i = 0; i < n; i++)     {         h = i;         max = t[i].m;         for(j = i + 1; j < n; j++) {             if(t[j].m > max) {                 max = t[j].m;                 h = j;             }         }         if(h != i)         {             temp = t[i];             t[i] = t[h];             t[h] = temp;         }     } }   void print_list(List *l, int len) {     int i;      for (i = 0; i < len; i++)         printf("[%3d, %3d]\t", l[i].x, l[i].m);     putchar(10);  } int merge(List *a, List *b, List *c, int alen, int blen) {      int i = 0, j = 0, k, cnt = 0;      while(i < alen && j < blen &&(a[i].m >= 0 && b[j].m >= 0))     {         if(a[i].m > b[j].m) {             for (k = 0; k < cnt; k++)                 if (c[k].m == a[i].m) {                     c[k].x += a[i].x;                     i++;                     break;                 }              if (k >= cnt) {                 c[cnt] = a[i];                 i++;                 cnt++;             }         }         if(a[i].m < b[j].m) {             for (k = 0; k < cnt; k++)                 if (c[k].m == b[j].m) {                     c[k].x += b[j].x;                     j++;                     break;                 }             if (k >= cnt) {                 c[cnt] = b[j];                 j++;                 cnt++;             }         }         if(a[i].m == b[j].m) {             if(a[i].x + b[j].x == 0) {                 i++;                 j++;             } else {                 c[cnt].x = a[i].x + b[j].x;                 c[cnt++].m = a[i].m;                 i++;                 j++;             }          }     }     while(i < alen && a[i].m >= 0) {         c[cnt++] = a[i];         i++;     }     while(j < blen && b[j].m>=0) {         c[cnt++]=b[j];         j++;     }      return cnt; } int main() {     int n, i, j, d, k = 0, z = 0;     List a[300], b[300], c[600];      scanf("%d", &n);      while(n--)     {         for(i = 0; i < 300; i++)         {             scanf("%d%d", &a[i].x, &a[i].m);             if(a[i].m<0)                 break;             k++;         }         for(j = 0; j < 300; j++)         {             scanf("%d%d",&b[j].x, &b[j].m);             if(b[j].m<0)                 break;             z++;         }         select_sort(a, k);         printf("List one: ");         print_list(a, k);         select_sort(b, z);         printf("List two: ");         print_list(b, z);         d = merge(a, b, c, k, z);         for(i = 0; i < d; i++) {             printf("[%d %d] ",c[i].x,c[i].m);         }         printf("\n");         //print_list(c, d);         /*Initize*/         k = 0;         z = 0;     }     return 0; } 这道题怎么那么熟悉呢，前两天提过这个问题吧  前两天提的时候没注意输出的格式，今天提交发现输出的格式不对，另用一个while输出的话就只能输出第二组的数据，我用了一个for循环输出又发现没有输出结果，求改，谢谢[/quote] 需要什么样的格式？我的代码测试还有问题吗？[/quote]  代码的答案没有问题，我只是需要一个连续的输入，最后再连续的按照输入的顺序输出

仅供参考：//链表实现一元多项式的加法减法乘法 #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; }

引用 1 楼 cfjtaishan 的回复:#include<stdio.h>  typedef struct{     int x;     int m; }List;  void select_sort(List *t, int n) {     int i, j, h, max;     List temp;      for(i = 0; i < n; i++)     {         h = i;         max = t[i].m;         for(j = i + 1; j < n; j++) {             if(t[j].m > max) {                 max = t[j].m;                 h = j;             }         }         if(h != i)         {             temp = t[i];             t[i] = t[h];             t[h] = temp;         }     } }   void print_list(List *l, int len) {     int i;      for (i = 0; i < len; i++)         printf("[%3d, %3d]\t", l[i].x, l[i].m);     putchar(10);  } int merge(List *a, List *b, List *c, int alen, int blen) {      int i = 0, j = 0, k, cnt = 0;      while(i < alen && j < blen &&(a[i].m >= 0 && b[j].m >= 0))     {         if(a[i].m > b[j].m) {             for (k = 0; k < cnt; k++)                 if (c[k].m == a[i].m) {                     c[k].x += a[i].x;                     i++;                     break;                 }              if (k >= cnt) {                 c[cnt] = a[i];                 i++;                 cnt++;             }         }         if(a[i].m < b[j].m) {             for (k = 0; k < cnt; k++)                 if (c[k].m == b[j].m) {                     c[k].x += b[j].x;                     j++;                     break;                 }             if (k >= cnt) {                 c[cnt] = b[j];                 j++;                 cnt++;             }         }         if(a[i].m == b[j].m) {             if(a[i].x + b[j].x == 0) {                 i++;                 j++;             } else {                 c[cnt].x = a[i].x + b[j].x;                 c[cnt++].m = a[i].m;                 i++;                 j++;             }          }     }     while(i < alen && a[i].m >= 0) {         c[cnt++] = a[i];         i++;     }     while(j < blen && b[j].m>=0) {         c[cnt++]=b[j];         j++;     }      return cnt; } int main() {     int n, i, j, d, k = 0, z = 0;     List a[300], b[300], c[600];      scanf("%d", &n);      while(n--)     {         for(i = 0; i < 300; i++)         {             scanf("%d%d", &a[i].x, &a[i].m);             if(a[i].m<0)                 break;             k++;         }         for(j = 0; j < 300; j++)         {             scanf("%d%d",&b[j].x, &b[j].m);             if(b[j].m<0)                 break;             z++;         }         select_sort(a, k);         printf("List one: ");         print_list(a, k);         select_sort(b, z);         printf("List two: ");         print_list(b, z);         d = merge(a, b, c, k, z);         for(i = 0; i < d; i++) {             printf("[%d %d] ",c[i].x,c[i].m);         }         printf("\n");         //print_list(c, d);         /*Initize*/         k = 0;         z = 0;     }     return 0; } 这道题怎么那么熟悉呢，前两天提过这个问题吧  前两天提的时候没注意输出的格式，今天提交发现输出的格式不对，另用一个while输出的话就只能输出第二组的数据，我用了一个for循环输出又发现没有输出结果，求改，谢谢


Question: 单片机按钮控制跑马灯

百度搜相关关键字。

补充一下，需要用到定时器和中断器。


Question: 哪位能阐述关于编码思路的问题，求各位分享编码思路，共同学习！

《C语言课程设计案例精编》——俄罗斯方块

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

我做的大多都是单片机的编程。 单片机的编程比较简单。硬件驱动和业务区分很清楚。分模块实现硬件功能，分模块实现软件业务。模块化的设计思想在单片机里，个人感觉是最实用的。

编码首先需要熟悉一门语言吧，然后根据需求用这门语言去解决问题。

这属于《软件工程》的问题了吧

上网查用什么库，找到库，看库的例子确定是否合适。 确定之后则参考文档与例子开写，不会写则继续用搜索引擎搜。


Question: czt算法的c语言实现

百度搜相关关键字。


Question: 网络编程，怎么实现数据发送成功率？

引用 6 楼 cfjtaishan 的回复:[quote=引用 5 楼 qq_38374462 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] [quote=引用 2 楼 qq_38374462 的回复:] 我写的就是TCP，失败的次数指send返回哪个值？就是数跟总成功的比率吗？ 看send的返回值，send成功和失败都会有对应的返回值[/quote] send成功是根据recv成功同时判断的吗，会不会send成功了，recv会失败？[/quote] 这个是TCP来保证的，底层会重传，recv失败那是接收的问题，你要计算两边的成功率吗？ 如果你要保证发过去的对方真的接收了，并且接收成功了，那么你就让对端发一个接收成功的回应包（或者失败的回应包），本端通过判断该回应包来确定是否成功或着失败[/quote] 这样写对不对 可是打印出来有问题，这里显示发送成功率100%，但是已经不能从数据库读数据，应该是逻辑显示错误的，大神可以帮我改一下吗

引用 5 楼 qq_38374462 的回复:[quote=引用 3 楼 cfjtaishan 的回复:] [quote=引用 2 楼 qq_38374462 的回复:] 我写的就是TCP，失败的次数指send返回哪个值？就是数跟总成功的比率吗？ 看send的返回值，send成功和失败都会有对应的返回值[/quote] send成功是根据recv成功同时判断的吗，会不会send成功了，recv会失败？[/quote] 除非经常断网，否则不太可能。

引用 5 楼 qq_38374462 的回复:[quote=引用 3 楼 cfjtaishan 的回复:] [quote=引用 2 楼 qq_38374462 的回复:] 我写的就是TCP，失败的次数指send返回哪个值？就是数跟总成功的比率吗？ 看send的返回值，send成功和失败都会有对应的返回值[/quote] send成功是根据recv成功同时判断的吗，会不会send成功了，recv会失败？[/quote] 这个是TCP来保证的，底层会重传，recv失败那是接收的问题，你要计算两边的成功率吗？ 如果你要保证发过去的对方真的接收了，并且接收成功了，那么你就让对端发一个接收成功的回应包（或者失败的回应包），本端通过判断该回应包来确定是否成功或着失败

引用 3 楼 cfjtaishan 的回复:[quote=引用 2 楼 qq_38374462 的回复:] 我写的就是TCP，失败的次数指send返回哪个值？就是数跟总成功的比率吗？ 看send的返回值，send成功和失败都会有对应的返回值[/quote] send成功是根据recv成功同时判断的吗，会不会send成功了，recv会失败？

引用 1 楼 cfjtaishan 的回复:这个成功率是发送次数的总数除以成功的次数； 如果是TCP的可以做到，如果是UDP，可以考虑加一个回应协议包。 发送成功跟发送失败是根据什么判定的？

引用 2 楼 qq_38374462 的回复:我写的就是TCP，失败的次数指send返回哪个值？就是数跟总成功的比率吗？ 看send的返回值，send成功和失败都会有对应的返回值

我写的就是TCP，失败的次数指send返回哪个值？就是数跟总成功的比率吗？

在服务器端增加回应逻辑， 如果客户端收到了server的回应包，则就可以确保client发送是成功的 如果没有收到回应包，超过发送timeout时间，就认为是失败的

搜“心跳包”

引用 9 楼 zhao4zhong1 的回复:不知道有多少前人掉在TCP Socket send(人多)send(病少)send(财富) recv(人多病)recv(少财富) 陷阱里面啊！ http://bbs.csdn.net/topics/380167545 感谢你的回复 请问大神我这样写的发送成功率对不对？因为我把服务器关闭的时候，send还没有返回-1，直到第二次开始发送才返回-1，我想要的是当我把服务器关闭的时候（或者数据发送失败的时候），send能否马上响应到？


Question: printf()里的自动转换规则是怎样的？

int 或者short 都可以，

引用 2 楼 自信男孩的回复:%u是unsigned int类型的，printf以%u输出，类似unsigned int a = (unsigned int )v; printf("%u", a);
那想请问一下unsigned char要怎么输出呢，用%u就转换成int了嘛

@jianwen0529 @cfjtaishan  感谢二位解答，论坛解决问题效率高，对新人帮助很大

unsigned char uv=(unsigned)v; // uv = 255，数据截断  %u 是指输出无符号int类型， -1 转换为无符号int类型 = 4294967295


Question: 关于动态分配内存的问题

引用 3 楼 cfjtaishan 的回复:[quote=引用 2 楼 oYeYuanXinZhiZhu1 的回复:] 这是我自己修改后的代码，其中有一点，在动态创建z【n】这个数组后，如何将元素初始值全部赋为0？ 我不知道就用了个循环一个个赋值的#include <stdio.h> #include <stdlib.h> int main () { 	int n; 	while(scanf("%d",&n)!=EOF) 	{ 		//int  x[n],y[n],z[n]={0}; 	//	int y[n],z[n]={0}; 		int *x=(int *)malloc(n*sizeof(int)); 		int *y=(int *)malloc(n*sizeof(int)); 		int *z=(int *)malloc(n*sizeof(int)); 		for(int i=0;i<n;i++) 		{ 			z[i]=0; 		} 		for(int i=0;i<n;i++) 		{ 			scanf("%d%d",&x[i],&y[i]); 			z[x[i]]=y[i]+z[x[i]];	 		} 		for(int i=0;i<n;i++) 		{	 			if(z[i]!=0) 			{ 				printf("%d %d\n",i,z[i]); 			} 		} 		free(x); 		free(y); 		free(z); 	} 	return 0; } calloc就能做到，它是申请空间并且对元素初始化为0；所以，我建议你查查这两个函数的不同嘛[/quote] 谢谢~

引用 2 楼 oYeYuanXinZhiZhu1 的回复:这是我自己修改后的代码，其中有一点，在动态创建z【n】这个数组后，如何将元素初始值全部赋为0？ 我不知道就用了个循环一个个赋值的#include <stdio.h> #include <stdlib.h> int main () { 	int n; 	while(scanf("%d",&n)!=EOF) 	{ 		//int  x[n],y[n],z[n]={0}; 	//	int y[n],z[n]={0}; 		int *x=(int *)malloc(n*sizeof(int)); 		int *y=(int *)malloc(n*sizeof(int)); 		int *z=(int *)malloc(n*sizeof(int)); 		for(int i=0;i<n;i++) 		{ 			z[i]=0; 		} 		for(int i=0;i<n;i++) 		{ 			scanf("%d%d",&x[i],&y[i]); 			z[x[i]]=y[i]+z[x[i]];	 		} 		for(int i=0;i<n;i++) 		{	 			if(z[i]!=0) 			{ 				printf("%d %d\n",i,z[i]); 			} 		} 		free(x); 		free(y); 		free(z); 	} 	return 0; } calloc就能做到，它是申请空间并且对元素初始化为0；所以，我建议你查查这两个函数的不同嘛

#include <stdio.h> #include <stdlib.h> int main () {     int n;     int *x, *y, *z;     while(scanf("%d",&n)!=EOF)     {         x = (int *)malloc(n * sizeof(int));         if (!x) {             fprintf(stderr, "malloc error!\n");             exit(-1);         }         y = (int *)malloc(n * sizeof(int));         if (!y) {             fprintf(stderr, "malloc error!\n");             exit(-1);         }         z = (int *)calloc(1, n * sizeof(int));         if (!z) {             fprintf(stderr, "malloc error!\n");             exit(-1);         }         for(int i=0;i<n;i++)         {             scanf("%d%d",&x[i],&y[i]);             z[x[i]]=y[i]+z[x[i]];         }         for(int i=0;i<n;i++)         {             if(z[i]!=0)             {                 printf("%d %d\n",i,z[i]);             }         }         free(x);         free(y);         free(z);     }     return 0; } 注意输入x[i]时，可能会导致z越界。 建议百度一下malloc, calloc


Question: 分享几本C语言的书，适合新手看

要注册啊 好像很麻烦

谭老师的书是否已经更新，老版本已经不适应现在的使用了。

收下了，我再网上视频中也听老师介绍了基本关于C的书，可以去看看 《C Primer plus》这本书我买了，不过暂时我看不懂，需要一定的基础 《C语言程序设计》网上有视频，可以对照视频看 《C和指针》介绍和学习指针的，为学习JAVA打基础

谢谢，指明学习方向

顶一下，

帮顶  《深入理解C指针》 《C语言点滴》 《C陷阱与缺陷》 《C专家编程》

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

收下了


Question: C嵌套SQL 多个c文件link问题

将错误信息中出现的标识符放在百度里面搜一下，看其在哪个.lib中，然后在本地硬盘上搜索该.lib,如果没有，在网上搜索相关库或模块下载安装，然后将其所在目录填写到“附加依赖库所在目录”中，将其名字添加到“附加依赖库”中，重新连接。 项目、属性、链接器、常规、附加库目录：填写附加依赖库所在目录 分号间隔多项 项目、属性、链接器、输入、附加依赖项：填写附加依赖库的名字.lib 空格或分号间隔多项


Question: 问个问题，

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

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

电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。  不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了

建议自己动手做一下，不论是是命令拷贝，还是编程读写，都可以尝试一下，这样说服力可能会更好

通常不一样  比如存：1.23，文本4个字符4字节，二进制double则8字节

一般不一样。如整数12在文本文件中占两个字符，dat文件中占sizeof (int)个字节，小数1.2文本中3个字符，dat中double是8个字节

没人吗？？？？？？？？？？？？？？？？？？


Question: define的问题

理解和讨论之前请先学会如何观察！  VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898

首先宏定义，A(x) 为   x/2，当执行时把参数直接替换X 不做任何处理  就变为7+3/2，这就是宏定义存在的缺陷，在运算时会存在副作用，还有就是不能通过调试解决，一般定义时就要带上括号，看做一个整体((x)/2)

楼上正解，即 7+（3/2）

替换成 7+3/2    先运算除法，再加法  所以：宏与函数不同，宏只是替换

A(7+3) ==> 7+3/2 就是8了


Question: my.cpp(1): fatal error C1083: 无法打开包括文件:“stdafx.h”: No such file or directory

引用 3 楼 zhao4zhong1 的回复:引用 2 楼 suifengjz 的回复:[quote=引用 1 楼 zhao4zhong1 的回复:] //#include "stdafx.h"为什么要注释掉呢，我看网上大部分的源码都带这个，新手不懂 百度搜stdafx.h[/quote]在百科里面看到了答案，谢谢了

引用 2 楼 suifengjz 的回复:引用 1 楼 zhao4zhong1 的回复://#include "stdafx.h"为什么要注释掉呢，我看网上大部分的源码都带这个，新手不懂 百度搜stdafx.h

//#include "stdafx.h"


Question: #ifdef 怎么判断 #define XX 2

The #if, #elif, #else, and #endif Directives The #if directive, with the #elif, #else, and #endif directives, controls compilation of portions of a source file. If the expression you write (after the #if) has a nonzero value, the line group immediately following the #if directive is retained in the translation unit.  Syntax  conditional :  if-part elif-partsopt else-partopt endif-line  if-part :  if-line text  if-line :  #if constant-expression #ifdef identifier #ifndef identifier  elif-parts :  elif-line text elif-parts elif-line text  elif-line :  #elif constant-expression  else-part :  else-line text  else-line :  #else  endif-line :  #endif  Each #if directive in a source file must be matched by a closing #endif directive. Any number of #elif directives can appear between the #if and #endif directives, but at most one #else directive is allowed. The #else directive, if present, must be the last directive before #endif.   The #if, #elif, #else, and #endif directives can nest in the text portions of other #if directives. Each nested #else, #elif, or #endif directive belongs to the closest preceding #if directive.  All conditional-compilation directives, such as #if and #ifdef, must be matched with closing #endif directives prior to the end of file; otherwise, an error message is generated. When conditional-compilation directives are contained in include files, they must satisfy the same conditions: There must be no unmatched conditional-compilation directives at the end of the include file.  Macro replacement is performed within the part of the command line that follows an #elif command, so a macro call can be used in the constant-expression.  The preprocessor selects one of the given occurrences of text for further processing. A block specified in text can be any sequence of text. It can occupy more than one line. Usually text is program text that has meaning to the compiler or the preprocessor.  The preprocessor processes the selected text and passes it to the compiler. If text contains preprocessor directives, the preprocessor carries out those directives. Only text blocks selected by the preprocessor are compiled.  The preprocessor selects a single text item by evaluating the constant expression following each #if or #elif directive until it finds a true (nonzero) constant expression. It selects all text (including other preprocessor directives beginning with #) up to its associated #elif, #else, or #endif.  If all occurrences of constant-expression are false, or if no #elif directives appear, the preprocessor selects the text block after the #else clause. If the #else clause is omitted and all instances of constant-expression in the #if block are false, no text block is selected.  The constant-expression is an integer constant expression with these additional restrictions:   Expressions must have integral type and can include only integer constants, character constants, and the defined operator.   The expression cannot use sizeof or a type-cast operator.   The target environment may not be able to represent all ranges of integers.   The translation represents type int the same as type long, and unsigned int the same as unsigned long.   The translator can translate character constants to a set of code values different from the set for the target environment. To determine the properties of the target environment, check values of macros from LIMITS.H in an application built for the target environment.    The expression must not perform any environmental inquiries and must remain insulated from implementation details on the target computer.  The preprocessor operator defined can be used in special constant expressions, as shown by the following syntax:  Syntax  defined( identifier )  defined identifier  This constant expression is considered true (nonzero) if the identifier is currently defined; otherwise, the condition is false (0). An identifier defined as empty text is considered defined. The defined directive can be used in an #if and an #elif directive, but nowhere else.  In the following example, the #if and #endif directives control compilation of one of three function calls:  #if defined(CREDIT)     credit(); #elif defined(DEBIT)     debit(); #else     printerror(); #endif  The function call to credit is compiled if the identifier CREDIT is defined. If the identifier DEBIT is defined, the function call to debit is compiled. If neither identifier is defined, the call to printerror is compiled. Note that CREDIT and credit are distinct identifiers in C and C++ because their cases are different.  The conditional compilation statements in the following example assume a previously defined symbolic constant named DLEVEL.  #if DLEVEL > 5     #define SIGNAL  1     #if STACKUSE == 1         #define STACK   200     #else         #define STACK   100     #endif #else     #define SIGNAL  0     #if STACKUSE == 1         #define STACK   100     #else         #define STACK   50     #endif #endif #if DLEVEL == 0     #define STACK 0 #elif DLEVEL == 1     #define STACK 100 #elif DLEVEL > 5     display( debugptr ); #else     #define STACK 200 #endif  The first #if block shows two sets of nested #if, #else, and #endif directives. The first set of directives is processed only if DLEVEL > 5 is true. Otherwise, the statements after #else are processed.  The #elif and #else directives in the second example are used to make one of four choices, based on the value of DLEVEL. The constant STACK is set to 0, 100, or 200, depending on the definition of DLEVEL. If DLEVEL is greater than 5, then the statement   #elif DLEVEL > 5 display(debugptr);  is compiled and STACK is not defined.  A common use for conditional compilation is to prevent multiple inclusions of the same header file. In C++, where classes are often defined in header files, constructs like the following can be used to prevent multiple definitions:  // EXAMPLE.H - Example header file  #if !defined( EXAMPLE_H ) #define EXAMPLE_H  class Example { ... };  #endif // !defined( EXAMPLE_H )  The preceding code checks to see if the symbolic constant EXAMPLE_H is defined. If so, the file has already been included and need not be reprocessed. If not, the constant EXAMPLE_H is defined to mark EXAMPLE.H as already processed.  Microsoft Specific   Conditional compilation expressions are treated as signed long values, and these expressions are evaluated using the same rules as expressions in C++. For example, this expression:  #if 0xFFFFFFFFL > 1UL  is true.  END Microsoft Specific

#define XX 2  #define XX 3  #if XX == 2 	//......... #endif


Question: 点用这个函数，输入为123返回什么

建议动手运行一下～


Question: 新生用cfree写了个石头剪刀布，运行出现问题，求解。

你的user是char类型，当你输入1，2，3的时候，user得到的是这个数字的ascii码的值49,50,51。你用这么大的数字和cp进行比较得到的结果是负数，而不是你需要的结果。一个简单的修复：         do {             color(7);             printf("\t\t\t\t\tplease correct input: ");             fflush(stdin);             color(11);             scanf("%d",&user);         } while((user!=1)&&(user!=2)&&(user!=3));

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


Question: 第一个和第二个for语句不是很明白，有打大神能详解一下吗？

引用 2 楼 sonefinn 的回复:[quote=引用 1 楼 user-5 的回复:] ++i先自加后参与与运算啊，i++是先运算后自加，你是不明白哪呢   是这吗     for(gap=n/2;gap>0;gap/=2)是这里，这里的思维逻辑是怎样的？ [/quote] 逻辑的设计是根据需求来的，如果仅仅是分析语法，可以接看代码，但是如果要分析为什么要这样做循环要看你的需求是什么！ 代码不会无故写出，要看你的需求

假设此时n=8 对于for的两个循环  for(gap=n/2;gap>0;gap/=2) for(i=gap;i<n;++i)  来说 第一次循环，以上代码等价于 gap=4 for(i=4;i<8;++i) gap=2 第二次循环 for(i=2;i<8;++i) gap=1 第三次循环 for(i=1;i<8;++i) gap=0

C必须学会单步调试啊你试试就知道啊  放n=100 gap=100/2 gap/=2 每次都2  25  12  6 3 1

引用 1 楼 user-5 的回复:++i先自加后参与与运算啊，i++是先运算后自加，你是不明白哪呢   是这吗     for(gap=n/2;gap>0;gap/=2)是这里，这里的思维逻辑是怎样的？

++i先自加后参与与运算啊，i++是先运算后自加，你是不明白哪呢   是这吗


Question: C语言问题，大神们帮帮忙！

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

非常感谢您！

scanf("%c",&ok); =====>>>>> scanf("%d", &a);


Question: C语言数据保存到TXT文本中，打开TXT看全是乱码，那么该如何做才能让信息变成人能看懂的文字呢？

对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A  电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。  不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了

fwrite是按照块去写的，不想fprintf，fputs这样，文本形式并且带格式的写入。

用fprintf函数写入，fwrite写入的是二进制

先sprintf,再fwrite


Question: 数据结构，多项式加法，改错，实在不知道咋改了！！！

仅供参考：//链表实现一元多项式的加法减法乘法 #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; }

#include<stdio.h>  typedef struct{     int x;     int m; }List;  void select_sort(List *t, int n) {     int i, j, h, max;     List temp;      for(i = 0; i < n; i++)     {         h = i;         max = t[i].m;         for(j = i + 1; j < n; j++) {             if(t[j].m > max) {                 max = t[j].m;                 h = j;             }         }         if(h != i)         {             temp = t[i];             t[i] = t[h];             t[h] = temp;         }     } }   void print_list(List *l, int len) {     int i;      for (i = 0; i < len; i++)         printf("[%3d, %3d]\t", l[i].x, l[i].m);     putchar(10);  } int merge(List *a, List *b, List *c, int alen, int blen) {      int i = 0, j = 0, k, cnt = 0;      while(i < alen && j < blen &&(a[i].m >= 0 && b[j].m >= 0))     {         if(a[i].m > b[j].m) {             for (k = 0; k < cnt; k++)                 if (c[k].m == a[i].m) {                     c[k].x += a[i].x;                     i++;                     break;                 }              if (k >= cnt) {                 c[cnt] = a[i];                 i++;                 cnt++;             }         }         if(a[i].m < b[j].m) {             for (k = 0; k < cnt; k++)                 if (c[k].m == b[j].m) {                     c[k].x += b[j].x;                     j++;                     break;                 }             if (k >= cnt) {                 c[cnt] = b[j];                 j++;                 cnt++;             }         }         if(a[i].m == b[j].m) {             if(a[i].x + b[j].x == 0) {                 i++;                 j++;             } else {                 c[cnt].x = a[i].x + b[j].x;                 c[cnt++].m = a[i].m;                 i++;                 j++;             }          }     }     while(i < alen && a[i].m >= 0) {         c[cnt++] = a[i];         i++;     }     while(j < blen && b[j].m>=0) {         c[cnt++]=b[j];         j++;     }      return cnt; } int main() {     int n, i, j, d, k = 0, z = 0;     List a[300], b[300], c[600];      scanf("%d", &n);      while(n--)     {         for(i = 0; i < 300; i++)         {             scanf("%d%d", &a[i].x, &a[i].m);             if(a[i].m<0)                 break;             k++;         }         for(j = 0; j < 300; j++)         {             scanf("%d%d",&b[j].x, &b[j].m);             if(b[j].m<0)                 break;             z++;         }         select_sort(a, k);         printf("List one: ");         print_list(a, k);         select_sort(b, z);         printf("List two: ");         print_list(b, z);         d = merge(a, b, c, k, z);         for(i = 0; i < d; i++) {             printf("[%d %d] ",c[i].x,c[i].m);         }         printf("\n");         //print_list(c, d);         /*Initize*/         k = 0;         z = 0;     }     return 0; } 这个版本是可以的，主要是输入的第二组数据有重复的（相同的幂）的一组数据。 这个版本对这种情况做了判断。测试一下吧

引用 1 楼 cfjtaishan 的回复:#include<stdio.h>  typedef struct{     int x;     int m; }List;  void fun_1(List *t,int n) {     int i,j,h,max;     List temp;      for(i = 0; i < n; i++)     {         h = i;         max = t[i].m;         for(j = i + 1; j < n; j++)         {             if(t[j].m > max)             {                 max = t[j].m;                 h = j;             }         }         if(h != i)         {             temp=t[i];             t[i]=t[h];             t[h]=temp;         }     } }   void print_list(List *l, int len) {     int i;      for (i = 0; i < len; i++)         printf("[%d, %d]\t", l[i].x, l[i].m);     putchar(10);  } int  fun(List *a,List *b,List *c,int k,int z) {      int i = 0,j = 0, q = 0;      while(i<k && j<z &&(a[i].m>=0 && b[j].m>=0))     {         if(a[i].m>b[j].m) {c[q++]=a[i]; i++;}         if(a[i].m<b[j].m) {c[q++]=b[j]; j++;}         if(a[i].m==b[j].m)         {             if(a[i].x + b[j].x == 0) {                 i++; j++;             } else {                 c[q].x=a[i].x+b[j].x;                 c[q++].m=a[i].m;                 i++;                 j++;             }          }     }     while(i<k && a[i].m>=0) {         c[q++] = a[i];         i++;     }     while(j<z && b[j].m>=0) {         c[q++]=b[j];         j++;     }      return q; } int main() {     int n, i, j, d, k=0,z=0;     List a[300], b[300], c[600];      scanf("%d", &n);      while(n--)     {         for(i = 0; i < 300; i++)         {             scanf("%d%d", &a[i].x, &a[i].m);             if(a[i].m<0)                 break;             k++;         }         for(j = 0; j < 300; j++)         {             scanf("%d%d",&b[j].x, &b[j].m);             if(b[j].m<0)                 break;             z++;         }         fun_1(a, k);         //print_list(a, k);         fun_1(b, z);         //print_list(b, z);         d = fun(a, b, c, k, z);         /*         for(i = 0; i < d; i++) {             printf("[%d %d] ",c[i].x,c[i].m);         }         printf("\n");         */         print_list(c, d);         /*Initize*/         k = 0;         z = 0;     }     return 0; }  两个问题， 1. a和b的计数，需要放在判断m的值是否为0之后，这样就不计数最后一个输入了。 2. k, z需要重新初始化（若n >= 2)时。  我跟着你的改了，但是我的输出还和原来一样，就是每组两个多项式，但是第二组的第一个多项式，有一个幂数是5的，和第二个多项式里的第一个幂数为5的加上了，但是之后的就加不上了 这是第二组的的输入： -1 17 2 23 22 2 6 8 -4 7 -18 0 1 5 21 4 0 -1 12 7 -7 5 3 17 23 4 15 10 -10 5 13 5 2 19 9 -7 这是标准输出： [ 2 23 ] [ 2 19 ] [ 2 17 ] [ 15 10 ] [ 6 8 ] [ 8 7 ] [ -3 5 ] [ 44 4 ] [ 22 2 ] [ -18 0 ] 下面是我的输出： [2 23] [2 19] [2 17] [15 10] [6 8] [8 7] [-6 5] [-10 5] [13 5] [44 4] [22 2] [-18 0]


Question: return 在函数中返回错误！ 为什么

int gcd(int x, int y) { 	int tmp = x; 	if(tmp > 0) 	{ 		if( x > y ) 		{ 			tmp = x % y; 			return gcd(tmp, y); 		} 		else 		{ 			tmp = y % x; 			return gcd(tmp, x); 		} 	} 	return y; }

或者用简单的方法 int gcd(int x, int y) { 	if( y != 0 ) 		return gcd(y, x%y); 	return x; }

引用 2 楼 yaoqibbs 的回复:又改了下 if(tmp>0)     tmp＝x>y?gcd(x%y,y):gcd(y%x,x); else       return y; 手机打得 真费劲啊 把手机砸了！换笔记本电脑。  “给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出

虽然不太懂函数与堆栈关系 但是还是把这道题用两种方法做出来了

引用 3楼自信男孩 的回复:这个问题需要去理解递归的原理，递归简单的讲是从一个函数里调用自己的函数；在函数栈上理解是，一直申请函数栈（函数栈都是一样的），不同的地方是实参值不一样。每次函数调用都要返回，你看到return y；应该是最后一次的调用的返回或者倒数第二次函数调用的返回值等等，直到第一次调用的返回值返回了，才是递归调用的结束。 递归是一个申请自身函数栈和释放自身函数栈的过程；这两个过程是相反的你的意思是每次调用自己结束后都要返回一次？

递归返回之后还会继续执行没执行完的代码，不加else，递归返回之后还会执行后面的代码

没人吗 帮帮啊


Question: Call 大牛，关于PE头的问题

仅供参考：#include <stdio.h> #define field_offset(s,f) (int)(&(((struct s *)(0))->f)) struct AD  { int a; char b[13]; double c;}; #pragma pack(push) #pragma pack(1) struct A1  { int a; char b[13]; double c;}; #pragma pack(2) struct A2  { int a; char b[13]; double c;}; #pragma pack(4) struct A4  { int a; char b[13]; double c;}; #pragma pack(8) struct A8  { int a; char b[13]; double c;}; #pragma pack(16) struct A16 { int a; char b[13]; double c;}; #pragma pack(pop) int main() {     printf("AD.a %d\n",field_offset(AD,a));     printf("AD.b %d\n",field_offset(AD,b));     printf("AD.c %d\n",field_offset(AD,c));     printf("AD sizeof %d\n", sizeof(AD));     printf("\n");     printf("A1.a %d\n",field_offset(A1,a));     printf("A1.b %d\n",field_offset(A1,b));     printf("A1.c %d\n",field_offset(A1,c));     printf("A1 sizeof %d\n", sizeof(A1));     printf("\n");     printf("A2.a %d\n",field_offset(A2,a));     printf("A2.b %d\n",field_offset(A2,b));     printf("A2.c %d\n",field_offset(A2,c));     printf("A2 sizeof %d\n", sizeof(A2));     printf("\n");     printf("A4.a %d\n",field_offset(A4,a));     printf("A4.b %d\n",field_offset(A4,b));     printf("A4.c %d\n",field_offset(A4,c));     printf("A4 sizeof %d\n", sizeof(A4));     printf("\n");     printf("A8.a %d\n",field_offset(A8,a));     printf("A8.b %d\n",field_offset(A8,b));     printf("A8.c %d\n",field_offset(A8,c));     printf("A8 sizeof %d\n", sizeof(A8));     printf("\n");     printf("A16.a %d\n",field_offset(A16,a));     printf("A16.b %d\n",field_offset(A16,b));     printf("A16.c %d\n",field_offset(A16,c));     printf("A16 sizeof %d\n", sizeof(A16));     printf("\n");     return 0; } //AD.a 0 //AD.b 4 //AD.c 24 //AD sizeof 32 // //A1.a 0 //A1.b 4 //A1.c 17 //A1 sizeof 25 // //A2.a 0 //A2.b 4 //A2.c 18 //A2 sizeof 26 // //A4.a 0 //A4.b 4 //A4.c 20 //A4 sizeof 28 // //A8.a 0 //A8.b 4 //A8.c 24 //A8 sizeof 32 // //A16.a 0 //A16.b 4 //A16.c 24 //A16 sizeof 32 // //

《Windows PE权威指南》

char *FileToFileBuffer(char* pPath) {     //open the read file     FILE* pFile=fopen(pPath,"rb");     if(!pFile) {         printf("open read file failed!\n");         return NULL;     }     //get size of file     int size = FileSize(pFile);     //apply memory     char* pFileBuffer = (char *)malloc(size * sizeof(char));     if(!pFileBuffer) {         printf("Apply the memorry failed!\n");         fclose(pFile);         return 0;     }     //read file to memory     fread(pFileBuffer, size, 1, pFile);     fclose(pFile);     return pFileBuffer; } 从文间里读数据，一般都是char类型吧


Question: windows编程中打开文件问题

你说的“文件却不显示”，那文件打开成功了吗？输出一下获取的文件名看是否正确，调用GetLastError看一下是什么错误


Question: 利用栈将数学中的中缀表达式转换为后缀表达式并输出，求助求助求助！！！

引用 1 楼 cfjtaishan 的回复:#include <iostream> #include <stdio.h> #include <string.h> #include <math.h>  using namespace std;  int Priority(char);    //将运算符的优先级转换为可比较大小的数字  int main(void) {     char infix[100], suffix[100];   //分别用于接收中缀表达式和后缀表达式     char stack[100] = { 0 };     int inlen = 0, suflen = 0;     cin >> infix;   //接收中缀表达式      puts(infix);     int pti = -1;   //创建一个空栈,stcak[pti]为栈顶      for (inlen = 0; infix[inlen]; inlen++)  //依次检查每一个元素     {         if (infix[inlen] >= 'A' && infix[inlen] <= 'Z') { //操作数A--Z             suffix[suflen++] = infix[inlen];         } else if (Priority(infix[inlen]) > 0) //运算符+ - * / ^(乘方)         {             while (pti >= 0 && stack[pti] != '(' && Priority(stack[pti]) > 0 && Priority(infix[inlen]) <= Priority(stack[pti]))       //栈不空且栈顶元素不为'('且满足优先级条件                 suffix[suflen++] = stack[pti--];             stack[++pti] = infix[inlen];      //栈为空的时候,当前运算符入栈         } else if (infix[inlen] == '(')  //为(             stack[++pti] = infix[inlen];          else if (infix[inlen] == ')')  //为）         {             while (pti >= 0 && stack[pti] != '(')                 suffix[suflen++] = stack[pti--];   //退栈并且输出出栈的运算符             if (stack[pti]>=0)                 pti--;             else                 cout << "Error\n";  //做一次退栈操作         } else  //其他字符             cout << "Error\n";      }     while (pti >= 0 && stack[pti] != '(')  //栈不空且栈顶元素不为'('时         suffix[suflen++] = stack[pti--];   //退栈并且输出出栈的运算符     suffix[suflen] = '\0';     if (pti >= 0)    //如果栈不空，报错         cout << "Error\n";      //测试     for (int i = 0; i <= suflen; i++)         cout << suffix[i];     //测试     cout<<endl;      return 0; } int Priority(char ch)  //将运算符的优先级转换为可比较大小的数字 {     if (ch == '+' || ch == '-')         return 1;     else if (ch == '*' || ch == '/')         return 2;     else if (ch == '^')         return 3;     else         return 0; } 问题是出在不细心。 对比一下这两个表达式的区别：  else if (Priority(infix[inlen]>0)) 和 else if (Priority(infix[inlen])>0) 的区别； 是这样的，是我粗心了，没想到这么一个小小的粗心竟然让我对自己的算法质疑了两天，谢谢前辈，谢谢！！


Question: 多组数据输入——如何避免第一个scanf对输出结果的影响。

不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。

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

#include<stdio.h> #include<math.h> #include<string.h> int main() {     int n,b,c,d,e=0;     int i = 0;      while(scanf("%d",&n)!=EOF &&n != 0)     {         //scanf("%d",&n);         if(n < 8) {             b = n;         } else         {             c = n;             e = 0;    /* Initize the value. */             do{                 d = c % 8;                 e += d * pow(10,i);                 c /= 8;                 i++;             }while(c >= 8);             b = c * pow(10, i) + e;         }         printf("%d\n", b); 	/* Initize the value */         i = 0;     }     return 0; } 注意对e和i的初始化。

引用 1 楼 user-3 的回复:尝试使用一下dowhile试试看 我尝试了一下使用do while ,但是输出结果还是错误的。 输出成： 110 156 18 然后就没有结果了

尝试使用一下dowhile试试看


Question: C语言问题，大神帮帮忙！

仅供参考：#include <stdio.h> #include <stdlib.h> char c1[]="abcdefghigklmnopqrstuvwxyz"; char c2[]="zyxwvutsrqponmlkgihgfedcba"; int n,i,k; int main(int argc, char *argv[]) {     for (n=0;n<26;n++) {         printf("%d\n",n+1);         for (i=-n;i<=n;i++) {             k=n+1-abs(i);             printf("%*s%.*s",abs(i),"",k,c1);             printf("%s\n",c2+27-k);         }     }     return 0; } //1 //a //2 // a //aba // a //3 //  a // aba //abcba // aba //  a //4 //   a //  aba // abcba //abcdcba // abcba //  aba //   a //5 //    a //   aba //  abcba // abcdcba //abcdedcba // abcdcba //  abcba //   aba //    a //6 //     a //    aba //   abcba //  abcdcba // abcdedcba //abcdefedcba // abcdedcba //  abcdcba //   abcba //    aba //     a //...... //26 //                         a //                        aba //                       abcba //                      abcdcba //                     abcdedcba //                    abcdefedcba //                   abcdefgfedcba //                  abcdefghgfedcba //                 abcdefghihgfedcba //                abcdefghigihgfedcba //               abcdefghigkgihgfedcba //              abcdefghigklkgihgfedcba //             abcdefghigklmlkgihgfedcba //            abcdefghigklmnmlkgihgfedcba //           abcdefghigklmnonmlkgihgfedcba //          abcdefghigklmnoponmlkgihgfedcba //         abcdefghigklmnopqponmlkgihgfedcba //        abcdefghigklmnopqrqponmlkgihgfedcba //       abcdefghigklmnopqrsrqponmlkgihgfedcba //      abcdefghigklmnopqrstsrqponmlkgihgfedcba //     abcdefghigklmnopqrstutsrqponmlkgihgfedcba //    abcdefghigklmnopqrstuvutsrqponmlkgihgfedcba //   abcdefghigklmnopqrstuvwvutsrqponmlkgihgfedcba //  abcdefghigklmnopqrstuvwxwvutsrqponmlkgihgfedcba // abcdefghigklmnopqrstuvwxyxwvutsrqponmlkgihgfedcba //abcdefghigklmnopqrstuvwxyzyxwvutsrqponmlkgihgfedcba // abcdefghigklmnopqrstuvwxyxwvutsrqponmlkgihgfedcba //  abcdefghigklmnopqrstuvwxwvutsrqponmlkgihgfedcba //   abcdefghigklmnopqrstuvwvutsrqponmlkgihgfedcba //    abcdefghigklmnopqrstuvutsrqponmlkgihgfedcba //     abcdefghigklmnopqrstutsrqponmlkgihgfedcba //      abcdefghigklmnopqrstsrqponmlkgihgfedcba //       abcdefghigklmnopqrsrqponmlkgihgfedcba //        abcdefghigklmnopqrqponmlkgihgfedcba //         abcdefghigklmnopqponmlkgihgfedcba //          abcdefghigklmnoponmlkgihgfedcba //           abcdefghigklmnonmlkgihgfedcba //            abcdefghigklmnmlkgihgfedcba //             abcdefghigklmlkgihgfedcba //              abcdefghigklkgihgfedcba //               abcdefghigkgihgfedcba //                abcdefghigihgfedcba //                 abcdefghihgfedcba //                  abcdefghgfedcba //                   abcdefgfedcba //                    abcdefedcba //                     abcdedcba //                      abcdcba //                       abcba //                        aba //                         a

可以考虑从上三角和下三角的形式输出，上三角和下三角正好是相反的。

你的代码没办法输出菱形。在网上找的一个代码，你可以试试  #include "stdafx.h" #include <stdio.h> #include <stdlib.h> //功能：输出菱形 //说明：参数为菱形的行数 void zmtx(int maxRows) { 	int i,j,k;     	//先打印上边的行   	for(i=1;i<maxRows;i++)   	{   		for(j=1;j<maxRows-i;j++)//控制要打印的空格数   			printf(" ");   		for(k=1;k<=2*i-1;k++)//控制要打印的星号数   			printf("*");   		printf("\n");   	}    	//打印下边的行   	for(i=1;i<=maxRows - 2;i++)   	{   		for(j=1;j<=i;j++)//控制要打印的空格数   			printf(" ");   		for(k=1;k<=(maxRows - i) * 2 - 3;k++)//控制要打印的星号数   			printf("*");   		printf("\n");   	}   }  int _tmain(int argc, _TCHAR* argv[]) { 	zmtx(5); 	system("pause"); 	return 0; }

要求输出这个样子的！

能输出菱形吗？


Question: 哪位大牛能帮我解释下软件保护及分析技术的问题

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

去看雪论坛逛逛。


Question: 用迭代法求平方根遇到一个输出的问题

这是因为float类型和double类型占用的内存长度不一样，所以表示精度不一样，如果将一个float类型（4个字节）放在double类型的低4字节位置，那么输出的就是0.00000 若改成double，输入和输出都都要用%lf

printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。

引用 4 楼 FancyMouse 的回复:[quote=引用 3 楼 cfjtaishan 的回复:] 若改成double，输入和输出都都要用%lf 输出可以不要的[/quote] 嗯，我建议是要的

引用 3 楼 cfjtaishan 的回复:若改成double，输入和输出都都要用%lf 输出可以不要的

scanf("%f",&a);  这里也要换成 %lf


Question: 学生成绩管理系统中文件操作问题.

所谓修改删除文件a某位置的内容，其实是读打开文件a，再将‘a中修改删除位置之前的内容＋修改删除的内容＋a中修改删除位置之后的内容’保存到文件b，关闭文件a，删除文件a，将文件b改名为与之前文件a相同的名字，仅此而已。http://bbs.csdn.net/topics/391975224

引用 1 楼 Kaciry 的回复:对文件操作的函数还不能用，怎么更改？，比如要删除某学生的成绩 如果要删除文件中的某个学生信息，需要现将文件内容读到内存，然后将该学生信息从内存里删除，最后再将剩余的学生信息写入文件。

对文件操作的函数还不能用，怎么更改？，比如要删除某学生的成绩


Question: C语言 re原因：无效内存引用

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

仅供参考：//有两个每一项都是0或1组成的二维数组：A[50][50]和B[2][2] //找出在A里包含有多少与B相同的项，并标出坐标 #include <stdio.h> #include <stdlib.h> #include <time.h> int A[50][50]; int B[2][2]; int y,x; int j,i; int n; int main() {     srand(time(NULL));     for (y=0;y<50;y++) {         for (x=0;x<50;x++) {             A[y][x]=rand()%2;         }     }     for (y=0;y<2;y++) {         for (x=0;x<2;x++) {             B[y][x]=rand()%2;         }     }     n=0;     for (y=0;y<50-2+1;y++) {         for (x=0;x<50-2+1;x++) {             for (j=0;j<2;j++) {                 for (i=0;i<2;i++) {                     if (A[y+j][x+i]!=B[j][i]) goto NE;                 }             }             n++;             printf("n    y,x=%4d %2d,%2d\n",n,y,x);             NE:;         }     }     return 0; } //n    y,x=   1  0, 1 //n    y,x=   2  0, 3 //n    y,x=   3  0,17 //n    y,x=   4  1,12 //n    y,x=   5  1,20 //n    y,x=   6  1,33 //n    y,x=   7  2, 4 //n    y,x=   8  2,32 //n    y,x=   9  3,13 //n    y,x=  10  3,31 //n    y,x=  11  3,48 //n    y,x=  12  4, 0 //n    y,x=  13  5,14 //n    y,x=  14  5,32 //n    y,x=  15  5,36 //n    y,x=  16  5,47 //n    y,x=  17  6, 7 //n    y,x=  18  6,17 //n    y,x=  19  6,45 //n    y,x=  20  7, 1 //n    y,x=  21  7,31 //n    y,x=  22  8, 0 //n    y,x=  23  8,16 //n    y,x=  24  8,18 //n    y,x=  25  8,25 //n    y,x=  26  9, 9 //n    y,x=  27  9,27 //n    y,x=  28 10,12 //n    y,x=  29 10,26 //n    y,x=  30 12,12 //n    y,x=  31 12,20 //n    y,x=  32 13,36 //n    y,x=  33 13,45 //n    y,x=  34 13,48 //n    y,x=  35 14, 5 //n    y,x=  36 14, 7 //n    y,x=  37 14, 9 //n    y,x=  38 14,21 //n    y,x=  39 15, 4 //n    y,x=  40 15,20 //n    y,x=  41 16,10 //n    y,x=  42 16,23 //n    y,x=  43 16,45 //n    y,x=  44 17,16 //n    y,x=  45 17,22 //n    y,x=  46 17,40 //n    y,x=  47 18, 1 //n    y,x=  48 18, 5 //n    y,x=  49 18,26 //n    y,x=  50 18,43 //n    y,x=  51 19,40 //n    y,x=  52 19,46 //n    y,x=  53 20,31 //n    y,x=  54 20,38 //n    y,x=  55 21,27 //n    y,x=  56 21,41 //n    y,x=  57 21,48 //n    y,x=  58 22,10 //n    y,x=  59 22,15 //n    y,x=  60 22,20 //n    y,x=  61 22,24 //n    y,x=  62 23, 0 //n    y,x=  63 23, 3 //n    y,x=  64 23,40 //n    y,x=  65 24,11 //n    y,x=  66 24,14 //n    y,x=  67 24,29 //n    y,x=  68 24,34 //n    y,x=  69 24,43 //n    y,x=  70 25,16 //n    y,x=  71 25,19 //n    y,x=  72 25,25 //n    y,x=  73 26,18 //n    y,x=  74 26,23 //n    y,x=  75 27, 9 //n    y,x=  76 27,44 //n    y,x=  77 28, 7 //n    y,x=  78 28,22 //n    y,x=  79 28,24 //n    y,x=  80 28,33 //n    y,x=  81 28,48 //n    y,x=  82 29, 0 //n    y,x=  83 29,35 //n    y,x=  84 29,41 //n    y,x=  85 29,44 //n    y,x=  86 30, 7 //n    y,x=  87 30,23 //n    y,x=  88 31,35 //n    y,x=  89 31,41 //n    y,x=  90 31,45 //n    y,x=  91 33,21 //n    y,x=  92 33,27 //n    y,x=  93 34, 2 //n    y,x=  94 34,19 //n    y,x=  95 34,25 //n    y,x=  96 34,47 //n    y,x=  97 35,14 //n    y,x=  98 36, 6 //n    y,x=  99 36,13 //n    y,x= 100 36,25 //n    y,x= 101 36,31 //n    y,x= 102 36,41 //n    y,x= 103 36,47 //n    y,x= 104 37,11 //n    y,x= 105 37,16 //n    y,x= 106 37,24 //n    y,x= 107 37,30 //n    y,x= 108 38,18 //n    y,x= 109 38,20 //n    y,x= 110 38,28 //n    y,x= 111 38,38 //n    y,x= 112 39,32 //n    y,x= 113 39,43 //n    y,x= 114 39,45 //n    y,x= 115 39,48 //n    y,x= 116 40,35 //n    y,x= 117 40,38 //n    y,x= 118 41,33 //n    y,x= 119 42, 9 //n    y,x= 120 42,13 //n    y,x= 121 42,22 //n    y,x= 122 42,25 //n    y,x= 123 43,21 //n    y,x= 124 44,25 //n    y,x= 125 45,15 //n    y,x= 126 45,20 //n    y,x= 127 45,42 //n    y,x= 128 46, 4 //n    y,x= 129 47, 3 //n    y,x= 130 47,22 //n    y,x= 131 47,33 //n    y,x= 132 47,43 //n    y,x= 133 47,45 //n    y,x= 134 47,48 //n    y,x= 135 48, 0 //

字符串比较为什么不用strcmp或者strncmp呢？ 代码的可读性不好呀

t是用例的个数  m是行 n是列


Question: 帮我看看这个程序

x y 没有传递给什么函数，你程序中x y 只是用于循环记录，x向重复width次， y向重复height次

x和y并没有传递给谁，x是控制循环的次数，控制打印换行符的数量从而打印宽度。而y也是同样的道理，则是控制打印的高度。


Question: 急死了，求助大神

谢谢指导！

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

引用 3 楼 自信男孩的回复:#include<stdio.h> #include<stdlib.h>  int main() {     int N;//有N组测试数据     int i;     char ch1, ch2, ch3,temp;     scanf_s("%d", &N);      getchar();    /* recv '\n' from stdin*/     for (i = 0; i < N; i++)     {         scanf_s("%c%c%c", &ch1, 1, &ch2, 1,  &ch3, 1);         if (ch1 > ch2)         {             temp = ch2;             ch2 = ch1;             ch1 = temp;         }         if (ch1 > ch3)         {             temp = ch3;             ch3 = ch1;             ch1 = temp;         }         if (ch2 > ch3)         {             temp = ch3;             ch3 = ch2;             ch2 = temp;         }         printf("%c %c %c\n", ch1, ch2, ch3);         getchar();    /* recv '\n' from stdin*/     }     system("pause"); } 注意输入之后的回车符 谢谢！


Question: 新生在限制判断字符时遇到问题

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

#include <stdio.h> #include <string.h>  int main() {     char user[8];     int len;      do {         printf("请正确输入: ");         //scanf("%c",&user);         fgets(user, 8, stdin);         if (len > 2)             user[strlen(user)-1] = 0;         len = strlen(user);     }while(len > 2 || (user[0] != '1' && user[0] != '2' && user[0] != '3'));      return 0; }

你的程序只判断了输入的第一个字符是不是你需要的。如果你需要验证全部的输入，你需要用 #include <stdio.h> main() {char user[100];   do     {      printf("\t\t\t\t\t请正确输入: ");      fflush(stdin);      scanf("%s",&user);     }while(strcmp(user, "1") != 0 && strcmp(user, "2") != 0 && strcmp(user, "3") != 0); }

我没太明白你要说的是什么意思，不懂什么叫“通过了”  while((user!='1')&&(user!='2')&&(user!='3')); 表示只有user同时不为 '1'  '2'  '3'才继续循环  如果你需要为其中一个就继续循环，改成；while ((user == '1') || (user == '2') || (user -= '3'));

改为字符串，用strcmp进行比较是否 "1", "2", "3"


Question: C语言文件的3个问题

理解和讨论之前请先学会如何观察！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  读写文件的函数对应的C源代码都有，自己看或单步调试一下，在crt\src\*.c

电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。  不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了

因为最后一次EOF时并没有读取，但你代码又会把之前的 i再输出一次   这样改可以：   int main() { 	FILE *f1, *f2; 	int i; 	f1 = fopen("F:\\date.dat", "wb"); 	for (i = 1; i <= 10; i++) 		fwrite((int*)&i, sizeof(int), 1, f1); 	fclose(f1); 	f2 = fopen("F:\\date.dat", "rb"); 	while (1) 	{ 		fread((int*)&i, sizeof(int), 1, f2); 		if (feof(f2)) 			break; 		printf("%d ", i); 	} 	fclose(f2); 	return 0; }

看操作系统吧，WINDOWS下，文本文件换行符会被替换为\r\n  控制台中按Enter得到的是\n


Question: malloc时出错。提示 0xC0000374: 堆已损坏 (参数: 0x778CD8D0)什么原因？

Link s = (Link)malloc(sizeof(Link)) 这句肯定是有问题的；sizeof(Link)是指针的长度，4个字节（32位系统）；	 Link s = (Link)malloc(sizeof(LNode))

少用点typedef

检查使用堆内存有没越界，越界会导致堆被破坏，之后申请内存或释放内存都可能崩溃

至少这里是要改的  Link s = (Link)malloc(sizeof(*Link))


Question: 【c语言】关于文件的读写，并把数据读入单链表，大佬帮帮忙

#include <stdio.h> #include <stdlib.h> #include <string.h>  typedef struct worker {     char workerNo[10];     char name[10];     char sex[2]; }workerinfo;  typedef struct node {     workerinfo data;     struct node *next; }ListNode,*LinkList;  LinkList createNullList_link() {     LinkList llist = (LinkList)malloc(sizeof(struct node));     if(llist)         llist->next = NULL;     else         printf("Out of space!\n");     return llist; }  void inputinfo() {     FILE *fp;     workerinfo *s;     fp = fopen("信息表.txt","wb");     if(!fp)         printf("打开文件失败！");     else     {         s = (workerinfo *)malloc(sizeof(workerinfo));         printf("请输入职工号：\n");         scanf("%s", s->workerNo);         while(strcmp(s->workerNo, "9999")!=0)         {             printf("请输入:姓名 性别\n");             scanf("%s %s", s->name, s->sex);             fwrite(s,sizeof(struct worker), 1, fp);             memset(s, 0, sizeof(workerinfo));             printf("请输入职工号：\n");             scanf("%s", s->workerNo);         }         if(s)         {             free(s);             s = NULL;         }     }     fclose(fp); }  LinkList displayinfo(LinkList head) {     FILE *fp;     workerinfo *s;     ListNode *p,*q;      p = head;     fp = fopen("信息表.txt","rb");     if(!fp) {         printf("没有相应的职工信息！");     }     else     {         s = (workerinfo *)malloc(sizeof(workerinfo));         printf("职工号 姓名 性别\n");         while(!feof(fp))         {             memset(s,0,sizeof(workerinfo));             if(fread(s, sizeof(struct worker), 1, fp) != 0)             {                 printf("%s %s %s\n", s->workerNo, s->name, s->sex);                 q = (ListNode *)malloc(sizeof(ListNode));                 strcpy(q->data.workerNo, s->workerNo);                 strcpy(q->data.name, s->name);                 strcpy(q->data.sex, s->sex);                 p->next = q;                 p = p->next;             }           }         if(s)         {             free(s);             s = NULL;         }         p->next = NULL;         fclose(fp);     }     return head; }  void outputinfo(LinkList head) {     ListNode *p;     p = head->next;     printf("职工号 姓名 性别\n");     while(p)     {         printf("%s %s %s\n",p->data.workerNo,p->data.name,p->data.sex);         p = p->next;     } } int main(void) {     LinkList head;     head = createNullList_link();     inputinfo();     head = displayinfo(head);     outputinfo(head);     printf("Hello world!\n");     return 0; }  程序主要是在main函数里没有调用inputinfo()；函数，该函数是将数据写入文件的，即没有该文件，后面的displayinfo就打不开文件。

仅供参考：//将c:\\tmp文件夹下的所有文件的内容全部放到用malloc分配的内存中 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <io.h> struct FB {     char fn[256];     size_t fl;     char *b;     struct FB *next;     struct FB *prev; } *fh,*fb,*ft; char ln[256]; char fpn[256]; FILE *af; FILE *f; int L,n; int main() {     system("dir /b /a-d c:\\tmp\\*.* >c:\\allfn.txt");     af=fopen("c:\\allfn.txt","r");     if (NULL==af) {         printf("Can not open file c:\\allfn.txt!\n");         return 1;     }     fh=NULL;     fb=NULL;     n=0;     while (1) {         if (NULL==fgets(ln,256,af)) break;         L=strlen(ln);         if ('\n'==ln[L-1]) ln[L-1]=0;         printf("read %s\n",ln);         strcpy(fpn,"c:\\tmp\\");         strcat(fpn,ln);         ft=(struct FB *)malloc(sizeof(struct FB));         if (NULL==ft) {             printf("Can not malloc ft!\n");             fclose(af);             return 2;//之前的malloc在main退出后由操作系统自动free         }         printf("ft[%d]==%p\n",n,ft);         strcpy(ft->fn,fpn);         f=fopen(fpn,"rb");         if (NULL==f) {             printf("Can not open file %s!\n",fpn);             fclose(af);             return 3;//之前的malloc在main退出后由操作系统自动free         }         ft->fl=_filelength(fileno(f));         ft->b=malloc(ft->fl);         if (NULL==ft->b) {             printf("Can not malloc ft->b!\n");             fclose(f);             fclose(af);             return 4;//之前的malloc在main退出后由操作系统自动free         }         printf("ft[%d]->b==%p\n",n,ft->b);         if (ft->fl!=fread(ft->b,1,ft->fl,f)) {             printf("fread error!\n");             fclose(f);             fclose(af);             return 5;//之前的malloc在main退出后由操作系统自动free         }         fclose(f);         ft->next=NULL;          if (NULL==fh) {             ft->prev=NULL;             fh=ft;         } else {             fb->next=ft;             ft->prev=fb;         }         fb=ft;         n++;     }     fclose(af);     printf("-----list-----\n");     for (ft=fh;NULL!=ft;ft=ft->next) {         printf("%8d %s\n",ft->fl,ft->fn);         if (NULL!=ft) fb=ft;     }     printf("-----free-----\n");     n--;     if (NULL!=fh) {         for (ft=fb->prev;NULL!=ft;ft=ft->prev) {             if (NULL!=ft->next->b) {                 printf("ft[%d]->b==%p\n",n,ft->next->b);                 free(ft->next->b);             }             if (NULL!=ft->next) {                 printf("ft[%d]==%p\n",n,ft->next);                 free(ft->next);             }             n--;         }         if (NULL!=fh->b) {             printf("ft[0]->b==%p\n",fh->b);             free(fh->b);         }         printf("ft[0]==%p\n",fh);         free(fh);     }     return 0; } //C:\tmp\tmp\Debug>dir /a-d c:\tmp // 驱动器 C 中的卷是 C_HD5_1 // 卷的序列号是 1817-D526 // // c:\tmp 的目录 // //找不到文件 // //C:\tmp\tmp\Debug>tmp //找不到文件 //-----list----- //-----free----- // //C:\tmp\tmp\Debug>dir /a-d c:\tmp // 驱动器 C 中的卷是 C_HD5_1 // 卷的序列号是 1817-D526 // // c:\tmp 的目录 // //2011-06-30  18:04            44,840 my_c.rar //2011-06-30  17:18             1,036 err.frm //2011-06-30  14:32            14,243 出租.txt //2011-06-28  12:08            23,681 MSDN98书签.txt //             4 个文件         83,800 字节 //             0 个目录 17,041,870,848 可用字节 // //C:\tmp\tmp\Debug>tmp //read my_c.rar //ft[0]==00421800 //ft[0]->b==00520068 //read err.frm //ft[1]==00421670 //ft[1]->b==0052AFC0 //read 出租.txt //ft[2]==00421530 //ft[2]->b==00378F28 //read MSDN98书签.txt //ft[3]==004213F0 //ft[3]->b==0052B3F8 //-----list----- // 44840 c:\tmp\my_c.rar //  1036 c:\tmp\err.frm // 14243 c:\tmp\出租.txt // 23681 c:\tmp\MSDN98书签.txt //-----free----- //ft[3]->b==0052B3F8 //ft[3]==004213F0 //ft[2]->b==00378F28 //ft[2]==00421530 //ft[1]->b==0052AFC0 //ft[1]==00421670 //ft[0]->b==00520068 //ft[0]==00421800 // //C:\tmp\tmp\Debug>


Question: 汉诺塔II

“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出


Question: 字符串中最小时间间隔

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

int find_min_diff(char *str, int len) {     struct tm_info from, to;     int min = 0;      while (*str == ' ')         str++;     if (len <= 0)         return -1;     sscanf(str, "[\"%d:%d\", \"%d:%d\"]",            &from.hour, &from.min,            &to.hour, &to.min);      if (to.min < from.min) {         to.min += 60;         to.hour -= 1;     }     if (to.hour < from.hour)         to.hour += 24;     min = (to.hour - from.hour) * 60 + to.min - from.min;      return min; }  int main() {     char s[50];     fgets(s, 50, stdin);      printf("Min diff: %d\n", find_min_diff(s, strlen(s)));     return 0; } 你的代码可读性比较差呀，如果可以不建议使用那么多局部变量，并且局部变量都是一些a,b单个字母，这样不知道变量用来做什么的。可读性自然不好了。 如果可以多用结构体，联合体来处来多变量的问题，多用库函数来解决我们的问题。


Question: 大神看下逗号运算符的问题

写了篇关于逗号操作符的小文章 http://blog.csdn.net/hou09tian/article/details/70943684 请多指教

你说的是逗号表达式

引用 3 楼 qq_36639412 的回复:[quote=引用 1 楼 qq_17449813 的回复:]  首先这个代码是先判断的a是否等于2，不等于返回0，就是if(0,3)。等号表达式取最右的 就是3，所以条件成立输出逗号 一个优先级的问题。 a=8.3能成立条件？[/quote] if(a=8.3)  这样也可以成立条件,条件永远是真

引用 14楼棉猴 的回复:[quote=引用 11 楼 qq_36639412 的回复:] [quote=引用 7 楼 hou09tian 的回复:] [quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 4 楼 hou09tian 的回复:] 同意楼上说的， 逗号运算符的优先级没有相等运算符的优先级高，所以 if(a==2,3)中 先执行a==2，该表达式的值是false，此时相当于 if(false, 3)，那就相当于if（3） 可以考虑修改为if(a==(2,3)) 那也不能相等[/quote] 啥子意思？[/quote] a被赋值为8，而if里面都没有满足a的值，怎么会输出？是判断2，还有个3，最右边的值也不能等于a的值呢，是判断2后面还有值，所以2不成立，3是最右边的值，所以3这个值成立？可a！=3.[/quote] 逗号表达式的值是逗号后面那个表达式的值 即逗号表达式（2， 3）的值是3 所以即使a等于8，在a==2，3这个逗号表达式的值是逗号后面的表达式的值，即是3[/quote]谢了，懂了，原来第一个不成立，接着执行逗号运算符判断非零

引用 16楼自信男孩 的回复:逗号运算表达式的结果为最后一个逗号后面的表达式的值。那么if判断的就是3是否为真逗号也要运算？就是判断非零

引用 15楼stone_cc 的回复:#include<stdio.h> int main() { int a=8; if(a==2,3) printf(","); getchar(); return 0; } if判断中，有两个运算符==和逗号，优先级==高于逗号，所以先判断a==2，值为false 0，此时变为if(0,3),逗号运算符取最右边的值，所以变为if(3)，条件永远成立，所以执行if后的printf打印就是if(a＝＝2)不成立，然后3非0为真，所以等价于if(3)

//C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+

引用 11 楼 qq_36639412 的回复:[quote=引用 7 楼 hou09tian 的回复:] [quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 4 楼 hou09tian 的回复:] 同意楼上说的， 逗号运算符的优先级没有相等运算符的优先级高，所以 if(a==2,3)中 先执行a==2，该表达式的值是false，此时相当于 if(false, 3)，那就相当于if（3） 可以考虑修改为if(a==(2,3)) 那也不能相等[/quote] 啥子意思？[/quote] a被赋值为8，而if里面都没有满足a的值，怎么会输出？是判断2，还有个3，最右边的值也不能等于a的值呢，是判断2后面还有值，所以2不成立，3是最右边的值，所以3这个值成立？可a！=3.[/quote] 逗号表达式的值是逗号后面那个表达式的值 即逗号表达式（2， 3）的值是3 所以即使a等于8，在a==2，3这个逗号表达式的值是逗号后面的表达式的值，即是3

引用 12 楼 qq_36639412 的回复:[quote=引用 10 楼 paschen 的回复:] ==优先级高于逗号  所以先比较，然后执行逗号表达式  逗号表达式值取右边那个  所以if 中的内容始终会被执行 不懂，能不能详细点，等于运算符不判断等于2，3？接着执行逗号运算符，2不成立，3成立，但3也！=a[/quote]  if(a==2,3) 实际是 if((a==2),3)  判断a是否为2，判断结果是0或1，然后执行逗号表达式  并不是判断a是否2或3  判断a是否2或3要写成： if (a==2 || a==3)

引用 10 楼 paschen 的回复:==优先级高于逗号  所以先比较，然后执行逗号表达式  逗号表达式值取右边那个  所以if 中的内容始终会被执行 不懂，能不能详细点，等于运算符不判断等于2，3？接着执行逗号运算符，2不成立，3成立，但3也！=a

引用 7 楼 hou09tian 的回复:[quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 4 楼 hou09tian 的回复:] 同意楼上说的， 逗号运算符的优先级没有相等运算符的优先级高，所以 if(a==2,3)中 先执行a==2，该表达式的值是false，此时相当于 if(false, 3)，那就相当于if（3） 可以考虑修改为if(a==(2,3)) 那也不能相等[/quote] 啥子意思？[/quote] a被赋值为8，而if里面都没有满足a的值，怎么会输出？是判断2，还有个3，最右边的值也不能等于a的值呢，是判断2后面还有值，所以2不成立，3是最右边的值，所以3这个值成立？可a！=3.

引用 8 楼 user-8 的回复:if（flase,ture） printf（","） 你想干嘛,你这是在写代码啊！ 你想实现什么？ if语句完全是放了个屁嘛，什么作用都没 只是不理解为什么a=8，在2，3之间能判断成功，没有什么功能，只是为什么会相等，是在2，3之间进行判断？不用跟a的值进行比较？

引用 6 楼 qq_36639412 的回复:[quote=引用 4 楼 hou09tian 的回复:] 同意楼上说的， 逗号运算符的优先级没有相等运算符的优先级高，所以 if(a==2,3)中 先执行a==2，该表达式的值是false，此时相当于 if(false, 3)，那就相当于if（3） 可以考虑修改为if(a==(2,3)) 那也不能相等[/quote] 啥子意思？

引用 4 楼 hou09tian 的回复:同意楼上说的， 逗号运算符的优先级没有相等运算符的优先级高，所以 if(a==2,3)中 先执行a==2，该表达式的值是false，此时相当于 if(false, 3)，那就相当于if（3） 可以考虑修改为if(a==(2,3)) 那也不能相等

引用 3 楼 qq_36639412 的回复:[quote=引用 1 楼 qq_17449813 的回复:]  首先这个代码是先判断的a是否等于2，不等于返回0，就是if(0,3)。等号表达式取最右的 就是3，所以条件成立输出逗号 一个优先级的问题。 a=8.3能成立条件？[/quote] if(a==2,3）这个表达式中，跟a的值没关系，这个表达式等价于if(3) 即使是if( a==8, 3)此时还是等价于if（3）


Question: LSB隐写 显示隐写信息的时候，将二进制数据读入txt文件中，打开txt乱码

请问你现在弄清楚了吗？可以说一下吗？


Question: 多个结构体相互嵌套，变量初始化有问题，使用vector导致栈溢出

引用 13 楼 qq_26303031 的回复:[quote=引用 10 楼 jack960330 的回复:] [quote=引用 8 楼 qq_26303031 的回复:] [quote=引用 5 楼 zhao4zhong1 的回复:] 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 谢谢，根据你的方法，找到了问题所在，暂时解决了[/quote]  你指针是NULL  就不能使用这个指针。。。[/quote] 我知道问题在哪了，因为我定义函数时， c_node InsertBETree(Event sub, c_node cnode, c_directory cdir，vector <string> attrMatched) 也算把attrMatched初始化了。[/quote]  恭喜

引用 10 楼 jack960330 的回复:[quote=引用 8 楼 qq_26303031 的回复:] [quote=引用 5 楼 zhao4zhong1 的回复:] 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 谢谢，根据你的方法，找到了问题所在，暂时解决了[/quote]  你指针是NULL  就不能使用这个指针。。。[/quote] 我知道问题在哪了，因为我定义函数时， c_node InsertBETree(Event sub, c_node cnode, c_directory cdir，vector <string> attrMatched) 也算把attrMatched初始化了。

引用 10 楼 jack960330 的回复:[quote=引用 8 楼 qq_26303031 的回复:] [quote=引用 5 楼 zhao4zhong1 的回复:] 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 谢谢，根据你的方法，找到了问题所在，暂时解决了[/quote]  你指针是NULL  就不能使用这个指针。。。[/quote] 我想定义一个vector<string>attrMatched，任何一个函数里面改变它之后，这个改变都会一直传下去，不需要用return才能把改变后的值传回去。static vector<string>attrMatched不行啊。我得怎么定义

引用 5 楼 zhao4zhong1 的回复:崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 谢谢，根据你的方法，找到了问题所在，暂时解决了

引用 6 楼 jack960330 的回复:[quote=引用 4 楼 qq_26303031 的回复:] [quote=引用 2 楼 jack960330 的回复:] 用你查看函数堆栈的功能，能知道到底发生了什么  我不会看堆栈，我猜问题出在了InsertBETree(subscription_set1,*cnode,cdir,attrMatched);这里。 但是我改代码，只考虑subscription_set1时  Event Insert(Event sub) { 	predicate pred = { "B", "<", 2 }; 	for (int i = 0; i < 2; i++) 	{ 		sub.pred.push_back(pred); 	} 	return sub; } int main() { //前面不写了 for (int i = 0; i < 3; i++) 	{ 		Event sub = subscription_set1; 		sub=Insert(sub); 		cout << sub.pred.size() << endl; 	} }  并没有出现问题，完美运行[/quote] 根据堆栈 ，问题发生在InsertBETree函数里[/quote]  恩，根据5楼给的方法，发现确实是发生在InsertBETree里面。里面有个*cnode.lnode=Insert(sub, *cnode.lnode);函数，好像是地址有问题。试了下写个小代码          Event subscription_set1= { { predicate("a", "=", 1), predicate("B", "<", 2), predicate("C", "<", 2) } };         Lnode lnode1; 	Lnode *lnode2; 	lnode2 = NULL; 	lnode1.saveSub.push_back(subscription_set1); 	(*lnode2).saveSub.push_back(subscription_set1);  lnode1.saveSub.push_back(subscription_set1);可以执行，(*lnode2).saveSub.push_back(subscription_set1)报错和我发帖时出现的错误一样，应该是定义vector指针的问题吧。没办法，我只能不用指针了，问题倒是解决了，但还不知道其他地方是不是需要指针

引用 4 楼 qq_26303031 的回复:[quote=引用 2 楼 jack960330 的回复:] 用你查看函数堆栈的功能，能知道到底发生了什么  我不会看堆栈，我猜问题出在了InsertBETree(subscription_set1,*cnode,cdir,attrMatched);这里。 但是我改代码，只考虑subscription_set1时  Event Insert(Event sub) { 	predicate pred = { "B", "<", 2 }; 	for (int i = 0; i < 2; i++) 	{ 		sub.pred.push_back(pred); 	} 	return sub; } int main() { //前面不写了 for (int i = 0; i < 3; i++) 	{ 		Event sub = subscription_set1; 		sub=Insert(sub); 		cout << sub.pred.size() << endl; 	} }  并没有出现问题，完美运行[/quote] 根据堆栈 ，问题发生在InsertBETree函数里

引用 7 楼 qq_26303031 的回复:[quote=引用 6 楼 jack960330 的回复:] [quote=引用 4 楼 qq_26303031 的回复:] [quote=引用 2 楼 jack960330 的回复:] 用你查看函数堆栈的功能，能知道到底发生了什么  我不会看堆栈，我猜问题出在了InsertBETree(subscription_set1,*cnode,cdir,attrMatched);这里。 但是我改代码，只考虑subscription_set1时  Event Insert(Event sub) { 	predicate pred = { "B", "<", 2 }; 	for (int i = 0; i < 2; i++) 	{ 		sub.pred.push_back(pred); 	} 	return sub; } int main() { //前面不写了 for (int i = 0; i < 3; i++) 	{ 		Event sub = subscription_set1; 		sub=Insert(sub); 		cout << sub.pred.size() << endl; 	} }  并没有出现问题，完美运行[/quote] 根据堆栈 ，问题发生在InsertBETree函数里[/quote]  恩，根据5楼给的方法，发现确实是发生在InsertBETree里面。里面有个*cnode.lnode=Insert(sub, *cnode.lnode);函数，好像是地址有问题。试了下写个小代码          Event subscription_set1= { { predicate("a", "=", 1), predicate("B", "<", 2), predicate("C", "<", 2) } };         Lnode lnode1; 	Lnode *lnode2; 	lnode2 = NULL; 	lnode1.saveSub.push_back(subscription_set1); 	(*lnode2).saveSub.push_back(subscription_set1);  lnode1.saveSub.push_back(subscription_set1);可以执行，(*lnode2).saveSub.push_back(subscription_set1)报错和我发帖时出现的错误一样，应该是定义vector指针的问题吧。没办法，我只能不用指针了，问题倒是解决了，但还不知道其他地方是不是需要指针 [/quote]  你指针是NULL  就不能使用这个指针。。。

引用 8 楼 qq_26303031 的回复:[quote=引用 5 楼 zhao4zhong1 的回复:] 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 谢谢，根据你的方法，找到了问题所在，暂时解决了[/quote]  你指针是NULL  就不能使用这个指针。。。

引用 7 楼 qq_26303031 的回复:[quote=引用 6 楼 jack960330 的回复:] [quote=引用 4 楼 qq_26303031 的回复:] [quote=引用 2 楼 jack960330 的回复:] 用你查看函数堆栈的功能，能知道到底发生了什么  我不会看堆栈，我猜问题出在了InsertBETree(subscription_set1,*cnode,cdir,attrMatched);这里。 但是我改代码，只考虑subscription_set1时  Event Insert(Event sub) { 	predicate pred = { "B", "<", 2 }; 	for (int i = 0; i < 2; i++) 	{ 		sub.pred.push_back(pred); 	} 	return sub; } int main() { //前面不写了 for (int i = 0; i < 3; i++) 	{ 		Event sub = subscription_set1; 		sub=Insert(sub); 		cout << sub.pred.size() << endl; 	} }  并没有出现问题，完美运行[/quote] 根据堆栈 ，问题发生在InsertBETree函数里[/quote]  恩，根据5楼给的方法，发现确实是发生在InsertBETree里面。里面有个*cnode.lnode=Insert(sub, *cnode.lnode);函数，好像是地址有问题。试了下写个小代码          Event subscription_set1= { { predicate("a", "=", 1), predicate("B", "<", 2), predicate("C", "<", 2) } };         Lnode lnode1; 	Lnode *lnode2; 	lnode2 = NULL; 	lnode1.saveSub.push_back(subscription_set1); 	(*lnode2).saveSub.push_back(subscription_set1);  lnode1.saveSub.push_back(subscription_set1);可以执行，(*lnode2).saveSub.push_back(subscription_set1)报错和我发帖时出现的错误一样，应该是定义vector指针的问题吧。没办法，我只能不用指针了，问题倒是解决了，但还不知道其他地方是不是需要指针 [/quote]  指针要小心使用

用你查看函数堆栈的功能，能知道到底发生了什么

引用 2 楼 jack960330 的回复:用你查看函数堆栈的功能，能知道到底发生了什么  我不会看堆栈，我猜问题出在了InsertBETree(subscription_set1,*cnode,cdir,attrMatched);这里。 但是我改代码，只考虑subscription_set1时  Event Insert(Event sub) { 	predicate pred = { "B", "<", 2 }; 	for (int i = 0; i < 2; i++) 	{ 		sub.pred.push_back(pred); 	} 	return sub; } int main() { //前面不写了 for (int i = 0; i < 3; i++) 	{ 		Event sub = subscription_set1; 		sub=Insert(sub); 		cout << sub.pred.size() << endl; 	} }  并没有出现问题，完美运行

引用 1 楼 user-3 的回复:0x00000008 你这是指针指向了非法地址吧。。这种地址应该不会用到的 你看下你那个指针怎么赋值和运算的 不知道指针怎么赋值了啊，因为定义的结构体相互嵌套，我都不清楚怎么初始化和赋值了


Question: 如何用c语言判断是否有泛洪攻击.

使用libpcap库，模拟一个ARP（发送大量的ARP包）攻击。


Question: C和C++的默认链接属性

你要了解c语言变量的存储类别，可以参考这个博文http://blog.csdn.net/libing403/article/details/72934528

是指的外部链接, 内部链接这种属性吗? 是一样的.


Question: xcode环境下int强制转成unsigned char报错问题

a=unsigned char(inta[i]);  =>  a=(unsigned char)inta[i];  这个是语法错误.  至于死循环, 和转型没关系, 还是检查下循环自身的结束条件吧.


Question: C和C++的一些区别

C++支持C语言的用法，C++相对于C主要区别是支持了面向对象编程；


Question: 运行程序的时候，程序停止

printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。

c语言基础编程问题，scanf(格式化字符串，格式化变量地址);

#include<stdio.h> int main() {     int T, i;      do     {         printf("how many example?(1<=T<=100)  ");         scanf("%d", &T);     } while(T>100||T<1);      int a[T], b[T], c[T], d[T];      printf("enter example:\n");     for(i=0;i<T;i++) {         scanf("%d%d%d%d", &a[i], &b[i], &c[i], &d[i]);         //scanf("%d%d%d%d", a + i, b + i, c + i, d + i);     }     for(i = 0; i < T; i++)     {         if(a[i]==10 && b[i] <= 255 && b[i] >= 0 && c[i] >= 0 && c[i] <= 255 && d[i] >= 0 && d[i] <= 255)             printf("yes\n");         else if(a[i] == 172 && b[i] <= 31 && b[i] >= 16 && c[i] >= 0 && c[i] <= 255 && d[i] >= 0 && d[i] <= 255)             printf("yes\n");         else if(a[i] == 192 && b[i] == 168 && c[i] >= 0 && c[i] <= 255 && d[i] >= 0 && d[i] <= 255)             printf("yes\n");         else             printf("no\n");     }     return 0; } 注意代码风格；  #if 0     scanf("%d%d%d%d", &a[i], &b[i], &c[i], &d[i]); #else     scanf("%d%d%d%d", a + i, b + i, c + i, d + i); #endif  两种方式都是可以

scanf的参数应该是变量的地址，而非变量本身。应该改成： scanf("%d%d%d%d",&a[i],&b[i],&c[i],&d[i]);

scanf的参数应该是变量的地址，而非变量本身。应该改成： scanf("%d%d%d%d",a[i],b[i],c[i],d[i]);


Question: 数据结构 栈问题求助

#include <iostream> #include <stdlib.h> #include <stdio.h> //#include <malloc.h> using namespace std;  typedef int SElemType; typedef int Status;  const int STACK_INIT_SIZE = 100; const int STACKINCREMENT = 10; #define ERROR 0 #define OK 1  typedef struct {     SElemType  *base;        //在栈构造之前和销毁之后,base的值为NULL     SElemType  *top;        //栈顶指针     int  stacksize;            //当前分配的存储空间,以元素为单位 }SqStack;  Status InitStack_Sq(SqStack &S) {     S.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));     if (!S.base)         exit(0);    //存储分配失败     S.top = S.base;     S.stacksize = STACK_INIT_SIZE;     return true; }  Status GetTop(SqStack S, SElemType &e) {     if (S.top == S.base)         return ERROR;     e = *(--S.top);     return OK; } //Push Status Push(SqStack &S, SElemType e) {     if (S.top - S.base >= S.stacksize)     {         S.base = (SElemType *) realloc (S.base,             (S.stacksize + STACKINCREMENT) * sizeof(SElemType));         if (!S.base)             exit(0);//失败         S.top = S.base + S.stacksize;         S.stacksize += STACKINCREMENT;     }     *S.top++ = e;      return OK; }  // Pop Status Pop(SqStack &S, SElemType &e) {     if (S.top == S.base)         return ERROR;      e = *--S.top;     return OK; }  Status StackEmpty(SqStack &S) {     //if (*S.top == -1)     if (S.top == S.base)         return OK;     else         return ERROR; } void conversion(int n, int m, SqStack &S) {     SElemType e;     while (n) {         Push(S, n % m);         n = n / m;     }     while (!StackEmpty(S)) {         Pop(S, e);         printf("%d", e);     }     printf("\n"); }  int main() {     int N, M;     SqStack S;     InitStack_Sq(S);      cout << endl << "输入计算的十进制数据：N=  ";     cin >> N;     cout << endl << "输入转换为什么进制数据：M=  ";     cin >> M;     conversion(N, M, S);      return 0; } 参考一下上面的代码吧；问题主要是： 1. 宏定义后面加分号，这是不对的，宏定义是等价替换（在预编译阶段），如果带着分号替换，你看是否可行； 2. main函数调用使用栈时，没有初始化栈，那么就无法使用； 3. 栈判断是否为空，不能判断其是否等于-1,初始化时，并没有对其初始化为-1； 4. Gettop，需要先自减，再取值，指针减1，不能指向下一个元素，因为指针是4个字节，减1只是偏移1个字节。 注意代码风格，希望有自己的一个代码风格，主要是让读代码的人能比较舒服


Question: 关于C语言输入的问题，出现奇怪的输出

上面那个是main函数的，这个是print函数 #include"ADD.h" #include<stdio.h> void print(struct staff *head) { 	struct staff *p; 	printf("\n员工的数据为："); 	p = head; 	if (head != NULL) 		do 		{ 			printf("%d  %-10s  %f  %d  %d  %d  %d\n", p->no, p->name, p->gender, p->birthday.month, p->birthday.day, p->birthday.year, p->salary); 			p = p->next; 		} while (p != NULL);  }

#include<stdio.h> #include<malloc.h> #define LEN sizeof(struct staff) #include"ADD.h" #include"alter.h" #include"delete.h" #include"search.h" #include"print.h"  int n; void main() { 	struct staff *creat(); 	extern staff *add(struct staff *head, struct staff *info); 	extern staff *alter(struct staff *head, int m); 	extern struct staff *Delete(struct staff *head, int m); 	extern void search(struct staff *head, int m); 	void print(struct staff *head); 	int x; 	struct staff *head,sta; 	head = creat(); 	printf("添加请输入1，删除请输入2，查找请输入3，修改请输入4"); 	scanf("%d", &x); 	if (x == 1) 	{ 		scanf("%d,%s,%f,%d,%d,%d,%d", &sta.no, &sta.name, &sta.gender, &sta.birthday.month, &sta.birthday.day, &sta.birthday.year, &sta.salary); 		head=add(head,&sta); 		print(head); 	} 	else if (x == 2) 	{ 		printf("请输入要删除的职工的员工号:"); 		int c; 		scanf("%d", &c); 		head=Delete(head,c); 		print(head); 	} 	else if (x == 3) 	{ 		int c; 		scanf("%d", &c); 	 search(head,c); 	} 	else if (x == 4) 	{ 		int b1; 		scanf("%d", &b1); 		head=alter(head,b1); 		print(head); 	} 	else 	{ 		printf("輸入有誤！"); 	};    } struct staff *creat() { 	struct staff *head; 	struct staff *p1, *p2; 	n = 0; 	p1 = p2 = (struct staff*)malloc(LEN); 	scanf("%d,%s,%f,%d,%d,%d,%d", &p1->no, &p1->name, &p1->gender, &p1->birthday.month, &p1->birthday.day, &p1->birthday.year, &p1->salary); 	head = NULL; 	while (p1->no != 0) 	{ 		n = n + 1; 		if (n == 1)head = p1; 		else p2->next = p1; 		p2 = p1; 		p1 = (struct staff*)malloc(LEN); 		scanf("%d,%s,%f,%d,%d,%d,%d", &p1->no, &p1->name, &p1->gender, &p1->birthday.month, &p1->birthday.day, &p1->birthday.year, &p1->salary);  	} 	p2->next = NULL; 	return(head); }

最好能贴出代码～

scanf("%d,%s,%f,%d,%d,%d,%d", &p1->no, p1->name, &p1->gender, &p1->birthday.month, &p1->birthday.day, &p1->birthday.year, &p1->salary); 这个地方也是需要去掉&

scanf("%d,%s,%f,%d,%d,%d,%d", &sta.no, sta.name, &sta.gender, &sta.birthday.month, &sta.birthday.day, &sta.birthday.year, &sta.salary); 去掉sta.name前面的&

如果需要代碼請回復


Question: 一个关于C语言的问题，值得思考一下。

“多一少一”问题占程序员常犯错误的10%以上！ 避免“多一少一”问题的方法之一是将比如<10甚至<5的数代入程序片断，掰手指头心算验证一下程序到底应该写为 x、x-1、x+1中的哪个？ <、<=、==、>、>=中的哪个？

这个题是从《C和指针》（Kenneth A.Reek）中文版（徐波译）的113页看到的，对于给出的参考答案我不是很理解，参考答案给出了两个错误，其中一个是数组越界，有没有人能找出并理解另一个错误？

上面的我发的太快，有误，请看下面的 int array[ARRAY_SIZE]; int *pi; for(pi = array; pi < array+ARRAY_SIZE;)     *pi++ = 0;  或者  int array[ARRAY_SIZE]; int *pi; for(pi = array; pi < array + ARRAY_SIZE; pi++)     *pi = 0;

int array[ARRAY_SIZE]; int *pi; for(pi = &array[0]; pi < &array[ARRAY_SIZE);)     *++pi = 0; 或者 int array[ARRAY_SIZE]; int *pi; for(pi = array; pi < array+ARRAY_SIZE;pi++)     *pi = 0;

越界了呗，前置++是先自加  *++pi = 0;  改成：  *pi++ = 0;


Question: 输出字符串中某一字符的个数，哪里出错了？

哦，不区分大小写字母

引用 3 楼 user-2 的回复:scanf 输入时最后留在缓冲区中的换行符\n被下一次gets接收了  在scanf后加上getchar()接收了换行符即可 谢谢，受教了

引用 2 楼 cfjtaishan 的回复:#include <stdio.h> #include <string.h>  int main() {      char str[1000];     char a;     int sum = 0, i;     while(1)     {         gets(str);         scanf("%c", &a);         getchar();    /*接收输入a之后的回车符*/         int n = strlen(str);         sum = 0;         for(i = 0; i < n; i++)         {             if(str[i] == a || str[i] + 32 == a|| str[i] - 32 == a)             {                 sum++;             }         }         printf("%d\n",sum);     }     return 0; } 这是一个小细节，不容易发现；在输入a字符之后，会有一个回车符在输入缓存里，下次在输入字符串时，gets遇到了这个回车符，然后就立即结束了，所以没有数据进入str中，即字符传str为空； 以上是加了一句getchar()可以将输入缓存里的回车符接收了，这样下次就可以正常输入字符串了。 为了验证上面的描述是正确的，可以用一下代码验证，第二次输入的字符串的长度是否为空： #include <stdio.h> #include <string.h>  int main() {      char str[1000];     char a;     int sum = 0, i;     while(1)     {         gets(str);         int n = strlen(str);         printf("n = %d\n", n);         scanf("%c", &a);         //getchar();         sum = 0;         for(i = 0; i < n; i++)         {             if(str[i] == a || str[i] + 32 == a|| str[i] - 32 == a)             {                 sum++;             }         }         printf("%d\n",sum);     }     return 0; } 该代码仅供验证不加getchar()的问题谢谢，受教了


Question: leetcode detect capital

bool detectCapitalUse(char* word) {     int tag = 0, i = 0, count = 0; /* tag, i, count should be initized. */     while(word[i]!='\0') {         count++;         i++;     }      if (word[0] >= 65 && word[0] <= 90) {         for(i=0;i<count;i++)             if(word[i]>=65&&word[i]<=90) 		tag++;         if(tag==0||tag==count)             return true;         else             return false;     }     else     {         for(i=0;i<count;i++)         {             if(word[i]<=90) return false;         }         return true;     } } 似乎是对的，实际上还是不对的。 tag， i, count都没有初始化，很容易导致数组越界，程序无法继续执行的。

初始化了还不对...