Question: 求助一下大佬，其他的都没问题帮我看一下multpoly函数哪里出错了，实在不知道怎么错的，帮我一下，跪求

仅供参考：//链表实现一元多项式的加法减法乘法 #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> #include <stdlib.h>  typedef struct Node *PtrToNode;  struct Node  {     int Coefficient;     int Exponent;     PtrToNode Next; }; typedef PtrToNode Polynomial;  Polynomial Read(Polynomial); /* details omitted */ void Print( Polynomial p ); /* details omitted */ Polynomial Add( Polynomial a, Polynomial b ); Polynomial Multpoly(Polynomial P1, Polynomial P2);  int main(void) {     Polynomial a, b, s1,s2;      a = Read(a);     //Print(a);     b = Read(b);     //Print(b);  #if 1     s2 = Add(a, b);     Print(s2); #else     s1=Multpoly(a, b);     Print(s1); #endif     return 0; }   Polynomial Multpoly(Polynomial P1, Polynomial P2) {     Polynomial P, temp1, temp2, Rear, temp;     int c, e;     if(!P1 || !P2)         return NULL;     temp1 = P1;     temp1=temp1->Next;     temp2 = P2;     temp2=temp2->Next;     P = (Polynomial)malloc(sizeof(struct Node));     P->Next = NULL;     Rear = P;     Rear=Rear->Next;     while(temp2){         c = temp1->Coefficient * temp2->Coefficient;         e = temp1->Exponent + temp2->Exponent;         if(c != 0){             temp = (Polynomial)malloc(sizeof( struct Node));   /* 类型不匹配*/             temp->Coefficient=c;             temp->Exponent=e;             Rear->Next=temp;             temp->Next=NULL;             Rear=Rear->Next;             temp2 = temp2->Next;         }     }     temp1 = temp1->Next;     while(temp1){         temp2 = P2;         temp2=temp2->Next;         Rear = P;         Rear=Rear->Next;         while(temp2){             c = temp1->Coefficient * temp2->Coefficient;             e = temp1->Exponent + temp2->Exponent;             if(c != 0){                 while(Rear->Next && Rear->Next->Exponent > e)                     Rear = Rear->Next;                 if(Rear->Next && Rear->Next->Exponent == e){                     if(Rear->Next->Coefficient + c)                         Rear->Next->Coefficient += c;                     /*else{                       temp = Rear->Next;                       Rear->Next = temp->Next;                       free(temp);                       }*/                 }                 else{                     temp = (Polynomial)malloc(sizeof( struct Node));                     temp->Coefficient = c;                     temp->Exponent = e;                     temp->Next=NULL;                     temp->Next = Rear->Next;                     Rear->Next = temp;                     Rear = Rear->Next;                 }                 temp2 = temp2->Next;             }         }         temp1 = temp1->Next;     }      /*    temp = P;           P = P->Next;           free(temp);*/     return P; }   Polynomial Add( Polynomial a, Polynomial b ) {     Polynomial s,temp;     s=(Polynomial)malloc(sizeof(struct Node));     s->Next=NULL;     temp = s;     a=a->Next;     b=b->Next;     while(a && b)     {         if(a->Exponent > b->Exponent)         {               temp->Next = a;             a = a->Next;             temp->Next->Next=NULL;             temp = temp->Next;           }         else if(b->Exponent > a->Exponent)         {             temp->Next=b;             b=b->Next;             temp->Next->Next=NULL;             temp=temp->Next;          }         else         {             Polynomial t, del;             t = (Polynomial)malloc(sizeof(struct Node));             t-> Coefficient = a-> Coefficient + b->Coefficient;             t->Exponent = a->Exponent;             t->Next = NULL;             if(t->Coefficient != 0)             {                 temp->Next = t;                 temp=temp->Next;             }             del = a;             a = a->Next;             free(del);              del = b;             b = b->Next;             free(del);         }     }     while(a)     {          temp->Next=a;         a = a->Next;         temp = temp->Next;       }     while(b)     {          temp->Next = b;         b = b->Next;         temp = temp->Next;     }     temp->Next=NULL;      return s;  } /*struct Node  {   int Coefficient;   int Exponent;   PtrToNode Next;   };   typedef PtrToNode Polynomial;*/ Polynomial Read(Polynomial L) {     int N;     Polynomial t,ptr;     L=(Polynomial)malloc(sizeof(struct Node));     L->Next=NULL;     t=L;     scanf("%d",&N);     while(N>0)     {         ptr=(Polynomial)malloc(sizeof(struct Node));         scanf("%d %d",&ptr->Coefficient,&ptr->Exponent);         L->Next=ptr;         ptr->Next=NULL;         L=L->Next;         N--;      }      return t;  } void Print(Polynomial L) {     Polynomial p = L->Next;     while(p) {         printf("+++%d %d\n",p->Coefficient,p->Exponent);         p = p->Next;     } } 多项式相加和多项式输出有些问题，帮你改了一下；目前，多项式相加没问题。 但是，需要注意的是多项式相加时，你已经将a或者b的多项式某些点加到了s多项式上，那么a,b已经不是原来的多项式链表了。所以，在执行多项式相乘就会有问题。 建议重新设计一下多项式相加，可以考虑多项式相加时，不对多项式a, b做修改（只是访问），而是通过创建新节点链接到s链表上。

此外，你最上面的声明Polynomial Read(); 这句中Read函数应该是带有一个参数的

temp = (Polynomial*)malloc(sizeof(struct Node)); 这句你的temp是Polynomial类型，而你后面的是Polynomial*类型，将指针赋值给非指针，这里编译肯定出错


Question: 请教，关于scanf格式问题！

很少见过这样使用scanf的，因为scanf是格式化输入，一般只会将数组格式放在第一个参数里，其他比如提示内容，建议用printf输出。 比如  printf("a = "); scanf("%d", &a); printf("b = "); scanf("%f", &b);

