Question: 想问一下这个关于返回值、数组名和指针的问题

引用 6 楼 user-3 的回复:[quote=引用 3 楼 weixin_37836059 的回复:] 我写int*编译没通过，  前面声明也要改  改了还是不能过发你的编译错误信息来[/quote] 捂脸

数组名可以理解为（指针常量，指针常量不能做左值，所以数组名不能作为左值）； #include <stdio.h>  int *statistics(void);  char string[20];  int main() {     int *p;     printf("输入字符串:");     gets(string);     p = statistics();     puts("字母:\t数字:\t其他符号:\t");     printf("%d\t%d\t%d\n", *p, *(p+1), *(p+2));     system("pause");     return 0; }  int *statistics(void) {     int i;     static int stat[3];     for(i=0;string[i];i++)     {         if((string[i]>='a'&&string[i]<='z')||(string[i]>='A'&&string[i]<='Z'))             stat[0]++;         else if(string[i]>='0'&&string[i]<='9')             stat[1]++;         else             stat[2]++;     }     return stat; } 函数名定义和声明时，都需要是int *类型； 另外，gets函数不安全，建议使用fgets

引用 3 楼 weixin_37836059 的回复:我写int*编译没通过，前面的函数声明和后面的定义，两处都写

我写int*编译没通过，

引用 3 楼 weixin_37836059 的回复:我写int*编译没通过，  前面声明也要改  改了还是不能过发你的编译错误信息来

int statistics()  要改成：  int* statistics()  用 int 返回值是错的  数组类型作为返回值会退化为指针类型

应该返回指针，带星号的 返回整数有隐患


Question: 求科普 word 类型

在 Windows 开发中，大写的 WORD 等同于 unsigned short。但不代表 word 在哪都是这个意义。有的语言里 word 是 unsigned long 即 32 位整数。

VS IDE中，在不明白的符号上点鼠标右键，选转到定义。   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])();"

引用 3 楼 cfjtaishan 的回复:[quote=引用 1 楼 wang0635 的回复:] 哪有这个类型 都是 typedef的 比如 typedef    word    unsigned int; 它就跟unsigned int一样了 是不是应该这样：typedef unsigned int word;  另外，word是占两个字节[/quote] 谢谢，我写错了

引用 1 楼 wang0635 的回复:哪有这个类型 都是 typedef的 比如 typedef    word    unsigned int; 它就跟unsigned int一样了 是不是应该这样：typedef unsigned int word;  另外，word是占两个字节

一般来说 word 是 unsigned short dword 是 unsigned long


Question: 求助|c语言链表问题，请大神相助！

引用 1 楼 user-4 的回复:你每次输入新网址的时候，head都被更新到最后输入的那个网址  在输入 b 的时候，if (k != head) 不成立，故一输出不能后退  这个我在输入第二次是flag=0，不是把head跳过去了吗？能具体说清楚一点儿吗？我发现调试的时候也是head每次都会变，哪些代码需要改呢？

访问新网站，后退还有前进有没有基于哪个网站（节点），这个不明确怎么来确定前进，后退，还有新网站的正确性。 你的需求还不够晚上或者有歧义。

引用 5 楼 cutmelon 的回复:想复杂了吧，既然是链表，head一般不会变，建立起光标的概念就好了，每次分配内存应该只是一个节点，而不是你现在这样两三个的分配#include<stdio.h> #include<malloc.h>  struct Node { 	char site[500]; 	struct Node*next; 	struct Node*back; };  void free_nodes(struct Node *p) { 	struct Node *q; 	while (p!=NULL) 	{ 		q=p->next; 		free(p); 		p=q; 	} }  int main() { 	struct Node *head=NULL; 	struct Node *cursor=head; 	char c; 	bool exit=false;  	printf("请输入浏览器命令：V（访问新网站），F（前进），B（后退），X（退出）\n"); 	while (!exit) 	{ 		scanf_s("%c",&c,1); 		switch (c) 		{ 		case 'X': 		case 'x': 			exit=true; 			break; 		case 'V': 		case 'v': 			if (head==NULL) 			{ 				head=(struct Node*)malloc(sizeof(struct Node)); 				cursor=head; 				cursor->next=NULL; 				cursor->back=NULL; 			} 			else 			{ 				if (cursor->next==NULL) 				{ 					cursor->next=(struct Node*)malloc(sizeof(struct Node)); 					cursor->next->next=NULL; 					cursor->next->back=cursor; 					cursor=cursor->next; 				} 				else 				{ 					cursor=cursor->next; 					free_nodes(cursor->next); 					cursor->next=NULL; 				} 			} 			printf("请输入新的网址："); 			scanf_s("%s",cursor->site,500); 			printf("当前网址是：%s\n",cursor->site); 			break; 		case 'F': 		case 'f': 			if (cursor!=NULL&&cursor->next!=NULL) 			{ 				cursor=cursor->next; 				printf("当前网址是：%s\n",cursor->site); 			} 			else 				printf("无法前进！\n"); 			break; 		case 'B': 		case 'b': 			if (cursor!=NULL&&cursor->back!=NULL) 			{ 				cursor=cursor->back; 				printf("当前网址是：%s\n",cursor->site); 			} 			else 				printf("无法后退！\n"); 			break; 		default: 			printf("请输入正确指令！\n"); 			break; 		} 		getchar(); 	}  	free_nodes(head); } 谢谢谢谢，已解决

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

引用 3 楼 qq_36338004 的回复:[quote=引用 1 楼 user-4 的回复:] 你每次输入新网址的时候，head都被更新到最后输入的那个网址  在输入 b 的时候，if (k != head) 不成立，故一输出不能后退  这个我在输入第二次是flag=0，不是把head跳过去了吗？能具体说清楚一点儿吗？我发现调试的时候也是head每次都会变，哪些代码需要改呢？[/quote]  建议你在关键位置设置断点，然后单步跟踪程序运行，观察变形的变化情况，很容易找出原因


Question: 求助，关于一个魔方的代码出现编译错误

多谢了，成功了

int check(int n);  int main(){

前面声明是：int check();  后面实现是：int check(int n)   把前面的声明改成：int check(int n); 即可

引用 1 楼 wang0635 的回复:#include"stdio.h" #include"math.h"   int a[256][256]; int sum; int check(); <<<<<====== 这里的声明与后面的参数个数不同。后面有一个参数，这里没有 void ins(int n);    还是没有成功，不知道该怎么修改，初学C ，不是太懂


Question: int型不能用指数形式输出吗？

printf("%22.15e\n", s*1.0); 转换一下即可。

哦哦

当然了，指数输出的是实数（float或double）


Question: 一维数组赋值问题（为什么x[0]!=0）

x[i+1]和y[i+1]越界了，把循环次数变成5，这样就不越界了。 x[0] != 0是什么意思？ 浮点数等于0的判断是：  /*双精度*/ if( abs(f) <= 1e-15 )     printf("f == 0\n"); /*单精度*/ if( abs(f) <= 1e-6 )     printf("f == 0\n");  http://blog.csdn.net/gogokongyin/article/details/51105745

x[i+1],y[i+1]越界，可能导致系统把其他内存分配给了x[0]。

越界了     for(i=0;i<6;i++) {     x[0]=0.0;     y[0]=1.0; x[i+1]=x[i]+h; y[i+1]=y[i]+(h/(2+4*x[i]))*(-0.9*y[i]-0.982*0.9*y[i]/(1+2*x[i+1]));  // 这里  i== 5 时 越界了，  没有 y[6] ， y[6] 正好是指向 x[0] ,所以改的是x[0] 的值   }    x[0]=0.0;  y[0]=1.0; for(i=0;i< 5 ;i++) {          x[i+1]=x[i]+h;          y[i+1]=y[i]+(h/(2+4*x[i]))*(-0.9*y[i]-0.982*0.9*y[i]/(1+2*x[i+1]));   }

因为数组y共有6个元素，从y[0]到y[5]。y[6]在逻辑上不是合法的，给y[6]赋值时就把其他的东西改了，有可能改的就是x[0]

我的意思是x[0]=0.0;已经给他初值了，但是结果却是


Question: 操作两个有序链表合并时显示program received signal SIGSEGV,Seqmentation fault 错误

引用 7 楼 zj19941201 的回复:[quote=引用 5 楼 cfjtaishan 的回复:] #include <stdio.h> #include <stdlib.h>  typedef int ElementType; typedef struct Node *PtrToNode;  struct Node {     ElementType Data;     PtrToNode   Next; }; typedef PtrToNode List;  List create_list(void); void Print(List L); List Merge(List L1, List L2);  int main(void) {     List L1, L2, L;      L1 = create_list();     L2 = create_list();     Print(L1);     Print(L2);      L = Merge(L1, L2);     Print(L);     return 0; }   List create_list(void) {     List phead, pcur, pnew;     int a, i = 0;      phead = (List)malloc(sizeof(struct Node));     if (!phead) {         fprintf(stderr, "malloc error!\n");         exit(1);     }     phead->Next = NULL;     pcur = phead;     scanf("%d", &a);      for(i = 0; i < a; i++) {         pnew = (List)malloc(sizeof(struct Node));         if (!pnew) {         fprintf(stderr, "malloc error!\n");         exit(1);         }         scanf("%d", &(pnew->Data));         pcur->Next = pnew;         pcur = pcur->Next;     }     pcur->Next = NULL;      return phead; }  /* 拆除L1,L2,合并成L3*/ List Merge( List L1, List L2 ) {     List L3, q, p, s, t;      L3 = (List)malloc(sizeof(struct Node));     if (!L3) {         fprintf(stderr, "malloc error!\n");         exit(1);     }     L3->Next = NULL;      q = L1->Next;     p = L2->Next;     s = L3;       while (p && q) {         if (p->Data >= q->Data) {            t = q->Next;            s->Next = q;            s = q;            q = t;         } else {            t = p->Next;            s->Next = p;            s = p;            p = t;         }     }     /*L2链表剩余的节点*/     while (p) {         t = p->Next;         s->Next = p;         s = p;         p = t;     }      /*L1链表剩余的节点*/     while (q) {         t = q->Next;         s->Next = q;         s = q;         q = t;     }      return L3; }  void Print(List L) {     List p = L->Next;      while (p) {             printf("%d ", p->Data);             p = p->Next;     }     putchar(10); }  最后的putchar（10）是干嘛用？ [/quote] 回车符，ASCII码值是10

引用 5 楼 cfjtaishan 的回复:#include <stdio.h> #include <stdlib.h>  typedef int ElementType; typedef struct Node *PtrToNode;  struct Node {     ElementType Data;     PtrToNode   Next; }; typedef PtrToNode List;  List create_list(void); void Print(List L); List Merge(List L1, List L2);  int main(void) {     List L1, L2, L;      L1 = create_list();     L2 = create_list();     Print(L1);     Print(L2);      L = Merge(L1, L2);     Print(L);     return 0; }   List create_list(void) {     List phead, pcur, pnew;     int a, i = 0;      phead = (List)malloc(sizeof(struct Node));     if (!phead) {         fprintf(stderr, "malloc error!\n");         exit(1);     }     phead->Next = NULL;     pcur = phead;     scanf("%d", &a);      for(i = 0; i < a; i++) {         pnew = (List)malloc(sizeof(struct Node));         if (!pnew) {         fprintf(stderr, "malloc error!\n");         exit(1);         }         scanf("%d", &(pnew->Data));         pcur->Next = pnew;         pcur = pcur->Next;     }     pcur->Next = NULL;      return phead; }  /* 拆除L1,L2,合并成L3*/ List Merge( List L1, List L2 ) {     List L3, q, p, s, t;      L3 = (List)malloc(sizeof(struct Node));     if (!L3) {         fprintf(stderr, "malloc error!\n");         exit(1);     }     L3->Next = NULL;      q = L1->Next;     p = L2->Next;     s = L3;       while (p && q) {         if (p->Data >= q->Data) {            t = q->Next;            s->Next = q;            s = q;            q = t;         } else {            t = p->Next;            s->Next = p;            s = p;            p = t;         }     }     /*L2链表剩余的节点*/     while (p) {         t = p->Next;         s->Next = p;         s = p;         p = t;     }      /*L1链表剩余的节点*/     while (q) {         t = q->Next;         s->Next = q;         s = q;         q = t;     }      return L3; }  void Print(List L) {     List p = L->Next;      while (p) {             printf("%d ", p->Data);             p = p->Next;     }     putchar(10); }  最后的putchar（10）是干嘛用？

最后的putchar（10）是干嘛用？

引用 3 楼 zhao4zhong1 的回复:进程意外退出会在当前目录下产生‘core’文件或形如‘core.数字’的文件比如‘core.1234’ 使用命令 gdb 运行程序名 core或core.数字 进入gdb然后使用bt命令 可以查看进程意外退出前函数调用的堆栈，内容为从上到下列出对应从里层到外层的函数调用历史。 如果进程意外退出不产生core文件，参考“ulimit -c core文件最大块大小”命令  百度搜“合并两个有序链表” 如何实现类似于GPU-Z可以获取集显GPU使用率信息的功能？？大神

是不是还少一个指针去遍历链表啊？

程序中还有应该其他错误的地方，还请大神指点


Question: C中函数指针问题 求大神指教

引用 4 楼 HHfight 的回复:[quote=引用 楼主 HHfight 的回复:] /* 邻接表存储的图 - DFS */   void Visit( Vertex V ) {     printf("正在访问顶点%d\n", V); }   /* Visited[]为全局变量，已经初始化为false */ void DFS( LGraph Graph, Vertex V, void (*Visit)(Vertex) ) {   /* 以V为出发点对邻接表存储的图Graph进行DFS搜索 */     PtrToAdjVNode W;           Visit( V ); /* 访问第V个顶点 */     Visited[V] = true; /* 标记V已访问 */       for( W=Graph->G[V].FirstEdge; W; W=W->Next ) /* 对V的每个邻接点W->AdjV */         if ( !Visited[W->AdjV] )    /* 若W->AdjV未被访问 */             DFS( Graph, W->AdjV, Visit );    /* 则递归访问之 */ } 为何要把visit当参数传入？ 但感觉不用函数指针对代码也没什么影响吧？[/quote] 谢谢呀

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

引用 楼主 HHfight 的回复:/* 邻接表存储的图 - DFS */   void Visit( Vertex V ) {     printf("正在访问顶点%d\n", V); }   /* Visited[]为全局变量，已经初始化为false */ void DFS( LGraph Graph, Vertex V, void (*Visit)(Vertex) ) {   /* 以V为出发点对邻接表存储的图Graph进行DFS搜索 */     PtrToAdjVNode W;           Visit( V ); /* 访问第V个顶点 */     Visited[V] = true; /* 标记V已访问 */       for( W=Graph->G[V].FirstEdge; W; W=W->Next ) /* 对V的每个邻接点W->AdjV */         if ( !Visited[W->AdjV] )    /* 若W->AdjV未被访问 */             DFS( Graph, W->AdjV, Visit );    /* 则递归访问之 */ } 为何要把visit当参数传入？ 但感觉不用函数指针对代码也没什么影响吧？

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

VS IDE中，在不明白的符号上点鼠标右键，选转到定义或查找所有引用。

这个地方类似函数调用； 函数指针是表示一类函数的指针


Question: C语言实践

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

百度搜相关关键字。


Question: Linux下关于文件操作出现乱码的问题

对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%08x -",i+addr);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             printf("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         printf("%s\n",binstr);     } }  //iconv_linux下字符集编码转换轻松实现 (1) iconv_t iconv_open(const char *tocode, const char *fromcode); //此函数说明将要进行哪两种编码的转换,tocode是目标编码,fromcode是原编码,该函数返回一个转换句柄,供以下两个函数使用。 (2) size_t iconv(iconv_t cd,char **inbuf,size_t *inbytesleft,char **outbuf,size_t *outbytesleft); //此函数从inbuf中读取字符,转换后输出到outbuf中,inbytesleft用以记录还未转换的字符数,outbytesleft用以记录输出缓冲的剩余空间。 (3) int iconv_close(iconv_t cd); //此函数用于关闭转换句柄,释放资源。  //例子1: 用C语言实现的转换示例程序  /* f.c : 代码转换示例C程序 */ #include <iconv.h> #define OUTLEN 255 main() { char *in_utf8 = "姝ｅ?ㄥ??瑁?"; char *in_gb2312 = "正在安装"; char out[OUTLEN];  /*unicode码转为gb2312码*/ rc = u2g(in_utf8,strlen(in_utf8),out,OUTLEN); printf("unicode-->gb2312 out=%sn",out); //gb2312码转为unicode码  rc = g2u(in_gb2312,strlen(in_gb2312),out,OUTLEN); printf("gb2312-->unicode out=%sn",out); } /*代码转换:从一种编码转为另一种编码*/ int code_convert(char *from_charset,char *to_charset,char *inbuf,int inlen,char *outbuf,int outlen) { iconv_t cd; int rc; char **pin = &inbuf; char **pout = &outbuf;  cd = iconv_open(to_charset,from_charset); if (cd==0) return -1; memset(outbuf,0,outlen); if (iconv(cd,pin,&inlen,pout,&outlen)==-1) return -1; iconv_close(cd); return 0; } /*UNICODE码转为GB2312码*/ int u2g(char *inbuf,int inlen,char *outbuf,int outlen) { return code_convert("utf-8","gb2312",inbuf,inlen,outbuf,outlen); } /*GB2312码转为UNICODE码*/ int g2u(char *inbuf,size_t inlen,char *outbuf,size_t outlen) { return code_convert("gb2312","utf-8",inbuf,inlen,outbuf,outlen); }  //例子2: 用C++语言实现的转换示例程序  /* f.cpp : 代码转换示例C++程序 */ #include <iconv.h> #include <iostream>  #define OUTLEN 255  using namespace std;  // 代码转换操作类  class CodeConverter {  private: iconv_t cd; public:  // 构造 CodeConverter(const char *from_charset,const char *to_charset) { cd = iconv_open(to_charset,from_charset); }   // 析构 ~CodeConverter() { iconv_close(cd); }   // 转换输出 int convert(char *inbuf,int inlen,char *outbuf,int outlen) { char **pin = &inbuf; char **pout = &outbuf;  memset(outbuf,0,outlen); return iconv(cd,pin,(size_t *)&inlen,pout,(size_t *)&outlen); } };  int main(int argc, char **argv) { char *in_utf8 = "姝ｅ?ㄥ??瑁?"; char *in_gb2312 = "正在安装"; char out[OUTLEN];  // utf-8-->gb2312 CodeConverter cc = CodeConverter("utf-8","gb2312"); cc.convert(in_utf8,strlen(in_utf8),out,OUTLEN); cout << "utf-8-->gb2312 in=" << in_utf8 << ",out=" << out << endl;  // gb2312-->utf-8 CodeConverter cc2 = CodeConverter("gb2312","utf-8"); cc2.convert(in_gb2312,strlen(in_gb2312),out,OUTLEN); cout << "gb2312-->utf-8 in=" << in_gb2312 << ",out=" << out << endl; }    二、利用iconv命令进行编码转换  iconv命令用于转换指定文件的编码,默认输出到标准输出设备,亦可指定输出文件。  用法： iconv [选项...] [文件...]  有如下选项可用:  输入/输出格式规范： -f, --from-code=名称 原始文本编码 -t, --to-code=名称 输出编码  信息： -l, --list 列举所有已知的字符集  输出控制： -c 从输出中忽略无效的字符 -o, --output=FILE 输出文件 -s, --silent 关闭警告 --verbose 打印进度信息  -?, --help 给出该系统求助列表 --usage 给出简要的用法信息 -V, --version 打印程序版本号  例子: iconv -f utf-8 -t gb2312 aaa.txt >bbb.txt 这个命令读取aaa.txt文件，从utf-8编码转换为gb2312编码,其输出定向到bbb.txt文件。  小结: Linux为我们提供了强大的编码转换工具,给我们带来了方便。

