Question: 求救啊   数据结构链表删除

嗯嗯 谢谢老师  你的教导我会听取的  谢谢！

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

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。  崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。   仅供参考（一般我能按Ctrl+V轻松粘贴正确代码的时候，决不费劲去找楼主提供的错误代码具体错在哪里）： //链表实现一元多项式的加法减法乘法 #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; }

引用 10 楼 zhao4zhong1 的回复:本ID贴出来的代码，研究后都说“酸爽”！赵老师 帮我看看这段代码吧#include<stdio.h> #include<stdlib.h>  #define MAX 100  typedef struct ce{ int c; int e; }CE;//多项式系数和指数的结构体 typedef CE ElemType; typedef struct SeqList{ ElemType a[MAX + 1]; int len; }SeqList;//数组  void InitList (SeqList **a) { *a=(SeqList*)malloc(sizeof(SeqList)); (*a)->len=0; };//初始化一个顺序链表 int SeqFull(SeqList *pList){ return pList->len==MAX ? 1:0; }//判断链表是否为空  int InsertSeq(SeqList *pList,int i ,CE elem) {int k; if(SeqFull(pList)==1){     puts("List is full!");     return 0; }//在线性表的第i个位置插入元素  if(i<1||i>pList->  len+1){     puts("wrong location!");     return 0; }for(k=pList->len+1;k>i;k--) pList->a[k]=pList->a[k-1]; pList->a[i]=elem; pList->len+=1;  }  void  PrintList(SeqList *pList){ int i; for (i=1;i<=pList->len;i++){     printf("(C:%d,E:%d)",pList->a[i].c,pList->a[i].e); } } int main() {    int i ,j,k,tmp;    SeqList*A,*B,*C;    InitList(&A);    InitList(&B);    InitList(&C);     CE a[5]= { {0,0},{1,2},{3,4},{5,6}, {7,8} };    CE b[5]= { {0,0},{1,2},{3,4},{5,6}, {7,8} };     for(i=1;i<5;i++ ){     InsertSeq(A,i,a[i]);    InsertSeq(B,i,b[i]);    }    PrintList(A);    putchar('\n');    PrintList(B);        i = j = k =1; while (i<=5&&j<=5){     if(A->a[i].e<B->a[j].e)         InsertSeq(C,k++,A->a[i++]);     else if (A->a[i].e>B->a[i].e)         InsertSeq(C,k++,B->a[j++]); else {     tmp.e= A->a[i].e;     tmp.c= A->a[i].c + B->a[j].c;     InsertSeq(C,k++,tmp);     i++,j++; } } while(j<=5)     C->a[k++]=B->a[j++]; while(i<=5) C->a[k++]=A->a[i++];    return 0; }这是一个A多项式+B多项式得C 多项式的程序    tmp.e= A->a[i].e;到这句话是错误的  原因是“e"not a structure or union  我实在不会改，求教，谢谢啦！！

本ID贴出来的代码，研究后都说“酸爽”！