你的scanf用法不太正确 [code=c][/#include <stdio.h>  int main(void) {    int a;    float b;     printf("a = ");    scanf("%d", &a);     printf("b = ");    scanf("%f", &b);     printf("%d, %f\n", a, b);    return 0; } code]

scanf第一个参数最好不要加提示符，会导致函数无法结束。可以使用ctrl+d或者ctrl+z结束，不过不推荐。 提示符最好用printf()


Question: c快排求助请看代码最后

会变化，因为递归传进去的虽然是begin，end，但是这两个值是变化的（i, 和j 分别取代了end和start，i,j是变化的变量）。建议详细了解一下递归的原理。

递归的时候，参数传递过程中，begin和end的值不断变化的 自己做个简单的模拟就了解了。 1、quicksort(array, maxlen, begin, i);  //这时候begin不变，但是end的值是i了，变化了 2、quicksort(array, maxlen, j, end);   //同理，begin的值是j，变了 不断递归下去，只有最左边的一个组，begin永远不变，最右边的组，end永远不变，中间的组，begin和end都变了。


Question: 奇怪的出错 VC里死循环 但是代码应该没错 普通简单的for循环

#include<stdio.h> int main() {     int day=0,t,a,b;     int aa[366];     scanf("%d%d",&a,&b);     printf("a=%d b=%d\n\n",a,b);     for(day=0;day<366-7;day=day+7)     {         /*      aa[day]=1;                 aa[day+1]=2;                 aa[day+2]=3;                 aa[day+3]=4;                 aa[day+4]=5;                 aa[day+5]=6;                 aa[day+6]=7;*/         for(int j=0;j<7;j++)             aa[day+j]=j+1;         printf("day=%d  %d\n\n",day,aa[day]);     }     day=0;     printf("a=%d b=%d\n\n",a,b);     switch(a)     {         case 12: day+=30;         case 11:day+=31;         case 10: day+=30;         case 9: day+=31;         case 8: day+=31;         case 7: day+=30;         case 6: day+=31;         case 5: day+=30;         case 4: day=day+31;         case 3: day=day+28;         case 2: day=day+31;         case 1: day=day+b;     }     printf("%d\n", day);    /*这儿的day远大于366-1*/     printf("day=%d %d\n\n",day,aa[day]);     return 0; } 楼主的问题主要体现在数组越界，第一个for循环已经会导致aa越界，所以循环退出条件应该为day < 366 - 7;另外，该循环语法也有问题，for的第三个表达式后没有分号  下面的第二个循环后，day已经远大于366-1，下标最大为365，所以也会导致越界； 建议重新梳理一下逻辑，另外注意数组的边界。

for(int j=0;j<7;j++)          aa[day+j]=j+1; ---->当day=364 j>=2时数组越界了 需要加个条件判断 [code=c][/for(int j=0;j<7;j++)          {             if ((day+j)<366)                aa[day+j]=j+1;          } code]


Question: 最后一句一直在报错！

C语言不支持&运算符，只有C++的编译器才支持。建议使用C++的编译器或者将参数定义成指针；这两种方法其实都是传地址到initList中，通过调用都能将初始化的list带回。

Status initList(SqList &L, int initSize) 中的&时C++中的引用，C语言中时没有的 你需要改为C语言的方式 Status initList(SqList L, int initSize)  或 Status initList(SqList *L, int initSize)  --》程序中的L需要改为(*L)


Question: 求个算法，用c或vb，拜托了

Dijkstra算法求无向图的最短距离，如果自己没有思路，可以从网上看一下别人的算法和实现，或改一改别人的算法；

首先要设计输入数据格式，可以是这样的一个结构体：  struct direct_path { 	char start; 	char end; 	int length; }  用这个结构来定义一个表（数组），这样你就可以定义任意两点的直接距离，注意是直接路径，只有两点之间可以直达才能出现在这个表里。 问题是以A为起点 ，求给出的另一个点的最短距离，那么应该在这个表里找到所有包含A的成员，记录下一个点，然后从下一个点开始，又找下一个点，这个过程中已走过的点不要重复。直到出现目标，或遍历结束。 最后你会得到多个结果，取最小的即可。  我有实现此算法的代码，若需要可发给你。

数学问题问数学老师啊！


Question: 求大佬指點，有關輸出的問題

static double b[36],c[36],d1[36],d2[36],M1[36],M2[36],x[361],h[36]; static double u[36],v[36],y1[36],y2[36]; 在占用内存空间较大的局部数组声明的前面加static将其从堆栈数据段挪到全局数据段即可避开因局部数组大小超过默认堆栈大小1MB造成程序不能正常运行的问题。

调试也是IT必备的技能

浮点数值溢出了就会有这样的结果

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

楼主的需求是什么？代码定义的变量太多，代码可读性很差呢。如果可以，个人建议没必要定义那么多变量，变量多了会使代码变得乱，可读性降低；


Question: 求助！约瑟夫环的问题

仅供参考：//假设有n个人团团围做，从第1个人开始数数，数到第m个人时候，第m个人出列， //然后继续从1开始数数，数到第m个人退出 #include <stdio.h> #include <conio.h> int i,k,t; int n,m; static char f[1001];//0该座位未出圈,1该座位已出圈 void main() {     while (1) {         printf("Input n m(1000>=n>=m>=1):");         fflush(stdout);         rewind(stdin);         if (2==scanf("%d%d",&n,&m)) {             if (1000>=n && n>=m && m>=1) break;         }     }     t=0;//已出圈总人数     i=1;//座位编号     k=1;//当前要数的数     while (1) {         if (0==f[i]) {             if (m==k) {                 t++;                 f[i]=1;                 printf("%3d ",i);                 if (0==t%10) printf("\n");                 if (t>=n) break;             }             k++;if (k>m) k=1;         }         i++;if (i>n) i=1;     }     cprintf("Press any key ...");     getch(); }

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

C++自定义链表实现约瑟夫环（上） http://blog.csdn.net/hou09tian/article/details/78220636 C++自定义链表实现约瑟夫环（下） http://blog.csdn.net/hou09tian/article/details/78256196 希望能帮到你

#include<stdio.h> #include<stdlib.h>  //创建结构体 typedef struct Node {     int Num;//编号     int pass;//密码     struct Node *next; }Node,*PNode,*HNode;  int JoseInsert(Node *h, int pos/*创建第几个人*/, int x/*每个人的密码*/); int JoseInit(HNode h); void TraverseNode(HNode h, int M/*参与人数*/); int JoseDelete(HNode &h, int M/*参与人数*/, int &k/*出局密码*/);    //初始化链表 int JoseInit(HNode h) {     if (!h)     {         printf("链表初始化错误!\n");         return 0;     }     h->next = h;     return 1; } //单链表插入工作 int JoseInsert(Node **h, int pos/*创建第几个人*/,int x/*每个人的编号*/) {     int pa;     PNode p = *h, q;     int i = 1;     scanf("%d", &pa);     if (pos == 1)     {         p->Num = x;         p->pass = pa;         p->next = p;         return 1;     }     while (i < pos-1)     {         p = p->next;         i++;     }     q = (PNode)malloc(sizeof(Node));     q->Num = x;     q->pass = pa; /* p to q */     q->next = p->next;     p->next = q;      return 1; }  //遍历 void TraverseNode(HNode h, int M/*参与人数*/) {     int i = 0;     PNode p = h;     printf("参与的人的编号为\n");     while (i < M )     {          printf("%d\t", p->Num);         p = p->next;         i++;     }      p = h;     i = 0;     printf("\n参与的人的密码为\n");     while (i < M)     {         printf("%d\t", p->pass);         p = p->next;         i++;     }     printf("\n"); } //出局 int JoseDelete(HNode &h, int M/*参与人数*/, int &k/*出局密码*/) {     int i;     PNode p = h, q;     while (M > 1)     {         for (i = 1; i < k - 1; i++)         {             p = p->next;         }         q = p->next;         p->next = q->next;         printf("出局的人为：%d号\n", q->Num);         printf("密码变更为：%d\n", q->pass);         k = q->pass;         free(q);         p = p->next;         M--;     }     return 1; }    int main() {     int i;//计数器     int N;//参与人数     int k;//密码     printf("请输入初始密码\n");     scanf("%d", &k);     printf("请输入参与人数\n");     scanf("%d", &N);     HNode h = (HNode)malloc(sizeof(Node));//头节点     JoseInit(h);//初始化     for (i = 1; i <= N; i++) /* delete ;*/     {         JoseInsert(&h, i, i);//插入法创建链表     }     TraverseNode(h,N);//遍历链表     if (k)         JoseDelete(h, N, k);//进行游戏     return 0; } 代码中问题做了修改； 目前发现约瑟夫环的执行逻辑还是有点问题，比如初始密码为1，那么就会先删除头节点，这种情况没有考虑到吧 建议在这个基础上继续完善你的功能；


Question: c语言链表水题纠错

楼主能分享下正确的代码嘛

约瑟夫环的变式吧

分析需求，可以得到的问题的分类，就是一个约瑟夫环变相问题。

咋就那么多0粉贴呢

visio画图工具，画图理解


Question: 想问一下这个代码为什么不正确，关于两个一元多项式链表相乘的问题，还有一个问题就是下面还有一个关于两个交集的问题我的代码应该怎么修改

#include <stdio.h> #include <stdlib.h> #include <string.h>  #define OK      1 #define ERROR   0 #define TRUE    1 #define FALSE   0  typedef int Status; typedef int Elemtype;  typedef struct Node{     Elemtype cof;     Elemtype inx;     struct Node *next; }Node, *LinkList;  Status visit(Elemtype a, Elemtype b) {     printf("%d %d", a, b);      return OK; }  Status InitList(LinkList *L) {     (*L) = (LinkList)malloc(sizeof(Node));     if (!(*L))         return ERROR;      (*L)->next = NULL;      return OK; }  /* count the length */ int ListLength(LinkList L) {     int i = 0;     LinkList p;      p = L->next;     while (p) {         i++;         p = p->next;     }      return i; }   /* get the data of no. i nodes, i start from 1 */ Status GetElem(LinkList L, int i, Elemtype *cof, Elemtype *inx) {     LinkList p;     int j;      p = L;     j = 1;     while (p && j < i) {         p = p->next;         j++;     }     if (!p)         return ERROR;      *cof=p->next->cof;     *inx=p->next->inx;      return OK; }  Status ListInsert(LinkList *L, int i, Elemtype cof, Elemtype inx) {     if(i < 1 || i > ListLength(*L) + 1)         return ERROR;      int j;     LinkList p, q;       p = *L;     j = 1;     while (p && j < i) {         p = p->next;         j++;     }     if (!p || j > i)         return ERROR;      q = (LinkList)malloc(sizeof(Node));     if (!q) {         fprintf(stderr, "malloc error!\n");         return ERROR;     }     q->cof = cof;     q->inx = inx;      q->next = p->next;     p->next = q;      return OK; }   /*打印L中系数非零的项*/ Status ListTraverse(LinkList L) {     LinkList p;      p = L->next;     while (p) {         if (p->cof != 0) {             visit(p->cof, p->inx);             printf(" ");         }         p = p->next;     }     printf("\n");      return OK; }  Status PlusList(LinkList *L3,LinkList L1,LinkList L2) {     int i, j, k;     Elemtype cof1, inx1;     Elemtype cof2, inx2;      k = i = j = 1;     while ((i <= ListLength(L1)) && (j <= ListLength(L2))) {         GetElem(L1, i, &cof1, &inx1);         GetElem(L2, j, &cof2, &inx2);         if (inx1 == inx2) {             ListInsert(L3, k++, cof1 + cof2, inx1);             i++;             j++;         } else if (inx1 > inx2) {             ListInsert(L3, k++, cof1, inx1);             i++;         } else {             ListInsert(L3, k++, cof2, inx2);             j++;         }     }      return OK; } int main() {     LinkList L1, L2, L3;     int cofn, inxn;     int i;      InitList(&L1);     InitList(&L2);     InitList(&L3);      i = 1;     while(scanf("%d%d", &cofn, &inxn) == 2 && inxn != -1){         ListInsert(&L1, i++, cofn, inxn);     }     i = 1;     while(scanf("%d%d", &cofn, &inxn) == 2 && cofn != -1){         ListInsert(&L2, i++, cofn, inxn);     }     PlusList(&L3, L1, L2);     ListTraverse(L3);      return 0; }  多项式加法，作为一个参考吧

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

谢谢你们的回答，本以为不会有人回复，原来这里有这么多热心的人 谢谢    谢 谢


Question: 关于同步互斥问题

s=1;//垫子资源 m=1;//计数器访问资源数,防止多进程同时改变计数器 a=0;//计数器，判断a方向前面有几个小朋友 b=0;//计数器，判断b方向前面有几个小朋友  p1() {    while(1)    {       p(m);       a++;       if(a==1)          p(s);       v(m);       a方向上桥;       p(m);       a--;       if(a==0)          v(s);       v(m);    } }   p2() {    while(1)    {       p(m);       b++;       if(b==1)          p(s);       v(m);       b方向上桥;       p(m);       b--;       if(b==0)          v(s);       v(m);    } }  你看下喽

求大神！谢谢，没搜到答案


Question: 关于code blocks的使用问题

过了这么久才想起发过这个帖子，我最后是删除了360就好了，嘻嘻

路径或者程序名中有中文的问题吧。

求大神帮我解答一下T^T

关闭UAC、防火墙、杀毒软件、…… 以管理员身份运行  程序员的常识之一：不要将程序源代码或项目或exe放在桌面这种复杂（多半带空格和汉字且在防火墙或杀毒软件严密控制的C盘上）的目录下。


Question: 求大神解答

栈中的变量通常包括函数参数和函数里声明的临时变量。 栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。 而栈中的类变量退出其作用域时，会自动执行其析构函数，……  其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。


Question: 【求助】子函数定义一个字符串变量，返回指针。由数组和指针定义而出现的不同现象，挺有趣的！！

栈中的变量通常包括函数参数和函数里声明的临时变量。 栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。 而栈中的类变量退出其作用域时，会自动执行其析构函数，……  其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。  http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

返回局部变量数组是未定义行为，如果能够得到正确的值，那么说明释放的函数空间没有被申请，数据自然没有被覆盖。

#pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！

char *s="abcde"; 这种方式定义的字符串"abcde"在常量区，即s指向常量区，所以返回的是常量区的地址，常量区的内容是不会变化的


malloc Allocates memory blocks.  void *malloc( size_t size );  Routine Required Header Compatibility  malloc <stdlib.h> and <malloc.h> ANSI, Win 95, Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  malloc returns a void pointer to the allocated space, or NULL if there is insufficient memory available. To return a pointer to a type other than void, use a type cast on the return value. The storage space pointed to by the return value is guaranteed to be suitably aligned for storage of any type of object. If size is 0, malloc allocates a zero-length item in the heap and returns a valid pointer to that item. Always check the return from malloc, even if the amount of memory requested is small.  Parameter  size  Bytes to allocate  Remarks  The malloc function allocates a memory block of at least size bytes. The block may be larger than size bytes because of space required for alignment and maintenance information.  The startup code uses malloc to allocate storage for the _environ, envp, and argv variables. The following functions and their wide-character counterparts also call malloc:  calloc fscanf _getw setvbuf  _exec functions fseek _popen _spawn functions  fgetc fsetpos printf _strdup  _fgetchar _fullpath putc system  fgets fwrite putchar _tempnam  fprintf getc _putenv ungetc  fputc getchar puts vfprintf  _fputchar _getcwd _putw vprintf  fputs _getdcwd scanf    fread gets _searchenv      The C++ _set_new_mode function sets the new handler mode for malloc. The new handler mode indicates whether, on failure, malloc is to call the new handler routine as set by _set_new_handler. By default, malloc does not call the new handler routine on failure to allocate memory. You can override this default behavior so that, when malloc fails to allocate memory, malloc calls the new handler routine in the same way that the new operator does when it fails for the same reason. To override the default, call   _set_new_mode(1)  early in your program, or link with NEWMODE.OBJ.  When the application is linked with a debug version of the C run-time libraries, malloc resolves to _malloc_dbg. For more information about how the heap is managed during the debugging process, see Using C Run-Time Library Debugging Support.  Example  /* MALLOC.C: This program allocates memory with  * malloc, then frees the memory with free.  */  #include <stdlib.h>         /* For _MAX_PATH definition */ #include <stdio.h> #include <malloc.h>  void main( void ) {    char *string;     /* Allocate space for a path name */    string = malloc( _MAX_PATH );    if( string == NULL )       printf( "Insufficient memory available\n" );    else    {       printf( "Memory space allocated for path name\n" );       free( string );       printf( "Memory freed\n" );    } }   Output  Memory space allocated for path name Memory freed   Memory Allocation Routines  See Also   calloc, free, realloc

<stdlib.h> and <malloc.h>

应该是放在<malloc.h>，Windows下malloc声明的头文件和Linux下有些不同。Linux引入<stdlib.h>即可，但是Windows下要引入<malloc.h> 详细的可以从网上搜一下<malloc.h>都有那些函数或变量声明

引用 2 楼 qq_38204686 的回复:我的可以vs2008 你就用下面那个头文件吧  应该是配置的问题吧，我一直用的linux，换到vs不会用，也不会配置。

我的可以vs2008 你就用下面那个头文件吧

我的图呢？


Question: 新手遇到点小问题，求大神解答

引用 1 楼 qq_21193563 的回复:程序运行到puts时，数组a的内存生命周期结束了，内部内存被释放，指针乱指 指针没有乱指哦，只是指向的那部分内存区域不能使用了（被释放了），若被其他函数栈占用，就会把arr的数组覆盖掉；

你定义的函数返回了一个局部变量arr[]的地址，会在函数返回后销毁，值就是随机的了

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

返回局部变量是未定义行为，建议将数组arr定义成static变量，改变数组的生命周期；  int* decimaltobinary(int x) {     int i;     static int arr[32]={0};     int * p;      for(i=0;i<32;i++)     {         //printf("%d ",x%2);         arr[i]=x%2;         if(x==1)             break;         x/=2;     }     p=arr;     return p; }

还是不要返回指针了，直接在参数里传入指针不是更好？

程序运行到puts时，数组a的内存生命周期结束了，内部内存被释放，指针乱指


Question: error: missing binary operator before token "("

#elif define 改为 #elif defined

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

咋就那么多0粉贴呢

这种宏的错误 , 很可能是前面的东西导致的.


Question: 关于线性表的链式存储结构

创建那个元素的时候当然知道其地址（比如用new创建的话，返回的就是对应指针），然后把它存储到前一个元素里就可以了。

对于c语言里的结构体数据内存存储，会按照不同机器采用不同的对齐方式。所以，要了解结构体的元素地址先了解一下这个结构体里数据内存存储的对齐方式。 比如 struct {      int  a；     char  b；     int  c； }temp； 假设 a地址是1000；b的地址是1004；c的地址是1008；而不是1006；

typedef struct List{ 	struct List *start; 	int num; 	struct List *end; }list;

通过这个后继元素的地址找到后继，地址值，就像门牌号，知道了门牌号还不容易找到对应的后继吗？如果你要了解，怎么找到的，这个过程那就不是链表知识能解答了。建议看一下内存管理机制

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

比如  struct node_info { 	int data; 	struct node_info *next; }  这里的next就用来存储下一个元素的地址，这样组成了一个任意长度的链表。

记录后一个元素的内存地址呀


Question: 初始化问题

谢谢你们，我懂了，还请以后多多帮忙

要用就初始化 不用就无需初始化  好的习惯是 先初始化

不初始化，在大多数系统中就是一个随机值，程序是否能正常运行，取决于你如何使用变量。 第一个程序其实没有任何初始值被使用，因此不初始化并没有影响。第二个程序直接把x和A等变量做对比，若无初始化，对比结果是未知的，这不代表程序运行不下去，只是结果是你无法预期的而已。

上面的代码中，虽然定义并初始化了A B C D E变量，但代码中并未使用，所以可以去掉 下面的代码中则不一样，if语句是根据x变量与A B C D E变量的值进行比较来做判断而显示的，所以必须初始化


Question: 求问二维数组怎样写入二进制文件。。。。

引用 3 楼 losercat 的回复:[quote=引用 2 楼 zhao4zhong1 的回复:] 搜“序列化 反序列化” www.json.org 谢谢！！刚刚我又在网上查了一下，原来是fread和fwrite里的参数写错了。。。。。现在解决了  这位老师。。。。。第一次看到你头像的时候就觉得是不是初中的数学老师在回答别人问题。。。。。你们长得简直一毛一样  还有就是我第一次发帖，不知道要给分的。。。。。抱歉啊[/quote] 没准你遇到了我失散多年的孪生兄弟。

搜“序列化 反序列化” www.json.org

FILE 文件操作

引用 2 楼 zhao4zhong1 的回复:搜“序列化 反序列化” www.json.org 谢谢！！刚刚我又在网上查了一下，原来是fread和fwrite里的参数写错了。。。。。现在解决了  这位老师。。。。。第一次看到你头像的时候就觉得是不是初中的数学老师在回答别人问题。。。。。你们长得简直一毛一样  还有就是我第一次发帖，不知道要给分的。。。。。抱歉啊


Question: c语言

咋就那么多0粉贴呢

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

前面是输出、后面等你输入


Question: 关于释放结点的问题

必须先释放指针域指向的空间，然后才释放本节点。

释放某个节点，只是释放的该节点的占用空间（由使用状态变为未使用状态），该空间里的数据域和指针域都会释放，但是指针域指向的内存空间不会释放，但是指针域指向的地址有可能找不到了。因为释放之后指针域不可用了。

数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633


Question: Push函数出错Program received signal SIGSEGV, Segmentation fault

看这个函数：  81 Tree create_Tree(void)  82 {  83     Stack S;  84     Tree T, R;  85     char s[50], E;  86     int i = 0;  87     gets(s);  88     puts(s);  89     for (i = 0; s[i] != '\0'; i++) {  90         if (s[i] >= '0' && s[i] <= '9') {  91             T = (Tree) malloc(sizeof(Tree));  92             T->data = s[i];  93             T->left = NULL;  94             T->right = NULL;  95             Push(T, S);  96             printf("aaaaaaa");  97         } else  98             if (s[i] == '+' || s[i] == '-' || s[i] == '*'  99             || s[i] == '/') { 100             T = (Tree) malloc(sizeof(Tree)); 101             T->data = s[i]; 102             E = s[i]; 103             T->left = Top(S); 104             Pop(S); 105             T->right = Top(S); 106             Pop(S); 107             Push(T, S); 108         } 109     } 110     printf("bbbbbbb"); 111     return R; 112 }  Stack S; 这一行，S只是一个指针，并没有分配空间，此时S指向的地址是随机的，很可能是不能访问的，特别是写操作，后面第一次调用Push()函数的时修，第一次访问S就是楼主所说的那一行： tmp->next = S->next; 如果S是空，或其它不可访问的地址，这句就错了。 楼主应该先给S分配空间。

程序的若干问题： 第一个，=与==的区别；建议注意下； void MakeEmpty(Stack S) {     if(S==NULL) /* = 与 == */         printf("Must create first!");     else         while(!IsEmpty(S))             Pop(S); }  第二个，Tree create_Tree(void)函数的返回值R是一个随机值的指针，该函数中并没有对R做赋值或者修改操作； 返回一直随机值应该是无意义的；同时该函数里有push操作，但是S一样是为初始化的，我想这个栈应该通过参数传进来。 第三个，Levelorder函数里， void Levelorder(Tree X) {     Tree Q[50];     Q[0]=X;     int front=0,rear=1;     while(front<rear)     {         printf("%c ",Q[front]->data);         if(Q[front]->left)             Q[rear++]=Q[front]->left;         if(Q[front]->right)             Q[rear++]->right;    /*无意义的表达式*/         ++front;     } }

进程意外退出会在当前目录下产生‘core’文件或形如‘core.数字’的文件比如‘core.1234’ 使用命令 gdb 运行程序名 core或core.数字 进入gdb然后使用bt命令 可以查看进程意外退出前函数调用的堆栈，内容为从上到下列出对应从里层到外层的函数调用历史。 如果进程意外退出不产生core文件，参考“ulimit -c core文件最大块大小”命令

s为空么？  设置断点调试一下


Question: While 语句 问题

对楼上进行指正： （2）while(!(x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0))  x++;  X对2取余为1，对3取余为2，对5取余为4，对6取余为5和能被7整除。当这些条件不满足其一的时候，X才会++。

（1）while(x%2!=1 && x%3!=2 && x%5!=4 && x%6!=5 && x%7!=0) x++; X对2取余不为1，对3取余不为2，对5取余不为4，对6取余不为5和不能被7整除。当这些条件都满足的时候，X才会++。  （2）while(!(x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0)) x++; X对2取余为1，对3取余为2，对5取余为4，对6取余为5和能被7整除。当这些条件都不满足的时候，X才会++。  而与的逻辑是，当第一个条件为假时，结果为假，后面的条件不进行运算，就算后面的条件为真也不进行运算。只有第一个为真时，按照从左到右的规则，继续判断。 所以，在（1）中，当X为2时，"x % 2 != 1"的运算结果为0，所以while将跳出循环。此时X的值为1（如果X的初值是1） 而在（2）中，当X为2时，“x %2 == 1”的运算结果也为0，但是有一个“！”在前面，所以while会继续循环，直到不满足while条件时才会退出循环。  以上是我的理解，不正确之处请指正。

首先要知道运算符的优先级和不同编译器的编译原理才能做，因为你的各个表达式都没加括号，不同的编译器出来结果可能不一样

while(x%2!=1 && x%3!=2 && x%5!=4 && x%6!=5 && x%7!=0)  while(!(x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0))  这两个是不一样的，比如 一旦 x%2!=1 为0，那0根谁&&都是0 ，所以就不会往下执行（也就是说不会去判断  x%3!=2 && x%5!=4 && x%6!=5 && x%7!=0 这些东西），

与或区别， 逻辑问题

感谢大佬们的回答

引用 2 楼 zhao4zhong1 的回复:!(A && B)等价于(!A || !B) !(A || B)等价于(!A && !B) 赞同

与非   逻辑 我记得数电有公式  上面的必须全部不满足才可以 全部不等于才可以  下面的只要不满足一个就可以 只要有一个不等于就为0 取反为1


Question: 这段代码出了什么问题呢

n和10有什么关系，为什么用一个10来作为实参呢，不是n吗？

因为实参实际上是10 我这里是错了，应该是n的 但是这个好像不影响，问题依然存在


Question: while 语句

两个中，如果把其中一个里面的“&&”改成“||”，就是一样的了

对于第一种，当x等于3时：先计算x%2!=1，该表达式为假，后面的 x%3!=2等都不会再计算了。整个表达式为假（0） 对于第二种，当x等于3时：先计算x%2==1，该表达式为真，于是再计算 x%3==2，该表达式为假，后面的x%5==4等都不会再计算了。 整个括号中的表达式为假，再套上个！，结果为真（1） 所以第一种和第二种并不等价，代入一个数字算算就知道了

while(!(x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0)) x++  等价于 while((x%2!=1 || x%3!=2 || x%5！=4 || x%6!=5 || x%7!=0)) x++   对于这么唱的多个判断不容易判断，建议可以利用一个简单的例子对比学习：  while (!(x == 1 && x == 2)) 等价与 while (x != 1 || x != 2)

while(x%2!=1 || x%3!=2 || x%5!=4 || x%6!=5 || x%7!=0) x++ 与 while(!(x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0)) x++ 等价

上面的必须全部不满足才可以 全部不等于才可以  下面的只要不满足一个就可以 只要有一个不等于就为0 取反为1


Question: 简单代码-字符转换 运行无限输出 求解

循环的最后加上ch = getchar();，否则下一次循环开始时，ch还是之前输入的值，永远不为\n

因为你的第一个字符若不是换行符'\n'，那么就会进入while循环，然后在while循环体内并没有修改ch为'\n'，所以ch就一直不会是换行符，就会是死循环；  加一句ch = getchar();就会解决死循环

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

只要不输入换行符就会进入循环，若在A-Z中间，执行一次if后，就>Z不在里面了，此后就不会执行if语句，只是一直输出；若最开始不在里面直接无限输出。

或者这样 #include <stdio.h>  int main(void) {     char ch;       while((ch = getchar()) != '\n')     {         if (ch >= 'A' && ch <= 'Z')             ch = ch + 32;         putchar(ch);      }      return 0; }

ch没变过 所以一直循环

把getchar放在while里面


Question: 求助大佬：

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

引用 3 楼 qq_40470949 的回复:那直接b[N] = {a}本质是什么？为什么可以这样做？ 把a的值（一个地址）当做字符（一般要截断变短），存入 b[0]

那直接b[N] = {a}本质是什么？为什么可以这样做？

至少应该这样吧 char b[N] = {a[0], a[1]};

赋值改一下memcpy（b，a，N）；


Question: 位数组  c和指针 第5章 第5道题

感谢大家的解答，这是我结合大家的答案，和我的理解 ，搞清了这个输入到输出的过程： 以下是我的理解  和源代码的改动：  MASK1 4294967295 MASK2 4095 MASK3 65520 originl_value1 65535 originl_value2 15 value_to_store1 4656 0x123f #include <stdio.h> #include <limits.h> #define  INT_BITS     ( CHAR_BIT * sizeof( int ) )  int store_bit_field( int original_value, int value_to_store, unsigned starting_bit, unsigned ending_bit ) {     unsigned mask;      if( starting_bit < INT_BITS && ending_bit < INT_BITS &&starting_bit >= ending_bit ){  //      printf("%32d\n",INT_BITS); //      printf("%ld\n",mask);         mask = (unsigned)(-1);   //把～0强制转换为无符号值?????????         printf("MASK1 %ld\n",mask);         mask >>= INT_BITS - (starting_bit-ending_bit+1);         printf("MASK2 %ld\n",mask);         mask <<= ending_bit;         printf("MASK3 %ld\n",mask);          printf("originl_value1 %ld\n",original_value);                                      //以上为创建MASK         original_value &= ~mask;         printf("originl_value2 %ld\n",original_value);         value_to_store <<= ending_bit;         printf("value_to_store1 %ld\n",value_to_store);         original_value |= value_to_store & mask;              }      return original_value; } int main() {     printf("%d\n%d\n",INT_BITS,sizeof(int));     int m=store_bit_field(0xffff,0x123,15,4);     printf("0x%0x\n",m);     return 0; }

#include <stdio.h>  #define WIRTE_UINT(des ,x ,pos ,len)  (                                   \     (des)                                                                 \     &                                                                     \        ~(                                /* 除要修改的位为0，其余都为1 */ \             (                                                             \                 (1<<(len))-1             /* 长度为len位的1             */ \             )                                                             \             <<(32-(pos)-(len))           /* 左移32-(pos)-(len)位       */ \         )                                                                 \     |                                                                     \         (                                                                 \             (x)                                                           \             <<(32-(pos)-(len))                                            \         )                                                                 \ ) #define READ_UINT(src ,pos ,len)      (                                   \     (                                                                     \         (                                                                 \             (unsigned)(src)                                               \         )                                                                 \         >>(32-(pos)-(len))               /* 逻辑右移32-(pos)-(len)位   */ \     )                                                                     \     &                                                                     \     (                                                                     \         (1<<(len))-1                     /* 长度为len位的1             */ \     )                                                                     \ )  int main()                              //                1111111111222222222233 {                                       //bit   01234567890123456789012345678901     unsigned int des = 0x661;           //      00000000000000000000011001100001     unsigned int r;      des = WIRTE_UINT(des ,3 ,28 ,2);    //      00000000000000000000011001101101     printf("des==0x%08X\n",des); 	r =	READ_UINT(des ,28 ,2);     printf("r==%d\n",r);     return 0; } //des==0x0000066D //r==3

mask = (unsigned)(-1);  //意思是mask的类型能表达的最大的正整数，所有的二进制位都是1 假如mask的类型是32位正整数，那么这样做就是 0xFFFF。 写(unsigned)(-1) 比直接写 0xFFFF更好，因为不同编译器中，unsigned int的长度可能是不同的。  mask >>= INT_BITS - (starting_bit-ending_bit+1); //这是位操作，右移 你的例子里有大量的位操作，是可以在纸上一步步演算的。

-1在内存中的存储方式 原码 反码 补码

自己根据位运算方法，在纸上推一下就懂了

大神给我讲解一下这个  mask是怎么生成的  也就是这个行代码的意思是什么 mask = (unsigned)(-1);   //把～0强制转换为无符号值????????? //      printf("%ld\n",mask);         mask >>= INT_BITS - (starting_bit-ending_bit+1);         mask <<= ending_bit;[code=c][/code] 你好  能具体讲一下这个掩码mask的生成原理吗  万分感谢


Question: 从控制台向变量输入值出现的问题

第15行多余，删掉。

float a,b; char c; while (1) {  rewind(stdin);  if (3!=scanf("%f%c%f", &a, &c, &b)) break;  switch (c) {   case '*':    printf("%g*%g=%g\n",a,b,a*b);   break;   case '/':    printf("%g/%g=%g\n",a,b,a/b);   break;   default:   break;  }  } }

scanf只是按%s的说明识别输入项。 如果你想输入 0,3.14/2，应该用 scanf("%f,%f/%f", &a, &b, &c)，结果abc分别为0、3.14、2

你得自己按字符去接收运算符，然后判断这个字符是什么运算符，然后采取不同的操作

控制台能接收 但是无法识别  那只是一个符号 不是运算符

你就输入两个运算符然后监控程序中变量的值……你就明白了

抱歉，乘号计算也是错的


Question: 顺序表目前那种C语言的实现适合处理大规模的数据增删改查 ？？

B+树


Question: 有switch语句编程成绩由百分制转为等级制

引用 1 楼 lamb666666的回复:这里的问题出在case条件，case 的条件必须是要个常量，而且在C语言中也没有90~100这样的表达方式。这里还是推荐使用if else的判断语句来做  if (grade >= 90 && grade <= 100)      printf("A"); else if (grade >=80 && grade < 90)     printf("B");   另外提供一下switch的用法  //switch的用法 switch (X) {     case 1:         //do something         break;     case 2:         //do something         break;     default:         //do something }  谢谢，我if语句会用，但就是case这里不知道如何去写，因为我要输入一个分数段，不太会写

引用 2 楼 自信男孩的回复:#include <stdio.h>  int main(void) {     int grade, ch;      scanf("%d", &grade);     if (grade < 0 || grade > 100)         return 0;      ch = grade / 10;      switch (ch) {         case 0:         case 1:         case 2:         case 3:         case 4:         case 5:             printf("E\n");             break;          case 6:             printf("D\n");             break;          case 7:             printf("C\n");             break;          case 8:             printf("B\n");             break;          case 9:         case 10:             printf("A\n");             break;          default:             printf("Enter error data!\n");             break;     }      return 0; } 可以参考一下 谢谢，可是我需要将分数段输入到case里要怎么做，不太清楚

引用 1 楼 lamb666666的回复:这里的问题出在case条件，case 的条件必须是要个常量，而且在C语言中也没有90~100这样的表达方式。这里还是推荐使用if else的判断语句来做  if (grade >= 90 && grade <= 100)      printf("A"); else if (grade >=80 && grade < 90)     printf("B");   另外提供一下switch的用法  //switch的用法 switch (X) {     case 1:         //do something         break;     case 2:         //do something         break;     default:         //do something }  谢谢指教，我明白了，下次还请多多帮忙

引用 6 楼 user-3的回复:#include <stdio.h>  int main(void) {    int grade;     //scanf("%d\n", &grade); //不能加\n    scanf("%d", &grade);     switch (grade)    {       case 100:       case  99:       case  98:       case  97:       case  96:       case  95:       case  94:       case  93:       case  92:       case  91:       case  90:          printf("A\n");          break;       case  89:       case  88:       case  87:       case  86:       case  85:       case  84:       case  83:       case  82:       case  81:       case  80:          printf("B\n");          break;       case  79:       case  78:       case  77:       case  76:       case  75:       case  74:       case  73:       case  72:       case  71:       case  70:          printf("C\n");          break;       case  69:       case  68:       case  67:       case  66:       case  65:       case  64:       case  63:       case  62:       case  61:       case  60:          printf("D\n");          break;       case  59:       case  58:       //其他自己写,一般有区间的不宜用switch case语句表达，而应该使用if else语句       case   1:       case   0:          printf("E\n");          break;    }         return 0; }  我明白了谢谢，刚刚接触C语言，不懂的有很多，还请多多帮忙

这是两个代码的对比谢谢帮忙


Question: c++ debug assertion failed 新人求教！！！

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


Question: 什么时候要进行初始化，初始化是什么意思

引用 2 楼 自信男孩的回复:变量定义一般是要求初始化的，不初始化会导致变量时随机值，若直接使用（一般是读）没有初始化的变量，则结果是未定义（随机值）；所以，初始化能保证数据是固定的； 比如，指针不初始化，那么指针是野指针，使用野指针可能会导致段错误；  具体楼主的问题，建议贴出相关代码，然后根据代码来确定具体是什么问题 一个是必须初始化，一个可以初始化也可以省略

引用 1 楼 user-2的回复:变量尽量都初始化。避免没有处理这个变量造成bug。 比如成绩是0-100分， 变量就初始化为0.  加入有人没参加考试， 不用单独赋值就是0分了。如果没初始化， 后续又忘记给这个变量赋值， 那么发成绩单的时候。。。。。。 谢谢了，还是有点不明白。

引用 2 楼 自信男孩的回复:变量定义一般是要求初始化的，不初始化会导致变量时随机值，若直接使用（一般是读）没有初始化的变量，则结果是未定义（随机值）；所以，初始化能保证数据是固定的； 比如，指针不初始化，那么指针是野指针，使用野指针可能会导致段错误；  具体楼主的问题，建议贴出相关代码，然后根据代码来确定具体是什么问题 我是初学C语言，没有学过指针


Question: 求大佬看一看这串代码的warning是怎么回事

char reverse(char s[]); 函数reverse的参数类型是字符数组，本质上是一个指针 而返回值的类型是字符，本质上是一个整数值 两者是不一样的 你把那几个函数的返回类型改为char *即可

都是类型不匹配的警告；首先reverse函数的返回值定义的是char类型，但是你返回的是一个地址（指针），所以接收用指针也是不可以的。因为reverse返回的是char类型，不是指针。itoa一样，定义的返回值是char，返回的是地址

把前两个函数的返回类型改为char* 应该能解决问题

s[] 不是char  建议看看函数的值传递和引用传递 传数组引用传递就好了


Question: 关于while(scanf("%d", &n) != EOF)无法停止的一些问题

while后面的; 去掉

大佬直接百度eof就知道输入什么啦


Question: 数字常量真就没办法取地址吗？

引用 4 楼 大尾巴猫 的回复:const常量可以取地址 const int i = 6; int* pi = &i; 应该用指向int常量的指针来指常量啊 const int i=6; const int *p=&i;

常量有可能直接使用，不需要占用内存（比如立即数），因此取地址没意义； 字符串常量，字符串本身就是地址，因此也无需再取地址。

获得一个数字常量的地址的目的是什么？ 如果是为了限制代码的膨胀，你直接写成const int变量形式就行了 如果是为了单纯的看看地址，我认为编译器是直接在编译过程中将常量数字写进了汇编代码里，而没有用符号解析，所以，没有意义

数字是一个临时变量，生命周期未知，假如你取到了它的地址，下一时刻地址里边的值可能就改变了。

楼主的直接定义指针好吧-

咋个取地址啊  把整数当地址用? 那就把整数强制转换成指针  然后指向指针的指针  大概是这样 比如说st标准库里对寄存器地址的访问都是这么定义的

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

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

立即数本身可能就没地址，已经直接被编入了指令中


Question: 如何有选择的对数组进行操作

引用 2 楼 Wezty 的回复:能具体写下思路吗？ 根据你说的，我突然想到可以给每个数组再加一个（数字）标识，这样就可以解决 我问个比较笨的问题，数组a【3】最前面的是存放它的地址，可以用标识a得到其地址，然后传入函数进行运算，这样可以实现吗？ #include <stdio.h>  int a[3] = {1,2,3}; int b[3] = {2,3,4}; int c[3] = {4,5,6}; int arr[3][3];  //addArr加的数组序号，addedArr被加的数组需要,用指针传递结果 void fun(int addArr, int addedArr,int *result) {     for(int i=0;i<3;++i)        //组成一个二维数组     {         arr[0][i] = a[i];         arr[1][i] = b[i];         arr[2][i] = c[i];     }      for(int i=0;i<3;++i)    //对应数组相加     {         result[i] = arr[addArr][i] + arr[addedArr][i];     }      return; }  int main() {     unsigned int add1,add2;     int ret[3];     scanf("%d %d", &add1, &add2);     if(add1<3 && add2<3)     {         fun(add1, add2, ret);          for(int i=0;i<3;++i)             printf("result[%d] = %d\n", i, ret[i]);     }     else         printf("input error.\n");      return 0; }

用二维数组？输入的话就可以是int了，返回一个新的一维数组。怎么样？

函数参数 求和的函数 void f(int* arr, int num); 根据用户输入，调用f的时候给不同的数组做参数


Question: 关于删除结构体变量的数据的问题

这样的问题，解决起来方法不止一种。统计数组的有效长度是一种方法，也有一种方法就是s[4], s[5]赋值非法值，使用s[4], s[5]时增加判断，若是非法值则不用

程序中再增加一个变量，用于记录数组元素的长度，访问时不访问超出范围的元素


Question: 冒泡排序法。各位前辈，我检查过很多遍 可是结果输出来就是不对 帮忙看看

引用 2楼Arlen22 的回复:我觉得应该是里面的for循环，改成for i，j小于9，j++。抱歉手机上写的.:-)没事 谢谢噢

引用 3楼wang0635 的回复:for (j=0;j<9-i;j++);  <-------!!!!! 后面多了一个分号谢谢。现在完成了

#include <stdio.h>  int main () {     int a[10];     int i,j,t;     printf("please input num：");     for(i=0;i<10;i++)         scanf("%d",&a[i]);      for (i=0;i<9;i++)     {         for (j=0;j<9-i;j++) /* delete ;*/         {             if(a[j]>a[j+1])             {                 t=a[j];                 a[j]=a[j+1];                 a[j+1]=t;             }         }     }     for (i=0;i<10;i++)     {         printf("%d",a[i]);     }      //getch();     return 0; }

getch（）是conio.h的函数，无回显。让他等待用两个getchar()吧。第一个消掉scanf剩余的\n第二个让它等待

for循环有问题-应该条件都是小于10；另一个条件是10-i


Question: 怎么通过数组标记找到前几个不重复的最小值？

#include<iostream> #include <cmath> using namespace std;  int a[6] = { 6,3,2,5,4,1 };  int get_min(int *arr, int len);  int main(void) {     int min = 100, tmp, MIN[3];     int i, j;      MIN[0] = get_min(a, 6);     for (i = 0; i < 2; i++) {         for (j = 0; j < 6; j++) {             tmp = a[j] - MIN[i];             if (tmp > 0 && tmp < min) {                 min = tmp;                 MIN[i+1] = a[j];             }         }         min = 100;     }      for (i = 0; i < 3; i++)         cout<<MIN[i]<<endl;     return 0;  }   int get_min(int *arr, int len) {     int i, min;      min = arr[0];     for (i = 1; i < len; i++)         if (arr[i] < min)             min = arr[i];      return min; }

是因为变量min在第一次循环中就是最小的了，而你却没有清楚标记，造成了三次循环找到的都是一个数。 int i=0,j,middle ,min = 100, aa[6] = { 0 }, MIN[3];   //aa[6]是一个标记数组，分配好了就让其自增为1                for (j = 0;j < 3;j++)     { 	min=100;         for (i = 0;i < 6;i++)         if (aa[i]==0)                 if (a[i] < min)                 {                     min = a[i];                     middle = i;                 }         MIN[j] = middle;         aa[middle] = 1;     }  增加一句min=100，就OK了，位置如代码所示。

/* 找最小的前3个不重复的数字*/ #include<stdio.h> #include<iostream> using namespace std; int a[6] = { 6,3,2,5,4,1 }; int main() {     int i=0,j,middle ,min = 100, aa[6] = { 0 }, MIN[3];   //aa[6]是一个标记数组，分配好了就让其自增为1                for (j = 0;j < 3;j++)     {         for (i = 0;i < 6;i++)         if (aa[i]==0)                 if (a[i] < min)                 {                     min = a[i];                     middle = i;                 }         MIN[j] = middle;         aa[middle] = 1;     }   }  这个为什么选出来的是都是几个重复的数字


Question: const限定符失效的疑问

不要纠结各种常量了，这个世界上唯一不变的就是变化。用API WriteProcessMemory还能修改正运行的其它进程的内存里面的所谓常量呢！

const限定符是供编译器使用的，实际上，只要在系统允许修改的空间内取得地址，你就可以修改，编译后，根本没有const限定符的语义，那是编译前的语义

const 是本来就是伪常量，不管在C还是在CPP


Question: 成绩转化为等级制，帮忙找一下问题。

引用 7 楼 自信男孩的回复:#include <stdio.h>  int main(void) {     int grade, ch;      scanf("%d", &grade);     if (grade < 0 || grade > 100)         return 0;      ch = grade / 10;      switch (ch) {         case 0:         case 1:         case 2:         case 3:         case 4:         case 5:             printf("E\n");             break;          case 6:             printf("D\n");             break;          case 7:             printf("C\n");             break;          case 8:             printf("B\n");             break;          case 9:         case 10:             printf("A\n");             break;          default:             printf("Enter error data!\n");             break;     }      return 0; } 多于2个if，建议使用switch case 谢谢，我明白了，但case的用法不太会写，如果case后面是分数段我要怎么去写？

引用 5 楼 user-3的回复:[quote=引用 4 楼 qq_40814199 的回复:] 我说的不是对x的初始化而是对ABCD的初始化 这四个字母，都是常数，也就是说，程序中写死了的，无法修改的。写死它们，不叫初始化。至于它们应该是什么值，是由程序要完成的功能所决定的，也就是我们常说的需求[/quote] 谢谢，我明白了。刚刚学C语言有很多问题，麻烦你了

引用 9 楼 Intel0011的回复:问题1:什么时候要初始化？ 变量在使用前必须初始化，否则里面的值是不确定的垃圾值  问题2:若最后使用else()括号后面是否要加分号  例:if() y＝ ； else if() y＝ ； else()；y＝ ；  这样是否正确 正确，必须要加分号，y＝ ；语句不属于if结构  问题3:编程改了两次无论输入什么数值都只输出E，问题找不出来 问题在于你定义的x变量的类型是float，而你调用scanf是却使用了%d，%d是整形int，long的说明符，float应该用%f [code=c][/#include <stdio.h>  int main(void) {    float x;     //scanf("%d", &x); //整形数和浮点数的存储格式是不一样的，不能搞混    scanf("%f", &x);     if (x >= 90) printf("A\n");    else if (x >= 80 && x <=89) printf("B\n");    else if (x >= 70 && x <=79) printf("C\n");    else if (x >= 60 && x <=69) printf("D\n");    else if (x < 60) printf("E\n");      return 0; }code] 谢谢，我明白了。刚刚接触C语言，不懂的还有很多，以后请多多帮忙

引用 1 楼 user-3的回复:1. 只要用到的数，就要有确定的值。可以初始化，可以输入，可以由其他数值运算得到，等等 2. else 后面没有括号，有括号就不对了 3. 因为你的变量x是float型，scanf中却用了%d，二者不匹配，输入不会被正确识别。应该用%f 谢谢，但是第一个还是不太懂

引用 4 楼 qq_40814199 的回复:我说的不是对x的初始化而是对ABCD的初始化 这四个字母，都是常数，也就是说，程序中写死了的，无法修改的。写死它们，不叫初始化。至于它们应该是什么值，是由程序要完成的功能所决定的，也就是我们常说的需求

我说的不是对x的初始化而是对ABCD的初始化

引用 2 楼 qq_40814199 的回复:[quote=引用 1 楼 user-3的回复:]1. 只要用到的数，就要有确定的值。可以初始化，可以输入，可以由其他数值运算得到，等等 2. else 后面没有括号，有括号就不对了 3. 因为你的变量x是float型，scanf中却用了%d，二者不匹配，输入不会被正确识别。应该用%f 谢谢，但是第一个还是不太懂[/quote]  想要根据变量 x 的内容判断它在哪个区间，x 的内容必须是一个确定的值才能得到确定的结果


Question: while（E）中的(E)不等价的表达式是

这个题 选B 呀

真假不仅仅局限于bool类型，对于其他类型，只要不为0即为真，为0即为假。

就是当E不为0时，就会执行循环。所以E就相当于非零。不理解就直接把A,B,C,D四个选项直接代进while（）里，看看哪个结果与while（E）不同。

非0为真  0为家

while(E)的意思是当E为真时，进行循环。 A：E大于0或者E小于0，为真； C：非E等于0，就是E不等于0 ，为真； D：E不等于0 ，为真。  而B选项：E等于0 ，为假，所以错

就是 B 呀


Question: 链接时出现问题，大神帮忙看一下，一直没找到问题，谢谢！

你的代码中有#include<iostream>，这是C++的头文件，C编译器是不支持的 可能你用的是C的编译器编译你的程序，所以出错 你将#include<iostream>这句删除即可

#include<stdio.h> #include<iostream>      void exchange(int *q1,int *q2,int *q3); void swap(int **pt1,int **pt2);  int main() {     int a=9;     int b=0;     int c=10;     int *p1,*p2,*p3;     p1=&a;     p2=&b;     p3=&c;     exchange(p1,p2,p3);     printf("\n%d,%d,%d\n",a,b,c);      return 0; }  void exchange(int *q1,int *q2,int *q3) {     if(*q1<*q2) swap(&q1, &q2);     if(*q1<*q3) swap(&q1, &q3);     if(*q2<*q3) swap(&q2, &q3); }  void swap(int **pt1,int **pt2) {     int temp;     temp = **pt1;     **pt1 = **pt2;     **pt2 = temp; } 建议了解一下一重指针和二重指针

swap没有在前面声明吧

仅供参考：#include <stdio.h> #define SWAP(a,b) do ((&(a))!=(&(b)))?((a)^=(b)^=(a)^=(b)):((a)=(a)); while (0) char   *p1="1" ,*p2="2" ; char    c1=1   , c2=2   ; short   s1=1   , s2=2   ; int     i1=1   , i2=2   ; __int64 I1=1i64, I2=2i64; float   f1=1.0f, f2=2.0f; double  d1=1.0 , d2=2.0 ; void main() {     SWAP((int)p1,(int)p2);                printf("char *     %5s,   %5s\n",p1,p2);     SWAP(c1,c2);                          printf("char       %5d,   %5d\n",c1,c2);     SWAP(s1,s2);                          printf("short      %5d,   %5d\n",s1,s2);     SWAP(i1,i2);                          printf("int        %5d,   %5d\n",i1,i2);     SWAP(I1,I2);                          printf("__int64 %5I64d,%5I64d\n",I1,I2);     SWAP(*(int     *)&f1,*(int     *)&f2);printf("float      %5g,   %5g\n",f1,f2);     SWAP(*(__int64 *)&d1,*(__int64 *)&d2);printf("double    %5lg,  %5lg\n",d1,d2);      SWAP(c1,c1);     printf("%d\n",c1); } //char *         2,       1 //char           2,       1 //short          2,       1 //int            2,       1 //__int64     2,    1 //float          2,       1 //double        2,      1 //2

#include<stdio.h> #include<iostream>  void exchange(int *q1, int *q2, int *q3); //使用该函数前必须声明 void swap(int *pt1, int *pt2);  void main() { 	int a = 9; 	int b = 0; 	int c = 10; 	int *p1, *p2, *p3; 	p1 = &a; 	p2 = &b; 	p3 = &c; 	exchange(p1, p2, p3); 	printf("\n%d,%d,%d\n", a, b, c); 	system("pause"); }  void exchange(int *q1, int *q2, int *q3)  //该函数用来交换q1,q2,q3的值，使得三者的值由大到小的顺序排序 { 	if (*q1<*q2) swap(q1, q2); 	if (*q1<*q3) swap(q1, q3); 	if (*q2<*q3) swap(q2, q3); }  void swap(int *pt1, int *pt2)           //该函数用来交换pt1和pt2的值 { 	int temp; 	temp = *pt1; 	*pt1 = *pt2; 	*pt2 = temp; }

前向声明不是写在函数里面，是写在外面的。


Question: 如何取4x4数组中不同行不同列的元素的全部排列

如何拓展至n*n呢

#include <stdio.h> int isright(int i,int j, int x,int y) { 	int a[4]={0,0,0,0}; 	a[i]+=1;a[j]+=1;a[x]+=1;a[y]+=1; 	if(a[0]*a[1]*a[2]*a[3]==0) 	    return 0; 	printf("%d,%d,%d,%d>>",i,j,x,y); 	return 1; } int main() {          int i,j,x,y;          for(i=1;i<=4;i++)             for(j=5;j<=8;j++)                for(x=9;x<=12;x++)                    for(y=13;y<=16;y++)                    {                    	if(isright(i%4,j%4,x%4,y%4))        	           printf("%d,%d,%d,%d\n",i,j,x,y);                    } 	     return 0;    }


Question: 为什么下面的程序错误

scanf("%d,%d,%d",year,month,day); ===>   scanf("%d,%d,%d",&year,&month,&day);


Enter、Ctrl+Z、Enter


Question: 求c语言 1000的阶乘 详细教学

#include <stdio.h> #include <stdlib.h> #include <string.h>  #define MAX_NUM_LEN 2048  int cal_factorial(unsigned char *num_list, int num_size, int n);  int cal_val(unsigned char *num_list, int num_size, int base, int num) {     int i = 0, j;     int len = 1, tmp, carry_bit;      num_list[1] = 1;      while (i < num) {         carry_bit = 0;         for (j = 1; j <= len; j++) {             tmp = num_list[j] * base + carry_bit;             num_list[j] = tmp % 10;             carry_bit = tmp / 10;             if (j >= len && carry_bit != 0)                 len++;             if (num_size-1 < len) {/* overflow */                 printf("Overflow!\n");                 return num_size-1;             }         }         i++;     }      return len; }   int main(void) {     unsigned char num_list[MAX_NUM_LEN];     int num_len, i;     int base, power;      memset(num_list, 0, sizeof(num_list));     printf("Please input two numbers: ");     scanf("%d%d", &base, &power);      if (base < 0 && power % 2)         num_list[0] = 1; /* negative number */     else         num_list[0] = 0;     base = abs(base);      num_len = cal_val(num_list, MAX_NUM_LEN, base, power);     printf("len = %d\n", num_len);     if (num_list[0])         putchar('-');     for (i = num_len; i >= 1; i--)         printf("%d", num_list[i]);     printf("\n");     return 0; }   int cal_factorial(unsigned char *num_list, int num_size, int n) {     int carry_bit, i, j, len = 1;     int tmp;      num_list[1] = 1;     for (i = 2; i <= n; i++)     {         carry_bit = 0;         for (j = 1; j <= len; j++) {             tmp = num_list[j] * i + carry_bit;             num_list[j] = tmp % 10;             carry_bit = tmp / 10;             if (j >= len && carry_bit != 0)                 len++;             if (num_size -1 < len) { /* overflow */                 printf("Overflow!\n");                 return num_size-1;             }         }      }      /*     for (i = len; i >= 1; i--)//逆序输出数组就是结果         printf("%d", a[i]);     printf("\n");     */     return len; } 参考一下吧

#include<stdio.h> #define N 1000    //要计算的N long s[N]={1,1},n=N,t=2,a=1,b=0; int main()//雨中飞燕之作 {     for(;a<=*s||(++t<=n?(b=0,a=1):0);(*s==a++&&b)?(*s)++:0)         s[a]=(b+=s[a]*t)%10000,b/=10000;     for(printf("%d",s[*s]);--*s>0;) printf("%04d",s[*s]);     return 0; }  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。


Question: 简单的代码，一看就懂。结果却不对，为什么

scanf格式的问题，注意格式匹配问题就可以。

根据你的代码，输入应该是4,2中间的逗号少不了，格式匹配问题

仅供参考：#include <stdio.h> int main() {     int a,b,n,v,r,k;     char buf[80];     char *p;      k=0;     r=EOF;     while (1) {         if (EOF==r) {             fgets(buf,80,stdin);             p=buf;         }         while (1) {             r=sscanf(p,"%d%n",&v,&n);             if (1==r) {k++;break;}             if (EOF==r) break;             p++;         }         if (EOF==r) continue;         p+=n;         if (1==k) a=v;         if (2==k) {             b=v;             break;         }     }     printf("%d,%d\n",a,b);     return 0; }

scanf("%lf,%lf\n", &a, &b); 改成 scanf("%lf%lf\n", &a, &b);  或者输入的时候用逗号分隔，而不是空格

scanf("%lf,%lf\n", &a, &b);这一句代码中多了一个逗号 改成scanf("%lf %lf\n", &a, &b);

printf输出double的时候，最好不用%lf，不是每个编译器都支持的，直接用%f

浮点数不能判断精确的相等

double a, b, c,d;     printf("请输入两个数：A和B\n");     scanf("%lf%lf", &a, &b);     assert(b != 0);     c = a / b;     printf("%lf\n", c);  	getchar(); 	getchar(); 		getchar(); 	getchar();         return 0;

你的第八行代码，是我的vc6的12行

#include <stdio.h> #include <assert.h>  int main() { 	double a, b, c,d; 	printf("请输入两个数：A和B\n"); 	scanf("%lf%lf", &a, &b); 	assert(b != 0); 	c = a / b; 	printf("%lf\n", c);         return 0; }  把第12行的逗号和\n符号去掉就正常了

输入的时候少个逗号； 或者直接将代码里的逗号去掉，重新编译然后按照你现在的格式输入也是可行的。

是不是初始化的问题？


Question: 成绩等级转为百分制

引用 1 楼 自信男孩的回复:if 判断表达式都是赋值表达式；注意=和==是不一样的。一个是赋值符，一个是判断相等的表达式； 谢谢，我懂了，以后还请多多关照

引用 2 楼 abc_18217053753的回复:你的程序有比较大的问题，逻辑都不是很清晰，针对上面两张图片和你提出的问题，我的说明如下： 针对第一张图片： #include<stdio.h> int main() {  char A,B,C,D,x;            //  A,B,C,D只定义了变量，没有初始化，所以他们的值是随机的。 scanf("%c",&x); if(A) printf();                  //  if,else if 和else 在做判断时是判断括号内的表达式是否成立或者括号内的值为0还是不为0（不为0就是成立，无论值是正还是负），而此时A,B,C,D的值都是随机值，若A的值不为0，就直接执行if（A）这个条件，然后程序结束。所以走哪个条件都是在碰运气。 else if(B) printf(); else if(C) printf();  else if(D) printf(); return 0; }  针对第二张图： 虽然你的变量A，B,C,D都有初始化，但是你每个if条件都是并列的（程序会依次判断每一个if），并且你括号内的条件是个赋值语句（等号）而并不是判断是否相等（判等语句，判等语句是==，两个等号），所以在判断if的时候每次赋值给x的值都不为0（,字符类型对应ASCII码，A,B,C,D的ASCII码都大于0），因此每一条if语句都会执行。 谢谢我懂了，初学C语言还有很多问题请多多指教


Question: 稀疏矩阵加法问题求解

我又写了个，结果测试输出是 10 10 5 2 3 8 2 7 97 2 9 20 4 6 32 5 0 35    #include <stdio.h> #include <malloc.h> #define MAXSIZE 10002  typedef struct {     int i;     int j;     int e; }Triple; typedef struct {     int row;     int col;     int cnt;     Triple data[MAXSIZE]; }Matrix;  int main() {     int k, n1, n2, n3, sum;     Matrix *A, *B, *C;     A = (Matrix *)malloc(sizeof(Matrix));     B = (Matrix *)malloc(sizeof(Matrix));     C = (Matrix *)malloc(sizeof(Matrix));      scanf("%d%d%d", &A->row, &A->col, &A->cnt);     for(k = 1; k <= A->cnt; k++)         scanf("%d%d%d", &A->data[k].i, &A->data[k].j, &A->data[k].e);     scanf("%d%d%d", &B->row, &B->col, &B->cnt);     for(k = 1; k <= B->cnt; k++)         scanf("%d%d%d", &B->data[k].i, &B->data[k].j, &B->data[k].e);      C->row = A->row;     C->col = A->col;     C->cnt = 0;     n1 = n2 = n3 = 1;      while(n1 <= A->cnt && n2 <= B->cnt)     {         if(A->data[n1].i == B->data[n2].i)         {             if(A->data[n1].j == B->data[n2].j)             {                 sum = A->data[n1].e + B->data[n2].e;                 if(sum)                 {                     C->data[n3].i = A->data[n1].i;                     C->data[n3].j = A->data[n1].j;                     C->data[n3].e = sum;                     n3++;                 }                 n1++;                 n2++;             }             else if(A->data[n1].j > B->data[n2].j)             {                 C->data[n3].i = B->data[n2].i;                 C->data[n3].j = B->data[n2].j;                 C->data[n3].e = B->data[n2].e;                 n2++;                 n3++;             }             else             {                 C->data[n3].i = A->data[n1].i;                 C->data[n3].j = A->data[n1].j;                 C->data[n3].e = A->data[n1].e;                 n1++;                 n3++;             }         }         if(A->data[n1].i < B->data[n2].i)         {             C->data[n3].i = A->data[n1].i;             C->data[n3].j = A->data[n1].j;             C->data[n3].e = A->data[n1].e;             n1++;             n3++;         }         else         {             C->data[n3].i = B->data[n2].i;             C->data[n3].j = B->data[n2].j;             C->data[n3].e = B->data[n2].e;             n2++;             n3++;         }     }      C->cnt = n3-1;     printf("%d %d %d\n", A->row, A->col, C->cnt);     for(k = 1; k <= C->cnt; k++)         printf("%d %d %d\n", C->data[k].i, C->data[k].j, C->data[k].e);      return 0; }

#include <stdio.h> #include <malloc.h> #define MAXSIZE 10002  typedef struct {     int i;     int j;     int e; }Triple; typedef struct {     int row;     int col;     int cnt;     Triple data[MAXSIZE]; }Matrix;  int main() {     int k, n1, n2, n3, sum;     Matrix *A, *B, *C;     A = (Matrix *)malloc(sizeof(Matrix));     B = (Matrix *)malloc(sizeof(Matrix));     C = (Matrix *)malloc(sizeof(Matrix));      scanf("%d%d%d", &A->row, &A->col, &A->cnt);     for(k = 1; k <= A->cnt; k++)         scanf("%d%d%d", &A->data[k].i, &A->data[k].j, &A->data[k].e);     scanf("%d%d%d", &B->row, &B->col, &B->cnt);     for(k = 1; k <= B->cnt; k++)         scanf("%d%d%d", &B->data[k].i, &B->data[k].j, &B->data[k].e);      C->row = A->row;     C->col = A->col;     C->cnt = 0;     n1 = n2 = n3 = 1;      //while(n1 <= A->cnt && n2 <= B->cnt)     for(k = 1; k <= A->row; k++)     {         while(A->data[n1].i < k)             n1++;         while(B->data[n2].i < k)             n2++;          while(A->data[n1].i == k && B->data[n2].i == k)         {             if(A->data[n1].j == B->data[n2].j)             {                 sum = A->data[n1].e + B->data[n2].e;                 if(sum)                 {                     C->data[n3].i = k;                     C->data[n3].j = A->data[n1].j;                     C->data[n3].e = sum;                     n3++;                 }                 n1++;                 n2++;             }             else if(A->data[n1].j > B->data[n2].j)             {                 C->data[n3].i = k;                 C->data[n3].j = B->data[n2].j;                 C->data[n3].e = B->data[n2].e;                 n2++;                 n3++;             }             else             {                 C->data[n3].i = k;                 C->data[n3].j = A->data[n1].j;                 C->data[n3].e = A->data[n1].e;                 n1++;                 n3++;             }         }         while(A->data[n1].i == k)         {             C->data[n3].i = k;             C->data[n3].j = A->data[n1].j;             C->data[n3].e = A->data[n1].e;             n1++;             n3++;         }         while(B->data[n2].i == k)         {             C->data[n3].i = k;             C->data[n3].j = B->data[n2].j;             C->data[n3].e = B->data[n2].e;             n2++;             n3++;         }     }      C->cnt = n3-1;     printf("%d %d %d\n", A->row, A->col, C->cnt);     for(k = 1; k <= C->cnt; k++)         printf("%d %d %d\n", C->data[k].i, C->data[k].j, C->data[k].e);      return 0; }


Question: 用codeblocks向main函数传递参数，控制台输出乱码

#include <stdio.h>  // int main(int argc, char* argv[]) int main()  {     char* s[] = {"myexe", "abc", "123"};     int argc = 3;      char** argv = s;      while (argc > 1) {         ++argv;   // 指向 s[1];         printf("%s\n", *argv); //用*argv         --argc;  //(3-1)     }      return 0; }  实际是这样的

引用 9 楼 zhao4zhong1 的回复:http://bbs.csdn.net/topics/390469280 多谢赵老师

引用 6 楼 hongwenjun 的回复:#include <stdio.h>  int main(int argc, char* argv[]) {     while (argc-- > 1) {         printf("%s\n", *++argv);     }     return 0; }  更加挖坑的写法，这个运行是正确的 对于指针数组，例如char *s[]={"abc","123"};，既然s[0  引用 6 楼 hongwenjun 的回复:#include <stdio.h>  int main(int argc, char* argv[]) {     while (argc-- > 1) {         printf("%s\n", *++argv);     }     return 0; }  更加挖坑的写法，这个运行是正确的 您好，“挖坑的写法”是指使用指针变量吗？

引用 3 楼 hongwenjun 的回复: 命令行参数  如图中所示  *argv 这个指针，实际 指向 argv[0] .  ++ argv后就指向了  argv[1]  楼主的代码 正确的写法应该如下面 ，不过这样写，感觉在给自己挖坑  #include <stdio.h>  int main(int argc, char* argv[]) {     while (argc > 1) {         ++argv;         printf("%s\n", *argv);         --argc;     }     return 0; }  非常感谢。 现在被谭书的指针绕的云里雾里的

下载了电子版  教程 确实是错了， 少了  *

#include <stdio.h>  int main(int argc,char *argv[]) {     while(argc>1)     {         ++argv;         printf("%s\n", *argv); //用*argv         --argc;     }     return 0; } 用*argv，注意argv的类型是char **是字符类型的的指针数组

#include<stdio.h> int main(int argc, char* argv[]) {      printf("You have inputed total %d argments\n", argc);     for (int  i = 0 ; i < argc ; i++) {         printf("arg%d : %s\n", i, argv[i]);     }      return 0; }   你学的教材不行，学参数 应该要这样的代码，这样才好理解

printf("%s\n", argv[0]);


Question: 为什么下面的程序错误

明白了，谢谢了诸位

#include<stdio.h>  int main() {     int year,month,day,what_day = 0;     //   int a[130],b[130];     int a[13]={0,31,29,31,30,31,30,31,31,30,31,30,31};     int b[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};     scanf("%d,%d,%d", &year, &month, &day);     if(year%400 ==0 || (year % 4 == 0 && year % 100 != 0))     {         for(month = month-1;month>0;month--)             what_day+=a[month];         printf("\n%d",what_day);     }     else     {         for(month = month-1;month>0;month--)             what_day+=b[month];         printf("\n%d",what_day);     }     what_day+=day;     //  printf("\n第%d天",what_day);     return 0; } 四个问题： 1. 输入格式不正确，年月日变量缺少& 2. 闰年判断不对； 3. what_day没有初始化；  4. a的下标month应从month - 1开始

引用 4 楼 zjq9931 的回复:来晚了，上面已经有正解了。 还有问题呢，what_day没有初始化，闰年的判断是否正确？

来晚了，上面已经有正解了。

for(;month>0;month--)改成 for(;month>1;month--) what_day+=a[month];改成what_day+=a[month-1] 看看;

还有scanf  里面&year ...  以及闰年判断方法

多算了一个月吧 假如是五月二十日 你这算了12345月的总和+20 应该是1234+20


Question: C语言问题求助 求知道这种方式的人给解释下

这是旧式的C语言函数定义，具体可参看：http://blog.csdn.net/talent_CYJ/article/details/51302816  实际使用时，建议使用新式的

函数定义的形式不对呢，用matlab的语法写C语言程序，本身语法的规则都不一样，怎么可能编译过去呢； 函数的定义就像main函数定义一样，有大括号包起来；需要的变量可以在大括号里定义，需要外部传递过来的变量，在参数里体现；

fftsf是一个函数，后面的double x只是把参数表的定义单独拿出来写，相当于这样的写法： double fftsf(double x) 后面的ffts也是一样的道理。  这些写法，包括变量是否可以随处定义等等，可能跟编译器有关，如果编译器不支持，你就改一下，按标准写法来就好了。


Question: 为什么下面的程序输出错误

当然还有多算一个月，a的下标应该从month-1开始算 #include<stdio.h>  int main() {     int year,month,day,what_day = 0;     //   int a[130],b[130];     int a[13]={0,31,29,31,30,31,30,31,31,30,31,30,31};     int b[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};     scanf("%d,%d,%d", &year, &month, &day);     if(year%400 ==0 || (year % 4 == 0 && year % 100 != 0))     {         for(month = month-1;month>0;month--)             what_day+=a[month];         printf("\n%d",what_day);     }     else     {         for(month = month-1;month>0;month--)             what_day+=b[month];         printf("\n%d",what_day);     }     what_day+=day;     //  printf("\n第%d天",what_day);     return 0; }

#include<stdio.h>  int main() {     int year,month,day,what_day = 0;     //   int a[130],b[130];     int a[13]={0,31,29,31,30,31,30,31,31,30,31,30,31};     int b[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};     scanf("%d,%d,%d", &year, &month, &day);     if(year%4==0 || (year % 4 == 0 && year % 100 != 0))     {         for(;month>0;month--)             what_day+=a[month];         printf("\n%d",what_day);     }     else     {         for(;month>0;month--)             what_day+=b[month];         printf("\n%d",what_day);     }     what_day+=day;     //  printf("\n第%d天",what_day);     return 0; } 三个问题： 1. 输入格式不正确，年月日变量缺少& 2. 闰年判断不对； 3. what_day没有初始化；

scanf("%d,%d,%d", &year, &month, &day);  //添加 &


Question: 萌新求教，关于内存分配的问题

因为你年轻，精力旺盛！  帮结帖＋蹭分

int  main（void） {           struct name * my_name;           my_name=(struct name *)malloc(siezeof(struct name));           my_name->fname=(char *)malloc(10*sizeof(char));           return 0; } 这样就可以了...... 作为一个金融专业的，我TM为什么要看C语言呢.............

struct name * my_name; 这样定义的是一个野指针，对于野指针的使用是未定义的，有可能会导致段错误； 通过malloc之后，my_name指针就指向的堆上的空间，堆上的空间就是可以正常访问了。

好吧 我感觉自己找到答案了，因为指针初始化的问题。


Question: main()的形参argc个数的问题

exe 空格后面加参数

引用 10 楼 hefashion0190 的回复:引用 6 楼 zhao4zhong1 的回复:http://bbs.csdn.net/topics/390469280

程序自身是一个参数，然后后边空格＋其他字符串又为一个参数

把你的参数用空格分开就可以 "chin" "beijing" "bbb" "asdf" "asd" "fsdf"

程序自身路径是一个参数，你输入的整体是一个参数，所以一共两个，输入多个参数你可以用空格分隔

因为有两个参数，第一个就是可执行文件，即Text1.exe文件； 第二个就是你输入的（...） 所以，argc最小是1，因为对于系统来讲，至少有要执行的程序

因为整个字符串没有空格，所以被认为是一个参数。因为中间的空格都在""中，被认为是字符而不是参数分隔符

参数变量是以空格来隔开区分的，不是逗号

#include <stdio.h>  // int main(int argc, char* argv[]) int main()  {     char* s[] = {"myexe", "abc", "123"};     int argc = 3;      char** argv = s;      for (int i = 0; i != argc ; i++) {          printf("%s\n", argv[i]);       }      return 0; }

你输入的参数 当做一个参数了 命令名   参数0 你输入的 参数1


Question: 求大佬来看看,在线等，谢谢。

要把 StrDelete函数提到main函数上面

定义的方式不对

把你的StrDelete函数放到main函数的外面，不能在一个函数里实现另一个函数

为什么要这样定义啊？

C语言规定函数不能嵌套定义

看不懂你的代码，main函数里嵌套StrDelete函数吗？ 建议重发一下你的代码


Question: 为什么在c语言头文件中函数的声明是下划线格式的，但我们引用时可以不加下划线  _ ?

http://www.cnblogs.com/zhulin/archive/2011/12/27/2303398.html 有一部分原因是区分是系统函数或库函数还是自定义函数；系统或库函数一般前加_下划线，主要会和用户自己定义的函数名不冲突 http://bbs.csdn.net/topics/390471598

这些  “—” 下划线前缀的函数的 不是 C语言标准定义的函数，所以加了个  _  区别出来。 对于函数 好像 使用的时候  _fun 和 fun 没区别吧

VS IDE中，在不明白的符号上点鼠标右键，选转到定义。


Question: 为什么这段代码的结果为空（代码在VS2017编译器下运行的）

谢谢热心的你们吗

引用 3 楼 zhao4zhong1 的回复:[quote=引用 2 楼 cfjtaishan 的回复:] strcat_s参数不对，缺少参数； #include"stdafx.h" #include<stdio.h> #include<string.h> int main() { char str1[30] = {"People's Republic of"}; char str2[] = {"China"}; printf("%s\n", strcat_s(str1, 30， str2));         return 0; }  看看楼上MSDN节选中strcat_s的返回值是啥吧！想当然害死人的。[/quote] 它和strcat不一样呗，不一样的库。  #include"stdafx.h" #include<stdio.h> #include<string.h> int main() { char str1[30] = {"People's Republic of"}; char str2[] = {"China"}; strcat_s(str1, 30， str2); printf("%s\n", str1);         return 0; }

引用 2 楼 cfjtaishan 的回复:strcat_s参数不对，缺少参数； #include"stdafx.h" #include<stdio.h> #include<string.h> int main() { char str1[30] = {"People's Republic of"}; char str2[] = {"China"}; printf("%s\n", strcat_s(str1, 30， str2));         return 0; }  看看楼上MSDN节选中strcat_s的返回值是啥吧！想当然害死人的。

Collapse AllExpand All      Code: All Code: Multiple Code: Visual Basic Code: C# Code: Visual C++ Code: J# Code: JScript   Visual Basic C# Visual C++ J# JScript Run-Time Library Reference  strcat_s, wcscat_s, _mbscat_s  Example  See Also  Send Feedback     Append a string. These are versions of strcat, wcscat, _mbscat with security enhancements as described in Security Enhancements in the CRT.    errno_t strcat_s(    char *strDestination,    size_t numberOfElements,    const char *strSource  ); errno_t wcscat_s(    wchar_t *strDestination,    size_t numberOfElements,    const wchar_t *strSource  ); errno_t _mbscat_s(    unsigned char *strDestination,    size_t numberOfElements,    const unsigned char *strSource  ); template <size_t size> errno_t strcat_s(    char (&strDestination)[size],    const char *strSource  ); // C++ only template <size_t size> errno_t wcscat_s(    wchar_t (&strDestination)[size],    const wchar_t *strSource  ); // C++ only template <size_t size> errno_t _mbscat_s(    unsigned char (&strDestination)[size],    const unsigned char *strSource  ); // C++ only    Parameters strDestination Null-terminated destination string buffer.  numberOfElements Size of the destination string buffer.  strSource Null-terminated source string buffer.  Return Value Zero if successful; an error code on failure.  strDestination  numberOfElements  strSource  Return value  Contents of strDestination   NULL or unterminated  any  any  EINVAL  not modified   any  any  NULL  EINVAL  strDestination[0] set to 0   any  0, or too small  any  ERANGE  strDestination[0] set to 0    Remarks The strcat_s function appends strSource to strDestination and terminates the resulting string with a null character. The initial character of strSource overwrites the terminating null character of strDestination. The behavior of strcat_s is undefined if the source and destination strings overlap.  Note that the second parameter is the total size of the buffer, not the remaining size:    Copy Code  char buf[16]; strcpy_s(buf, 16, "Start"); strcat_s(buf, 16, " End");               // Correct strcat_s(buf, 16 – strlen(buf), " End"); // Incorrect    wcscat_s and _mbscat_s are wide-character and multibyte-character versions of strcat_s. The arguments and return value of wcscat_s are wide-character strings; those of _mbscat_s are multibyte-character strings. These three functions behave identically otherwise.  If strDestination is a null pointer, or is not null-terminated, or if strSource is a NULL pointer, or if the destination string is too small, the invalid parameter handler is invoked, as described in Parameter Validation . If execution is allowed to continue, these functions return EINVAL and set errno to EINVAL.  In C++, using these functions is simplified by template overloads; the overloads can infer buffer length automatically (eliminating the need to specify a size argument) and they can automatically replace older, non-secure functions with their newer, secure counterparts. For more information, see Secure Template Overloads.  The debug versions of these functions first fill the buffer with 0xFD. To disable this behavior, use _CrtSetDebugFillThreshold.  TCHAR.H routine   _UNICODE & _MBCS not defined  _MBCS defined  _UNICODE defined   _tcscat_s  strcat_s  _mbscat_s  wcscat_s    Requirements Routine  Required header   strcat_s  <string.h>   wcscat_s  <string.h> or <wchar.h>   _mbscat_s  <mbstring.h>    For additional compatibility information, see Compatibility in the Introduction.  Example See the code example in strcpy_s, wcscpy_s, _mbscpy_s.  .NET Framework Equivalent System::String::Concat  See Also Concepts String Manipulation (CRT) strncat, _strncat_l, wcsncat, wcsncat_l, _mbsncat _mbsncat_l strncmp, wcsncmp, _mbsncmp, _mbsncmp_l strncpy, _strncpy_l, wcsncpy, _wcsncpy_l, _mbsncpy, _mbsncpy_l _strnicmp, _wcsnicmp, _mbsnicmp, _strnicmp_l, _wcsnicmp_l, _mbsnicmp_l strrchr, wcsrchr, _mbsrchr, _mbsrchr_l strspn, wcsspn, _mbsspn, _mbsspn_l Send feedback on this topic to Microsoft.  #include <stdio.h> #include <string.h> int main() {     char str1[30] = "People's Republic of";     char str2[] = "China";     strcat_s(str1, 30, str2);     printf("%s\n", str1);     return 0; } //People's Republic ofChina //


Question: 输入N后一直死循环

1、ch应该在循环前先进行初始化，否则第一次循环判断的只是一个随机的值  2、其次，在scanf("%d", &n);后加一个getchar();把缓冲区中的换行符接收了，否则会被后面的scanf("&c", &ch);直接接收，而不等待用户输入

首先scanf里是%c 其次应该是while (ch != 'N'&&ch != 'n')吧

还有一个问题，逻辑，输入N或n就要退出循环，但是循环执行的条件就应该是输入的ch既不是'n'也不是’N' 即改成如下形式： while (ch != 'N' && ch != 'n')

# include <stdio.h>      int prime(int); int main(void) {     int n;     char ch;      while (ch != 'N' || ch != 'n')     {         printf("I will tell whether this integer is prime, Please input an integer:");         scanf("%d",&n); 	getchar();    /*接收输入缓冲区里的换行符'\n'*/         if (prime(n))             printf("Prime!\n");         else             printf("Not a prime!\n");         printf("Continue: Y/N:");         scanf("%c", &ch);     }      return 0; }  两个问题，ch的输入格式应该是%c，而不是&c 第二个问题：论坛里提到很多次了，就是第二个输入是%c，那么输入n的时候会将换行符留在输入缓冲区，正好被ch收到，所以加一句getchar()接收这个换行符；

int prime (int n) {     int i;     int flag = 1;      for (i=2; i<=n/2 && flag==1; i++)     if (n%i == 0)     flag = 0;      return (flag); } 这边少一个i<=2否则结果不对。


Question: 编程的基本运算

百度搜相关关键字。

建议个人先写一写，有问题可以提出来。


Question: dll文件开辟的内存（存有数据）可否不回收，下次调用的dll文件直接对内存操作

这应该不是个事儿。 DLL  和内存没有任何联系的。 只要你的进程不关闭就没有任何问题的。

可以呀，你只要不卸载dll就行

不要低估操作系统在处理“多次打开循环读写文件”优化时使用相应策略的智商。  无profiler不要谈效率！！尤其在这个云计算、虚拟机、模拟器、CUDA、多核 、多级cache、指令流水线、多种存储介质、……满天飞的时代！


Question: 新手学着玩，求指导。

表面上看这段程序是没有错的，也可以运行，但运行过程中到 第二个scanf输入值给ch2时，程序并不会停止下来等待你输入，而是直接运行到最后一个printf ！  为什么？当时百思不得其解。。。  今天上网查了下才知道，原来scanf是从标准输入缓冲区中读取输入的数据，而%c的字符输入格式会接收回车字符，在输入第一个scanf时输入字符后按回车结束，输入缓冲中保存了这个回车符，遇到第二个scanf时，它自动把这个回车符赋给了ch2 。而如果第二个scanf的输入格式不是%c时，由于格式不匹配，这个回车符会被自动忽略，所以只有在连续输入两个%c的格式时才会出现这样的问题！  解决办法：(二办法任选其一)  1、清空输入缓冲区  第一个scanf后加入语句：fflush(stdin); //C语言清空输入缓冲区函数  2、格式控制中加入空格  将第二个scanf改为：scanf(" %c",&ch2);//在%号前面加一个空格  scanf格式输入时要求输入格式与格式控制符中的完全一样(如：scanf("abcd%c",&ch);输入时必须输入abcde,ch得到的值为e)空格可以抵消前面输入的回车符。 网上找的，足够解决问题了

flush(stdin)刷新标准输入缓冲区，把输入缓冲区里的东西丢弃 fflush(stdout)刷新标准输出缓冲区，把输出缓冲区里的东西打印到标准输出设备上。 你打完Y或者N之后缓冲区里还有个回车在 把flush(stdin)放在你的scanf("%c",&a);后试试

if (a == 89) { printf("减肥的第%d天\n", i); i++; } for里的i++删了

>schtasks /?  SCHTASKS /parameter [arguments]  描述:     允许管理员创建、删除、查询、更改、运行和中止本地或远程系统上的计划任     务。替代 AT.exe。  参数列表:     /Create         创建新计划任务。      /Delete         删除计划任务。      /Query          显示所有计划任务。      /Change         更改计划任务属性。      /Run            立即运行计划任务。      /End            中止当前正在运行的计划任务。      /?              显示帮助消息。  示例:     SCHTASKS     SCHTASKS /?     SCHTASKS /Run /?     SCHTASKS /End /?     SCHTASKS /Create /?     SCHTASKS /Delete /?     SCHTASKS /Query  /?     SCHTASKS /Change /?  C:\>schtasks /create /?  SCHTASKS /Create [/S system [/U username [/P [password]]]]     [/RU username [/RP password]] /SC schedule [/MO modifier] [/D day]     [/M months] [/I idletime] /TN taskname /TR taskrun [/ST starttime]     [/RI interval] [ {/ET endtime | /DU duration} [/K] ]     [/SD startdate] [/ED enddate] [/IT] [/Z] [/F]  描述:     允许管理员在本地或远程系统上创建计划任务。  参数列表:     /S           system            指定要连接到的远程系统。如果省略这个                                    系统参数，默认是本地系统。      /U           username          指定命令执行的用户上下文。      /P           [password]        指定给定用户上下文的密码。如果省略则                                    提示输入。      /RU          username          指定任务在其下运行的“运行方式”用户                                    帐户(用户上下文)。对于系统帐户，有效                                    值是 ""、"NT AUTHORITY\SYSTEM" 或                                    "SYSTEM"。      /RP          [password]        指定“运行方式”用户的密码。要提示输                                    入密码，值必须是 "*" 或无。系统帐户                                    会忽略该密码。      /SC          schedule          指定计划频率。                                    有效计划任务: MINUTE, HOURLY,                                    DAILY, WEEKLY, MONTHLY, ONCE,                                    ONSTART, ONLOGON, ONIDLE.      /MO          modifier          改进计划类型以允许更好地控制计划重复                                    周期。有效值列于下面“修改者”部分中。      /D           days              指定该周内运行任务的日期。有效值:                                    MON, TUE,WED, THU, FRI, SAT, SUN                                    和对 MONTHLY 计划的 1 - 31                                    (某月中的日期)。通配符“*”指定所有                                    日期。      /M           months            指定一年内的某月。默认是该月的第一天。                                    有效值: JAN, FEB, MAR, APR, MAY, JUN,                                    JUL, AUG, SEP, OCT, NOV, DEC。通配符                                    “*” 指定所有的月。      /I           idletime          指定运行一个已计划的 ONIDLE 任务之前                                    要等待的空闲时间。                                    有效值范围: 1 到 999 分钟。      /TN          taskname          指定唯一识别这个计划任务的名称。      /TR          taskrun           指定在这个计划时间运行的程序的路径                                    和文件名。                                    例如: C:\windows\system32\calc.exe      /ST          starttime         指定运行这个任务的开始时间。时间格式                                    是 HH:mm (24 小时时间) 例如 14:30 为                                    2:30 PM。默认到当前时间。      /RI          interval          用分钟指定重复间隔。这无法应用于                                    已计划的类型: MINUTE, HOURLY,                                    ONSTART, ONLOGON, ONIDLE。                                    有效范围: 1 - 599940 分钟。                                    如果指定了 /ET 或 /DU，它会默认到                                    10 分钟。      /ET          endtime           指定运行任务的结束时间。                                    时间格式是 HH:mm (24 小时时间)                                    例如 14:50 为 2:50 PM。这无法运用于                                    计划类型: ONSTART, ONLOGON, ONIDLE。      /DU          duration          指定运行此任务的持续时间。                                    时间格式是 HHHH:mm。                                    这不适用于 /ET 和计划类型: ONSTART，                                     ONLOGON, ONIDLE。如果指定了 /RI，                                    那么默认为 1 小时。      /K                             在结束时间或持续时间终止此任务。                                    这不适用于计划类型: ONSTART,                                    ONLOGON, ONIDLE。必须指定 /ET                                    或 /DU。      /SD          startdate         指定第一次运行这个                                    任务的日期。格式是 yyyy/mm/dd。                                    默认为当前时间。这不适用于计划                                    类型: ONCE, ONSTART, ONLOGON,                                    ONIDLE.      /ED          enddate           指定此任务运行的最后一天的日期。                                    格式是 yyyy/mm/dd。                                    这不适用于计划类型: ONCE, ONSTART,                                    ONLOGON, ONIDLE。      /IT                            /RU 用户在此作业运行时登录才启                                    用此任务用交互方式运行。                                    用户登录后此任务才运行。      /Z                             如果此任务没有计划再次运行，                                    会删除此任务。      /F                             如果指定的任务已经存在，强行                                    创建此任务并不显示警告。      /?                             显示该帮助消息。  修改者: 按计划类型的 /MO 开关的有效值:     MINUTE:  1 到 1439 分钟。     HOURLY:  1 到 23 小时。     DAILY:   1 到 365 天。     WEEKLY:  1 到 52 周。     ONCE:    无修改者。     ONSTART: 无修改者。     ONLOGON: 无修改者。     ONIDLE:  无修改者。     MONTHLY: 1 到 12，或              FIRST, SECOND, THIRD, FOURTH, LAST, LASTDAY。  示例:     ==> 在远程机器 "ABC" 上创建计划任务 "doc"，         该机器每小时在 "runasuser" 用户下运行 notepad.exe。          SCHTASKS /Create /S ABC /U user /P password /RU runasuser                  /RP runaspassword /SC HOURLY /TN doc /TR notepad      ==> 在远程机器 "ABC" 上创建计划任务 "accountant"，         在指定的开始日期和结束日期之间的开始时间和结束时间内，         每隔五分钟运行 calc.exe。          SCHTASKS /Create /S ABC /U domain\user /P password /SC MINUTE                  /MO 5 /TN accountant /TR calc.exe /ST 12:00 /ET 14:00                  /SD 2002/12/30 /ED 2002/12/30 /RU runasuser /RP      ==> 创建计划任务 "gametime"，在每月的第一个星期天         运行“空当接龙”。          SCHTASKS /Create /SC MONTHLY /MO first /D SUN /TN gametime                  /TR c:\windows\system32\freecell      ==> 在远程机器 "ABC" 创建计划任务 "report"，         每个星期运行 notepad.exe。          SCHTASKS /Create /S ABC /U user /P password /RU runasuser                  /RP runaspassword /SC WEEKLY /TN report /TR notepad.exe      ==> 在远程机器 "ABC" 创建计划任务 "logtracker"，         每隔五分钟从指定的开始时间到无结束时间，         运行 notepad.exe。将提示输入 /RP         密码。          SCHTASKS /Create /S ABC /U domain\user /P password /SC MINUTE                  /MO 5 /TN logtracker                  /TR c:\windows\system32\notepad.exe /ST 18:30                  /RU runasuser /RP      ==> 创建计划任务 "gaming"，每天从 12:00 点开始到         14:00 点自动结束，运行 freecell.exe。          SCHTASKS /Create /SC HOURLY /TN gaming /TR c:\freecell /ST 12:00                  /ET 14:00 /K

引用 4 楼 zhao4zhong1 的回复:在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 char c; scanf("%c",&c); //时，都改为 char s[2]; char c; scanf("%1s",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。  赵老师,帮个忙啊.. 我想问一下 您之前的那个计划任务创建命令不会 哎... 有没有c++的源代码 或者 windows的API 在那任务设置中 我无法更改过了计划任务时间,就立即启动 不能更改 求教  还有队DOS命令不是很清楚,看过您之前的回帖,都是用DOC命令搞得

#include <stdio.h> #include <stdlib.h>  int main() {     for (int i = 1;; i++)     {         printf("今天吃晚饭了吗?(请输入Y/N)");         char a;         scanf("%c",&a);         getchar();    //接收上次输入残留在输入缓冲区里的换行符         if (a == 89)         {             printf("减肥的第%d天\n", i);         }         else if (a == 78)         {             printf("我是死胖子！\n");         }         else         {             printf("输入错误\n");         }           //system("pause");     } }

非常感谢楼上所有的朋友！赵4老师 您的方法有效，厉害啦~~


Question: C语言多线程 openmp

我用线程的话一般是包装成类，每个线程就是一个类对象，很方便保存各种参数

Thread Local Storage Microsoft Specific —>  Thread Local Storage (TLS) is the mechanism by which each thread in a given multithreaded process allocates storage for thread-specific data. In standard multithreaded programs, data is shared among all threads of a given process, whereas thread local storage is the mechanism for allocating per-thread data. For a complete discussion of threads, seeProcesses and Threads in the Microsoft Win32® Software Development Kit documentation.  The Microsoft C language includes the extended storage-class attribute, thread, which is used with the __declspec keyword to declare a thread local variable. For example, the following code declares an integer thread local variable and initializes it with a value:  __declspec( thread ) int tls_i = 1;  These guidelines must be observed when you are declaring statically bound thread local variables:   The use of __declspec(thread) may interfere withdelay loading of DLL imports.   You can apply the thread attribute only to data declarations and definitions. It cannot be used on function declarations or definitions. For example, the following code generates a compiler error: #define Thread    __declspec( thread ) Thread void func();        /* Error */  You can specify the thread attribute only on data items with static storage duration. This includes global data (both static and extern) and local static data. You cannot declare automatic data with the thread attribute. For example, the following code generates compiler errors: #define Thread    __declspec( thread ) void func1() {     Thread int tls_i;            /* Error */ }  int func2( Thread int tls_i )    /* Error */ { return tls_i; }  You must use the thread attribute for the declaration and the definition of thread local data, regardless of whether the declaration and definition occur in the same file or separate files. For example, the following code generates an error: #define Thread    __declspec( thread ) extern int tls_i;     /* This generates an error, because the   */ int Thread tls_i;     /* declaration and the definition differ. */  You cannot use the thread attribute as a type modifier. For example, the following code generates a compiler error: char *ch __declspec( thread );        /* Error */  The address of a thread local variable is not considered constant, and any expression involving such an address is not considered a constant expression. This means that you cannot use the address of a thread local variable as an initializer for a pointer. For example, the compiler flags the following code as an error: #define Thread    __declspec( thread ) Thread int tls_i; int *p = &tls_i;        /* Error */  C permits initialization of a variable with an expression involving a reference to itself, but only for objects of nonstatic extent. For example: #define Thread    __declspec( thread ) Thread int tls_i = tls_i;             /* Error */ int j = j;                            /* Error */ Thread int tls_i = sizeof( tls_i )    /* Okay  */  Note that a sizeof expression that includes the variable being initialized does not constitute a reference to itself and is allowed.  The use of __declspec(thread) may interfere withdelay loading of DLL imports.  For more information about using the thread attribute, seeMultithreading Topics in Visual C++ Programmer’s Guide.  END Microsoft Specific

引用 7 楼 paschen 的回复:引用 6 楼 hezhe1008 的回复:引用 3 楼 xu6832281 的回复:[quote=引用 2楼呔妖怪来嘛 的回复:]你的意思是多个线程访问同一块内存？？如果是这样，访问会有冲突，需要增加锁，很难并行计算我的意思是怎么让各个线程都有一份独立的啥叫每个线程都有一份独立的，又全局，又独立的~~。你多整几个全局变量不就行了？？  使用线程局部存储(TLS)，具体用法可参看MSDN[/quote]   Thread Local Storage (TLS) Home |  Overview |  How Do I |  Sample  Thread Local Storage (TLS) is the method by which each thread in a given multithreaded process may allocate locations in which to store thread-specific data. Dynamically bound (run-time) thread-specific data is supported by way of the TLS API (TlsAlloc, TlsGetValue, TlsSetValue, TlsFree). Win32 and the Visual C++ compiler now support statically bound (load-time) per-thread data in addition to the existing API implementation.  API Implementation for TLS Thread Local Storage is implemented through the Win32 API layer as well as the compiler. For details, see the Win32 API documentation for TlsAlloc, TlsGetValue, TlsSetValue, and TlsFree.  The Visual C++ compiler includes a keyword to make thread local storage operations more automatic, rather than through the API layer. This syntax is described in the next section, Compiler Implementation for TLS.  Compiler Implementation for TLS To support TLS, a new attribute, thread, has been added to the C and C++ languages and is supported by the Visual C++ compiler. This attribute is an extended storage class modifier, as described in the previous section. Use the __declspec keyword to declare a thread variable. For example, the following code declares an integer thread local variable and initializes it with a value:  __declspec( thread ) int tls_i = 1;  See Also   Rules and Limitations for TLS

threadprivate指定全局变量被OpenMP所有的线程各自产生一个私有的拷贝，即各个线程都有自己私有的全局变量。threadprivate并不是针对某一个并行区域，而是整个于整个程序，所以其拷贝的副本变量也是全局的，即在不同的并行区域之间的同一个线程也是共享的。threadprivate只能用于全局变量或静态变量

《Windows核心编程》

我的意思是：threadprivate声明的指针变量在各个线程都有一份独立拷贝，互不影响。但这前提是在同一个文件中，如果跨文件的全局变量，这种机制就出错了

引用 2楼呔妖怪来嘛 的回复:你的意思是多个线程访问同一块内存？？ 如果是这样，访问会有冲突，需要增加锁，很难并行计算我的意思是怎么让各个线程都有一份独立的

引用 6 楼 hezhe1008 的回复:引用 3 楼 xu6832281 的回复:引用 2楼呔妖怪来嘛 的回复:你的意思是多个线程访问同一块内存？？如果是这样，访问会有冲突，需要增加锁，很难并行计算我的意思是怎么让各个线程都有一份独立的啥叫每个线程都有一份独立的，又全局，又独立的~~。你多整几个全局变量不就行了？？  使用线程局部存储(TLS)，具体用法可参看MSDN

引用 3 楼 xu6832281 的回复:[quote=引用 2楼呔妖怪来嘛 的回复:]你的意思是多个线程访问同一块内存？？ 如果是这样，访问会有冲突，需要增加锁，很难并行计算我的意思是怎么让各个线程都有一份独立的[/quote]  啥叫每个线程都有一份独立的，又全局，又独立的~~。你多整几个全局变量不就行了？？

访问改数组变量时→访问该数组变量时

线程函数中声明的占内存比较小的变量本来就在各个线程的堆栈中。 线程函数中声明的占内存比较大（比如超过1MB）的变量应该在前面加static，将其存储位置挪到全局变量区，或者使用new，将其挪到堆存储区；但这样一来，会导致多线程读写冲突，此时一个解决办法就是将变量数组化，每个线程访问改数组变量时，都使用比如varArray[thread_id%MAX_THREADS]的办法避免访问冲突。


Question: C语言实现将内存中的内容实时保存。

你代码本身就存在问题，你打开了多次fopen,如果你想向一个文件中紧接文件尾部继续写入可以用fflush

内存中的数据只要你程序没有崩溃或者关闭，就会一直存在，所以你要做的，就是写一个好的、鲁棒的程序，保证其稳定性，

嗯。。稀疏矩阵最好用位图bitmap，可以去自己参考一下思想。空间利用率和CPU利用率都很高 如果想进一步压缩时间的话，最好减少IO的操作次数，考虑把成堆数据一次性输出到文件中 最后，将数据从内存中输出到硬盘中的操作，是不怎么会用到CPU的，电脑自带存储管理管线和控制器，CPU只是吧数据放在控制器上而已，传输操作不归CPU管

由于C语言不能获得足够的权限，C程序是做成dll文件被其他程序调用使用的。不知道下面这个替代方法是否可行。  1，指定一个较大的内存区域，用于不停的存储新来的数据。 2. 主程序每调用一次C程序（dll文件），就在内存中进行一次基线检查，然后将剩下的矩阵元（1000个点）写入1中开辟的内存中。 并保证内存空间中的数据不消失（怎么保证？） 3.多次采集后例如（10万次后，将内存中的数据一次性写入硬盘）  由于每次主程序调用的是dll文件，每次调用完之后，dll文件都关闭了，那怎么保证内存空间中的数据不消失？  非常谢谢！

谢谢大家回复，重新编辑了一下. 因为数据量比较大，担心CPU运行不过来，所以打算每次都把数据保存下来，保存到不到的文件中。  for (int jj=0;jj<1000;jj++) // 采集1000次  {	 char* filename; //每一次的文件名     filename = char(jj);//每一次的文件名       FILE *f = fopen( filename, "w" ); //每次保存一个新文件       for (y=0; y<ny; y++) {          float *ptr = (float*)GetPtr(bufnum,y);          for (x=0; x<nx; x++, ptr++)             fprintf(f,"%*.3f ",12, *ptr); //把数据写入新文件          fprintf(f,"\n");       }       fclose(f); //数据采集完一次，关闭文件； }

打开文件会比较耗时，所以若是循环打开或者打开多个文件耗时就更多了。

你的文件打开次数太多了吧 for (int jj=0;jj<1000;jj++) { char* filename;     filename = char(jj);       FILE *f = fopen( filename, "w" );       for (y=0; y<ny; y++) {          float *ptr = (float*)GetPtr(bufnum,y);          for (x=0; x<nx; x++, ptr++)             fprintf(f,"%*.3f ",12, *ptr);          fprintf(f,"\n");       }     }    你要打开几个文件？看你的打开文件在一个循环里，那么应该是打开多次（或打开多个文件）。如果实时保存时，只需要保存一份数据，建议先把文件打开再循环写入。另外，再次写入时将文件指针，只需要将文件指针重新指向文件开头即可。使用fseek或者rewind都可以实现将文件指针指向文件开始位置

你这代码本身就有问题啊，在循环体里边执行fopen，却在循环体外边fclose，没有配对。fopen应该在循环之前做。

// 创建文件句柄 HANDLE hFile = ::CreateFile(lpszFileName, GENERIC_READ, NULL, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); // 创建文件映射 HANDLE hMap = ::CreateFileMapping(hFile, NULL, PAGE_READONLY | SEC_COMMIT, NULL, NULL, NULL); // 读取映射中的内存 LPVOID lpBuffer = ::MapViewOfFile(hMap, FILE_MAP_READ, NULL, NULL, NULL);  // 好了文件的内存已经获取了，你可以随意处理了  // 释放映射内存 ::UnmapViewOfFile(lpBuffer); // 关闭文件映射 ::CloseHandle(hMap); // close file handle ::CloseHandle(hFile);


Question: 简单问题求教！！！！！

建议看一下软件的使用说明吧，只有用过的朋友能回答你的这个问题；一般软件，建议从网上搜一搜，然后总结一下用法

百度搜相关关键字。


Question: devCPP4.9.9.2怎样操作单步调试和设断点调试？

说单步调试的，应该是其本人使用的编辑编译器支持，并且也需要专门的学习，如果是初学者，可能有难度。但是，也不是没有办法调试。对于初学者的代码长度一般不会很长，可以考虑添加打印信息，了解变量的值，这种办法虽然笨，但也不适一个解决问题的办法；调试办法有很多，建议自己能够熟练的使用一两种，对于不同的问题，也建议有对应的解决问题的策略，这个需要学习和总结的。 不要对回答问题的人，天天贴一些重复的“单步调试”，他们都是用的很顺的“老油条”了，我们应该一步步来，或者专门去学习一下单步调试的流程；平时遇到问题时也有意识的用一下；  我感觉，回复帖子是发几句单步调试等等方法，也是为了刷存在感。仅代表个人见解（见解可能有误）。

没用过，帮不了你。一般来说Windows下的IDE调试都比较方便，Linux的话常用的是gdb了。

现代中国人的能力差别很大程度上体现在会不会合理高效地使用百度上。 百度搜相关关键字。  https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=0&rsv_idx=1&tn=baidu&wd=devCPP4.9.9.2怎样操作单步调试和设断点调试  引用 3 楼 hzy_76 的回复:确实，有些程序是无法单步调试的，比如驱动程序、交叉编译的程序，那就只能预设输出信息，根据这些信息判断运行情况了。不一而足，视具体情况而定。 驱动程序、交叉编译的程序也可以单步调试。


Question: 大家帮忙看看哪里的问题 输出错误

楼上全是正解， printf("%d is a prime number");编译器不知道%d打出什么。 printf("%d is a prime number", m);需要在后面 ， 分开， 输入要打印的变量。

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

没有人在吗？

#include <stdio.h> #include <stdlib.h>  int main() {     int m,i;     printf("please enter a number:");     scanf("%d",&m);     for (i = 2;i< m;i++)         if (m%i == 0)  break;     if(i < m)         printf("%d is not a prime number", m);   /*缺少参数*/     else         printf("%d is a prime number", m);    /*缺少参数*/     return 0;  } printf输出缺少参数；有%d后面就应该跟一个对应的整形参数（楼主的代码里缺少m）； 像这样的错误，编译器会提出警告的，建议你不要放过警告信息。

算法问题建议设置断点调试 百度搜索相关程序参考