抱歉，图片传不上去，大概是出现了一个类似问号?的乱码

#include <sys/types.h> #include <sys/stat.h> #include <stdio.h> #include <string.h> #include <stdlib.h> #include <errno.h> #include <unistd.h> #include <fcntl.h> #include <pthread.h> #include <semaphore.h>  #define infile "infile.dat" #define outfile "outfile.dat"  sem_t f1; sem_t f2;  void inputdata() {     int infd;     char buf[50];      if ((infd = open(infile, O_WRONLY | O_TRUNC | O_CREAT, 10700)) == -1)     {         printf("ERROR, OPEN READ FILE FAILED:%s \n", sys_errlist[errno]);         //printf("ERROR, OPEN READ FILE FAILED:%s \n", strerror(errno));         exit(255);     }      printf("Please enter the data:\n");     printf("(Ctrl+D ---- quit)\n");      while(fgets(buf, sizeof(buf), stdin))     {         if (write(infd, buf, strlen(buf)) != strlen(buf)) {             printf("ERROR, WRITE FILE FAILED:%s \n", sys_errlist[errno]);             //printf("ERROR, WRITE FILE FAILED:%s \n", strerror(errno));             exit(255);         }     }     close(infd);      sem_post(&f1); }  void copydata() {     sem_wait(&f1);      int infd, outfd;     char buf[50];      if ((infd = open(infile, O_RDONLY))==-1)     {         printf("ERROR, OPEN READ FILE FAILED:%s \n", sys_errlist[errno]);         //printf("ERROR, OPEN READ FILE FAILED:%s \n", strerror(errno));         exit(255);     }      if ((outfd = open(outfile, O_WRONLY | O_TRUNC | O_CREAT, 10700))==-1)     {         printf("ERROR, OPEN WRITE FILE FAILED:%s \n", sys_errlist[errno]);         //printf("ERROR, OPEN WRITE FILE FAILED:%s \n", strerror(errno));         exit(255);     }      int count;      while((count = read(infd, buf, sizeof(buf))) > 0)     {         if (count != write(outfd, buf, count))         {             printf("ERROR, WRITE FILE FAILED:%s \n", sys_errlist[errno]);             //printf("ERROR, WRITE FILE FAILED:%s \n", strerror(errno));             exit(255);         }     }      close(infd);     close(outfd);      sem_post(&f2); }   void showdata() {     sem_wait(&f2);      int outfd;     char buf[50];      if ((outfd = open(outfile, O_RDONLY, 10700))==-1)     {         printf("ERROR, OPEN WRITE FILE FAILED:%s \n", sys_errlist[errno]);         //printf("ERROR, OPEN WRITE FILE FAILED:%s \n", strerror(errno));         exit(255);     }      int count;      printf("\nThe data in the file:\n");      memset(buf, 0, sizeof(buf));    /*初始化缓存为0*/     while((count = read(outfd, buf, sizeof(buf) - 1)) > 0)    /*防止读到的数据是50个字符，最后一个字符用于字符串结束标记 '\0' */     {         printf("count = %d\n", count);         printf("%s", buf);         memset(buf, 0, sizeof(buf));    /*初始化缓存为0*/     }      close(outfd); }  int main(void) {     pthread_t t1,t2,t3,t4;     sem_init(&f1,0,0);     sem_init(&f2,0,0);      pthread_create(&t1,NULL, (void *)showdata, NULL);     pthread_create(&t2,NULL, (void *)copydata, NULL);     pthread_create(&t3,NULL, (void *)inputdata, NULL);      pthread_join(t1,NULL);      return 0; } 出现乱码，是字符串没有找到'\0',即字符串结束标记；需要对缓存在读之前做初始化操作（初始化为0， 0 值等于'\0')，另一个方面，若文件中的字符大于缓存长度，所以每次读取都最大读取缓存长度减1。


Question: reverse words in a string

可以啊，你输入的时候这样写，hello空格world空格

if(a[i]=='\0') break;  这一句有问题 遇到字符串尾不应该直接跳出循环 而是应该检查结束前是否存在最后一个单词  并反转它  否则最后一个单次是无法输出的

谢谢楼上，我已经改好了。只是自己的代码不会提交到leetcode上，第一次用。只有一个char* reverseWords(char* s)函数，该怎么改呢？

通过运用这个回车符，可以将最后一个单词反转

#include<stdio.h> #include<string.h>  int main() {     char a[128];      fgets(a, 128, stdin);     int l = strlen(a);     char b[l];     int i,j,c=-1,d=0;      for(i = 0; i < l; i++)     {         if(a[i] == '\0')             break;         c++;         if(a[i] == ' ' || a[i] == '\n') {             for(j = 0; j < c; j++) {                 b[d + j] = a[i-1-j];             }             d = d + c;             b[d++] = ' ';             c = -1;         }     }     printf("%s",b);      return 0; }  之所以只对第一个单词反转，因为第二个单词后面没有空格，因为你的程序里只有遇到了空格才会反转；所以，在输入时注意在最后一个单词后面加空格； 考虑gets不安全，我用fgets代替，但fgets在最后会有一个回车符加入到缓存（当输入的数据少于字符数组长度时）

你应该最后再判断是否为\0，这样改：   #include<stdio.h> #include<string.h> int main() { 	char a[1000]; 	gets(a); 	int l=strlen(a); 	char b[l]; 	int i,m,c=-1,d=0; 	for(i=0;i<100;i++) 	{ 		c++; 		if(a[i]==' ' || a[i]=='\0') 		{ 			for(m=0;m<c;m++) 			{ 				b[d+m]=a[i-1-m]; 			} 			d=d+c; 			b[d++]=' '; 			c=-1; 			if(a[i]=='\0') 				break; 		} 	} 	printf("%s",b);  	return 0; }


Question: 指针问题

#include <stdio.h> #include <stdlib.h>  char *stract(char *s,char *t);  int main() {     char *s;     char *t;      s = (char *)malloc(sizeof(char) * 64);     if (!s) {         fprintf(stderr, "malloc error!\n");         exit(-1);     }     t = (char *)malloc(sizeof(char) * 32);     if (!t) {         fprintf(stderr, "malloc error!\n");         exit(-1);     }      printf("please input character S：");     scanf("%s", s);     printf("please input character t:");     scanf("%s", t);     printf("%s\n", stract(s, t));     puts(s);      free(s);     free(t);     return 0; }  char *stract(char *s, char *t) {     char *tmp = s;     while (*s)    /* '\0' is equal 0 */         s++;      while(*s++ = *t++)         ;      return tmp; } 在堆上申请空间，并释放。程序问题主要是： 1. 重定义指针，需要给野指针赋值一个可用的内存空间； 2. 自定义函数没有返回值（void），那么就没有返回值。