引用 7 楼 qq_34627769 的回复:[quote=引用 4 楼 qq423399099 的回复:] [quote=引用 3 楼 qq_34627769 的回复:] [quote=引用 1 楼 qq423399099 的回复:] 让每个元素都向前移一位就行了  int DelElem(SeqList *pList, int i, ElemType *pElm) { 	if (ListEmpty(pList)) { 		Error("delete element from an empty list"); 		return 0; 	} 	if (i < 1 || i > pList->len) { 		Error("delete element out of range"); 		return 0; 	} 	*pElm = pList->a[i]; 	for(; i < pList->len; i++){ 		pList->a[i] = pList->a[i + 1]; 	} 	pList->len -= 1; 	return 1; }   引用 1 楼 qq423399099 的回复:让每个元素都向前移一位就行了  int DelElem(SeqList *pList, int i, ElemType *pElm) { 	if (ListEmpty(pList)) { 		Error("delete element from an empty list"); 		return 0; 	} 	if (i < 1 || i > pList->len) { 		Error("delete element out of range"); 		return 0; 	} 	*pElm = pList->a[i]; 	for(; i < pList->len; i++){ 		pList->a[i] = pList->a[i + 1]; 	} 	pList->len -= 1; 	return 1; }  那123 号是不是没动呢  但是for(; i < pList->len; i++){ 		pList->a[i] = pList->a[i + 1];也适用于123啊   [/quote] 123没动，这个循环变量i的值和你传进来的i是同一个值，是4，不是从0开始循环的[/quote] #define MAXSIZE 20这个定义的最大值是定义的什么啊  如果是存储空间  具体是存储什么的呢  [/quote] 这个20定义的是这个顺序表所能存储的最大的元素个数，存储的就是double型的数据

引用 4 楼 qq423399099 的回复:[quote=引用 3 楼 qq_34627769 的回复:] [quote=引用 1 楼 qq423399099 的回复:] 让每个元素都向前移一位就行了  int DelElem(SeqList *pList, int i, ElemType *pElm) { 	if (ListEmpty(pList)) { 		Error("delete element from an empty list"); 		return 0; 	} 	if (i < 1 || i > pList->len) { 		Error("delete element out of range"); 		return 0; 	} 	*pElm = pList->a[i]; 	for(; i < pList->len; i++){ 		pList->a[i] = pList->a[i + 1]; 	} 	pList->len -= 1; 	return 1; }   引用 1 楼 qq423399099 的回复:让每个元素都向前移一位就行了  int DelElem(SeqList *pList, int i, ElemType *pElm) { 	if (ListEmpty(pList)) { 		Error("delete element from an empty list"); 		return 0; 	} 	if (i < 1 || i > pList->len) { 		Error("delete element out of range"); 		return 0; 	} 	*pElm = pList->a[i]; 	for(; i < pList->len; i++){ 		pList->a[i] = pList->a[i + 1]; 	} 	pList->len -= 1; 	return 1; }  那123 号是不是没动呢  但是for(; i < pList->len; i++){ 		pList->a[i] = pList->a[i + 1];也适用于123啊   [/quote] 123没动，这个循环变量i的值和你传进来的i是同一个值，是4，不是从0开始循环的[/quote] #define MAXSIZE 20这个定义的最大值是定义的什么啊  如果是存储空间  具体是存储什么的呢

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

删除节点，找前驱

引用 3 楼 qq_34627769 的回复:[quote=引用 1 楼 qq423399099 的回复:] 让每个元素都向前移一位就行了  int DelElem(SeqList *pList, int i, ElemType *pElm) { 	if (ListEmpty(pList)) { 		Error("delete element from an empty list"); 		return 0; 	} 	if (i < 1 || i > pList->len) { 		Error("delete element out of range"); 		return 0; 	} 	*pElm = pList->a[i]; 	for(; i < pList->len; i++){ 		pList->a[i] = pList->a[i + 1]; 	} 	pList->len -= 1; 	return 1; }   引用 1 楼 qq423399099 的回复:让每个元素都向前移一位就行了  int DelElem(SeqList *pList, int i, ElemType *pElm) { 	if (ListEmpty(pList)) { 		Error("delete element from an empty list"); 		return 0; 	} 	if (i < 1 || i > pList->len) { 		Error("delete element out of range"); 		return 0; 	} 	*pElm = pList->a[i]; 	for(; i < pList->len; i++){ 		pList->a[i] = pList->a[i + 1]; 	} 	pList->len -= 1; 	return 1; }  那123 号是不是没动呢  但是for(; i < pList->len; i++){ 		pList->a[i] = pList->a[i + 1];也适用于123啊   [/quote] 123没动，这个循环变量i的值和你传进来的i是同一个值，是4，不是从0开始循环的

引用 1 楼 qq423399099 的回复:让每个元素都向前移一位就行了  int DelElem(SeqList *pList, int i, ElemType *pElm) { 	if (ListEmpty(pList)) { 		Error("delete element from an empty list"); 		return 0; 	} 	if (i < 1 || i > pList->len) { 		Error("delete element out of range"); 		return 0; 	} 	*pElm = pList->a[i]; 	for(; i < pList->len; i++){ 		pList->a[i] = pList->a[i + 1]; 	} 	pList->len -= 1; 	return 1; }   引用 1 楼 qq423399099 的回复:让每个元素都向前移一位就行了  int DelElem(SeqList *pList, int i, ElemType *pElm) { 	if (ListEmpty(pList)) { 		Error("delete element from an empty list"); 		return 0; 	} 	if (i < 1 || i > pList->len) { 		Error("delete element out of range"); 		return 0; 	} 	*pElm = pList->a[i]; 	for(; i < pList->len; i++){ 		pList->a[i] = pList->a[i + 1]; 	} 	pList->len -= 1; 	return 1; }  那123 号是不是没动呢  但是for(; i < pList->len; i++){ 		pList->a[i] = pList->a[i + 1];也适用于123啊

跪谢！！！！！！


Question: c语言学习小问题，思考了许久。。

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

可是typedef不是一般只有2个参数吗？这个怎么多参数，还有宏，是怎么来理解的啊？

typedef 意思就是别名而已 ，前面的名字和后面的名字是等价的

引用 1 楼 user-2 的回复:_Null_terminated 的意思就是以/0为结尾的字符串 跟普通的字符串一样的  恩，，，\0不是/0


Question: 请教各位几个小问题，有点晕了不太理解

嗯。debug是王道

cout << n * (n + 1)  /  2;

这就是和1+……+100求和问题；n是循环变量；有多个线条就需要循环多少次；

撸主是刚入门吧，这是最基本的语法了

来学习的，和一样

把for循环中的n换小一点， 比如： for(n = 1;n<5;n++) t = t + n; 你会发现最后t的值等于10！ 总共循环了4次！ 第一次：t = 0,n = 1,t = t+n->t = 1; 第二次：t = 1,n = 2,t = t+n ->t = 3 第三次：t = 3,n = 3,t = t+n->t = 6 第四次：t = 6,n = 4,t = t+n->t = 10 …… n<200就是循环199次  类推

不就是for循环做累加吗   想想小学1到50求和就明白了 都是一个道理

lz数学好差

等差数列，累和，不复杂的。

楼主，支持一下！！！

美女喝茶 求关注静远茶城

看看C程序设计-谭浩强著（大学C语言经典教材）。

引用 6 楼 sinat_34615052 的回复:[quote=引用 2 楼 qq423399099 的回复:] 这个表达式就是1到200的累加求和 如果t不初始化为0，在很多编译器里它的值将是一个垃圾值（用垃圾值加上1到200的累加和还是一个垃圾值，打印的结果也就不对了） t = t + n会循环200次，循环完200次以后才printf打印结果  for(n = 1; n <= 200; n = n+1)     t = t + n; printf("从第一行到第200行所有的点个数为%d\n", t);  可不可以这样理解，t就是所有点的总和，n是第n条线上的点的个数，这样一来的话，t = 0 这个表达式（也就是初始化）可不可以看成是刚开始t是从0开始的，因为刚开始是没有点的，直到出现了第一条线上的第一个点才开始有意义，同理，如果把变量t的值变成1的话，那就是说一开始就已经有了一个点了（这也算是一种初始化，只是起始点不同对吧？），这样的话最终的打印结果在数值上也就多了一个1，而不会是一个垃圾值，我能这样理解吗？[/quote] 前半部分是对的，变量t的值是几，并不代表就有几个点，因为t是每个点的值的累加和，t是3的时候其实只有2个点

变量名没起好, 把t改成sum就简单了. t = 0 就是最初是0个点. t = t + n 就是总数等于之前的点数加上新的线上的点数.

引用 3 楼 wangjingtao1994 的回复:t = t + n 的意思不是说自己等于自己加一个数，，，，而是把自己和另一个数的和赋值给一个变量，而这个变量正好是自己，所以就把原来的值覆盖了，，，你可以这么理解，，，  int a = t+n; t = a;  用a的值覆盖t，而a就是t和n的和，，  注意：t = t+n 和 t += n虽然结果一样，但原理完全不同，不过在没学操作符重载的时候可以当一样的使  谢谢    你这一说好像我确实明白了一些，就是因为t被初始化了，才需要 t = t + n 这个表达式的对吧？不然就不必设置 t 这个变量而直接输出 n 的值就可以了（思想上是这样，虽然这在逻辑上行不通）对吧？因为 n 就代表了点数，如果哪里说得不对，请谅解，本人初入c没几天，正在学习中，这些问题都是琢磨不透才来提问的，我个人性格就是遇到再小的问题也要弄明白，不然不好受

引用 2 楼 qq423399099 的回复:这个表达式就是1到200的累加求和 如果t不初始化为0，在很多编译器里它的值将是一个垃圾值（用垃圾值加上1到200的累加和还是一个垃圾值，打印的结果也就不对了） t = t + n会循环200次，循环完200次以后才printf打印结果  for(n = 1; n <= 200; n = n+1)     t = t + n; printf("从第一行到第200行所有的点个数为%d\n", t);  可不可以这样理解，t就是所有点的总和，n是第n条线上的点的个数，这样一来的话，t = 0 这个表达式（也就是初始化）可不可以看成是刚开始t是从0开始的，因为刚开始是没有点的，直到出现了第一条线上的第一个点才开始有意义，同理，如果把变量t的值变成1的话，那就是说一开始就已经有了一个点了（这也算是一种初始化，只是起始点不同对吧？），这样的话最终的打印结果在数值上也就多了一个1，而不会是一个垃圾值，我能这样理解吗？

当为计数器呀

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


Question: 核心已转储！用scanf读数到动态数组时错误

引用 4 楼 qq_34309383 的回复:[quote=引用 3 楼 qq423399099 的回复:] [quote=引用 2 楼 qq_34309383 的回复:] [quote=引用 1 楼 qq423399099 的回复:] scanf("%d",&p[i]); 存int要取址才行，而且%d后面的;也可以去掉   	for (i = 0; i < n; i++) { 		scanf("%d",&p[i]);  	}    谢谢！想问下为什么？这个p原本是个指针啊 p确实是个指针，但是你p[i]却是int型的，给int赋值必须是int *才行，所以要取址 你改成scanf("%d",p+i);这样是可以的[/quote] 哦我知道了，p[i]==*(p+i)，谢谢你 核心已转储的意思是scanf发现类型不匹配（是吧）[/quote] 这里确实是由scanf引起的 通常是因为SEGMENT FAULT, 一般是访问越界引起的。

引用 3 楼 qq423399099 的回复:[quote=引用 2 楼 qq_34309383 的回复:] [quote=引用 1 楼 qq423399099 的回复:] scanf("%d",&p[i]); 存int要取址才行，而且%d后面的;也可以去掉   	for (i = 0; i < n; i++) { 		scanf("%d",&p[i]);  	}    谢谢！想问下为什么？这个p原本是个指针啊 p确实是个指针，但是你p[i]却是int型的，给int赋值必须是int *才行，所以要取址 你改成scanf("%d",p+i);这样是可以的[/quote] 哦我知道了，p[i]==*(p+i)，谢谢你 核心已转储的意思是scanf发现类型不匹配（是吧）

引用 2 楼 qq_34309383 的回复:[quote=引用 1 楼 qq423399099 的回复:] scanf("%d",&p[i]); 存int要取址才行，而且%d后面的;也可以去掉   	for (i = 0; i < n; i++) { 		scanf("%d",&p[i]);  	}    谢谢！想问下为什么？这个p原本是个指针啊[/quote] p确实是个指针，但是你p[i]却是int型的，给int赋值必须是int *才行，所以要取址 你改成scanf("%d",p+i);这样是可以的

引用 1 楼 qq423399099 的回复:scanf("%d",&p[i]); 存int要取址才行，而且%d后面的;也可以去掉   	for (i = 0; i < n; i++) { 		scanf("%d",&p[i]);  	}    谢谢！想问下为什么？这个p原本是个指针啊

scanf("%d",&p[i]); 存int要取址才行，而且%d后面的;也可以去掉  #include <stdlib.h> #include <stdio.h> int main() { 	int *p,*d; 	int n,i; 	puts("想申请的int个数："); 	scanf("%d",&n);  	p = (int *) malloc (n*sizeof(int));  	for (i = 0; i < n; i++) { 		scanf("%d",&p[i]); /*对数组进行赋值，这里错了，但不知道怎么改*/  	}  	for (i = 0; i < n; i++) { 		printf("%5d",p[i]); 	} 	free(p); 	return 0; }


Question: linux下设置系统时间然后在获取系统时间出问题

注意时区，另外检测函数返回值以确定是否成功

那要看你有没有root权限了

也许是因为你没有考虑时区 也许是因为你没有权限

修改系统时间需要 root 权限.


Question: 求教 谢谢

引用 17 楼 qq_34627769 的回复:[quote=引用 7 楼 trytry1992 的回复:] [quote=引用 5 楼 qq_34627769 的回复:] #include <stdio.h> #include <stdlib.h>  #define MAXSIZE 20 typedef double ElemType; typedef struct list {   ElemType a[MAXSIZE + 1];   int len; } SeqList;  SeqList * InitList(); void InitList2(SeqList **ppList); int ListFull(SeqList *pList); int ListEmpty(SeqList *pList); int ListLen(SeqList *pList); void Error(char *msg); int GetElem(SeqList *pList, int i, ElemType *pElm); int InsertElem(SeqList * pList, int i, ElemType elm); int DelElem(SeqList *pList, int i, ElemType *pElm); void PrintList(SeqList *pList); 这段里面的第一个void InitList2(SeqList **ppList);为什么用二级指针啊 而下面的都是一个星号？  去了解一下局部变量，形参[/quote]case 1:DelStu(pList);break; case 2:DelByName(pList);break;这样的while  case对吗  case后面直接跟的线性函数  [/quote]  应该是switch后面才用case，while里用正常的判断语句把，比如if，else if，还有在条件语句里这样写一般是没错的

箭头指向的当然是指针了啊！

写代码的人　自己定义的

引用 7 楼 trytry1992 的回复:[quote=引用 5 楼 qq_34627769 的回复:] #include <stdio.h> #include <stdlib.h>  #define MAXSIZE 20 typedef double ElemType; typedef struct list {   ElemType a[MAXSIZE + 1];   int len; } SeqList;  SeqList * InitList(); void InitList2(SeqList **ppList); int ListFull(SeqList *pList); int ListEmpty(SeqList *pList); int ListLen(SeqList *pList); void Error(char *msg); int GetElem(SeqList *pList, int i, ElemType *pElm); int InsertElem(SeqList * pList, int i, ElemType elm); int DelElem(SeqList *pList, int i, ElemType *pElm); void PrintList(SeqList *pList); 这段里面的第一个void InitList2(SeqList **ppList);为什么用二级指针啊 而下面的都是一个星号？  去了解一下局部变量，形参[/quote]case 1:DelStu(pList);break; case 2:DelByName(pList);break;这样的while  case对吗  case后面直接跟的线性函数

说白了，这是一个结构体指针，首先是指针，然后指向一个结构体。指针引用结构体内部的元素，就得用箭头，不是指针用点。

引用 13 楼 qq_34627769 的回复:[quote=引用 12 楼 zhao4zhong1 的回复:] A->B 等价于 (*A).B可以用汉语翻译一下A->B   (*A).B吗  ，谢谢啦[/quote] //A->B //等价于 //(*A).B #include <stdio.h> struct S {     int B; }; struct S cA; struct S *A; int main() {     cA.B=13;     A=&cA;     printf("  A->B:%d\n",  A->B);     printf("(*A).B:%d\n",(*A).B);     return 0; } //  A->B:13 //(*A).B:13 //

引用 12 楼 zhao4zhong1 的回复:A->B 等价于 (*A).B可以用汉语翻译一下A->B   (*A).B吗  ，谢谢啦

A->B 等价于 (*A).B

引用 10 楼 trytry1992 的回复:[quote=引用 8 楼 qq_34627769 的回复:] [quote=引用 4 楼 trytry1992 的回复:] [quote=引用 3 楼 qq_34627769 的回复:] p与箭头必须同时出现吗  箭头出现就是指针了，变量名看你自己了。[/quote]#include <stdio.h>  #include <stdlib.h>   #define MAXSIZE 20  typedef double ElemType;  typedef struct list {    ElemType a[MAXSIZE + 1];    int len;  } SeqList;   SeqList * InitList();  void InitList2(SeqList **ppList);  int ListFull(SeqList *pList);  int ListEmpty(SeqList *pList);  int ListLen(SeqList *pList);  void Error(char *msg);  int GetElem(SeqList *pList, int i, ElemType *pElm);  int InsertElem(SeqList * pList, int i, ElemType elm);  int DelElem(SeqList *pList, int i, ElemType *pElm);  void PrintList(SeqList *pList);  这段里面的第一个void InitList2(SeqList **ppList);为什么用二级指针啊 而下面的都是一个星号？ [/quote]  因为他如果只传一级指针进去初始化的是局部变量，没法真正的初始化[/quote]嗯嗯  谢谢啦  很有用

引用 8 楼 qq_34627769 的回复:[quote=引用 4 楼 trytry1992 的回复:] [quote=引用 3 楼 qq_34627769 的回复:] p与箭头必须同时出现吗  箭头出现就是指针了，变量名看你自己了。[/quote]#include <stdio.h>  #include <stdlib.h>   #define MAXSIZE 20  typedef double ElemType;  typedef struct list {    ElemType a[MAXSIZE + 1];    int len;  } SeqList;   SeqList * InitList();  void InitList2(SeqList **ppList);  int ListFull(SeqList *pList);  int ListEmpty(SeqList *pList);  int ListLen(SeqList *pList);  void Error(char *msg);  int GetElem(SeqList *pList, int i, ElemType *pElm);  int InsertElem(SeqList * pList, int i, ElemType elm);  int DelElem(SeqList *pList, int i, ElemType *pElm);  void PrintList(SeqList *pList);  这段里面的第一个void InitList2(SeqList **ppList);为什么用二级指针啊 而下面的都是一个星号？ [/quote]  因为他如果只传一级指针进去初始化的是局部变量，没法真正的初始化

引用 6 楼 trytry1992 的回复:[quote=引用 5 楼 qq_34627769 的回复:] #include <stdio.h> #include <stdlib.h>  #define MAXSIZE 20 typedef double ElemType; typedef struct list {   ElemType a[MAXSIZE + 1];   int len; } SeqList;  SeqList * InitList(); void InitList2(SeqList **ppList); int ListFull(SeqList *pList); int ListEmpty(SeqList *pList); int ListLen(SeqList *pList); void Error(char *msg); int GetElem(SeqList *pList, int i, ElemType *pElm); int InsertElem(SeqList * pList, int i, ElemType elm); int DelElem(SeqList *pList, int i, ElemType *pElm); void PrintList(SeqList *pList); 这段里面的第一个void InitList2(SeqList **ppList);为什么用二级指针啊 而下面的都是一个星号？  你把实现发出来，不要就发个声明，不过照这样来看是初始化一个链表，要初始化一个指针，就得传入那个指针的指针[/quote]对的就是一个链表，我是大一的网络工程专业正在学习数据结构你的意思是初始化一个链表就要传指针的指针是吧 这样说感觉能清楚一些谢谢哈     还有“ 实现”是什么意思啊

引用 4 楼 trytry1992 的回复:[quote=引用 3 楼 qq_34627769 的回复:] p与箭头必须同时出现吗  箭头出现就是指针了，变量名看你自己了。[/quote]#include <stdio.h>  #include <stdlib.h>   #define MAXSIZE 20  typedef double ElemType;  typedef struct list {    ElemType a[MAXSIZE + 1];    int len;  } SeqList;   SeqList * InitList();  void InitList2(SeqList **ppList);  int ListFull(SeqList *pList);  int ListEmpty(SeqList *pList);  int ListLen(SeqList *pList);  void Error(char *msg);  int GetElem(SeqList *pList, int i, ElemType *pElm);  int InsertElem(SeqList * pList, int i, ElemType elm);  int DelElem(SeqList *pList, int i, ElemType *pElm);  void PrintList(SeqList *pList);  这段里面的第一个void InitList2(SeqList **ppList);为什么用二级指针啊 而下面的都是一个星号？

引用 5 楼 qq_34627769 的回复:#include <stdio.h> #include <stdlib.h>  #define MAXSIZE 20 typedef double ElemType; typedef struct list {   ElemType a[MAXSIZE + 1];   int len; } SeqList;  SeqList * InitList(); void InitList2(SeqList **ppList); int ListFull(SeqList *pList); int ListEmpty(SeqList *pList); int ListLen(SeqList *pList); void Error(char *msg); int GetElem(SeqList *pList, int i, ElemType *pElm); int InsertElem(SeqList * pList, int i, ElemType elm); int DelElem(SeqList *pList, int i, ElemType *pElm); void PrintList(SeqList *pList); 这段里面的第一个void InitList2(SeqList **ppList);为什么用二级指针啊 而下面的都是一个星号？  去了解一下局部变量，形参

引用 5 楼 qq_34627769 的回复:#include <stdio.h> #include <stdlib.h>  #define MAXSIZE 20 typedef double ElemType; typedef struct list {   ElemType a[MAXSIZE + 1];   int len; } SeqList;  SeqList * InitList(); void InitList2(SeqList **ppList); int ListFull(SeqList *pList); int ListEmpty(SeqList *pList); int ListLen(SeqList *pList); void Error(char *msg); int GetElem(SeqList *pList, int i, ElemType *pElm); int InsertElem(SeqList * pList, int i, ElemType elm); int DelElem(SeqList *pList, int i, ElemType *pElm); void PrintList(SeqList *pList); 这段里面的第一个void InitList2(SeqList **ppList);为什么用二级指针啊 而下面的都是一个星号？  你把实现发出来，不要就发个声明，不过照这样来看是初始化一个链表，要初始化一个指针，就得传入那个指针的指针

引用 3 楼 qq_34627769 的回复:p与箭头必须同时出现吗  箭头出现就是指针了，变量名看你自己了。

p与箭头必须同时出现吗

那要是没有箭头 只有p那也是指针吗   还是必须p与指针同时出现才是指针啊

箭头代表pList是个指针，一般来说变量名是p开头的就是指针的意思 pointer

引用 14 楼 zhao4zhong1 的回复:[quote=引用 13 楼 qq_34627769 的回复:] [quote=引用 12 楼 zhao4zhong1 的回复:] A->B 等价于 (*A).B可以用汉语翻译一下A->B   (*A).B吗  ，谢谢啦[/quote] //A->B //等价于 //(*A).B #include <stdio.h> struct S {     int B; }; struct S cA; struct S *A; int main() {     cA.B=13;     A=&cA;     printf("  A->B:%d\n",  A->B);     printf("(*A).B:%d\n",(*A).B);     return 0; } //  A->B:13 //(*A).B:13 // [/quote]谢谢


Question: 这段话什么意思啊？大神进来看看

引用 5楼我是你的主体 的回复:[quote=引用 2 楼 qq423399099 的回复:] 变长数组GCC是可以编译的，如果楼主是VS什么的是通不过编译的 gcc确实可以，但是怎么实现的呢？我试了一下，确实给数组在栈上分配空间了，而且随着输入值的不同分配的空间还不同，这用到了什么高新技术吗？[/quote]这个数组是在栈上的，其效果相当于你定义了n*n个行参，其实也是压栈而已，数组太大容易溢出。

引用 2 楼 qq423399099 的回复:变长数组GCC是可以编译的，如果楼主是VS什么的是通不过编译的 gcc确实可以，但是怎么实现的呢？我试了一下，确实给数组在栈上分配空间了，而且随着输入值的不同分配的空间还不同，这用到了什么高新技术吗？

引用 3 楼 paschen 的回复:C99支持变长数组VLA，但C++里是没有的 奥，好吧，那底层是怎么实现的啊？编译器怎么知道该分配多少内存呢

引用 4 楼 cyfcsd 的回复:[quote=引用 3 楼 paschen 的回复:] C99支持变长数组VLA，但C++里是没有的 奥，好吧，那底层是怎么实现的啊？编译器怎么知道该分配多少内存呢[/quote]  http://blog.163.com/163_zhujingwei/blog/static/973305972011519114611170/

C99支持变长数组VLA，但C++里是没有的

变长数组GCC是可以编译的，如果楼主是VS什么的是通不过编译的

参数n必须在A[n][n]之前初始化

VMMap 是进程虚拟和物理内存分析实用工具。http://technet.microsoft.com/zh-cn/sysinternals/dd535533

引用 8 楼 cyfcsd 的回复:[quote=引用 6 楼 zhao4zhong1 的回复:] 请那些喜欢将数组作为函数参数传来传去的码农思考一下为什么不把整个互联网内容当作函数参数传来传去呢？ 不是要传整个互联网啊，是编译器怎么“提前”知道用户输入的啊[/quote] 我的意思是研究怎样将数组作为函数参数或函数返回值是浪费生命的一种方法。  默认栈大小参考：   /STACK   (Stack Allocations) Home |  Overview |  How Do I |  Linker Options  The Stack Allocations (/STACK:reserve[,commit]) option sets the size of the stack in bytes.   To find this option in the development environment, click Settings on the Project menu. Then click the Link tab, and click Output in the Category box. The Reserve text box (or in the reserve argument on the command line) specifies the total stack allocation in virtual memory. The default stack size is 1 MB. The linker rounds up the specified value to the nearest 4 bytes.  The optional value specified in the Commit text box (or in the commit argument on the command line) is subject to interpretation by the operating system. In Windows NT, it specifies the amount of physical memory to allocate at a time. Committed virtual memory causes space to be reserved in the paging file. A higher commit value saves time when the application needs more stack space, but increases the memory requirements and possibly the startup time.  Specify the reserve and commit values in decimal or C-language notation.  Another way to set the size of the stack is with the STACKSIZE statement in a module-definition (.DEF) file. STACKSIZE overrides the Stack Allocations (/STACK) option if both are specified. You can change the stack after the .EXE file is built by using the EDITBIN tool.

好像明白了  确实是用户输入后栈指针又移动了  并没有什么高新技术  这么简单的问题为什么别的编译器不支持呢

引用 7 楼 u014444402 的回复:[quote=引用 5楼我是你的主体 的回复:][quote=引用 2 楼 qq423399099 的回复:] 变长数组GCC是可以编译的，如果楼主是VS什么的是通不过编译的 gcc确实可以，但是怎么实现的呢？我试了一下，确实给数组在栈上分配空间了，而且随着输入值的不同分配的空间还不同，这用到了什么高新技术吗？[/quote]这个数组是在栈上的，其效果相当于你定义了n*n个行参，其实也是压栈而已，数组太大容易溢出。[/quote] 恩  压栈的问题我知道   就是不明白当系统调用main函数时是如何确定main栈帧大小的 难道是等用户输入后再移动栈指针？

引用 6 楼 zhao4zhong1 的回复:请那些喜欢将数组作为函数参数传来传去的码农思考一下为什么不把整个互联网内容当作函数参数传来传去呢？ 不是要传整个互联网啊，是编译器怎么“提前”知道用户输入的啊


Question: typedef struct list node; 什么意思啊？？？

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

可以认为node是list类型的别名

node是一个类型且和struct list类型一样

typedef struct list node; //node相当于struct list typedef node *link;         //link相当于node* typedef node vec[10];    //再给楼主补充个，定义了一个元素类型为node，含有10个元素的数组类型vec

定义类型别名，将node定义为list的同义词，将link定义为node *的同义词，之后就可以用新定义的类型定义变量了


Question: typedef vernode adjlist[MaxNode]; 这句是什么意思啊？

引用 2 楼 user-4 的回复:vernode adjlist[MaxNode];               -->这种情况下adjlist是vernode数组的变量 typedef vernode adjlist[MaxNode]; -->这种情况下adjlist是自定义的数组类型，该数组成员的类型是vernode，数组成员的的个数是MaxNode 举个例子 有了typedef vernode adjlist[MaxNode];之后 adjilist a;相当于vernode a[MaxNode]; 懂了，非常感谢！

引用 5 楼 renwotao2009 的回复:举例子typedef int[10] a; 等同于typedef int a[10]; int a[10];等同于int[10] a; 我这里说的有问题。 typedef功能相当于给包含10个int类型的数组起了个别名叫做a； a a_;// a_为包含10个int类型数据的数组。

typedef struct {     adjlist adj_list;     int n,e; }ALGraph;

vernode是邻接表头结点的类型 typedef vernode adjlist[MaxNode];定义的是一个邻接表类型 表示的意思是：定义一个元素类型是vernode，含有MaxNode个元素的数组类型adjlist 如果不加typedef的话则变成了数组定义 因为一般还会定义一个图的类型，所以上面定义这样一个数组类型  typedef struct {     adjlist adj_list;     int n,e; };

定义了元素类型为vernode，元素个数为MaxNode的一个数组类型adjlist vernode之前已经定义过


Question: c++静态成员问题

Int ii1;              //创建一个ii1对象，会调用构造函数，因为有默认值，num从0变到了1，这个应该没有疑问吧  { Int ii1(i1); }     //用i1去构建对象ii1,作用域是{ }内，也会调用构造函数，num从1到2  Int ii2(i2);        //执行这句之前第二个ii1已经离开作用域了，所以调用了析构，num从2到1了                        //用i2构建对象ii2,会调用构造函数，num从1到2  注：在C++中，类的静态成员（static member）必须在类内声明，在类外初始化。静态成员是属于整个类的而不是某个对象，静态成员变量只存储一份供所有对象共用。

[size=24px]Int ii1创建一个lnt类的ii1对象，默认参数值是零；  { Int ii1(i1); }修改参数值为i1=1；  Int ii2(i2)创建一个lnt的ii2对象，实参为i2=2。 它们在声明时就被创建，之后以先进后出的方式回收[/size]


Question: 一个C简单的C程序输入和逻辑都有些错误。。求大神修改。。

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


这个属性要设置一下 Instance.Altitude = "370000"

inf里有个属性要设置一下


Question: 帮我看看哪儿错了= =数据结构单链表 我真的尽力改了 可是还是乱码。。

引用 10 楼 qq423399099 的回复:引用 8 楼 qq_33428266 的回复:[quote=引用 7 楼 qq423399099 的回复:] 楼主用的什么IDE啊codeblocks Code::Blocks缺省文件编码是UTF-8 从菜单Settings->Compiler and debugger。。。。  打开编译器设定对话框，在Compiler setting tab上，选择Other Option,添加下面的设定  -fexec-charset=GBK -finput-charset=UTF-8 告诉编译器，文件输入字符编码是utf-8，执行时以gbk编码对待[/quote]能否帮我看看哪里还有毛病  刚忘了加break;TT

引用 10 楼 qq423399099 的回复:引用 8 楼 qq_33428266 的回复:[quote=引用 7 楼 qq423399099 的回复:] 楼主用的什么IDE啊codeblocks Code::Blocks缺省文件编码是UTF-8 从菜单Settings->Compiler and debugger。。。。  打开编译器设定对话框，在Compiler setting tab上，选择Other Option,添加下面的设定  -fexec-charset=GBK -finput-charset=UTF-8 告诉编译器，文件输入字符编码是utf-8，执行时以gbk编码对待[/quote]已改好 感激不尽TT

引用 8 楼 qq_33428266 的回复:引用 7 楼 qq423399099 的回复:楼主用的什么IDE啊codeblocks  没有用过，爱莫能助，但是可以肯定的是不可能不能输出中文

引用 11 楼 trytry1992 的回复:引用 8 楼 qq_33428266 的回复:[quote=引用 7 楼 qq423399099 的回复:] 楼主用的什么IDE啊codeblocks  没有用过，爱莫能助，但是可以肯定的是不可能不能输出中文[/quote]哈哈哈谢谢 已改好---

引用 8 楼 qq_33428266 的回复:引用 7 楼 qq423399099 的回复:楼主用的什么IDE啊codeblocks Code::Blocks缺省文件编码是UTF-8 从菜单Settings->Compiler and debugger。。。。  打开编译器设定对话框，在Compiler setting tab上，选择Other Option,添加下面的设定  -fexec-charset=GBK -finput-charset=UTF-8 告诉编译器，文件输入字符编码是utf-8，执行时以gbk编码对待

文件 -> 高级保存选项 -> 编码, 修改为UNICODE试试

引用 2 楼 user-3 的回复:不是程序代码问题，是字符编码问题。。。  实在不行用英文那怎么用汉字。。原来没这情况啊。。。

引用 4 楼 trytry1992 的回复:楼主用的VS的话可以用宏定义。。。那就是说不能用汉字了？

楼主用的什么IDE啊

楼主用的VS的话可以用宏定义

不是程序代码问题，是字符编码问题。。。  实在不行用英文

今天早上不是说了嘛，估计是字符编码的问题


Question: 求助：二维数组的指针引用，希望通过指针引用直接修改矩阵的值并返回

列数不确定的话直接传成int **b好了  #include <stdio.h> #include <math.h> typedef int data_type;   void R_Mult(int **b,int n,int m) {     int i,j;     for (i = 0; i < m; i++){         for (j = 0; j < n; j++){             printf("b[%d][%d]=%d ",i, j,  *((int*)b + i + j*m));             //printf("b[%d][%d]=%d ",i, j, (*b)[i+j*m]);         }         printf("\n");     } }   int main(void) {     printf("Checking Results:\r\n");     int A[4][3]={{8,5,7},{1,2,1},{3,9,5},{2,2,2}};     R_Mult((int **)A,4,3);     return 0; }

这个是我的意思，第一个代码可能没有表达清楚意思，意思是上述图片中的意思。请高手帮忙！   #include <stdio.h> #include <stdlib.h> typedef float data_type; //定义为32位浮点数   //暴力矩阵乘法 void R_Mult_tst(data_type *A[], data_type *B[], data_type *C[],int m,int n,int p) { 	int i=0, j=0, k=0; 	for (i = 0; i < m; i++) { //m行号 		for (j = 0; j < n; j++) { //列号 			for (k = 0; k < p; k++) {//并行 				//C[i][k] += A[i][j] * B[j][ k]; 			} 			printf("\n"); 		} 	} }  int main99(void) {     int i=0,j=0;     data_type A[4][4] = {1.0,2.0,3.0,4.0,1.0,2.0,3.0,4.0,1.0,2.0,3.0,4.0,1.0,2.0,3.0,4.0};     data_type B[4][4] = {1.0,2.0,3.0,4.0,1.0,2.0,3.0,4.0,1.0,2.0,3.0,4.0,1.0,2.0,3.0,4.0};     data_type C[4][4]={0.0}; //将数组元素初始化为全0,防止出现莫名其妙的运算结果。     //这里如何采用二维数组的方式来传递参数，以便控制元素的下标？     R_Mult_tst(A[0],B[0],C[0],4,4,4); //调用暴力矩阵乘法      return 0; }

要求：void R_Mult(int *b[],int n,int m)  形参这里不再更改，只想通过更改 实参 R_Mult(*A,3,3);这里的A的引用调用方式来实现。 #7和#3 楼的方法虽然可以实现，但是参数传递的时候数组的列数是位置的，不能显式地写在形参中。 # 2虽然明白我的意思，但是给出的方法我编译可以通过，但是运行程序就崩溃掉了。

不知道你要干嘛，这样就可以了啊

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

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式...的值【比如printf("%p\n",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495

#include <stdio.h> #include <stdlib.h> typedef float data_type;//定义为32位浮点数  //@data_type A[n][m], data_type B[n][p], data_type C[m][p] //计算机矩阵乘法 A'*B void R_MultA(data_type *A, data_type *B, data_type *C, int n, int m, int p) { 	int i, j, k; 	for (j = 0; j < m; j++) { //矩阵A转置前的列号，即转置后的行号 		for (i = 0; i < n; i++) { //B的列号 			for (k = 0; k < p; k++) { //并行 				printf("C[%d]=%f   ",j * p + k,C[j * p + k]);//检测部分数组的初始值不是0.0 				//若不添加此句，部分C的初值不一定为0. 				if(i==0){ 					C[j * p + k]=0.0; 				} 				C[j * p + k]+= A[i*m + j] * B[i * p + k]; 				//printf("\t C[%d][%d]+=A[%d][%d]*B[%d][%d]=%f",j,k,i,j,i ,k,C[i*p+k]); 				//printf("\t C[%d]+=A[%d]*B[%d]=%f",j*p+k,i*m+j,i*p+k,C[j*p+k]); 				//printf("\t C[%d]+=%f*%f=%f",j*p+k,A[i*m + j],B[i * p + k],C[j*p+k]); 			} 			printf("\n"); 		} 	} } #define m 3 #define n 2 #define p 3  int main(void) {     int i,j;     //data_type A[2][3] = {1.0,2.0,3.0,4.0,5.0,6.0};     data_type A[n][m] = {1.2,2.2,3.2,4.2,3.6,3.7};     data_type B[n][p] = {4.2,5.2,6.2,7.2,3.9,1.6};     data_type C[n][p];   //  R_MultA(*A,*B,*C,n,m,p); //函数调用     R_MultA(*A,*B,*C,n,m,p);     //  func(*A,3,3);     for(i = 0; i < n; i++){         for(j = 0; j < p; j++)           printf("C[%d][%d]=%f  ", i,j,C[i][j]);         printf("\n");     }     return 0; }

*b[]这个才是指针数组。。。。 （*b）[]才是数组指针 你要转置矩阵的话，i应该是小于列数，j小于行数，要反一下才行 printf("b[%d][%d]=%d ",i, j, b[j][i]);和printf("b[%d][%d]=%d ",i, j, (*b)[i+j*m]);都行  #include <stdio.h> #include <math.h> typedef int data_type;  void R_Mult(int b[][3],int n,int m) { 	int i,j; 	for (i = 0; i < m; i++){ 		for (j = 0; j < n; j++){ 			//printf("b[%d][%d]=%d ",i, j, b[j][i]); 			printf("b[%d][%d]=%d ",i, j, (*b)[i+j*m]); 		} 		printf("\n"); 	} }  int main(void) { 	printf("Checking Results:\r\n"); 	int A[4][3]={{8,5,7},{1,2,1},{3,9,5},{2,2,2}}; 	R_Mult(A,4,3); 	return 0; }

*b[] 是数组指针  （*b）[]是指针数组 A本身就是指向指针的指针 把*b[]改为（*b）[] 参数直接为A，没看懂你要做什么  b[i*m+j]？


Question: 一个c编码报错

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

结构体定义后面忘了分号  struct weapon{ int price; int atk; struct weapon *next; };


Question: 请问如何查看gtk+帮助？

引用 10 楼 king_2007的回复:引用 8 楼 zhao4zhong1 的回复:虽然我都没实际用过，但我觉得qt比gtk+更流行。老师，感谢你用感性回答我的问题。我渴望理性的答案。 qt面向对象设计，用c++开发大型程序比较好，但商业应用不免费。gtk用c语言实现了面向对象设计，是完全免费的，功能和性能都不逊于qt。很多大公司都支持gtk。gnome，gimp，chrome等大型系统和应用都是用gtk开发的。

linux: # apt-get install devhelp libgtk-3-doc  Windows: 从官网下载对应版本的html文档压缩包（https://developer.gnome.org/gtk3/），解压后直接用浏览器打开index.html

虽然我都没实际用过，但我觉得qt比gtk+更流行。

引用 5 楼 king_2007 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] http://www.gtk.org/documentation.php http://www.oschina.net/p/gtk/老师，qt和gtk+，让你选择，你会选择哪个？[/quote] qt

引用 6 楼 zhao4zhong1 的回复:[quote=引用 5 楼 king_2007 的回复:] [quote=引用 3 楼 zhao4zhong1 的回复:] http://www.gtk.org/documentation.php http://www.oschina.net/p/gtk/老师，qt和gtk+，让你选择，你会选择哪个？[/quote] qt[/quote]why?

引用 3 楼 zhao4zhong1 的回复:http://www.gtk.org/documentation.php http://www.oschina.net/p/gtk/老师，qt和gtk+，让你选择，你会选择哪个？

引用 3 楼 zhao4zhong1 的回复:http://www.gtk.org/documentation.php http://www.oschina.net/p/gtk/我就是在官方网站上下载的，不知道解压后，怎么用？

引用 1 楼 zhao4zhong1 的回复:https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=0&rsv_idx=1&tn=baidu&wd=如何查看gtk%2B帮助  看了，没有一个是具体怎么使用的，我都解压缩了，找不到一个正经文件。


Question: 帮我看看我的bug

printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。  在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 int c; scanf("%c",&c); //时，都改为 char s[2]; int c; scanf("%1s",s); c=s[0];

补充一句，serach_for_student里面还有点问题 printf后面打印的都应该是p[i].xx  void serach_for_student(struct student *p)    //查找学生信息// { 	int nu,i; 	printf("输入学生的学号:"); 	scanf("%d",&nu); 	for(i=0;i<N;i++) 	{ 		if(nu==p[i].num) 		{ 			printf("%s %c %d %d",p[i].nam,p[i].s,p[i].num,p[i].sc); 			return; 		} 	} 	printf("该学生不存在"); }

有几个问题： 1.scanf的用法scanf("%s %c%d%d",stu[i].nam,&stu[i].s,&stu[i].num,&stu[i].sc); 写入字符串直接用数组名就行了，%s和%c之间弄个空格，这样可以接收读完%s以后遗留的空格 2.serach_for_student函数里应该是if(nu==p[i].num),而且应该循环完N次，还没找到才打印出该学生不存在 3.serach_for_student的printf打印数组直接用数组名就好，你这样用p->nam[100]是打印nam的第101个字符，会越界 4.seq_student的scanf同上   #include<stdio.h> #include<malloc.h> typedef int score; typedef int number; typedef  char sex; typedef char name; //extern  int N; int N = 3; struct student { 	name nam[100]; 	sex s; 	number num; 	score sc; }; void seq_student(struct student *p)  //插入函数// { 	int m,j; 	struct student *q; 	printf("请检查你输入的信息是否有遗漏。若有遗漏请输入数字'1':"); 	scanf("%d",&j);	 	if(j==1)  	{ 		printf("输入遗漏的位置\n:"); 		scanf("%d",&m); 		p=p+m-1; 		q=p; 		printf("输入遗漏的学生信息\n:"); 		scanf("%s %c%d%d",q->nam,&q->s,&q->num,&q->sc); 		while(m<N) 		{ 			++m; 			p=q; 		} 	} } void serach_for_student(struct student *p)    //查找学生信息// { 	int nu,i; 	printf("输入学生的学号:"); 	scanf("%d",&nu); 	for(i=0;i<=N;i++) 	{ 		if(nu==p[i].num) 		{ 			printf("%s %c %d %d",p->nam,p->s,p->num,p->sc); 			return; 		} 	} 	printf("该学生不存在"); } void main() { 	int i; 	struct student *stu; 	printf("请输入学生的个数\n:"); 	scanf("%d",&N);  	stu=(struct student *)malloc(sizeof(struct student)*N); 	printf("请输入学生的姓名、性别、学号及该学科成绩\n:"); 	for(i=0;i<N;i++){ 		scanf("%s %c%d%d",stu[i].nam,&stu[i].s,&stu[i].num,&stu[i].sc); 	} 	seq_student(stu); 	serach_for_student(stu); }

申请内存那错了吧 你也不把错误信息贴出来


Question: strcpy

在strcpy中增加一条语句 char*s1=s; # include <stdio.h>  void strcpy(char * s, char * t);  int main() { 	char s1[] = "nima!"; 	char s2[] = "nibaba!";  	strcpy(s1, s2);  	return 0; }  void strcpy(char * s, char * t) { 	char*s1=s; 	while (*s++ = *t++) 		;     printf("%s", s1); }

#include <stdio.h> #include <stdlib.h> void strcpy(char *s, char *t) { 	if(s == NULL || t == NULL) 	{ 		return; 	} 	char *p_ret = s; 	while(*s != '\0' && *t != '\0') 	{ 		*s++ = *t++; 	} 	printf("%s\n", p_ret); }  int main(int argc, char *argv[]) { 	char s1[] = "nima"; 	char s2[] = "nibaba!"; 	strcpy(s1, s2); 	system("pause"); 	return 0; }  1 你自己要保证s1的空间比s2的空间大 2 传进去的指针一定要做check,一般判断是否为NULL

strcmp有什么问题

这个程序会内存溢出

这个程序感觉很有问题呀！

字符串最后还要补充 \0

楼上给出了实现 注意点： 1，检查指针有效性； 2，返回目的指针des； 3，源字符串的末尾 '\0' 需要拷贝。

char * strcpy(char *dst,const char *src)    {     assert(dst != NULL && src != NULL);          char *ret = dst;  //[3]      while ((*dst++=*src++)!='\0');       return ret; }

C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\strcat.c /*** *strcat.c - contains strcat() and strcpy() * *       Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *       Strcpy() copies one string onto another. * *       Strcat() concatenates (appends) a copy of the source string to the *       end of the destination string, returning the destination string. * *******************************************************************************/  #include <cruntime.h> #include <string.h>  #ifndef _MBSCAT #pragma function(strcat,strcpy) #endif  /* _MBSCAT */  /*** *char *strcat(dst, src) - concatenate (append) one string to another * *Purpose: *       Concatenates src onto the end of dest.  Assumes enough *       space in dest. * *Entry: *       char *dst - string to which "src" is to be appended *       const char *src - string to be appended to the end of "dst" * *Exit: *       The address of "dst" * *Exceptions: * *******************************************************************************/  char * __cdecl strcat (         char * dst,         const char * src         ) {         char * cp = dst;          while( *cp )                 cp++;                   /* find end of dst */          while( *cp++ = *src++ ) ;       /* Copy src to end of dst */          return( dst );                  /* return dst */  }   /*** *char *strcpy(dst, src) - copy one string over another * *Purpose: *       Copies the string src into the spot specified by *       dest; assumes enough room. * *Entry: *       char * dst - string over which "src" is to be copied *       const char * src - string to be copied over "dst" * *Exit: *       The address of "dst" * *Exceptions: *******************************************************************************/  char * __cdecl strcpy(char * dst, const char * src) {         char * cp = dst;          while( *cp++ = *src++ )                 ;               /* Copy src over dst */          return( dst ); }


Question: 初学者请教一个问题

尖括号换成括号。。。

分号的问题。。  你试用的分号是中文输入法的分号。。。所以出错了。

哈哈哈哈，各位各位，跑起来了跑起来了哈哈哈，谢谢各位，确实是因为弄了中文的分号，必须要细心啊，下次一定要注意了  开心啊

引用 10 楼 huahai_nb 的回复:问题解决了么，是不是用了中文的分号了？总觉得定义变量后面的分号有问题 错误里其实已经提示了，第五行最后的分号明显不对

问题解决了么，是不是用了中文的分号了？总觉得定义变量后面的分号有问题

引用 8 楼 qq423399099 的回复:点引用，被引用的人会有提示的 哈哈，原来如此，谢谢谢谢

点引用，被引用的人会有提示的

我要怎么才能对指定楼层回复啊，怎么只能单独回复啊

引用 4 楼 sinat_34615052 的回复:谢谢啊我才刚开始学，好多东西都不懂，我是想把十进制47变成十六进制2F输出，你的这个int  main 后面怎么没有void啊？难道是我错了吗？T0T 一般来讲,void在这里可以省略，int main(void) 可以看成 int main() . main 函数另一个重要的形式 是 ： int main(int argc ,char *argv[]) ，这个形式中 argc 是给main函数参数的个数，argv[] 中的成员就是相应的参数

谢谢你，学习了

#include<stdio.h> int main() { int x = 47; printf("%x\n", x);//如果打印整数用%d return 0; }  楼主还得多敲敲代码啊，编译器也提示了哪行错误。可以多看看错误。 还有楼主是要打印16进制数据么，使用%x，如果打印整数用%d。

双击错误应该会跳转到第二行 然后就会发现多了一个分号了

int main(void) { } )

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


Question: 【求助帖】关于指针

引用 5 楼 赵4老师的回复:仅供参考：#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  好的，谢谢大神的帮助！

引用 3 楼 qq423399099 的回复:[quote=引用 2 楼 hdj_cz_forever 的回复:] [quote=引用 1 楼 qq423399099 的回复:] 这个当然没有影响。。。 你在main函数中的p1和p2类型是int * 而你定义的swap函数类型也是int * 啊 （楼主以为*离p1近就和p1结合了啊。。。。） int swap(int *p1, int *p2)和int swap(int* p1, int* p2)一样的（这样楼主是不是就懂了呢）  受教了，谢谢哈~问一个题外话，我现在还是一名学生，语言方面是从C++开始学的，之前还有学过一些C，但是因为我怕贪多嚼不烂，所以暂时放弃C，我想问，我以后想找一份好点的工作，在学完C++之后应该学什么语言？[/quote] 这个问题有点大了，不过主要看楼主想往哪方面发展了，对哪方面感兴趣 如果是想毕业以后能比较轻松的找到工作，楼主不妨去逛逛招聘网站，比如拉勾（我不是做广告啊，哈哈） 看看他们对于招聘人员的要求，需要哪方面的技术[/quote] 好的，谢谢~

引用 2 楼 hdj_cz_forever 的回复:[quote=引用 1 楼 qq423399099 的回复:] 这个当然没有影响。。。 你在main函数中的p1和p2类型是int * 而你定义的swap函数类型也是int * 啊 （楼主以为*离p1近就和p1结合了啊。。。。） int swap(int *p1, int *p2)和int swap(int* p1, int* p2)一样的（这样楼主是不是就懂了呢）  受教了，谢谢哈~问一个题外话，我现在还是一名学生，语言方面是从C++开始学的，之前还有学过一些C，但是因为我怕贪多嚼不烂，所以暂时放弃C，我想问，我以后想找一份好点的工作，在学完C++之后应该学什么语言？[/quote] 这个问题有点大了，不过主要看楼主想往哪方面发展了，对哪方面感兴趣 如果是想毕业以后能比较轻松的找到工作，楼主不妨去逛逛招聘网站，比如拉勾（我不是做广告啊，哈哈） 看看他们对于招聘人员的要求，需要哪方面的技术

引用 1 楼 qq423399099 的回复:这个当然没有影响。。。 你在main函数中的p1和p2类型是int * 而你定义的swap函数类型也是int * 啊 （楼主以为*离p1近就和p1结合了啊。。。。） int swap(int *p1, int *p2)和int swap(int* p1, int* p2)一样的（这样楼主是不是就懂了呢）  受教了，谢谢哈~问一个题外话，我现在还是一名学生，语言方面是从C++开始学的，之前还有学过一些C，但是因为我怕贪多嚼不烂，所以暂时放弃C，我想问，我以后想找一份好点的工作，在学完C++之后应该学什么语言？


Question: C语言链表的功能实现

引用 8 楼 qinghong_xiao 的回复:对不起，我是有个函数老是不对，通过匹配结点内数据来达到删除结点的功能 这个坑很大： 都匹配不上 都匹配上 匹配第一个 匹配最后一个 如何匹配 ……

是啊，不明所以

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

引用 5 楼 trytry1992 的回复:一言不发就一堆代码 没见我上面“以其人之道还治其人之身”吗？

Delete_Node_Data函数改成下面这样就行了 思路：让p2指向当前要比较的结点，p1指向p2的前一个结点 （如果存在要删除的结点，则让p1的next指针指向p2的下一个结点就行了）  /*按数据删除结点*/   //功能未建设完全，存在BUG void Delete_Node_Data(struct LINK_NODE *head) { 	int num = 0,i = -1; 	struct LINK_NODE *p1 = head, *p2 = NULL; 	printf("\n请输入要删除的数据："); 	scanf(" %d",&num); 	if(head->next == NULL) 	{ 		printf("\n该链表中不存在任何数据!!\n"); 		exit(0); 	}  	p2 = p1->next; 	while(p2 != NULL) 	{ 		i = p2->data; 		if(p2->data == num ) 		{ 			break; 		} 		p1 = p2; 		p2 = p2->next; 	} 	/* 	while(p2->next != NULL) 	{ 		p2 = p1->next; 		i = p2->data; 		if(p2->data == num ) 		{ 			break; 		} 	}*/  	if(i != num) 	{ 		printf("\n该链表中没有您要删除的数据!!\n"); 		exit(0); 	} 	p1->next = p2->next; 	free(p2);     //结点删除后要释放掉所删除结点占用的内存空间，达到节约内存的目的 }

对不起，我是有个函数老是不对，通过匹配结点内数据来达到删除结点的功能

对不起，我是有个函数老是不对，通过匹配结点内数据来达到删除结点的功能

对不起，各位，我是有个函数老是不对，通过匹配结点内数据来达到删除结点的功能

一言不发就一堆代码

完全不懂

你什么也不说，谁知道你想干什么

楼主的代码有什么问题么？


Question: 帮我看下哪里出问题了 数据结构单链表

引用 7 楼 qq_33428266 的回复:[quote=引用 4 楼 小灸舞的回复:]没有引用那就传二级指针就行了  void InitiList(LinkList *L) {     *L=(LinkList)malloc(sizeof(LNode));     (*L)->next=NULL; }  想了好久 就是搞不明白为什么用二级指针。。用和不用有什么区别吗。。[/quote] 因为你要改变的是链表指针的指向（所以一定要传链表指针的引用或者二级指针） 如果仅仅是传一级指针的话只能改变链表指针所指向区域的值 （我这样说清楚吗？）

引用 4 楼 小灸舞的回复:没有引用那就传二级指针就行了  void InitiList(LinkList *L) {     *L=(LinkList)malloc(sizeof(LNode));     (*L)->next=NULL; }  想了好久 就是搞不明白为什么用二级指针。。用和不用有什么区别吗。。

不要依赖调试器输出复杂数据结构！而要将复杂数据结构的整个内容在处理它的每一步使用一小段代码按自己很容易理解的格式输出，非常有助于调试！或者可以说是“基础设施”

引用 2 楼 小灸舞的回复:楼主的问题相当多,帮楼主改了前面的 1.InitiList应该要传引用，光传指针是不行的 2.shuru函数改了几个地方，一个scanf就够了，要那么多scanf干嘛 3.帮楼主加了个ListDisplay用来打印链表，看一下自己插入删除成功没 4.主函数里if(t=1)应该是if(t==1) 5.主函数里else分支下的两句少大括号  #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct LNode { 	int num; 	struct LNode *next; }LNode,*LinkList;  void InitiList(LinkList &L) { 	L=(LinkList)malloc(sizeof(LNode)); 	L->next=NULL; } void LocateElem(LinkList L) { 	int e; 	LNode *p; 	p=L->next; 	printf("\n\t\t输入要查找的数据："); 	scanf("%d",&e); 	while(p&&p->num!=e) 		p=p->next; 	printf("%d",p->num); } void ListInsert(LinkList L) {  	int i; 	int e; 	LNode *p=L,*s; 	int j=0; 	printf("\n\t\t输入要插入的结点："); 	scanf("%d",&i); 	getchar(); 	printf("\n\t\t输入要插入的数据："); 	scanf("%d",&e); 	while(p&&(j<i-1)) 	{ 		p=p->next; 		++j; 	} 	if(!p||j<i-1) 		exit(0); 	s=(LinkList)malloc(sizeof(LNode)); 	s->num=e; 	s->next=p->next; 	p->next=s; } void ListDelete(LinkList L) { 	int i; 	LNode *p,*q; 	int j=0; 	printf("\n\t\t输入要删除的结点位置："); 	scanf("%d",&i); 	while((p->next)&&(j<i-1)) 	{ 		p=p->next; 		++j; 	} 	if(!(p->next)||j<i-1) 		exit(0); 	q=p->next; 	p->next=q->next; 	free(q); } void shuru(LinkList L) { 	LNode *p1,*p2; 	int n; 	//scanf("%d",&n); 	while(scanf("%d",&n)!=EOF) 	{ 		p1=(LinkList)malloc(sizeof(LNode)); 		p1->num=n; 		p1->next=NULL; 		if(L->next==NULL) 			L->next=p1; 		else 			p2->next=p1; 		p2=p1; 		//scanf("%d",&n); 		//printf("AAAAAAA\n"); 	} } void hebing(LinkList L,LinkList T) { 	LinkList LC; 	LNode *pa,*pb,*pc; 	pa=L->next; 	pb=T->next; 	LC=L; 	pc=LC; 	while(pa&&pb) 	{ 		if(pa->num<=pb->num) 		{ 			pc->next=pa; 			pc=pa; 			pa=pa->next; 		} 		else 		{ 			pc->next=pb; 			pc=pb; 			pb=pb->next; 		} 	} 	pc->next=pa?pa:pb; 	free(T); }  void ListDisplay(LinkList L) { 	LinkList A = L->next; 	printf("打印链表:"); 	while(A){ 		printf("%d ", A->num); 		A = A->next; 	} 	printf("\n"); }  int main() { 	int n,t; 	LinkList A; 	LinkList B; 	LinkList L; 	LinkList T; 	InitiList(A); 	InitiList(B); 	shuru(A); 	ListDisplay(A); 	shuru(B); 	ListDisplay(B); 	printf("\n\t\t选择需要操作的链表：1.A  其它.B"); 	scanf("%d",&t); 	if(t==1) 	{ 		L=A; 		T=B; 	} 	else 	{ 		L=B; 		T=A; 	} 	printf("\n\t\t操作选择："); 	printf("\n\t\t1：查找"); 	printf("\n\t\t2：插入"); 	printf("\n\t\t3：删除"); 	printf("\n\t\t4：合并"); 	printf("\n\t\t5：退出"); 	scanf("%d",&n); 	for(;;) 	{ 		switch(n) 		{ 		case 1:LocateElem(L);break; 		case 2:ListInsert(L);break; 		case 3:ListDelete(L);break; 		case 4:hebing(L,T);break; 		case 5:exit(0);  		} 	} 	free(A); 	free(B); 	return 0; }    可是c语言里没有引用参数这个概念啊。。。

链表 http://blog.csdn.net/zhangxiangdavaid/article/details/25082013


Question: 关于筛选相似数的问题？请进

提出一个问题往往比解决这个问题还难。

引用 2 楼 旧剑鞘的回复:3   6   9要怎么算？几个范围？ 肯定是两个啊，3和9肯定不是一组。那么两组，3与6，6与9。哈哈，我好机智

3   6   9要怎么算？几个范围？

做个窗口吧， 最大长度为5 ， 最小间距为1 如果不包含相等的这样足矣 每次遇到一个新数字滑动以下窗口，新数小于窗口允许最大值，加入窗口 有一个问题 1，2，3，4，5，6，7 如何处理 1，2，3，4，5，6， 8，9，10，11 如何处理


Question: C语言指针访问二维数组问题

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

TranspositionMatrix函数有两处问题： 1.内层循环j应该从0循环到COL 2.[]的优先级比*要高，所以要加上括号，而且括号内写的也不对，改成以下两种方式都可以 (*iTMartix)[j*ROW+i]=(*iSMartix)[i*COL+j]; 或 iTMartix[j][i]=iSMartix[i][j];  #include<stdio.h> #define ROW 3 #define COL 4  void InputMatrix(int iMatrix[ROW][COL]); void DisplaypSource(int iMatrix[][COL], int iROW); void TranspositionMatrix(int (*iSMartix)[COL], int (*iTMartix)[ROW]); void DisplayTarget(int iMatrix[][ROW], int iCOL); void prog9_7();  void prog9_7()  {  	int iSourceMatrix[ROW][COL];		//用于存放原始矩阵数据  	int iTargetMatrix[COL][ROW];		//用于存放结果矩阵数据    	InputMatrix(iSourceMatrix);  	DisplaypSource(iSourceMatrix, ROW);  	TranspositionMatrix(iSourceMatrix, iTargetMatrix);  	DisplayTarget(iTargetMatrix, COL);  }  void main()  {  	prog9_7();  }    //输入数据  void InputMatrix(int iMatrix[ROW][COL])  {  	int i,j;    	printf("请输入数据：\n");  	for (i = 0; i < ROW; i++)  		for (j = 0; j < COL; j++)  		{  			scanf("%d", &iMatrix[i][j]);  		}  		printf("\n");  }    //输出数据  void DisplaypSource(int iMatrix[][COL], int iROW)  {  	int i,j;    	printf("输出数据：\n");  	for (i = 0; i < ROW; i++)  	{  		for (j = 0; j < COL; j++)  		{  			printf("%5d", iMatrix[i][j]);  		}  		printf("\n");  	}  }    void DisplayTarget(int iMatrix[][ROW], int iCOL)  {  	int i,j;    	printf("输出数据：\n");  	for (i = 0; i < COL; i++)  	{  		for (j = 0; j < ROW; j++)  		{  			printf("%5d", iMatrix[i][j]);  		}  		printf("\n");  	}  }    //矩阵转置  void TranspositionMatrix(int (*iSMartix)[COL], int (*iTMartix)[ROW])  {  	int i,j;    	printf("矩阵转置中......\n\n");  	for (i = 0; i < ROW; i++)  	{  		for (j = 0; j < COL; j++)  		{ 			(*iTMartix)[j*ROW+i]=(*iSMartix)[i*COL+j]; 			//iTMartix[j][i]=iSMartix[i][j];  		}  	}  	printf("转置完成\n\n ");  }


Question: write 错误Input/output error

EIO比较棘手，你可能需要查看当时更多的信息。

#include <string.h> ... write printf("%d %s\n",errno,strerror( errno ) );  _write Writes data to a file.  int _write( int handle, const void *buffer, unsigned int count );  Routine Required Header Compatibility  _write <io.h> 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  If successful, _write returns the number of bytes actually written. If the actual space remaining on the disk is less than the size of the buffer the function is trying to write to the disk, _write fails and does not flush any of the buffer’s contents to the disk. A return value of –1 indicates an error. In this case, errno is set to one of two values: EBADF, which means the file handle is invalid or the file is not opened for writing, or ENOSPC, which means there is not enough space left on the device for the operation.  If the file is opened in text mode, each linefeed character is replaced with a carriage return – linefeed pair in the output. The replacement does not affect the return value.   Parameters  handle  Handle of file into which data is written  buffer  Data to be written  count  Number of bytes  Remarks  The _write function writes count bytes from buffer into the file associated with handle. The write operation begins at the current position of the file pointer (if any) associated with the given file. If the file is open for appending, the operation begins at the current end of the file. After the write operation, the file pointer is increased by the number of bytes actually written.  When writing to files opened in text mode, _write treats a CTRL+Z character as the logical end-of-file. When writing to a device, _write treats a CTRL+Z character in the buffer as an output terminator.  Example   /* WRITE.C: This program opens a file for output  * and uses _write to write some bytes to the file.  */  #include <io.h> #include <stdio.h> #include <stdlib.h> #include <fcntl.h> #include <sys/types.h> #include <sys/stat.h>  char buffer[] = "This is a test of '_write' function";  void main( void ) {    int fh;    unsigned byteswritten;     if( (fh = _open( "write.o", _O_RDWR | _O_CREAT,                                 _S_IREAD | _S_IWRITE )) != -1 )    {       if(( byteswritten = _write( fh, buffer, sizeof( buffer ))) == -1 )          perror( "Write failed" );       else          printf( "Wrote %u bytes to file\n", byteswritten );        _close( fh );    } }   Output  Wrote 36 bytes to file   Low-level I/O Routines  See Also   fwrite, _open, _read


Question: 结构体里面嵌套的结构体能不能被传回主函数

我是想问一下，为什么子函数中的结构体A如果不用指针子函数结束后就会被释放，但是这个结构体A中嵌套的结构体B不会？

那楼主手动释放一下呗。。。 程序结束反正也会自动释放掉的

用free啊，c里面是用free释放内存

代码应该没什么问题，就是在写的时候有点疑惑，函数中的结构体只能通过结构体指针传回，可是里面嵌套的结构体直接用函数结束后并没有释放掉


Question: C#如何实现保存功能

在MSDN里面搜C#文件操作的例子代码。


Question: 新人求助：算法结果可视化该怎么弄

引用 6 楼 zhao4zhong1 的回复:画箭头参考：#include <windows.h> #include <gdiplus.h> using namespace Gdiplus; #pragma comment(lib, "user32.lib") #pragma comment(lib, "gdi32.lib") #pragma comment(lib, "gdiplus.lib") VOID Example_SetStrokeCaps(HDC hdc) {    Graphics graphics(hdc);     //Create a Path, and add two lines to it.    Point points[3] = {Point(-2, -5), Point(0, 0), Point(2, -5)};    GraphicsPath capPath;    capPath.AddLines(points, 3);     // Create a CustomLineCap object.    CustomLineCap custCap(NULL, &capPath);     // Set the start and end caps for custCap.    custCap.SetStrokeCaps(LineCapRound, LineCapRound);    custCap.SetStrokeJoin(LineJoinRound);    // Create a Pen object, assign startStrokeCap and endStrokeCap as the    // start and end caps, and draw a line.    Pen strokeCapPen(Color(255, 255, 0, 255), 10.0f);    strokeCapPen.SetCustomEndCap(&custCap);    graphics.SetSmoothingMode(SmoothingModeHighQuality);    graphics.DrawLine(&strokeCapPen, Point(100, 100), Point(300, 100)); } VOID OnPaint(HDC hdc) {    Graphics     graphics(hdc);    Pen          pen(Color(255, 0, 0, 255));    FontFamily   fontFamily(L"宋体");    Font         font(&fontFamily, 12, FontStyleRegular, UnitPixel);    PointF       pointF1(30.0f, 60.0f),pointF2(230.0f, 60.0f);    SolidBrush   solidBrush(Color(255, 0, 0, 255));    StringFormat stringFormat;    WCHAR testString[] = L"Hello034∠你好";     stringFormat.SetFormatFlags(StringFormatFlagsDirectionVertical);     graphics.SetSmoothingMode(SmoothingModeDefault);    graphics.DrawLine(&pen, 0, 0, 200, 100);    graphics.DrawEllipse(&pen, 10, 10, 190, 90);    graphics.SetTextRenderingHint(TextRenderingHintSystemDefault);    graphics.DrawString(testString, -1, &font, pointF1, &stringFormat, &solidBrush);      graphics.SetSmoothingMode(SmoothingModeHighQuality);    graphics.DrawLine(&pen, 200, 0, 400, 100);    graphics.DrawEllipse(&pen, 210, 10, 190, 90);    graphics.SetTextRenderingHint(TextRenderingHintAntiAlias);    graphics.DrawString(testString, -1, &font, pointF2, &stringFormat, &solidBrush);     Example_SetStrokeCaps(hdc); } LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {    HDC          hdc;    PAINTSTRUCT  ps;     switch(message) {    case WM_PAINT:       hdc = BeginPaint(hWnd, &ps);       OnPaint(hdc);       EndPaint(hWnd, &ps);       return 0;    case WM_DESTROY:       PostQuitMessage(0);       return 0;    default:       return DefWindowProc(hWnd, message, wParam, lParam);    } } INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, PSTR, INT iCmdShow) {    HWND                hWnd;    MSG                 msg;    WNDCLASS            wndClass;    GdiplusStartupInput gdiplusStartupInput;    ULONG_PTR           gdiplusToken;     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);     wndClass.style          = CS_HREDRAW | CS_VREDRAW;    wndClass.lpfnWndProc    = WndProc;    wndClass.cbClsExtra     = 0;    wndClass.cbWndExtra     = 0;    wndClass.hInstance      = hInstance;    wndClass.hIcon          = LoadIcon(NULL, IDI_APPLICATION);    wndClass.hCursor        = LoadCursor(NULL, IDC_ARROW);    wndClass.hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);    wndClass.lpszMenuName   = NULL;    wndClass.lpszClassName  = TEXT("GettingStarted");     RegisterClass(&wndClass);     hWnd = CreateWindow(       TEXT("GettingStarted"),   // window class name       TEXT("Getting Started"),  // window caption       WS_OVERLAPPEDWINDOW,      // window style       CW_USEDEFAULT,            // initial x position       CW_USEDEFAULT,            // initial y position       CW_USEDEFAULT,            // initial x size       CW_USEDEFAULT,            // initial y size       NULL,                     // parent window handle       NULL,                     // window menu handle       hInstance,                // program instance handle       NULL);                    // creation parameters     ShowWindow(hWnd, iCmdShow);    UpdateWindow(hWnd);     while(GetMessage(&msg, NULL, 0, 0)) {       TranslateMessage(&msg);       DispatchMessage(&msg);    }     GdiplusShutdown(gdiplusToken);     return 0; }  谢谢了，不过这个对我有一点太复杂了。我自己写了一个相对简单一点的，虽然不好看~~

引用 4 楼 MisaKiq 的回复:[quote=引用 2 楼 u010165006 的回复:] 比如每一个节点都有(x,y)这对坐标，把节点所表示的网络图画出来，再把最短路径用特殊颜色再画一遍。 画图最简单的，可以使用EasyX。 太感谢了，真是帮大忙了。 但是这个好像没有画箭头的函数，有向图得有箭头，请问该怎么办啊[/quote]  这个画图是比较底层的，一个点、一条线都要自己画的。 你可以写一个函数画箭头，参数包括X、Y、方向、线型、粗细、颜色等等

引用 2 楼 u010165006 的回复:比如每一个节点都有(x,y)这对坐标，把节点所表示的网络图画出来，再把最短路径用特殊颜色再画一遍。 画图最简单的，可以使用EasyX。 太感谢了，真是帮大忙了。 但是这个好像没有画箭头的函数，有向图得有箭头，请问该怎么办啊

将算法结果保存为visio可导入的文件格式是不是就显得非常“高大上”了？

在百度图片搜索中搜相关图片。


Question: 链表问题，萌新求助

楼主你都没调用过Merge函数吧？怎么打印合并后的链表啊

我蠢了，我还没调用merge函数

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

head3等于ＮＵＬＬ了，断点跟踪，学会自己调试

引用 1 楼 face_t0_sea 的回复:head3等于NULL时，ListPtr p = head3->next; 一定会出错，根据调试信息，head3等于NULL了。  void show() { ListPtr p = head3;     while (p != NULL){ printf("%s/%d\n", p->stuName, p->age); p = p->next; }  改好后确实不会报错了，但为什么不会打印出合并后的链表呢？