引用 2 楼 user-3 的回复: char stract(char *s,char *t) {     while(s != '\0'){         s++;     }     while(*s++ == *t++){         ;     }     return s; } 函数要有返回值，因为main函数中用到了 注意指针s最后指向了那？是不是先要保存一下s的地址，然后返回s传进来的初始地址？另外，返回值也应该是指针。看来直接把程序写出来，没测试吧。

这样改吧：   #include<stdio.h> void stract(char *s,char *t);  int main() { 	char s[100]; 	char t[100]; 	printf("please input character S："); 	scanf("%s", s); 	printf("please input character t:"); 	scanf("%s", t); 	stract(s,t); 	printf("%s",s); 	return 0; }  void stract(char *s,char *t) { 	while(s != '\0'){ 		s++; 	} 	while(*s++ == *t++){ 		; 	} }

int main() {     char s[100];     char t[100];     printf("please input character S：");     scanf("%s", s);     printf("please input character t:");     scanf("%s", t);     printf("%s",stract(s,t));     return 0; } 必须有字符串的存储空间


Question: EOF的问题

引用 5 楼 to_flydream 的回复:我还是有点不清楚，你说的这个我知道。可是为什么这个程序不写！=EOF会超时？？这是什么道理 说明使用末尾多了一个换行回车的数据作为输入测试你的程序。

引用 3 楼 to_flydream 的回复:[code=c ]#include <stdio.h> #include <string.h> int number[30]; int reserve[30]; int prime[40]={0,0,1,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,1, 0,1,0,0,0,0,0,1,0,0}; void print(int n) { 	printf("1"); 	for(int i=2;i<=n;i++) 	{ 		printf(" %d",reserve[i]); 	} 	printf("\n"); 	return; } void dfs(int num,int n) { 	if(num==n) 	{ 		if(prime[reserve[num]+1]) 		{  			print(n); 			return;  		} 		else 		{ 			return ; 		} 	} 	for(int i=2;i<=n;i++) 	{ 		if(prime[i+reserve[num]]) 		{ 			if(!number[i]) 			{ 				number[i]=1; 				reserve[num+1]=i; 				dfs(num+1,n); 				number[i]=0; 			} 		} 	}  } int main() { 	int c=0; 	int n; 	reserve[1]=1; 	while(scanf("%d",&n)!=EOF) 	{ 		c++; 		memset(number,0,sizeof(number)); 		reserve[0]=1; 		printf("Case %d:\n",c); 		if(n%2==0) 		{ 			dfs(1,n); 		}	 		printf("\n"); 	} 	return 0; } [/code]    这是杭电oj的1016素数环的题目，如果不写！=EOF的话就会超时，写了的话就ac了 EOF这儿是需要键盘输入ctrl +d或者ctrl+z，windows和Linux会有不同

提前确定了数据长度就不用判断EOF

EOF是文件结束标识，在读文件时会用到。建议把你的使用需求和背景说一下吧


Question: 用过Matlab MEX的，编译时出现了一个错误，需求帮助

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

非常感谢赵老师的回复，我根据你给的建议，用源文件和头文件生成了所需的LIb库，成功完成了编译，万分感谢陈老师！


Question: 编译的时候提示头文件中 syntax error before numeric constant

先不说头文件的问题，看到这个函数的参数个数，是目前我看到最多的一个。数了数16个形参，参数建议不要超过5个。如果多余5个，建议使用结构体了。 其他问题，贴出代码吧

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

仅此一点，看不出来


Question: 字符串中字符倒叙排列，麻烦各位帮我看下

程序片段较多不要放贴图，直接用代码的功能（帖子编辑菜单栏倒数第6个图标）

引用 3 楼 cfjtaishan 的回复:#include <stdio.h> #include <string.h>  void convert(char *str, int len); void convert2(char *str, int len);  int main( void ) {     char str[32] = "Hello world";      convert(str, strlen(str));     //convert2(str, strlen(str));     puts(str);      return 0; }  void convert(char *str, int len) {     int i;     int tmp;      for (i = 0; i < len / 2; i++) {         tmp = str[i];         str[i] = str[len - 1 - i];         str[len - 1 - i] = tmp;     } } void convert2(char *str, int len) {     int i, j;     int tmp;      for (i = 0, j = len - 1; i < j; i++, j--) {         tmp = str[i];         str[i] = str[j];         str[j] = tmp;     } } 倒序输出，两种实现方式，其实是类似的。 谢谢，在百忙之中抽空帮我解答问题。

引用 2 楼 wang0635 的回复:for循环中 for (i = 0; i < (n / 2); i++) n随着循环体中的--n而变化了 可以改成  int    cnt = n / 2; for (i = 0; i < cnt; i++)  十分感谢，我明白我哪里想错了。

引用 1 楼 jianwen0529 的回复:程序片段较多不要放贴图，直接用代码的功能（帖子编辑菜单栏倒数第6个图标）谢谢第一次发帖。买了一本C Primer Plus，还在努力的啃。


Question: AddConsoleAlias

引用 5 楼 user-1的回复:不可能的啊，我试了是可以的。提示的是 test 还是 e:\test.exe 不是.... ？更可能是后者吧，你没把 test.exe 放到 E:\ 下？ 第三个参数指定为NULL之后返回了FALSE... 大佬加我QQ：1766087360，我发截图给你

引用 3 楼 qq_38052375的回复:[quote=引用 1 楼 user-1的回复:]BOOL flag=AddConsoleAlias(TEXT("test"), TEXT("E:\\test.exe"), NULL); 这样吧，如果是要在 a.exe 里调用 test.exe 的话。 也看了网上的些例子，拿个 cd 命令来说事，所以第三个参数需要是 cmd.exe，毕竟 cd 只是 cmd.exe 里的个子命令，不是个独立的可执行程序。 也不是不能....[/quote] 'test’不是内部或外部命令,也不是可运行程序或批处理文件

引用 1 楼 user-1的回复:BOOL flag=AddConsoleAlias(TEXT("test"), TEXT("E:\\test.exe"), NULL); 这样吧，如果是要在 a.exe 里调用 test.exe 的话。 也看了网上的些例子，拿个 cd 命令来说事，所以第三个参数需要是 cmd.exe，毕竟 cd 只是 cmd.exe 里的个子命令，不是个独立的可执行程序。 也不是不能....

引用 1 楼 user-1的回复:BOOL flag=AddConsoleAlias(TEXT("test"), TEXT("E:\\test.exe"), NULL); 这样吧，如果是要在 a.exe 里调用 test.exe 的话。 也看了网上的些例子，拿个 cd 命令来说事，所以第三个参数需要是 cmd.exe，毕竟 cd 只是 cmd.exe 里的个子命令，不是个独立的可执行程序。 真好，有人来回复了，感谢感谢


Question: 求大神指教！！！vigenere密码程序无法输出结果

#include<stdlib.h> #include<stdio.h> #include<string.h>  void Encry() {     char key[100];     char ch, temp;     int L, i = 0, j = 0;     if (getchar() == '\n')         temp = ' ';     printf("请输入密钥:");     gets_s(key,100);     //gets(key);     L = strlen(key);      printf("请输入明文:");      while ((ch = getchar()) != '\n')     {         if (ch == ' ')         {             i++;             continue;         }         if (ch >= 'a'&&ch <= 'z')         {             printf("%c", (ch + key[j%L] - 'a' - 'a') % 26 + 'A');             j++;         }         if (ch >= 'A'&&ch <= 'Z')         {             printf("%c", (ch + key[j%L] - 'a' - 'A') % 26 + 'A');             j++;         }         if (j%L == 0)             printf(" ");         i++;     }     putchar(ch); }  void Decry() {     char key[100];     char ch, temp;     int L, i = 0, j = 0;     if (getchar() == '\n')         temp = ' ';     printf("请输入密钥:");     gets_s(key,100);     //gets(key);     L = strlen(key);      printf("请输入密文:");      while ((ch = getchar())!= '\n')     {         if (ch == ' ')    /*此处不是赋值，而是判断 == */         {             i++;             continue;         }         if (ch >= 'A'&&ch <= 'Z')         {             printf("%c", (ch - key[j%L] - 'A' + 'a' + 26) % 26 + 'a');             j++;         }         if (j%L == 0)             printf("");         i++;     }     putchar(ch); }  int Exit() {     exit(0); }  int main() {     char ch;     for (;;)     {         printf("请输入操作  e:加密 d:解密 q:退出 ");         ch = getchar();         if (ch == 'e' || ch == 'E')             Encry();         else if (ch == 'd' || ch == 'D')             Decry();         else if (ch == 'q' || ch == 'Q')             Exit();         else         {             printf("输入命令错误");             putchar(getchar());             continue;         }     }     return 0; } 有一处问题，比较容易出错误。详见代码注释；

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


Question: c语言读txt文件 fread函数读 ，有部分数据乱码？？？

推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。

推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。  不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了

#include <stdio.h>  int main() {     int i;     int src[60016];      FILE *fp = fopen("1_new.txt","r");     if (!fp) {         printf("can't open 1_new.txt\n");     }      for(i = 0; i < 60016; i++) {         fread(&src[i], 4, 1, fp);    /*每个数据4个字节*/         printf("%u\n", src[i]);     }      return 0; }

引用 楼主 m0_37789286 的回复:各位路过的大神请帮忙解答一下，感激不尽！ 一个文件txt类型  里面存的是图像数据  在windows下打开就是乱码的，但是matlab用函数可以将其读出来。现在我将这个文件在linux系统中用c语言的fread读，一个一个的读出来  结果在最后的600多个数就开始不对了，输出的的数值很大 感觉像是输出的内存地址，还望明白的大神指点一下 #include<stdio.h> int main() {  int a,i;     int src[60016];        FILE *fp=fopen("1_new.txt","r");    if(!fp)      {        printf("can't open 1_new.txt\n");      }     for(i=0;i<60016;i++)     {       fread(&src[i],2,1,fp);       printf("%u\n",src[i]);       } }  这是输出的部分数据：       128 30 56 204 1835598096 1600061710 1869807754 1952776232 132 210 4194517 145 27 64 241 308 4194536 83 4194329 154 而应该输出的是： 128 30 56 204 272 270 138 40 132 210 213 145 27 64 241 308 232 83 25 154 而且用fscanf读根本就读不出来  不知道为什么。。 之前用的fscanf读出错 怎么改都不对  我才用的fread读的 fread读前面都是对的只有后面不对呢   这数据虽然放在txt里但是打开它是乱码的 所以我也不知道具体应该用什么读

引用 7 楼 cfjtaishan 的回复:[quote=引用 6 楼 m0_37789286 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 使用fread读，那么该文件是用fwrite写入的吗？ 如果文件是有格式的，建议使用fscanf/fprintf进行读写； 如果是二进制的读写，建议使用fread/fwrite 如果是按行的建议使用fgets/fputs 把你的文件格式截取片段看一下～ 最愁的就是那个文件的类型，他是被装到txt里   windows用记事本打开就是乱码的 但是matlab里用fread函数可以打开   然后 linux下打开直接有不可读字符  打开错误了呢  今天问了一下说应该是二进制   不是用fwrite写的  就是给了我一个txt 文件   [/quote] 里面的数据是什么？一个一个整数吗？[/quote] 我希望将他们读成一个一个整数16位的   file:///home/yujiaxin/%E6%A1%8C%E9%9D%A2/2017-04-12%2014-35-35%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE.png

引用 6 楼 m0_37789286 的回复:[quote=引用 3 楼 cfjtaishan 的回复:] 使用fread读，那么该文件是用fwrite写入的吗？ 如果文件是有格式的，建议使用fscanf/fprintf进行读写； 如果是二进制的读写，建议使用fread/fwrite 如果是按行的建议使用fgets/fputs 把你的文件格式截取片段看一下～ 最愁的就是那个文件的类型，他是被装到txt里   windows用记事本打开就是乱码的 但是matlab里用fread函数可以打开   然后 linux下打开直接有不可读字符  打开错误了呢  今天问了一下说应该是二进制   不是用fwrite写的  就是给了我一个txt 文件   [/quote] 里面的数据是什么？一个一个整数吗？

引用 3 楼 cfjtaishan 的回复:使用fread读，那么该文件是用fwrite写入的吗？ 如果文件是有格式的，建议使用fscanf/fprintf进行读写； 如果是二进制的读写，建议使用fread/fwrite 如果是按行的建议使用fgets/fputs 把你的文件格式截取片段看一下～ 最愁的就是那个文件的类型，他是被装到txt里   windows用记事本打开就是乱码的 但是matlab里用fread函数可以打开   然后 linux下打开直接有不可读字符  打开错误了呢  今天问了一下说应该是二进制   不是用fwrite写的  就是给了我一个txt 文件

txt类型文件你按二进制文件读肯定不对


Question: json_object_add()后的json_object对象怎么没有随父对象的释放而释放

引用 3 楼 zhao4zhong1 的回复:new、delete 对应 借、还 而不对应 创建、销毁。 赵老师，您的意思是，new_field内存可以访问，但是最后的访问不太安全，对吗？

new、delete 对应 借、还 而不对应 创建、销毁。

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

引用 4 楼 u013910218 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] new、delete 对应 借、还 而不对应 创建、销毁。 赵老师，您的意思是，new_field内存可以访问，但是最后的访问不太安全，对吗？[/quote] 谢谢老师，分数稍后就给！

你过去租住过的房子合同到期已经退租了，你现在拿着过去的钥匙开门进去，接下来会发生什么呢？

自己顶一下。大神们来帮忙啊


Question: 大哥来看看

引用 5 楼 yi19861209 的回复:我不会才问 我的意思是别用数组作为函数参数和返回值。

引用 1 楼 zhao4zhong1 的回复:请那些喜欢将数组作为函数参数传来传去或作为函数返回值的码农思考一下为什么不把整个互联网内容当作函数参数传来传去或作为函数返回值呢？ 赵4老师又调皮了

我不会才问

float (*n)[]  改成：  float (*n)[5]  不能省略   #include<stdio.h> int main() { 	float ty(float (*n)[5]); 	float a[4][5]={{79,77,56,43,86},{47,87,99,75,45},{43,76,23,54,76},{86,90,85,99    }}; 	float (*p)[5],k;                                                   //(*p)[5]这里为什么不是“(*p)[4]”，a[4][5]不是4行吗？ 	p=a; 	k=ty(p); 	printf("%f\n",k); 	return 0; }  float ty(float (*n)[5]) { 	int i; 	float h; 	for(i=0;i<4;i++) 	{ 		printf("* %f\n",*(*(n+i)+0)); 		h=h+*(*(n+i)+0);                       //19:6: 错误：对未指定边界的数组的使用无效 	}   	h=h/5; 	return h; }

#include<stdio.h>   float ty(float (*n)[5]); int main(void) {     float a[4][5] = {         {79,77,56,43,86},         {47,87,99,75,45},         {43,76,23,54,76},         {86,90,85,99 }     };     float (*p)[5], k;     p = a;     k = ty(p);     printf("%f\n", k);     return 0; } float ty(float (*n)[5]) {     int i;     float h = 0.0;      for(i = 0; i < 4; i++) {         printf("* %f\n", *(*(n+i)+0));         printf("* %f\n", n[i][0]);         h = h + *(*(n+i)+0);     }     h = h / 5;      return h; } 参数是二维数组的传参，需要将形参的列数告知，不然对于一个数组其不知道应该分配多少列数据。列数可以不确定。 float (*p)[5]; 这个5是列数，即这个是一个数组指针，指向一个列数为5个数组指针。概念上和指针数组容易混淆（int *p[5]) ty函数里，h为初始化，那么它是一个随机值。 注意代码风格～


Question: 求解分段函数问题

代码风格很关键。

#include<stdio.h> main() { int x,y; scanf("%d",&x); if (x>0) { y=2*x+1; printf("y=%d",y); } else  if (x<0) { y=-x-1; printf("y=%d",y); } else { y=0; printf("y=0"); } }

#include<stdio.h>  int main(void) {     int x,y;      scanf("%d",&x);      if (x > 0) {         y = 2 * x + 1;         printf("y = %d\n",y);     } else if (x < 0){         y = -x - 1;         printf("y = %d\n", y);     } else {         y=0;         printf("y = %d\n", y);     }      return 0; }   原因是缺少括号，没有将y = 0;和输出y的值放在同一判断条件里。 以上是修改后的代码，注意代码风格；

没有啊，是你最后的：printf("y=0"); 这句输出的0


Question: 关于三角形求面积的问题

你的问题是程序的警告你不明白，还是三角形的计算你不明白

sqrt返回值类型是double，S类型是float，所以有警告。 因为可能造成有效数字位数的减少，也不能忽略它。 如果确定用不着那么多的有效数字，那就强制转换，S = (float)sqrt(....); 否则，S直接声明为double类型。

warning 而已啊


Question: 求解

你是不懂程序，还是三角形相关的计算方法

输入：  123 回车   456 回车    433 回车


Question: 求助各位大佬，有关于xbmc播放器源码编译问题~~（C++）

https://sourceforge.net/projects/boost/files/boost/1.63.0/ 下载文件boost_1_63_0.7z，使用好压软件解压到C:\ 有shared_ptr.hpp文件： C:\boost_1_63_0\boost\shared_ptr.hpp

引用 11 楼 zhao4zhong1 的回复:也许是因为你安装的不是boost源代码而是boost二进制包。 老师，我这个boost库是从网上下载下来的，所以不太清楚究竟是什么情况，什么状态的包包，我这个项目也是从网上下来的开源项目，出现配置的问题再正常不过了，所以才想跟您讨要解决的办法，虽然问题没什么进展，但是也是真的感谢您的热心帮助

也许是因为你安装的不是boost源代码而是boost二进制包。

引用 8 楼 zhao4zhong1 的回复:比如你将boost安装到 C:\boost_1_38_0文件夹下 shared_ptr.hpp文件的绝对路径： C:\boost_1_38_0\boost\shared_ptr.hpp 设置 项目、属性、C/C++、附加包含目录：填写附加头文件所在目录 分号间隔多项 为 原来内容;C:\boost_1_38_0 或 原来内容;C:\boost_1_38_0\您好老师，十分感谢您的回帖，根据您的提醒以及指导，我按照并且执行后，错误仍然存在，已经打扰您很多宝贵的时间，所以不好意思再多加打扰，万分感谢您对我的帮助，结贴

引用 5 楼 zhao4zhong1 的回复:项目、属性、C/C++、附加包含目录：填写附加头文件所在目录 分号间隔多项 项目、属性、链接器、常规、附加库目录：填写附加依赖库所在目录 分号间隔多项 项目、属性、链接器、输入、附加依赖项：填写附加依赖库的名字.lib 空格或分号间隔多项 by the way，我在项目中已经搜索过了，确实不存在shared_prt.hpp文件，所以仍一头雾水

引用 5 楼 zhao4zhong1 的回复:项目、属性、C/C++、附加包含目录：填写附加头文件所在目录 分号间隔多项 项目、属性、链接器、常规、附加库目录：填写附加依赖库所在目录 分号间隔多项 项目、属性、链接器、输入、附加依赖项：填写附加依赖库的名字.lib 空格或分号间隔多项  十分感谢老师耐心的解答，本人小白一个，问的比较粗显，希望您能多担待，看到了您的答案，理解是肯定理解的，操作的步骤也都清楚，但是由于这个不是自己的项目，是一个下载的开源项目，所以对有关头文件以及附加库的所在目录都不是特别清楚，如果您能够在百忙之中抽出时间，更加细微的指导小生一二，小生将不胜感激，分值肯定是给您了，多谢

引用 2 楼 zhao4zhong1 的回复:安装boost大佬，我试过了，去网上新下载了一个boot库，并且也按照网上的知道进行路径设置，但是还是出现相同的错误 请大神费心指导一下~

引用 2 楼 zhao4zhong1 的回复:安装boost好的~~我先来试一下，谢谢您咯~

安装boost

大佬们快来哦~~~大佬们快来哦~~~~~~


Question: C语言里面对二维数组的初始化

http://edu.csdn.net/course/detail/2516 C语言指针与汇编内存地址-三.数组和二维数组

初始化赋值后，数组中其他的数会被赋值为0，如果是循环每个赋值的时候只是改变当前数组值。

int a[10][10]={{1},{1},{1},{1},{1},{1},{1},{1},{1},{1}}; //每行第一个元素初始化为1，其余为0 for(i=0;i<10;i++)  {  a[i][0]=1;  a[i][i]=1;  } //每行第一个元素和最后一个元素初始化为1，其余为未初始化，为随机的垃圾值

void YH() { 	int a[10][10]; 	int i,j,k; 	for(i=0;i<10;i++) 	{ 		a[i][0]=a[i][i]=1; 		for(j=1;j<=i-1;j++) 			a[i][j]=a[i-1][j-1]+a[i-1][j]; 	} 	for(i=0;i<10;i++) 	{ 		for(j=0;j<=i;j++) 			printf("%4d",a[i][j]); 		printf("\n"); 	}  } 可以直接在for里复制 只是在算具体列的值时，j循环要从1开始 i-1结束

谢谢各位的解答~~ 刚才弄了一下~把下面代码 for(i=0;i<10;i++)  {  a[i][0]=1;  a[i][i]=1;  }    改成  for(i=0;i<10;i++)  {      for(j=0; j<10; j++)     {     	if(i==j)         a[i][j]=1;         else         a[i][j]=0;      }  } 这样子加上后面的语句就能跑出来了啦~ THX各位

a[i][0]=1; a[i][i]=1; 你只赋值了一列和一个对角线，其他都是未定义的

#include <stdio.h> #include <string.h> int main() {     int i,j,a[10][10];      memset(a, 0, sizeof(a));     /* 列的第一个元素*/     for (i = 0; i < 10; i++)         a[0][i] = 1;     /*     for(i=0;i<10;i++)     {         a[i][0]=1;         a[i][i]=1;     }     */      for(i = 1; i < 10; i++)         for(j = 1; j < 10; j++)             a[i][j] = a[i-1][j]+a[i-1][j-1];      for(i=0;i<10;i++)     {         for(j=0;j<10;j++)             if(a[i][j]!=0)                 printf("%4d",a[i][j]);         printf("\n\n");     }      return 0; } 数组若不对其初始化，里面的元素都是随机值，所以输出的内容有很多随机值。 对每列的第一个元素赋值为1，那么就是a[0][i] = 1;

在初始化多维数组a的代码中 for(i=0;i<10;i++) { a[i][0]=1; a[i][i]=1; } 并没有把a中的所有元素都初始为1，改为 for(i=0;i<10;i++) {     for(j=0; j<10; j++)    {        a[i][j]=1;     } } 试试

昨晚想了一宿，能想到的就是数组其他元素没有初始化，跟楼上大神回复一样

插眼，同样不懂！                  来自萌新


Question: 在网上找了一个关于移动笑脸的代码，哪位懂得帮忙解答一下，谢谢

引用 2 楼 qq_36289732 的回复:[quote=引用 1 楼 hou09tian 的回复:] 运行了一下代码，产生如下效果  这个程序的主要功能是根据不同的时间输出数量不同的空格，即随着程序运行时间的增大，输出空格的数量也在增加。  	char a[50];// 定义数组a，该数组即为输出的“口口口口” 	int flag,i=0; 	double time,k,temp=0; 	memset(a,1,sizeof(a));//将数组a中的元素都设置为1，在此后将元素看作字符串来输出时，都是“口口口口” 	a[19]='\0';//将数组的第20个元素设置为'\0'，也就是说，之后的输出中，只输出a数组中的19个元素， 	while(1)//循环输出 	{ 		//以下3行代码得到k的值，该值为程序从运行到调用clock()函数之间所消耗的时间 		time=(double)clock()/CLOCKS_PER_SEC;//CLOCKS_PER_SEC的值是1000 		flag=(int)(time*100); 		k=flag/10; 		if(temp!=k)//temp与k进行比较的作用是为了保证如果while(1)两次循环中间的间隔时间较小时，不输出 		{ 			//输出空格，while(1)每循环一次，i的值加1 			//这样输出的空格随着程序运行时间的增多而增多 			for(flag=0;flag<i;flag++) 				printf(" "); 			printf("%s\r",a);//输出a中19个元素，此时按字符串格式输出，所以输出都是“口口口口” 			i++;//每次循环i都要加1 			//将temp赋值为上一次循环时k的值，之后在下一次循环中，将两次循环时k的值进行比较，如果两次循环 			//间隔较小，则不输出 			temp=k; 		} 		if(i==62)//循环62次，也就是输出62次之后，程序退出 			break; 	}   我有在网上查了一下，clock()/CLOCKS_PER_SEC是返回当前进程的运行时间（以秒为单位），我不太明白 time=(double)clock()/CLOCKS_PER_SEC; flag=(int)(time*100); k=flag/10;  这三句代码是怎么确定多少秒之后执行输出的    问一下，在编程里，是不是如果某个值非常小，就会很当作0 比如上面的代码，k为消耗时间，如果k过小，就会被识别为0，就是这条判断语句  if(temp!=k)[/quote] clock()函数返回值应该是从程序运行到调用clock()函数时的间隔时间，单位是毫秒；而CLOCKS_PER_SEC的定义是1000 所以clock()/CLOCKS_PER_SEC表示从程序运行到调用clock()函数的间隔时间，单位是秒；后面两个乘以100和除以10的处理，我个人觉得就是为了获得一个表示时间的变量，之后对两次返回的时间变量进行比较，如果间隔时间很小，则不输出

system("chcp 437");

引用 1 楼 hou09tian 的回复:运行了一下代码，产生如下效果  这个程序的主要功能是根据不同的时间输出数量不同的空格，即随着程序运行时间的增大，输出空格的数量也在增加。  	char a[50];// 定义数组a，该数组即为输出的“口口口口” 	int flag,i=0; 	double time,k,temp=0; 	memset(a,1,sizeof(a));//将数组a中的元素都设置为1，在此后将元素看作字符串来输出时，都是“口口口口” 	a[19]='\0';//将数组的第20个元素设置为'\0'，也就是说，之后的输出中，只输出a数组中的19个元素， 	while(1)//循环输出 	{ 		//以下3行代码得到k的值，该值为程序从运行到调用clock()函数之间所消耗的时间 		time=(double)clock()/CLOCKS_PER_SEC;//CLOCKS_PER_SEC的值是1000 		flag=(int)(time*100); 		k=flag/10; 		if(temp!=k)//temp与k进行比较的作用是为了保证如果while(1)两次循环中间的间隔时间较小时，不输出 		{ 			//输出空格，while(1)每循环一次，i的值加1 			//这样输出的空格随着程序运行时间的增多而增多 			for(flag=0;flag<i;flag++) 				printf(" "); 			printf("%s\r",a);//输出a中19个元素，此时按字符串格式输出，所以输出都是“口口口口” 			i++;//每次循环i都要加1 			//将temp赋值为上一次循环时k的值，之后在下一次循环中，将两次循环时k的值进行比较，如果两次循环 			//间隔较小，则不输出 			temp=k; 		} 		if(i==62)//循环62次，也就是输出62次之后，程序退出 			break; 	}   我有在网上查了一下，clock()/CLOCKS_PER_SEC是返回当前进程的运行时间（以秒为单位），我不太明白 time=(double)clock()/CLOCKS_PER_SEC; flag=(int)(time*100); k=flag/10;  这三句代码是怎么确定多少秒之后执行输出的    问一下，在编程里，是不是如果某个值非常小，就会很当作0 比如上面的代码，k为消耗时间，如果k过小，就会被识别为0，就是这条判断语句  if(temp!=k)


Question: c语言释放内存不彻底问题

for（i=0;i<10;i++）    free( qtest[i].aa);//释放 free(qtest);

两次动态分配的内存，需要分别两次释放。 再此种情况下，实现同样的功能，可以采用另一种方法，再结构体内使用0长度数组。 typedef struct {        int  num ;       char aa[0];      //char aa[] } TEST;  malloc(sizeof(TEST)+size_buff);用一个malloc将全部内存分配出来，之后一次释放解决问题。  size_buff  就是你所需要分配aa地址的内存大小

跟租房子差不多。

上面的描述有歧义的地方， 请看这段文字：释放空间并不能说明里面的数据就会跟着改变；申请空间和释放空间需要配合使用，否则可能会导致内存溢出 申请空间，申请之后的内存空间，那么该空间不能被其他使用。 释放空间，释放之后，只是说明别人可以再次申请这部分已经释放的空间，如果该空间没有被申请，那么里面的数据就不会改变。除非，其他程序或者变量申请了这部分空间，并且往这部分空间里写数据了，才会覆盖之前的数据。 所以，说释放了不能说明里面的数据就变化了，主要还看该内存是否被再次申请并用新的数据覆盖了。 对于释放之后，并想告知这部分空间不能用了，可以将其指针指向NULL，那么再次使用，比如查看里面的数据就会出错。

释放空间并不能说明里面的数据就会跟着改变；申请空间和释放空间需要配合使用，否则可能会导致内存溢出 申请空间，申请之后的内存空间，那么该空间不能被其他使用。 释放空间，释放之后，只是说明别人可以再次申请这部分已经释放的空间，如果该空间没有被申请，那么里面的数据就不会改变。除非，其他程序或者变量申请了这部分空间，并且往这部分空间里写数据了，才会覆盖之前的空间。 所以，说释放了不能与里面的数据就变化了，主要还看是否被申请并用新的数据覆盖了。 对于释放之后，并想告知这部分空间不能用了，可以将其指针指向NULL，那么再次使用，比如查看里面的数据就会出错。

malloc多少次就free多少次，哪个指针malloc就free哪个。qtest[i].aa一个都没有释放，另外，也不能用打印能判断是否释放，能打印说明不了任何问题，没崩溃只是你运气好。

qtest[i].aa也要记得释放  还有你怎么判断qtest[1]-qtest[9]没被释放？


Question: 一个简单c语言程序问题

//    A //   ABA //  ABCBA // ABCDCBA //ABCDEDCBA #include <stdio.h> #include <conio.h> int n,h,s,i; int main() {     while (1) {         printf("Please input a character(A-Z):");         fflush(stdout);         rewind(stdin);         scanf("%c",&n);         if ('A'<=n && n<='Z') {             for (h=0;h<n-'A'+1;h++) {                 for (s=n-'A'-h;s>0    ;s--) printf(" "   );                 for (i='A'    ;i<'A'+h;i++) printf("%c",i);                 for (i='A'+h  ;i>='A' ;i--) printf("%c",i);                                             printf("\n"  );             }             getch();             break;         }     }     return 0; }

#include <stdio.h> #include <stdlib.h>  int main(void) { 	int		lines; 	scanf("%d", &lines);  	for (int i = 0; i < lines; i++) 	{ 		int		j; 		for (j = 0; j < lines - i - 1; j++) 			printf(" "); 		for (j = 0; j < i; j++) 			printf("%c", 'A' + j); 		for (; j >= 0; j--) 			printf("%c", 'A' + j); 		printf("\n"); 	}  	return 0; }

和杨辉三角形一样的写法


Question: 求解点到曲线的垂直距离及垂足，类似于arcgis中的近邻分析

引用 2 楼 yedasha 的回复:定义是 设曲线外一点P，曲线上有一点A，过点A做曲线的切线，能使切线与AP垂直，求解AP的长度及点A的坐标。  这样的点A可以不止一个吧？ 曲线公式未知，我觉得不可能。

计算几何大牛:http://www.codeproject.com/KB/recipes/Wykobi.aspx

点到曲线的垂直距离，定义是什么？ 不会是点到曲线两个端点连线线段的垂直距离？


Question: 各位大神麻烦帮我看一下  这个链表冒泡排序运行时为什么出错了   我用的是vs2015

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

仅供参考：//带表头结点的单向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> struct NODE {     int          data;     struct NODE *next; } H,*head,*p,*q,*q1,*s1,*s2,*s3,*s4,*s; int i,j,k,n,t,m; int main() {     srand(time(NULL));      //填写头节点数据     H.data=-1;     H.next=NULL;     head=&H;      //创建10个节点的单链表     p=head;     for (i=0;i<10;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) return 1;         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         p->next=q;         p=q;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将值为5的结点插入到单链表的第k个结点前     k=3;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) return 1;             q->data=5;             q->next=p->next;             p->next=q;             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //删除第k个节点     k=5;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=p->next;             if (q) {                 p->next=q->next;                 free(q);             }             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //从小到大排序     for (p=head;p!=NULL && p->next!=NULL;p=p->next) {         for (q=p->next;q!=NULL && q->next!=NULL;q=q->next) {             if (p->next->data > q->next->data) {                  //交换data //              printf("swap %02d %02d\n",p->next->data,q->next->data); //              t=p->next->data;p->next->data=q->next->data;q->next->data=t;                  //或者                  //交换next //              printf("swap %02d %02d\n",p->next->data,q->next->data);                 s1=p->next;                 s2=p->next->next;                 s3=q->next;                 s4=q->next->next;                  if (s2!=s3) {                      p->next=s3;                     s3->next=s2;                      q->next=s1;                     s1->next=s4;                 } else {                      p->next=s3;                     s3->next=s1;                            q=s3;                     s1->next=s4;                 }                  //输出整个单链表 //              s=head->next; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d->",s->data); //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将整个链表逆序     if (head->next!=NULL && head->next->next!=NULL) {         p=head->next;         q=p->next;         p->next=NULL;         while (1) {             q1=q->next;             q->next=p;             p=q;             q=q1;             if (NULL==q) break;         }         head->next=p;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将单链表中前 m 个结点和后 n 个结点进行互换,m+n为链表总长10     m=4;     n=6;     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m+1==k) {             q=p;         }         s=p;         p=p->next;     }     s1=head->next;     head->next=q->next;     s->next=s1;     q->next=NULL;      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //释放所有节点     p=head->next;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //84->28->20->23->96->19->59->97->29->41-> //84->28->05->20->23->96->19->59->97->29->41-> //84->28->05->20->96->19->59->97->29->41-> //05->19->20->28->29->41->59->84->96->97-> //97->96->84->59->41->29->28->20->19->05-> //41->29->28->20->19->05->97->96->84->59-> //

真搞不懂链表为什么要用冒泡排序。 直接拆下数据建立一个新的有序链表不更方便些吗？

链表节点分为指针部分和数据部分；对于链表排序，若只交换数据，不改变指针指向，这样的排序（冒泡，选择都可以）会更好理解和简单；

谢谢老师 指点


Question: 关于严蔚敏c数据结构的一些问题，请高人指教一下

《数据结构（C语言描述）》

引用 3 楼 qq_38007994 的回复:[quote=引用 1 楼 user-3的回复:]对，是另外一些函数。 另外这是伪代码，很多局部变量没有声明，还用了c++的引用 那你说我是懂里面的思想就好，好事把伪代码都弄透，并且编程实现的好。我的学习数据结构时间不是很多。[/quote] 首先应该理解它的思想，思路，也就是方法；这样我们在在写的时候才能有思路，但这也只是停留在想得基础上，编程不能只是思想家，更要是实战家，建议了解思路之后，用一种语言去实现一下，这样对思想会更深入的理解和记忆

引用 1 楼 user-3的回复:对，是另外一些函数。 另外这是伪代码，很多局部变量没有声明，还用了c++的引用 那你说我是懂里面的思想就好，好事把伪代码都弄透，并且编程实现的好。我的学习数据结构时间不是很多。

对，是另外一些函数。 另外这是伪代码，很多局部变量没有声明，还用了c++的引用


Question: 二叉树实现问题

BiTree InorderLastNode(BiTree T) {   /*找二叉树中序遍历最后一个结点*/     datatype s;     if (T) {         InorderLastNode(T->lchild);         s = T->data;         InorderLastNode(T->rchild);     }     return s; }   这段程序也可以这样改   BiTree *InorderLastNode(BiTree T) {   /*找二叉树中序遍历最后一个结点*/     BiTree *Result =NULL;     if(T->lchild) {         Result = InorderLastNode(T->lchild);     } else if(T->rchild) {         Result = InorderLastNode(T->lchild);     } else {         Result = T;     }      return Result; }

可是程序运行出来全是黑屏，打什么字都没反应

可以这样改：   #include<stdio.h> #include<stdlib.h> typedef char datatype; typedef struct tnode { 	datatype data; 	struct tnode *lchild, *rchild; } BiTNode, *BiTree;  void visit(BiTree p);   /*输出p指针指向的结点*/ void Preorder(BiTree T);   /*前序遍历*/ void Inorder(BiTree T);   /*中序遍历*/ void Postorder(BiTree T);   /*后序遍历*/ BiTree  CreateTree();   /*以前序遍历的顺序建立二叉树*/ int deep(BiTree T);   /*求二叉树深度*/ int leaf(BiTree T);   /*求叶子结点数*/ int OneChild(BiTree T);   /*求1度结点数*/ int TwoChild(BiTree T);   /*求2度结点数*/ void Exchange(BiTree  T);   /*二叉树左右子树交换*/ datatype InorderLastNode(BiTree T);  /*找二叉树中序遍历最后一个结点*/  void visit(BiTree p) {       /*输出p指针指向的结点*/ 	if (p->data != ' ') { 		printf("%c ", p->data); 	} }  void Preorder(BiTree T) {    /*前序遍历*/ 	if (T != NULL) {    		visit(T);            //访问根节点 		Preorder(T->lchild); //访问左子节点 		Preorder(T->rchild); //访问右子节点 	} }  void Inorder(BiTree T) {     /*中序遍历*/ 	if (T != NULL) { 		Inorder(T->lchild);  //访问左子节点 		visit(T);            //访问根节点 		Inorder(T->rchild);  //访问右子节点 	} }  void Postorder(BiTree T) {   /*后序遍历*/ 	if (T != NULL) { 		Postorder(T->lchild); //访问左子节点 		Postorder(T->rchild); //访问右子节点 		visit(T);             //访问根节点 	} }  BiTree CreateTree() {          /*以前序遍历的顺序建立二叉树*/ 	char ch; 	BiTree T; 	if ((ch = getchar()) == ' ') { 		return NULL; 	} 	else { 		T = (BiTree)malloc(sizeof(BiTNode));   //生成根节点 		T->data = ch;           		T->lchild = CreateTree();   //构造左子树 		T->rchild = CreateTree();   //构造右子树 		return T; 	} }  int deep(BiTree T) {           /*求二叉树深度*/ 	if (T) { 		int leftdeep = deep(T->lchild); 		int rightdeep = deep(T->rchild); 		return leftdeep >= rightdeep ? leftdeep + 1 : rightdeep + 1; 	} 	else { 		return 0; 	} }  int leaf(BiTree T) {           /*求叶子结点数*/ 	int m, n; 	if (!T) {   /*空树没有叶子*/ 		return 0; 	} 	else if(!T->lchild&&!T->rchild){   /*叶子结点*/ 		return 1; 	} 	else {   /*左子树的结点数加上右子树的结点数*/ 		m = leaf(T->lchild); 		n = leaf(T->rchild); 		return m + n; 	} }  int OneChild(BiTree T) {      /*求1度结点数*/ 	int n = 0; 	if (T == NULL) { 		return 0; 	} 	else if ((T->lchild == NULL&&T->rchild != NULL) || (T->lchild != NULL&&T->rchild == NULL)) { 		n = 1; 	} 	return OneChild(T->lchild) + OneChild(T->rchild) + n; }  int TwoChild(BiTree T) {      /*求2度结点数*/ 	int n = 0; 	if (T == NULL) { 		return 0; 	} 	else if ((T->lchild!=NULL&&T->rchild!=NULL)) 	{ 		n = 1; 	} 	return TwoChild(T->lchild) + TwoChild(T->rchild) + n; }  void Exchange(BiTree  T) {    /*二叉树左右子树交换*/ 	if (T) { 		BiTree temp = T->lchild; 		T->lchild = T->rchild; 		T->rchild = temp; 		Exchange(T->lchild); 		Exchange(T->rchild); 	} }  datatype InorderLastNode(BiTree T) {   /*找二叉树中序遍历最后一个结点*/ 	datatype s; 	if (T) { 		InorderLastNode(T->lchild); 		s = T->data; 		InorderLastNode(T->rchild); 	} 	return s; }  int main() { 	BiTree T; 	T = CreateTree(); 	printf("\n以前序遍历的二叉树:"); 	printf("\n先序遍历:"); 	Preorder(T); 	printf("\n"); 	printf("\n中序遍历:"); 	Inorder(T); 	printf("\n"); 	printf("\n后序遍历:"); 	Postorder(T); 	printf("\n"); 	printf("\n树的深度=%d\n", deep(T)); 	printf("1度结点数=%d\n", OneChild(T)); 	printf("2度结点数=%d\n", TwoChild(T)); 	Exchange(T); 	printf("\n"); 	InorderLastNode(T); 	return 0; }

提示说的很明白啊，InorderLastNode函数中，你的s类型是datatype（也就是char），但你函数返回值需要的是BiTree类型


Question: 找二叉树中序遍历最后一个结点

代码如下 #include<stdio.h> #include<stdlib.h> typedef char datatype; typedef struct tnode { 	datatype data; 	struct tnode *lchild, *rchild; } BiTNode, *BiTree;  void visit(BiTree p);   /*输出p指针指向的结点*/ void Preorder(BiTree T);   /*前序遍历*/ void Inorder(BiTree T);   /*中序遍历*/ void Postorder(BiTree T);   /*后序遍历*/ BiTree  CreateTree();   /*以前序遍历的顺序建立二叉树*/ int deep(BiTree T);   /*求二叉树深度*/ int leaf(BiTree T);   /*求叶子结点数*/ int OneChild(BiTree T);   /*求1度结点数*/ int TwoChild(BiTree T);   /*求2度结点数*/ void Exchange(BiTree  T);   /*二叉树左右子树交换*/ BiTree InorderLastNode(BiTree T);  /*找二叉树中序遍历最后一个结点*/  void visit(BiTree p) {       /*输出p指针指向的结点*/ 	if (p->data != ' ') { 		printf("%c ", p->data); 	} }  void Preorder(BiTree T) {    /*前序遍历*/ 	if (T != NULL) {    		visit(T);            //访问根节点 		Preorder(T->lchild); //访问左子节点 		Preorder(T->rchild); //访问右子节点 	} }  void Inorder(BiTree T) {     /*中序遍历*/ 	if (T != NULL) { 		Inorder(T->lchild);  //访问左子节点 		visit(T);            //访问根节点 		Inorder(T->rchild);  //访问右子节点 	} }  void Postorder(BiTree T) {   /*后序遍历*/ 	if (T != NULL) { 		Postorder(T->lchild); //访问左子节点 		Postorder(T->rchild); //访问右子节点 		visit(T);             //访问根节点 	} }  BiTree CreateTree() {          /*以前序遍历的顺序建立二叉树*/ 	char ch; 	BiTree T; 	if ((ch = getchar()) == ' ') { 		return NULL; 	} 	else { 		T = (BiTree)malloc(sizeof(BiTNode));   //生成根节点 		T->data = ch;           		T->lchild = CreateTree();   //构造左子树 		T->rchild = CreateTree();   //构造右子树 		return T; 	} }  int deep(BiTree T) {           /*求二叉树深度*/ 	if (T) { 		int leftdeep = deep(T->lchild); 		int rightdeep = deep(T->rchild); 		return leftdeep >= rightdeep ? leftdeep + 1 : rightdeep + 1; 	} 	else { 		return 0; 	} }  int leaf(BiTree T) {           /*求叶子结点数*/ 	int m, n; 	if (!T) {   /*空树没有叶子*/ 		return 0; 	} 	else if(!T->lchild&&!T->rchild){   /*叶子结点*/ 		return 1; 	} 	else {   /*左子树的结点数加上右子树的结点数*/ 		m = leaf(T->lchild); 		n = leaf(T->rchild); 		return m + n; 	} }  int OneChild(BiTree T) {      /*求1度结点数*/ 	int n = 0; 	if (T == NULL) { 		return 0; 	} 	else if ((T->lchild == NULL&&T->rchild != NULL) || (T->lchild != NULL&&T->rchild == NULL)) { 			n = 1; 	} 	return OneChild(T->lchild) + OneChild(T->rchild) + n; }  int TwoChild(BiTree T) {      /*求2度结点数*/ 	int n = 0; 	if (T == NULL) { 		return 0; 	} 	else if ((T->lchild!=NULL&&T->rchild!=NULL)) 	{ 		n = 1; 	} 	return TwoChild(T->lchild) + TwoChild(T->rchild) + n; }  void Exchange(BiTree  T) {    /*二叉树左右子树交换*/ 	if (!T) { 		BiTree temp = T->lchild; 		T->lchild = T->rchild; 		T->rchild = temp; 		Exchange(T->lchild); 		Exchange(T->rchild); 	} }  BiTree InorderLastNode(BiTree T) {   /*找二叉树中序遍历最后一个结点*/  }  int main() { 	BiTree T; 	printf("\n以前序遍历的二叉树:"); 	T = CreateTree(); 	printf("\n先序遍历:"); 	Preorder(T); 	printf("\n"); 	printf("\n中序遍历:"); 	Inorder(T); 	printf("\n"); 	printf("\n后序遍历:"); 	Postorder(T); 	printf("\n"); 	printf("\n树的深度=%d\n", deep(T)); 	printf("1度结点数=%d\n", OneChild(T)); 	printf("2度结点数=%d\n", TwoChild(T)); 	Exchange(T); 	printf("\n"); 	Inorder(T); 	printf("二叉树中序遍历最后一个结点=%c\n", InorderLastNode(T)); 	return 0; }


Question: 帮我看看这个程序哪里有问题

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 判断是否越界访问，可以在数组的最后一个元素之后对应的地址处设置数据读写断点。如果该地址对应其它变量干扰判断，可将数组多声明一个元素，并设置数据读写断点在该多出元素对应的地址上。 #include <time.h> #include <stdlib.h> #include <windows.h> int main() {     int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]      srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。     while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。         b[(a=rand()%11)]=0;         Sleep(100);         b[(a=rand()%11)]=1;         Sleep(100);         b[(a=rand()%11)]=2;         Sleep(100);         b[(a=rand()%11)]=3;         Sleep(100);         b[(a=rand()%11)]=4;         Sleep(100);     }     return 0; }

引用 3楼自信男孩 的回复:游戏币变量名不是猴子(monkey)，应该是money吧； rewind(stdin);         scanf("%d", &i);         i--; 这句还有有问题的，若输入的是100，后面用到i的地方就会越界； 后面用到count的地方，它是一个全局变量，默认值是4，也是定义的数组长度。若，对其count++那么再次使用它做下标时，就会越界； 个人建议，不要用太多的全局变量。能用局部的尽量使用局部变量，通过参数传递来实现；这样一方面对数据来讲比较安全，另一方面阅读起来还比较好一些。为什么i输入100，之后会越界。count++，再做下标为什么也会越界

引用 5楼我是你的主体 的回复:[quote=引用 2楼幻夢之葉 的回复:]            if (p == 0)             {                 strcpy(backpack[count].name, market[i].name);                 backpack[count].number = 1;                 count++;             }  1：数组越界 2：backpack[count].name 数组的大小是7个字符，而且指向的是常量区字串（三个中文字 + 一个结束符） 先不说能不能修改，那它也不够存储market[i].name里面的字符串啊多谢，加了句backpack[count].name =（char*)malloc(50);解决问题了[/quote]前面定义backpack数组大小定义为20

引用 2楼幻夢之葉 的回复:if (p == 0)             {                 strcpy(backpack[count].name, market[i].name);                 backpack[count].number = 1;                 count++;             }  1：数组越界 2：backpack[count].name 数组的大小是7个字符，而且指向的是常量区字串（三个中文字 + 一个结束符） 先不说能不能修改，那它也不够存储market[i].name里面的字符串啊多谢，加了句backpack[count].name =（char*)malloc(50);解决问题了

使用strcpy的地方都会出现段错误，因为定义全局变量的地方都是字符常量，没有在内存里申请有效的空间。如下： Market market[NUM] = {     {"双倍经验卡",20,5},     {"幸运宝石",15,5},     { "五行转换卡",10,5},     { "银两袋子",5,5},   };   Backpack backpack[] = {     {"蓝水晶",10},     { "红水晶",15 },     { "绿水晶",18 },     { "紫水晶",12 }, }; 建议你把自己的构思在重新梳理一遍，不能想到哪儿就写到哪儿。整体有一个框架

头文件还有一个string，没复制进去


Question: 关于getchar()的用法

在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 [code=c]//请今后要用 char c; scanf("%c",&c); //时，都改为 char s[2]; char c; scanf("%1s",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。 [/code]

标准输入流中带有缓存，最后scanf只是把除了回车符之外的其他字符都吃了，scanf语句执行完之后，缓存里面还是有个回车符，随意要用getchar()来吃掉回车符。         你这样想，getchar()是阻塞的，这个库函数应该等着你在键盘输入字符后才会执行完，为什么你在终端值等到sancf这个语句让你输入字符，而getchar()这条语句就直接过去了。

(stdin)

fflush(sdin);

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

这是关于scanf函数缓冲区的问题，当你从键盘输入完数据之后，敲下回车，结果换行符被放入了缓冲区中，只不过因为输入格式是以%某某，所以换行符 不起作用，所以这里的getchar可以说是多余的，不过当输入格式不是以%×××，那么回车符就当作一个字符，进行匹配，赋值，那么这里的getchar就是为了防止回车符匹配成功后造成的问题，就是相当于用getchar读取上一步输入的回车符，getchar也是有缓冲区的，若缓冲区没有数据会等待用户输入，而上一步留下来的回车符在缓冲区内，所以getchar直接读取它，最后说一句，因为再此程序中，回车符匹配不成功，所以getchar在这里同样没什么鸟用的哦哦。

你除了输入需要的数据外还按了一个回车，这个回车如果是后续还有输入就会产生影响， getchar（）确实是来吃掉这个回车用的，注意 后续的输入如果是%c有影响，%d还是没有影响的，因为%d不可读取回车

这里不需要用，因为你后续再也没有读取的操作了，所以那个回车键是否被清除出输入流无关紧要  但是你后续如果有读取 字符/字符串的操作 的时候需要注意这个问题。

是吃掉最后输入的回车符。原因是这个输入你只输入一次，若需要输入多次（>=2)就会有问题，就能看出getchar()的需要了。 #include <stdio.h>   int main(void) {     char chA,chB;     int a,b;     int i = 0;      while (i < 3) {         scanf("%c%3d%c%2d",&chA,&a,&chB,&b);         //getchar();         b += a;         printf("%c%c",chA,chB);         printf("%d\n",b);         i++;     }      return 0; } 试一下这个，加上和不加的区别。


Question: linux 下fopen打开文件失败

引用 5 楼 user-4 的回复:file_name = "./fileptr.c"; /*文件路径*/ 编译能过吗？应该是strcpy(file_name, "./fileptr.c");吧 5楼正确

引用 8 楼 zcmerlin 的回复:[quote=引用 6 楼 cfjtaishan 的回复:] 我看原因是这个：file_name = "fileptr.c" 文件名没有./，把文件名的./去掉；程序在当前目录下找文件名是./fileptr.c，但是该文件应该不存在的。 引用 6 楼 cfjtaishan 的回复:我看原因是这个：file_name = "fileptr.c" 文件名没有./，把文件名的./去掉；程序在当前目录下找文件名是./fileptr.c，但是该文件应该不存在的。  那样没问题的[/quote] 没问题吗？

引用 11 楼 zhao4zhong1 的回复:strerror, _strerror Get a system error message (strerror) or prints a user-supplied error message (_strerror).  char *strerror( int errnum );  char *_strerror( const char *strErrMsg );  Routine Required Header Compatibility  strerror <string.h> ANSI, Win 95, Win NT  _strerror <string.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  strerror and _strerror return a pointer to the error-message string. Subsequent calls to strerror or _strerror can overwrite the string.  Parameters  errnum  Error number  strErrMsg  User-supplied message  Remarks  The strerror function maps errnum to an error-message string, returning a pointer to the string. Neither strerror nor _strerror actually prints the message: For that, you need to call an output function such as fprintf:  if (( _access( "datafile",2 )) == -1 )    fprintf( stderr, strerror(NULL) );  If strErrMsg is passed as NULL, _strerror returns a pointer to a string containing the system error message for the last library call that produced an error. The error-message string is terminated by the newline character ('\n'). If strErrMsg is not equal to NULL, then _strerror returns a pointer to a string containing (in order) your string message, a colon, a space, the system error message for the last library call producing an error, and a newline character. Your string message can be, at most, 94 bytes long.  The actual error number for _strerror is stored in the variable errno. The system error messages are accessed through the variable _sys_errlist, which is an array of messages ordered by error number. _strerror accesses the appropriate error message by using the errno value as an index to the variable _sys_errlist. The value of the variable _sys_nerr is defined as the maximum number of elements in the _sys_errlist array. To produce accurate results, call _strerror immediately after a library routine returns with an error. Otherwise, subsequent calls to strerror or _strerror can overwrite the errno value.  _strerror is not part of the ANSI definition but is instead a Microsoft extension to it. Do not use it where portability is desired; for ANSI compatibility, use strerror instead.  Example  /* PERROR.C: This program attempts to open a file named  * NOSUCHF.ILE. Because this file probably doesn't exist,  * an error message is displayed. The same message is  * created using perror, strerror, and _strerror.  */  #include <fcntl.h> #include <sys/types.h> #include <sys/stat.h> #include <io.h> #include <stdlib.h> #include <stdio.h> #include <string.h>  void main( void ) {    int  fh;     if( (fh = _open( "NOSUCHF.ILE", _O_RDONLY )) == -1 )    {       /* Three ways to create error message: */       perror( "perror says open failed" );       printf( "strerror says open failed: %s\n", strerror( errno ) );       printf( _strerror( "_strerror says open failed" ) );    }    else    {       printf( "open succeeded on input file\n" );       _close( fh );    } }   Output  perror says open failed: No such file or directory  strerror says open failed: No such file or directory _strerror says open failed: No such file or directory   String Manipulation Routines  See Also   clearerr, ferror, perror   多谢，问题已经解决，step进不到fopen里

引用 2 楼 zhao4zhong1 的回复:FOPEN Section: POSIX Programmer's Manual (P) Updated: 2003  --------------------------------------------------------------------------------    NAME fopen - open a stream    SYNOPSIS #include <stdio.h>     FILE *fopen(const char *restrict filename, const char *restrict mode);      DESCRIPTION The fopen() function shall open the file whose pathname is the string pointed to by filename, and associates a stream with it.   The mode argument points to a string. If the string is one of the following, the file shall be opened in the indicated mode. Otherwise, the behavior is undefined.   r or rb Open file for reading.  w or wb Truncate to zero length or create file for writing.  a or ab Append; open or create file for writing at end-of-file.  r+ or rb+ or r+b Open file for update (reading and writing).  w+ or wb+ or w+b Truncate to zero length or create file for update.  a+ or ab+ or a+b Append; open or create file for update, writing at end-of-file.   The character 'b' shall have no effect, but is allowed for ISO C standard conformance. Opening a file with read mode (r as the first character in the mode argument) shall fail if the file does not exist or cannot be read.   Opening a file with append mode (a as the first character in the mode argument) shall cause all subsequent writes to the file to be forced to the then current end-of-file, regardless of intervening calls to fseek().   When a file is opened with update mode ( '+' as the second or third character in the mode argument), both input and output may be performed on the associated stream. However, the application shall ensure that output is not directly followed by input without an intervening call to fflush() or to a file positioning function ( fseek(), fsetpos(), or rewind()), and input is not directly followed by output without an intervening call to a file positioning function, unless the input operation encounters end-of-file.   When opened, a stream is fully buffered if and only if it can be determined not to refer to an interactive device. The error and end-of-file indicators for the stream shall be cleared.   If mode is w, wb, a, ab, w+, wb+, w+b, a+, ab+, or a+b, and the file did not previously exist, upon successful completion, the fopen() function shall mark for update the st_atime, st_ctime, and st_mtime fields of the file and the st_ctime and st_mtime fields of the parent directory.   If mode is w, wb, w+, wb+, or w+b, and the file did previously exist, upon successful completion, fopen() shall mark for update the st_ctime and st_mtime fields of the file. The fopen() function shall allocate a file descriptor as open() does.   After a successful call to the fopen() function, the orientation of the stream shall be cleared,  the encoding rule shall be cleared, and the associated mbstate_t object shall be set to describe an initial conversion state.   The largest value that can be represented correctly in an object of type off_t shall be established as the offset maximum in the open file description.     RETURN VALUE Upon successful completion, fopen() shall return a pointer to the object controlling the stream. Otherwise, a null pointer shall be returned,  and errno shall be set to indicate the error.     ERRORS The fopen() function shall fail if:   EACCES  Search permission is denied on a component of the path prefix, or the file exists and the permissions specified by mode are denied, or the file does not exist and write permission is denied for the parent directory of the file to be created.  EINTR  A signal was caught during fopen().  EISDIR  The named file is a directory and mode requires write access.  ELOOP  A loop exists in symbolic links encountered during resolution of the path argument.  EMFILE  {OPEN_MAX} file descriptors are currently open in the calling process.  ENAMETOOLONG  The length of the filename argument exceeds {PATH_MAX} or a pathname component is longer than {NAME_MAX}.   ENFILE  The maximum allowable number of files is currently open in the system.  ENOENT  A component of filename does not name an existing file or filename is an empty string.  ENOSPC  The directory or file system that would contain the new file cannot be expanded, the file does not exist, and the file was to be created.  ENOTDIR  A component of the path prefix is not a directory.  ENXIO  The named file is a character special or block special file, and the device associated with this special file does not exist.  EOVERFLOW  The named file is a regular file and the size of the file cannot be represented correctly in an object of type off_t.  EROFS  The named file resides on a read-only file system and mode requires write access.   The fopen() function may fail if:   EINVAL  The value of the mode argument is not valid.  ELOOP  More than {SYMLOOP_MAX} symbolic links were encountered during resolution of the path argument.  EMFILE  {FOPEN_MAX} streams are currently open in the calling process.  EMFILE  {STREAM_MAX} streams are currently open in the calling process.  ENAMETOOLONG  Pathname resolution of a symbolic link produced an intermediate result whose length exceeds {PATH_MAX}.   ENOMEM  Insufficient storage space is available.  ETXTBSY  The file is a pure procedure (shared text) file that is being executed and mode requires write access.   The following sections are informative.     EXAMPLES    Opening a File The following example tries to open the file named file for reading. The fopen() function returns a file pointer that is used in subsequent fgets() and fclose() calls. If the program cannot open the file, it just ignores it.     #include <stdio.h> ... FILE *fp; ... void rgrep(const char *file) { ...     if ((fp = fopen(file, "r")) == NULL)         return; ... }      APPLICATION USAGE None.     RATIONALE None.     FUTURE DIRECTIONS None.     SEE ALSO fclose() , fdopen() , freopen() , the Base Definitions volume of IEEE Std 1003.1-2001, <stdio.h>     COPYRIGHT Portions of this text are reprinted and reproduced in electronic form from IEEE Std 1003.1, 2003 Edition, Standard for Information Technology -- Portable Operating System Interface (POSIX), The Open Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the Institute of Electrical and Electronics Engineers, Inc and The Open Group. In the event of any discrepancy between this version and the original IEEE and The Open Group Standard, the original IEEE and The Open Group Standard is the referee document. The original Standard can be obtained online at http://www.opengroup.org/unix/online.html .  --------------------------------------------------------------------------------  基本的使用会，现在遇到的情况是用gdb单步走时，就是帖子里遇到的情况，但直接运行编译好的程序没问题，也就是文件可以正常读取，这问题到底处在哪里呢

引用 6 楼 cfjtaishan 的回复:我看原因是这个：file_name = "fileptr.c" 文件名没有./，把文件名的./去掉；程序在当前目录下找文件名是./fileptr.c，但是该文件应该不存在的。 引用 6 楼 cfjtaishan 的回复:我看原因是这个：file_name = "fileptr.c" 文件名没有./，把文件名的./去掉；程序在当前目录下找文件名是./fileptr.c，但是该文件应该不存在的。  那样没问题的

引用 5 楼 user-4 的回复:file_name = "./fileptr.c"; /*文件路径*/ 编译能过吗？应该是strcpy(file_name, "./fileptr.c");吧 编译可以通过的

引用 3 楼 cfjtaishan 的回复:没有那个文件或目录。错误信息已经打出来了。 另外，确认一下该文件是否和可执行程序在同一目录下    在同一个目录下的，本来不在同一个目录下，后来怕出错，就专门给同一目录下也放了一份源文件； 另，fopen后面有if判断文件打开是否成功，怎么都走不到if就报错了呢

自己先顶一下


Question: 双向链表中内存访问错误问题.

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

引用 3 楼 cfjtaishan 的回复:可以参考一下我写的，整个功能100多行代码可以实现的，不用对数据解析那么复杂（新学可能对C语言了解的不很透彻，就像我对JAVA了解一些表面一样）。 另外，排序也可以更简单一些。建议自己试试练练，还有问题，可以继续提出来。  谢了，我下午也一直在改善代码，已经精简了好多了，最后这个内存崩溃还是不知道什么原理，不过用scanf的%3d截取给规避掉了BUG  BUG体现就是第一次输入很长字符串然后再输入正常的学生个数后面遍历就是内存访问异常，第一次输入不太长或者直接输入正确的就不会  字符串判断主要是规定一定要数字之外无效，小数点和加减术式都不行，所以多加了一道遍历  不管怎么样作为初学者还是很感谢回答

#include <stdio.h> #include <stdlib.h> #include <string.h>  #define NEW #define     MAX_ID_NUM  12  typedef struct stu {//学生节点     struct stu *pLast;     char stuId[MAX_ID_NUM];     short stuScore;     struct stu *pNext; }Stu;  Stu *Create() {//创建链表     int num, counts;     Stu *last,*head,*current;     head = (Stu *)malloc(sizeof(Stu));     if (!head) {         fprintf(stderr, "malloc error!\n");         exit(-1);     }     head->pLast = NULL;     head->pNext = NULL;     last = head;      /*        for(;;) {//输入人数验证        printf("学生の人数（1～35）を入力してください！ \n");     //flushall();     scanf("%s", str);     length = 0;     while(str[length] != '\0')     {     length++;     }     if (length > 0 && length < 3)//判断并且验证长度     {     for(a = 0; a < length; a++)     {     if(str[a] >= 48 && str[a] <= 57) {//验证是否一定是数字     ok = 1;     } else {     ok = 0;     break;     }     }     if(ok)     {     num = atoi(str);     }     else     {     num = -1;     }      }     if(num >= 1 && num <= 35)     {     break;     }     printf("入力した人数が間違いですから、ご確認してください！ \n");     }     */     printf("学生の人数（1～35）を入力してください！ \n");     scanf("%d", &num);       for(counts = 0;counts < num;counts++)     {         current = (Stu *)malloc(sizeof(Stu));         if (!current) {             fprintf(stderr, "malloc error!\n");             exit(-1);         }         last->pNext = current;         printf("学生の番号（00001～99999）と得点（0～100）を入力してください。 \n");         /*            for(;;)            {//输入学号            printf("番号：");         //flushall();         scanf("%s",&str2);         length = 0;         while(str2[length] != '\0')         {         length++;         }         if(length>0&&length<6)         {         for(a = 0; a < length ;a++)         {         if( str2[a] >=48&&str2[a]<=57)         {         ok = 1;         }         else         {         ok = 0;         break;         }         }         if(ok)         {         id = atol(str2);         }         else         {         id = -1;         }          }         if(id>=1&&id<=99999)         {         break;         }         printf("入力した番号が間違いですから、ご確認してください！ \n");         }         */         scanf("%s", current->stuId);         printf("得点：");         scanf("%hd", ¤t->stuScore);         /*            for(;;)            {//输入分数            flushall();            scanf("%s",&str3);            length = 0;            while(str3[length] != '\0')            {            length++;            }            if(length>0&&length<4)            {            for(a = 0; a < length ;a++)            {             if( str3[a] >=48&&str3[a]<=57)            {            ok = 1;            }            else            {            ok = 0;            break;            }            }            if(ok)            {            stuScore = atoi(str3);            }            else            {            stuScore = -1;            }             }            if(stuScore>=1&&stuScore<=100)            {            break;            }            printf("入力した得点が間違いですから、ご確認してください！ \n");            }            current->stuScore = stuScore;            */         current->pLast = last;         current->pNext = NULL;         last = current;     }     return head;//debug跑到这就崩溃了。 }  void OutPut(Stu *s) {     Stu *p;     p = s;     p = p->pNext;     while (p) {         //printf("番号：%d%d%d%d%d 得点：%d \n",p->stuId[0],p->stuId[1],p->stuId[2],p->stuId[3],p->stuId[4],p->stuScore);         printf("番号：%s\t 得点：%d \n", p->stuId, p->stuScore);         p = p->pNext;     } }  void Swap(Stu *l,Stu *n) {     Stu *temp;     if(n->pNext == NULL)     {         if(l->pNext ==n)         {             n->pNext = l;             n->pLast = l->pLast;             l->pNext = NULL;             l->pLast ->pNext = n;             l->pLast = n;         }         else         {             n->pNext = l->pNext;             n->pLast->pNext =l;             temp = n->pLast;             n->pLast = l->pLast;             l->pNext->pLast = n;             l->pNext = NULL;             l->pLast->pNext = n;             l->pLast =temp;         }     }     else     {         if(l->pNext ==n)         {             n->pNext->pLast = l;             temp = n->pNext;             n->pNext = l;             n->pLast = l->pLast;             l->pNext = temp;             l->pLast->pNext = n;             l->pLast = n;         }         else         {             n->pNext->pLast = l;             temp = n->pNext;             n->pNext = l->pNext;             l->pNext->pLast = n;             l->pNext = temp;             n->pLast->pNext = l;             temp = n->pLast;             n->pLast = l->pLast;             l->pLast->pNext = n;             l->pLast = temp;         }     } }  Stu *Sort(Stu *head) {     Stu *i,*j,*k;     if(!head->pNext)         return head;     for(i = head->pNext;i->pNext != NULL;i=k->pNext)     {         for(j=i->pNext,k=i;j!=NULL;j=j->pNext)             if(k->stuScore>j->stuScore||(k->stuScore==j->stuScore&&(k->stuId[0]*10000 + k->stuId[1]*1000 + k->stuId[2]*100 + k->stuId[3]*10 + k->stuId[4]*1)>(j->stuId[0]*10000 + j->stuId[1]*1000 + j->stuId[2]*100 + j->stuId[3]*10 + j->stuId[4]*1)))                 k=j;         if(k!=i)             Swap(i,k);     }     return head; }   void MemoryFree(Stu *head) { #ifdef NEW     Stu *p, *q;      p = head;     while (p) {         q = p->next;         free(p);         p = q;     } #else     Stu *l,*n;     n=head;     while(n->pNext!=NULL)     {         l=n;         n = n->pNext;         free(l);     }  #endif }  int main() {     Stu *head = Create();     Sort(head);     OutPut(head);     MemoryFree(head);     return 0; } 学号和成绩可以直接输入，另外，你的学号长度不能超过4个数字；计算字符串长度有专门的函数。成绩可以直接用scanf %d输入 这个功能可以用10多行代码完成，所以很多代码是冗余的

仅供参考：//不带表头结点的循环双向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> #include <locale.h> struct NODE {     int          data;     struct NODE *next;     struct NODE *prev; } *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;         q->prev=NULL;         if (NULL==p) {             head=q;             p=head;         } else {             p->next=q;             q->prev=p;             p=q;         }     }     p->next=head;     head->prev=p;      //输出整个循环双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d(=)",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         s=s->next;         if (s==head) {             printf(" Loop\n");             break;         }     }      k=3;     v=5;     printf("将值为%d的结点插入到循环双向链表的第%d个结点前:",v,k);//将值为v的结点插入到循环双向链表的第k个结点前     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) exit(1);             q->data=v;             q->next=head;             q->prev=head->prev;             head->prev->next=q;             head->prev=q;             head=q;             break;         } else {             if (k-1==n) {                 q=(struct NODE *)malloc(sizeof(struct NODE));                 if (NULL==q) exit(1);                 q->data=v;                 q->next=p->next;                 q->prev=p;                 p->next->prev=q;                 p->next=q;                 break;             }         }         p=p->next;         if (p==head) break;     }      //输出整个循环双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d(=)",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         s=s->next;         if (s==head) {             printf(" Loop\n");             break;         }     }      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;             head->prev=q->prev;             q->prev->next=head;             if (q==head) head=NULL;             free(q);             break;         } else {             if (k-1==n) {                 q=p->next;                 p->next=q->next;                 q->next->prev=p;                 free(q);                 break;             }         }         p=p->next;         if (p==head) break;     }      //输出整个循环双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d(=)",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         s=s->next;         if (s==head) {             printf(" Loop\n");             break;         }     }      printf("从小到大排序:");//从小到大排序     for (p=head;p!=NULL;) {         p1=p->prev;         for (q=p->next,q1=p;q!=NULL;) {             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;                  //或者                  //交换prev和next //              printf("swap %02d %02d\n",p->data,q->data);                 if (p==head) {//p是头                     if (p->next==q) {//pq挨着                         head=q;                         head->prev=p1;                         p1->next=q;                         p->next=q->next;                         p->prev=q;                         q->next->prev=p;                         q->next=p;                         q=p;                         p=head;                     } else {//pq不挨着                         head=q;                         head->prev=p1;                         p1->next=q;                         p2=p->next;                         p->next=q->next;                         p->next->prev=p;                         p->prev=q1;                         q->next->prev=p;                         q->next=p2;                         p2->prev=q;                         q1->next=p;                         q=p;                         p=head;                     }                 } else {//p不是头                     if (p->next==q) {//pq挨着                         p1->next=q;                         p->next=q->next;                         p->prev=q;                         q->next->prev=p;                         q->next=p;                         q->prev=p1;                         q=p;                         p=p1->next;                     } else {//pq不挨着                         p1->next=q;                         p2=p->next;                         p->next=q->next;                         p->prev=q->prev;                         q->next->prev=p;                         q->next=p2;                         q->prev=p1;                         p2->prev=q;                         q1->next=p;                         q=p;                         p=p1->next;                     }                 }                  //输出整个循环双向链表 //              s=head; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d(=)",s->data); //                  if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;} //                  s=s->next; //                  if (s==head) { //                      printf(" Loop\n"); //                      break; //                  } //              } //              printf("head,p,q:%02d %02d %02d\n",head->data,p->data,q->data); //              getchar();             }             q1=q;q=q->next;             if (q==head) break;         }         p=p->next;         if (p->next==head) break;     }      //输出整个循环双向链表并计算链表长度n     n=0;     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d(=)",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         n++;         s=s->next;         if (s==head) {             printf(" Loop\n");             break;         }     }      printf("将整个链表逆序:");//将整个链表逆序     if (n>=2) {         p=head;         while (1) {             q=p->prev;p->prev=p->next;p->next=q;             p=p->next;             if (p==head) break;         }     }      //输出整个循环双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d(=)",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         s=s->next;         if (s==head) {             printf(" Loop\n");             break;         }     }      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;             break;         }         p=p->next;         if (p==head) break;     }     head=q->next;      //输出整个循环双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d(=)",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         s=s->next;         if (s==head) {             printf(" Loop\n");             break;         }     }      //释放所有节点     p=head;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;         if (p==head) {             break;         }     }      return 0; } //创建10个节点的循环双向链表:12(=)46(=)31(=)63(=)25(=)91(=)39(=)02(=)92(=)68(=) Loop //将值为5的结点插入到循环双向链表的第3个结点前:12(=)46(=)05(=)31(=)63(=)25(=)91(=)39(=)02(=)92(=)68(=) Loop //删除第5个节点:12(=)46(=)05(=)31(=)25(=)91(=)39(=)02(=)92(=)68(=) Loop //从小到大排序:02(=)05(=)12(=)25(=)31(=)39(=)46(=)68(=)91(=)92(=) Loop //将整个链表逆序:92(=)91(=)68(=)46(=)39(=)31(=)25(=)12(=)05(=)02(=) Loop //将循环双向链表中前4个结点和后6个结点进行互换:39(=)31(=)25(=)12(=)05(=)02(=)92(=)91(=)68(=)46(=) Loop //


Question: 大神们，关于出栈的问题

引用 7楼自信男孩 的回复:[quote=引用 6 楼 pkuzhx 的回复:] 你压根就没搞明白题目是啥意思。 如果e1~e6是连续入栈，中间没有出栈操作，那么出栈顺序当然就是e6~e1。 题目这么问了，那显然入栈、出栈的操作是混在一起的，不是全部都入栈了才出栈，可能先入两个，出一个，再入两个，再出三个等等。 说到这里，具体怎么分析你应该知道了 嗯，这位兄台分析的比较到位。需求里已经有体现，并不是中间没有出栈情况，所以这个出栈顺序还得看你的实际中有没有是出栈和入栈混合进行的。[/quote]哦，可以入宅接着出宅，题目看懂了，出宅的顺序题目已经给出来了，是我理解错了，最少只有三个的存储空间，

引用 8楼angel6709 的回复:[quote=引用 4 楼 qq_36639412 的回复:] [quote=引用 3 楼 angel6709 的回复:] 这个要看代码的。。。 设栈S和队列Q的初始状态为空，元素E1,E2,E3,E4,E5,E6,依次通过栈S，一个元素出栈后即进入队列后Q，若6个元素出列的顺序为E2,E4,E3,E6,E5,E1,则栈的容量至少是多少，A，6，B，4，C，3，D，2，[/quote]  4，3，1或6,5,1 选c[/quote]嗯

引用 10楼wedragon 的回复:入栈中夹杂着出栈，就会出现这种情况。哦

引用 6 楼 pkuzhx 的回复:你压根就没搞明白题目是啥意思。 如果e1~e6是连续入栈，中间没有出栈操作，那么出栈顺序当然就是e6~e1。 题目这么问了，那显然入栈、出栈的操作是混在一起的，不是全部都入栈了才出栈，可能先入两个，出一个，再入两个，再出三个等等。 说到这里，具体怎么分析你应该知道了 嗯，这位兄台分析的比较到位。需求里已经有体现，并不是中间没有出栈情况，所以这个出栈顺序还得看你的实际中有没有是出栈和入栈混合进行的。

入栈中夹杂着出栈，就会出现这种情况。

引用 7 楼 cfjtaishan 的回复:[quote=引用 6 楼 pkuzhx 的回复:] 你压根就没搞明白题目是啥意思。 如果e1~e6是连续入栈，中间没有出栈操作，那么出栈顺序当然就是e6~e1。 题目这么问了，那显然入栈、出栈的操作是混在一起的，不是全部都入栈了才出栈，可能先入两个，出一个，再入两个，再出三个等等。 说到这里，具体怎么分析你应该知道了 嗯，这位兄台分析的比较到位。需求里已经有体现，并不是中间没有出栈情况，所以这个出栈顺序还得看你的实际中有没有是出栈和入栈混合进行的。[/quote]找一个最大递减序列。。

引用 4 楼 qq_36639412 的回复:[quote=引用 3 楼 angel6709 的回复:] 这个要看代码的。。。 设栈S和队列Q的初始状态为空，元素E1,E2,E3,E4,E5,E6,依次通过栈S，一个元素出栈后即进入队列后Q，若6个元素出列的顺序为E2,E4,E3,E6,E5,E1,则栈的容量至少是多少，A，6，B，4，C，3，D，2，[/quote]  4，3，1或6,5,1 选c

引用 1 楼 cfjtaishan 的回复:要看你的实现了；贴一下代码吧设栈S和队列Q的初始状态为空，元素E1,E2,E3,E4,E5,E6,依次通过栈S，一个元素出栈后即进入队列后Q，若6个元素出列的顺序为E2,E4,E3,E6,E5,E1,则栈的容量至少是多少，A，6，B，4，C，3，D，2，

引用 3 楼 angel6709 的回复:这个要看代码的。。。 设栈S和队列Q的初始状态为空，元素E1,E2,E3,E4,E5,E6,依次通过栈S，一个元素出栈后即进入队列后Q，若6个元素出列的顺序为E2,E4,E3,E6,E5,E1,则栈的容量至少是多少，A，6，B，4，C，3，D，2，

这个要看代码的。。。

百度搜相关关键字。

要看你的实现了；贴一下代码吧


Question: 魔力手环


Question: 主函数和子函数调用printf()输出主函数的i和子函数的i

int main(void)  {  int i=99;    // i初始化为99 printf("%d\n", i);  //打印99  i=f(5);              //i=f(5); 5以形式参数传递进入函数，然后返回值5，相当于 i= 5;  printf("%d\n", i);   //打印i，值为5 printf("%d\n", f(i));  // 这里没有任何歧义，这里调用的i为main函数中的i， //注意1：子函数中的i只在子函数中有效，出了子函数的大括号，那个子函数中的i已经消亡了。 //注意2：主函数中调用 f(i) 实际工作是借用主函数中i的值进行运算。 //小结：主函数中的i比喻为 张三，子函数中的i恰巧也叫张三，这两个i只是重名。把衣服比作值的话，，就是主函数中的张三把 //衣服借给子函数中的张三，子函数中的张三借用主函数中张三的衣服参加完典礼【函数运算】后还是要把衣服 //还给主函数中的张三的。 //如果子函数中使用的是&i ，那么两个张三就是同一个人了【这个时候就不是借衣服了，而是把张三完完整整的借过来了】， return 0;   }

不会有错，第二个和第三个的区别是，第二个把函数调用和打印结果分开。如果以后不想打印结果，那么只需要注释掉printf即可，而第三个注释掉printf以后会影响功能。代码维护方面肯定是第二个好。