Question: 求帮忙看看这个错误怎么改，在线等

引用 6 楼 max_min_ 的回复:下面代码修改了下几个基础的错误，忘记修改了那些了，所以把代码全部贴上！ 逻辑问题还没仔细看，但是楼主这个基础错误太多，先不要搞这些复杂东西先， 应该先把基础打好，一步一步的来，不要搞太难的东西打击自己的积极性！   #include<stdio.h> #include<malloc.h> #include<string.h> #include<stdlib.h>  #define MAX_SIZE  20//定义循环队列的长度  typedef struct{            //初始化的动态分配存储空间     char*base;     char front;     char rear;     int full;//队列是否已满的标志位     int length; }Queue;      int creat_queue(Queue*q)      //初始化队列 {   if (q->base!=NULL)//队列已经存在，要先销毁     return 0;     q->base=(char*)malloc(MAX_SIZE*sizeof(char));     q->front=q->rear=0;     q->full=0;     q->length=0;     return 1; }  int en_queue(Queue*q,char e)      //入队 {        if(q->base==NULL)         return -1;//是队列不存在      else if(q->full==1&&q->front==q->rear)         return 0;//入队前考虑队列是否满了     else {         q->base[q->rear]=e;         q->rear=(q->rear+1)%MAX_SIZE;//实现循环,如果rear+1满了并不是真正的满了，可以循环         if(q->front==q->rear)             q->full=1;         return 1;     } } int out_queue(Queue*q,char* e) {     if(q->base==NULL)     return -1;//是队列不存在      if(q->full==0&&q->front==q->rear)         return 0; //出队前考虑队列是否为空     else {         *e=q->base[q->front];         q->front=(q->front+1)%MAX_SIZE;//修改front位置         if(q->front==q->rear)             q->full=0;//如果出队后两位置相同则队为空了         return 1;     }  }  int main() {     Queue q;     int i,a1,a2,a3,a4;     char e,k=NULL;     char *e1,*e2;     q.base=NULL;     e1=e2=&k;//对于指针最好这样初始化定义一下，因为只声明是没有分陪内存的，不能直接用*e     a1=creat_queue(&q);                            //初始化队列     if(a1==1){         printf("已初始化队列！");     }else{         printf("初始化失败!");     }     for(i=0;i<11;i++){ //依次进队列e，n，g，i，n，e，e，r，i，n，g；         printf("请输入第%d个字符",i+1);         scanf("%c",&e);         getchar();         a2=en_queue(&q,e);         if(a2==-1)         {             printf("队列不存在!\n");             break;         }         else if(a2==0)         {             printf("队列已满!\n");             break;         }         else         {             printf("已入队!\n");             q.length++;         }     }     a3=out_queue(&q,e1); //出队一个元素，输出该元素；     if(a3==-1)     {         printf("队列不存在，请先创建队列！\n");     } else if(a3==0){         printf("出队失败！因为队列为空！\n");     }else{         printf("OK!出队成功");         printf("出队元素为：%d\n",*e1);         q.length--;     }      printf("队列q的元素个数为：%d",q.length);       //输出队列q的元素个数；   for(i=0;i<3;i++){ //依次进队列元素d,e,f；          printf("请输入第%d个字符",i+1);         scanf("%c",&e);         getchar();         a2=en_queue(&q,e);         if(a2==-1)         {             printf("队列不存在!\n");             break;         }         else if(a2==0)         {             printf("队列已满!\n");             break;         }         else{             printf("已入队!\n");             q.length++;         }     }      printf("队列q的元素个数为：%d",q.length);       //输出队列q的元素个数；       for(i=0;i<13;i++){ //输出出队序列；          out_queue(&q,e1);         printf("%d：%c\n",i+1,*e1);         q.length--;     }     free(q.base);          //释放队列     q.base=NULL;  } 我一个一个修改好了。。。。。坑爹啊，谢谢你们啦

。。。。。泪崩了，赶着交作业，麻烦各位大虾帮忙改下好吗

呵呵，楼主寻找智能改错机来啦。

引用 1 楼 u010553752 的回复:在线等，就这一个错误了，急着交作业。。。。 哥们你这个不是就这一个错误 是有一群错误 编辑器是不见到语法错误 就不往下报了 你是少个} 但是 改完后 你会崩溃 会出现一群错误 不下10个

#include<stdio.h>  #include<malloc.h>  #include<string.h>  #include<stdlib.h>  #define MAX_SIZE  20//定义循环队列的长度  typedef struct{            //初始化的动态分配存储空间 char*base;  char front;  char rear;  int full;//队列是否已满的标志位 int length;  }Queue;  int creat_queue(Queue*q)      //初始化队列  {   if (q->base!=NULL)//队列已经存在，要先销毁        return 0;  q->base=(char*)malloc(MAX_SIZE*sizeof(char));  q->front=q->rear=0;  q->full=0;  q->length=0;  return 1;  }  int en_queue(Queue*q,char e)      //入队  {   if(q->base==NULL)          return -1;//是队列不存在 else if(q->full==1&&q->front==q->rear)          return 0;//入队前考虑队列是否满了 else {  q->base[q->rear]=e;      q->rear=(q->rear+1)%MAX_SIZE;//实现循环,如果rear+1满了并不是真正的满了，可以循环      if(q->front==q->rear)   q->full=1;  return 1;}  }  int out_queue(Queue*q,int*e)  {  if(q->base==NULL)          return -1;//是队列不存在     if(q->full==0&&q->front==q->rear)     return 0; //出队前考虑队列是否为空   else {  *e=q->base[q->front];  q->front=(q->front+1)%MAX_SIZE;//修改front位置     if(q->front==q->rear)  q->full=0;//如果出队后两位置相同则队为空了 return 1;  }   }   int main(){   Queue q;  int i,a1,a2,a3,a4;  char e,k=NULL;  char *e1,*e2;  q.base=NULL;      e1=e2=&k;//对于指针最好这样初始化定义一下，因为只声明是没有分陪内存的，不能直接用*e  a1=creat_queue(&q);                            //初始化队列 if(a1==1){  printf("已初始化队列！");  }else{  printf("初始化失败!");  } for(i=0;i<11;i++){ //依次进队列e，n，g，i，n，e，e，r，i，n，g； printf("请输入第%d个字符",i+1);  scanf("%c",&e);  getchar(); a2=en_queue(&q,e);  if(a2==-1){  printf("队列不存在!\n");break;  }  else if(a2==0){  printf("队列已满!\n");break;  }  else{  printf("已入队!\n");  q.length++;  }  }   a3=out_queue(&q,e1); //出队一个元素，输出该元素；  if(a3==-1)   {   printf("队列不存在，请先创建队列！\n");   } else if(a3==0){   printf("出队失败！因为队列为空！\n");   }else{   printf("OK!出队成功");   printf("出队元素为：%d\n",*e1);   q.length--;  }    printf("队列q的元素个数为：%d",q.length);       //输出队列q的元素个数；  for(i=0;i<3;i++){ //依次进队列元素d,e,f； printf("请输入第%d个字符",i+1);  scanf("%c",&e);  getchar(); a2=en_queue(&q,e);  if(a2==-1) printf("队列不存在!\n");  else if(a2==0){  printf("队列已满!\n");  }  else{  printf("已入队!\n");  q.length++;  }  }    printf("队列q的元素个数为：%d",q.length);       //输出队列q的元素个数；    for(i=0;i<13;i++){ //输出出队序列； out_queue(&q,e1);  printf("%d：%c\n",i+1,*e1);   q.length--;  }  free(q.base);          //释放队列 q.base=NULL;  return 0; }   已经把所有错误改掉 但是你程序逻辑 我根本看不进去 代码风格惨淡啊 看看代码大全吧 我半年前也就你这水平  主要错误  if else if else 不要加break的  第二点  .与->的区别 ->是指针指向其成员的运算符.是结构体的成员运算符  有问题可以继续问

在线等，就这一个错误了，急着交作业。。。。


Question: 求牛人推荐本数据结构的书籍

《数据结构(c语言版)》  为什么要有数据结构这个东东？ 因为要将现实世界或者抽象理论中的各种数据保存在计算机外存（光盘、硬盘、U盘……）或内存（ROM、RAM、SRAM……）里面的二进制字节数组中。 然后让CPU这个只会执行预先保存好的加减乘除移位条件转移……等机器指令的家伙按照人的意志去处理这些数据。至于具体如何处理就是所谓算法。

看来看去严蔚敏版《数据结构》一直都以为数据结构就是死记各种数据结构的操作，后来做了配套的上机题（不是学校发的，是我在淘宝买的）之后，才发现。我的妈呀，原来数据结构是用来这样的。

引用 10 楼 u012507762 的回复:[quote=引用 8 楼 ak47_wz 的回复:] 我也不是牛人。 不过有一本书《数据结构（C语言版）》的不错。另外一本叫做《数据结构1000个问题》感觉也不错。 没看过多少。主要还是多用，多思考。 请问哪个出版社？？哪个作者[/quote] 都是外国人，我也忘了。。。

引用 5 楼 u011779875 的回复:算法导论  专业啊 话说我的水平也就看了一章算法导论的水准  太专业的还是别吧~~一步一步来

引用 8 楼 ak47_wz 的回复:我也不是牛人。 不过有一本书《数据结构（C语言版）》的不错。另外一本叫做《数据结构1000个问题》感觉也不错。 没看过多少。主要还是多用，多思考。 请问哪个出版社？？哪个作者

引用 6 楼 max_min_ 的回复:c语言版 数据结构 请问哪个出版社？？哪个作者

《大话数据结构》怎么样？

c语言版 数据结构

算法导论  专业啊 话说我的水平也就看了一章算法导论的水准

引用 3 楼 guojing3625 的回复:http://product.dangdang.com/9188635.html#catalog  我不是高手。。

俺也不是，接分

俺不是牛人，路过。


Question: ubuntu怎么做到在程序运行完会自动关闭终端？

引用 4 楼 ak47_wz 的回复:[quote=引用 2 楼 u011779875 的回复:] [quote=引用 楼主 q390511749 的回复:] ubuntu终端c语言程序，如何实现程序运行结束会自动关闭终端，而不是停留在命令行上？ 我上述方法是错误的 搞定不了 我试了一下 这样可以    #include <stdio.h>    #include <sys/types.h>    #include <signal.h>    #include <unistd.h>    #include <stdlib.h>   int main()    {      printf("hello world\n");      pid_t kill_num;      kill_num  =getppid();      kill(kill_num,4);      return 0;  }    子进程 得到父进程 子进程退出 kill掉父进程[/quote]  system函数相当于是调用一个shell来执行命令，应该是不能实现。这种方法可以。[/quote] 我才发现我回答的问题竟然没分 你说我对了 你却有分 我晕

引用 2 楼 u011779875 的回复:[quote=引用 楼主 q390511749 的回复:] ubuntu终端c语言程序，如何实现程序运行结束会自动关闭终端，而不是停留在命令行上？ 我上述方法是错误的 搞定不了 我试了一下 这样可以    #include <stdio.h>    #include <sys/types.h>    #include <signal.h>    #include <unistd.h>    #include <stdlib.h>   int main()    {      printf("hello world\n");      pid_t kill_num;      kill_num  =getppid();      kill(kill_num,4);      return 0;  }    子进程 得到父进程 子进程退出 kill掉父进程[/quote]  system函数相当于是调用一个shell来执行命令，应该是不能实现。这种方法可以。

引用 楼主 q390511749 的回复:ubuntu终端c语言程序，如何实现程序运行结束会自动关闭终端，而不是停留在命令行上？ 我上述方法是错误的 搞定不了 我试了一下 这样可以    #include <stdio.h>    #include <sys/types.h>    #include <signal.h>    #include <unistd.h>    #include <stdlib.h>   int main()    {      printf("hello world\n");      pid_t kill_num;      kill_num  =getppid();      kill(kill_num,4);      return 0;  }    子进程 得到父进程 子进程退出 kill掉父进程

引用 楼主 q390511749 的回复:ubuntu终端c语言程序，如何实现程序运行结束会自动关闭终端，而不是停留在命令行上？ man 3 system 加上头文件  程序结束时调用 system("exit"); 试试 好使不 我很久没用linux了


Question: malloc 的疑惑

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

引用 8 楼 daxiaoyuyu 的回复:[quote=引用 1 楼 u011779875 的回复:] 问题1  tmpCenter.value = (double) i;  (pVecCenter + i)->value = (double) i; ->是指针指向其成员的运算符 .是结构体的成员运算符 为什么不能用 *(pVecCenter + i).value = (double) i; 呢？[/quote] 可以这么用吧 但是你要这么用吧 我没测试 我也很久没敲这样的代码了 . 和*的优先级是.大于* 且结和性不同 (*(pVecCenter + i)).value = (double) i;

引用 1 楼 u011779875 的回复:问题1  tmpCenter.value = (double) i;  (pVecCenter + i)->value = (double) i; ->是指针指向其成员的运算符 .是结构体的成员运算符 为什么不能用 *(pVecCenter + i).value = (double) i; 呢？

跟Associativity无关，是优先级的问题，.比*在这里的优先级高。  这样就可以： (*(pVecCenter + i)).value = (double) i;   更常见的是：  (pVecCenter + i))->value = (double) i;

这程序的逻辑怎么这么别扭。。。

引用 5 楼 max_min_ 的回复:每次malloc一定长度的空间大小的时候，其实实际上会比这个多几个字节的内存空间的 这个空间就是用来存放free结束的标志量的！所以每次free的时候给出首地址，都能正确释放对应的内存空间地址！  ++

参考Linux的malloc和free相关源代码。

申请堆上的空间，对于申请多少，free掉的是不是开始申请的，这是由系统负责完成的，我们是看不到的。

问题2： 用 free(pVecCenter) 就能把分配的内存删掉了吗？free怎么会知道分配的内存空间有多少？难道说指针pVecCenter能够知道分配的内存空间的范围吗？  free是可以把pVecCenter 释放掉的 只要你释放的是正确的申请的地方 就会释放掉  free怎么会知道分配内存的多少？ 这个是malloc 貌似 啊 我敢说我一定对 我的理解是malloc管理一个内存区域的缓冲区的链表 你进行内存申请的时候 会对这个管理的内存缓冲区 空闲的地方进行申请 它会自动标示 你申请了哪个地方  这也就是为什么你申请不释放有时候不会出问题  也是为什么C++的new 与delete C语言的malloc 与free 要配对使用 它们管理的内存链表是不同的 所以应该是这样的


Question: 发个贴，吐个槽

引用 9 楼 z1179675084 的回复:[quote=引用 4 楼 u011779875 的回复:] [quote=引用 楼主 z1179675084 的回复:]    最近在论坛逛的比较平凡了点，也发现了部分回帖人不是很负责任，好多贴别人明明已经回答了，他看也不看，又来个相同的回复。这种还好，最怕的是那种连问题都没看清的人给你回帖。比如这个http://bbs.csdn.net/topics/390621996 人家的问题：依次输入十个自然数，输出最大的数及其输入次序 明明直接挑出最大的就可以了   #include <stdio.h>  int main() { 	int a[10],i,index = 0; 	for(i = 0;i < 10;i++) 	{ 		printf("please input the %d number\n",i + 1); 		scanf("%d",&a[i]); 		if(a[i] > a[index]) 		{ 			index = i; 		} 	} 	printf("The largest number is the %d value is%d  \n",index + 1,a[index]); 	return 0; }   结果绝大多数回帖都是说要冒泡排序别的什么排序之类的。各位解决这个问题有必要排序吗？把一个简单的问题复杂化（时间，空间的浪费我就不说了）。 大家回帖本来就是希望帮助别人的，吐个槽就是希望极其个别的人能本着认真负责的态度，看帖回帖！你可不要这么说啊 冒泡排序可是版主说的 什么叫相同回复 这个俩个人子啊回复的时候都是没人回复 这样在回复的时候 出现俩个人同时回复 这很正常  就像你同时写1个txt不加锁 会撞车一样 不可避免  第二 别人只不过是凭自己的理解去回答问题 并不是每个人思维都那么活跃 直接最简单的方法 还考虑毛时间空间 你把别人的热心当成不负责任 第三 别人回答不水点 怎么看出你是大神呢 第四 这个时间是需要对比的 要不然你怎么能学会吐槽 并不是每个人都知道最近的路  第五 冒泡排序怎么了 不能解决问题吗 这个时间上 不仅仅需要复杂的问题简单化  更需要简单的问题复杂化 就比如现在 你发这个帖子就是在把一件很简单的事在进行复杂化的过程一样 第六 无论何时都要宽容 你心眼也太小了吧 第七 每个人都有定式思维  一想到输出最大值 比然想到冒泡排序  难道你要说会冒泡排序难道还求不出来最大值吗[/quote] 版主确实说了冒泡排序，但是你连这个精神都没有吗？版主说的一定是最好的？ 冒泡排序没有任何问题，我只是说有点杀鸡用牛刀了，解决问题就是用最快的，最有效的。冒泡排序确实是好方法，但这个题并没有必要。我也相信能说出冒泡排序的都学的很好的，只是有一些并没有好好看一下题。我相信如果有面试官问这个绝对不希望你整个什么排序的出来！ 我心眼小不小你说了算。 我本人也是菜鸟一只，深切知道作为新手对过多的答案会迷糊，我说了希望大家认真看下题目，你有认真的看我的贴吗？我说了回答问题的都是热心人，只不过既然是为了帮助人，那再稍微多花点时间多为发帖人想想有问题吗？我有诋毁过任何人？  [/quote] 另外你注意一下版主的后一句话： 而且这个更简单，只要输出最大的，楼主找本书补补基础知识算法！

引用 8 楼 derekrose 的回复:空间上似乎并没有浪费什么。。  我的本意也并不是说空间时间的浪费掉，毕竟就10个元素，排序本身就花不了多少时间，解惑就是尽量能用咱们想到的最好办法，去答复人！因为我也是菜鸟 我的本意也并不是说空间时间的浪费掉，毕竟就10个元素，本身就花不了多少时间

引用 4 楼 u011779875 的回复:[quote=引用 楼主 z1179675084 的回复:]    最近在论坛逛的比较平凡了点，也发现了部分回帖人不是很负责任，好多贴别人明明已经回答了，他看也不看，又来个相同的回复。这种还好，最怕的是那种连问题都没看清的人给你回帖。比如这个http://bbs.csdn.net/topics/390621996 人家的问题：依次输入十个自然数，输出最大的数及其输入次序 明明直接挑出最大的就可以了   #include <stdio.h>  int main() { 	int a[10],i,index = 0; 	for(i = 0;i < 10;i++) 	{ 		printf("please input the %d number\n",i + 1); 		scanf("%d",&a[i]); 		if(a[i] > a[index]) 		{ 			index = i; 		} 	} 	printf("The largest number is the %d value is%d  \n",index + 1,a[index]); 	return 0; }   结果绝大多数回帖都是说要冒泡排序别的什么排序之类的。各位解决这个问题有必要排序吗？把一个简单的问题复杂化（时间，空间的浪费我就不说了）。 大家回帖本来就是希望帮助别人的，吐个槽就是希望极其个别的人能本着认真负责的态度，看帖回帖！你可不要这么说啊 冒泡排序可是版主说的 什么叫相同回复 这个俩个人子啊回复的时候都是没人回复 这样在回复的时候 出现俩个人同时回复 这很正常  就像你同时写1个txt不加锁 会撞车一样 不可避免  第二 别人只不过是凭自己的理解去回答问题 并不是每个人思维都那么活跃 直接最简单的方法 还考虑毛时间空间 你把别人的热心当成不负责任 第三 别人回答不水点 怎么看出你是大神呢 第四 这个时间是需要对比的 要不然你怎么能学会吐槽 并不是每个人都知道最近的路  第五 冒泡排序怎么了 不能解决问题吗 这个时间上 不仅仅需要复杂的问题简单化  更需要简单的问题复杂化 就比如现在 你发这个帖子就是在把一件很简单的事在进行复杂化的过程一样 第六 无论何时都要宽容 你心眼也太小了吧 第七 每个人都有定式思维  一想到输出最大值 比然想到冒泡排序  难道你要说会冒泡排序难道还求不出来最大值吗[/quote] 版主确实说了冒泡排序，但是你连这个精神都没有吗？版主说的一定是最好的？ 冒泡排序没有任何问题，我只是说有点杀鸡用牛刀了，解决问题就是用最快的，最有效的。冒泡排序确实是好方法，但这个题并没有必要。我也相信能说出冒泡排序的都学的很好的，只是有一些并没有好好看一下题。我相信如果有面试官问这个绝对不希望你整个什么排序的出来！ 我心眼小不小你说了算。 我本人也是菜鸟一只，深切知道作为新手对过多的答案会迷糊，我说了希望大家认真看下题目，你有认真的看我的贴吗？我说了回答问题的都是热心人，只不过既然是为了帮助人，那再稍微多花点时间多为发帖人想想有问题吗？我有诋毁过任何人？

空间上似乎并没有浪费什么。。

引用 5 楼 zhao4zhong1 的回复:回帖人不欠发帖人的。 恩，肯定不会存在欠不欠的，我意思是发帖人都是想帮助别人的既然是帮助别人，多花点时间看看题目应该没什么错吧！

回帖人不欠发帖人的。

引用 楼主 z1179675084 的回复:最近在论坛逛的比较平凡了点，也发现了部分回帖人不是很负责任，好多贴别人明明已经回答了，他看也不看，又来个相同的回复。这种还好，最怕的是那种连问题都没看清的人给你回帖。比如这个http://bbs.csdn.net/topics/390621996 人家的问题：依次输入十个自然数，输出最大的数及其输入次序 明明直接挑出最大的就可以了   #include <stdio.h>  int main() { 	int a[10],i,index = 0; 	for(i = 0;i < 10;i++) 	{ 		printf("please input the %d number\n",i + 1); 		scanf("%d",&a[i]); 		if(a[i] > a[index]) 		{ 			index = i; 		} 	} 	printf("The largest number is the %d value is%d  \n",index + 1,a[index]); 	return 0; }   结果绝大多数回帖都是说要冒泡排序别的什么排序之类的。各位解决这个问题有必要排序吗？把一个简单的问题复杂化（时间，空间的浪费我就不说了）。 大家回帖本来就是希望帮助别人的，吐个槽就是希望极其个别的人能本着认真负责的态度，看帖回帖！你可不要这么说啊 冒泡排序可是版主说的 什么叫相同回复 这个俩个人子啊回复的时候都是没人回复 这样在回复的时候 出现俩个人同时回复 这很正常  就像你同时写1个txt不加锁 会撞车一样 不可避免  第二 别人只不过是凭自己的理解去回答问题 并不是每个人思维都那么活跃 直接最简单的方法 还考虑毛时间空间 你把别人的热心当成不负责任 第三 别人回答不水点 怎么看出你是大神呢 第四 这个时间是需要对比的 要不然你怎么能学会吐槽 并不是每个人都知道最近的路  第五 冒泡排序怎么了 不能解决问题吗 这个时间上 不仅仅需要复杂的问题简单化  更需要简单的问题复杂化 就比如现在 你发这个帖子就是在把一件很简单的事在进行复杂化的过程一样 第六 无论何时都要宽容 你心眼也太小了吧 第七 每个人都有定式思维  一想到输出最大值 比然想到冒泡排序  难道你要说会冒泡排序难道还求不出来最大值吗

不明觉厉，楼主你说的很对。

我可以接个分吗？

萝卜快了 不洗泥


Question: 程序运行错误 显示 “process exited with return value 3221225725”

以下2行： struct convert part[(mesh/sampling+1)*(mesh/sampling+1)]; struct bccinput input[Ymax+1][Xmax+1]; 试加上static： static struct convert part[(mesh/sampling+1)*(mesh/sampling+1)]; static struct bccinput input[Ymax+1][Xmax+1]; 以解决数组很大时出现的问题。

Windows： 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处。  Linux： 进程意外退出会在当前目录下产生‘core’文件或形如‘core.数字’的文件比如‘core.1234’ 使用命令 gdb 运行程序名 core或core.数字 进入gdb然后使用bt命令 可以查看进程意外退出前函数调用的堆栈，内容为从上到下列出对应从里层到外层的函数调用历史。 如果进程意外退出不产生core文件，参考“ulimit -c core文件最大块大小”命令

程序非正常退出了吧！ (mesh/sampling+1)*(mesh/sampling+1)] 再看看这句话是不是可能引起问题的！

编译用-g参数，用gdb排查

mesh 这都是什么啊 程序又不全  根本不可能帮你debug 程序 没注释  比我写的还乱 我推荐你看看代码大全 如果不用调试一眼就看出你程序问题所在 那真是高手  错误提示 “process exited with return value 3221225725”.   程序非正常退出  检查方法 debug查看具体出错位置分析  我个人认为 应该是库函数异常退出你自己 debug试试 否则你就贴完整可运行代码


Question: C数组问题

#include <stdio.h> int main() { 	int i; 	int a[5]; 	for(i = 0;i <= 5;i++) 	{ 		a[i] = -1-i; 		printf("%d\n",a[i]); 	} 	return 0; }  一般来说上面的程序会出问题，无限循环。越界访问了a[5]就是i,因为被改写了，所以会无限循环，当然这个不一定。具体要看编译器怎么做了

有限制，但是你得自己注意。你这里越界了

引用 3 楼 fengyunsen4 的回复:那是不是以后码代码应该避免这样的情况，或者如果非要这样用必须要做出判断？ 是的我告诉你如何判断 成为高手 #include<assert.h>  assert(0 <= idx && idx < sizeof(a) /sizeof(a[0])); a[idx] 就是安全的   调试好程序后加上#DEBUG 这样可以自动避免 等写好程序在都去掉assert

那是不是以后码代码应该避免这样的情况，或者如果非要这样用必须要做出判断？

引用 1 楼 u011779875 的回复:char name[3]; 这个数组是线性存储的 它会随机找零散的线性内存区域 满足你的name[3]空间 如果name[4]后面的内存区域没与人在用 或者不是系统保护的地方 你是可以访问到的 但不代表你的程序每次运行都可以访问到 有可能会出段错误  比如你输入100多个j 你看看 必会出段错误  大一菜鸟飞飞又学到了


Question: uint8_t *和char*的相互转换 以及 uint8_t  *  和int16_t*的相互转换

那是16bit uint8_t * p3; p3 = (uint16_t *)p; 我访存的时候 就是按无符号16bit拿出值 *p3 就是我拿出的值 0x11ff吧 我可能算错了 但是就是这个意思

引用 11 楼 neuredfox 的回复:“是访存时候 我怎么去看 ”这是什么意思呢，亲 就是 我有一段空间 就是一个数组 假如 int a = 0x111111ff; 16进制 int * p = a; 这个指针p保存的是a的地址对吧  *p 的值就是0x111111ff吧 拿出4个字节  之后我就玩转换了 uint8_t * p2; p2 = (uint8_t *)p; 我访存的时候 就是按无符号8bit拿出值 *p2 就是我拿出的值 0xff吧  uint8_t * p3; p3 = (uint16_t *)p; 我访存的时候 就是按无符号8bit拿出值 *p3 就是我拿出的值 0x11ff吧 我可能算错了 但是就是这个意思

“是访存时候 我怎么去看 ”这是什么意思呢，亲

比如一段 内存区域 我想   1字节     uint8_t *  就是取前1个字节的看做无符号8bit数   2字节     uint16_t * 就是取前2个字节的看做无符号8bit数   4字节     uint32_t * 就是取前4个字节的看做无符号8bit数   8字节     uint64_t * 就是取前8个字节的看做无符号8bit数  这个是指针 是访存时候 我怎么去看  不会有溢出和符号任何问题

可以随便转换  我才看出来 原来我错了 那个是指针啊uint8_t *和char*的相互转换 以及 uint8_t * 和int16_t* 我说的是如果是类型就不可以随便强转了  他们操作的是地址  随便转没问题

可是，在调用一个别的库的时候， len1 = avcodec_decode_audio3(codecContext,audio_buf1,&data_size,pkt_temp);  这里的audio_buf1，不是一个int16_t*的类型么？这个难道不会溢出？ 我刚开始的代码是不转换的， ESPkt->data = audio_buf1;编译器会报错  error: cannot convert 'int16_t*' to 'uint8_t*' in assignment

你那个结构体这么定义uint8_t       *data; //!< AV packet data pointer   说明这个包最大返回也不会超过无符号8个字节  所以你转换的时候 不会 溢出 也不会有符号问题 但还是不建议这么来做 这不是在考验人的智商吗

可是最终的class ESPacket {  public:   explicit ESPacket();   ~ESPacket();   bool          IsEOS() { return is_EOS_; }   void          SetEOS(bool eos) { is_EOS_ = eos; size = 1024;}   int32_t       GetSize();   void          *private_data; //!< private data pointer which may be used by data reader   uint32_t      sequence_header_size; //!< sequence header size if need   uint8_t       *sequence_header_data; //!< sequence header data pointer if size > 0   uint32_t      frame_header_size; //!< frame header size if need   uint8_t       *frame_header_data; //!< frame header data pointer if size > 0   uint32_t      frame_header_need_free; //!< if the frame header data need be freed every time   uint8_t       seqheader_need_free; //!< if need free sequence_header_data every time    uint8_t       *data; //!< AV packet data pointer   //int16_t       *data; //!< AV packet data pointer   int32_t       size; //!< AV packet size   uint32_t      index; //!< Stream index of the packet   TimeStamp     pts;   uint32_t      is_i_frame; //!< Flag of I frame(for video only)    typedef enum {     ES_TYPE_INVALID = 0x100,     ES_TYPE_VIDEO,     ES_TYPE_AUDIO,     ES_TYPE_SUB,   } ES_TYPE;   ES_TYPE       GetType() { return type_; }   void          SetType(ES_TYPE type) { type_ = type; }   private:   bool          is_EOS_;   ES_TYPE       type_; };  这个库里面必须用  uint8_t       *data; //!< AV packet data pointer  这个要怎么弄。。。。被搞晕了几天了。

引用 3 楼 neuredfox 的回复:[quote=引用 1 楼 u011779875 的回复:] uint8_t,int16_t一般是指无符号8bit整型数和有符号16bit整形数，C语言无此类型，自己定义 如： typedef unsigned char uint8_t; 于char类型只相差一个符号，一般可以直接转换： char* a = (char*)b; uint8_t* b = (uint8_t*)a;    还有C语言有一个标准库叫 <stdint.h> stdint.h是c99中引进的一个标准C库的头文件. 二、干什么 C99中，<stdint.h>中定义了几种扩展的整数类型和宏。  那请问 uint8_t *a; int16_t* b; a = (uint *)b; 这样是否可行呢，谢谢。[/quote] 如果都是正的没问题吧 应该你最好用uint16_t* audio_buf1;

uint8_t  无符号8bit整型数 int16_t  有符号16bit整形数 个人意见 我不敢保证 仅供参考 没问题吧 就比如 char c = 2; int tmd; tmd = (int )c;  或者 int c = 444; char tmd; tmd = (char)c; 大了向小的转换没问题 小的向大的转换有问题 无符号向有符号之间的转换要小心

引用 1 楼 u011779875 的回复:uint8_t,int16_t一般是指无符号8bit整型数和有符号16bit整形数，C语言无此类型，自己定义 如： typedef unsigned char uint8_t; 于char类型只相差一个符号，一般可以直接转换： char* a = (char*)b; uint8_t* b = (uint8_t*)a;    还有C语言有一个标准库叫 <stdint.h> stdint.h是c99中引进的一个标准C库的头文件. 二、干什么 C99中，<stdint.h>中定义了几种扩展的整数类型和宏。  那请问 uint8_t *a; int16_t* b; a = (uint *)b; 这样是否可行呢，谢谢。

我在使用ffmpeg的库做ape的软解码， 其中 ESPacket* ESPkt = new ESPacket;  这个结构中的 一个成员是： uint8_t       *data; //!< AV packet data pointer 而我调用的 len1 = avcodec_decode_audio3(codecContext,audio_buf1,&data_size,pkt_temp); 使用了一个 int16_t* audio_buf1; 最后的回调前，赋值 ESPkt->data = (uint8_t  *)audio_buf1;  这样会不会有问题呀，各位大哥么。


Question: C语言指针问题

引用 9 楼 Luisfan 的回复:[quote=引用 2 楼 zhao4zhong1 的回复:] 取出内存地址0x40011400开始的4个字节对应的unsigned long值。  正[/quote]

引用 2 楼 zhao4zhong1 的回复:取出内存地址0x40011400开始的4个字节对应的unsigned long值。  正

感谢各位啦

看起来应该是强制转换，再读取指针内容。

强制转换，再解指针

1.将地址0x40011400强制转成volatile unsigned long*类型 2.对它进行解引用，就得到unsigned long类型的内容。 然后你可以把结果赋给unsigned long类型的变量了。

(*((volatile unsigned long*)0x40011400)) 用1个unsigned long*指针指向地址0x40011400里的内容，volatile表示每次都会重新进行读取，可能这块内存的数据会变化。

引用 3 楼 z1179675084 的回复:把0x40011400转化为（unsigned long *）的，前面那个*表示对其取值，就是从0x40011400开始连续读取8个字节的数据。至于volatile表示这个内存空间中的值可能会发生变化，每次取的时候都要重新读取这篇内存！ 上面有点问题是读取4个字节

百度啊 有多是答案的 http://blog.sina.com.cn/s/blog_65861d3f0100xsz0.html


Question: 大学初学者，c语言关于奇偶的问题。

引用 2 楼 max_min_ 的回复:动态数组！ malloc / free    new/delete ([])  版主大人   这个怎么做啊

来个人 啊

动态数组！ malloc / free    new/delete ([])

不知道具体问题是什么  所谓“不限定个数”，用动态分配内存吧； 比如  char *p = (char*) malloc(sizeof(c));         ...........;         free(p);  之类的，可以动态分配一个指针，指向一块内存， 最后需要用free函数释放这个区域；

六楼的就可以啊。

将 while (EOF != scanf("%d", &number))改为 while (1 == scanf("%d", &number))更友好些

随便输 如果想要节省内存 那就需要 malloc 和realloc 动态试探 申请内存  #define MAX_SIZE 1024 int elem[MAX_SIZE]; int num; int i; scanf("%d",&num);  for(i = 0; i < num;i++) scanf("%d",&elem[i]);

引用 6 楼 Kenier 的回复:#include <stdio.h>  int main(void) {     int number;     while (EOF != scanf("%d", &number))         puts(number % 2 ? "Yes" : "No");     return 0; }  谢谢。

引用 3 楼 u012541661 的回复:一个很简单的题目。就是输入一组整数，判断奇偶，奇数输出no偶数输出yes。老师留得作业，昨天搞了半夜，这题卡住了。 用一个字符串接收，然后自己分解成多个数，然后判断输出


Question: 多模匹配

google下呗， 如果还不能搜到也就没多少人有资料了。


Question: 依次输入十个自然数，输出最大的数及其输入次序

本人初学者忘大家多多帮助

引用 12 楼 BenRenYiGuaShi 的回复:[quote=引用 11 楼 z1179675084 的回复:] [quote=引用 9 楼 BenRenYiGuaShi 的回复:] 思路如下既不改变数组顺序，直接利用冒泡的算法循环一次 就行了  int input[]; int MaxNum; MaxNum = max(input[]);  你看看我七楼的回复，明明很简单的事情非要整那么复杂！！！[/quote]很复杂吗？？呵呵。。。都是那个是思想我只是简单写了操作的步骤而已。。。[/quote]  引用 12 楼 BenRenYiGuaShi 的回复:[quote=引用 11 楼 z1179675084 的回复:] [quote=引用 9 楼 BenRenYiGuaShi 的回复:] 思路如下既不改变数组顺序，直接利用冒泡的算法循环一次 就行了  int input[]; int MaxNum; MaxNum = max(input[]);  你看看我七楼的回复，明明很简单的事情非要整那么复杂！！！[/quote]很复杂吗？？呵呵。。。都是那个是思想我只是简单写了操作的步骤而已。。。[/quote] 淡定，好好看下，关键是这个问题没有必要进行排序！

引用 11 楼 z1179675084 的回复:[quote=引用 9 楼 BenRenYiGuaShi 的回复:] 思路如下既不改变数组顺序，直接利用冒泡的算法循环一次 就行了  int input[]; int MaxNum; MaxNum = max(input[]);  你看看我七楼的回复，明明很简单的事情非要整那么复杂！！！[/quote]很复杂吗？？呵呵。。。都是那个是思想我只是简单写了操作的步骤而已。。。

引用 15 楼 BenRenYiGuaShi 的回复:[quote=引用 13 楼 z1179675084 的回复:] [quote=引用 12 楼 BenRenYiGuaShi 的回复:] [quote=引用 11 楼 z1179675084 的回复:] [quote=引用 9 楼 BenRenYiGuaShi 的回复:] 思路如下既不改变数组顺序，直接利用冒泡的算法循环一次 就行了  int input[]; int MaxNum; MaxNum = max(input[]);  你看看我七楼的回复，明明很简单的事情非要整那么复杂！！！[/quote]很复杂吗？？呵呵。。。都是那个是思想我只是简单写了操作的步骤而已。。。[/quote]  引用 12 楼 BenRenYiGuaShi 的回复:[quote=引用 11 楼 z1179675084 的回复:] [quote=引用 9 楼 BenRenYiGuaShi 的回复:] 思路如下既不改变数组顺序，直接利用冒泡的算法循环一次 就行了  int input[]; int MaxNum; MaxNum = max(input[]);  你看看我七楼的回复，明明很简单的事情非要整那么复杂！！！[/quote]很复杂吗？？呵呵。。。都是那个是思想我只是简单写了操作的步骤而已。。。[/quote] 淡定，好好看下，关键是这个问题没有必要进行排序！[/quote]你笑死我了  。。。 我说排序了吗。。我只说利用冒泡算法的思想，循环一次 你不也循环了一次吗。。。你不是也是利用冒泡算法的思想嘛，，，别开玩笑了，。。[/quote] 你如果非要给我加个排序的思想，那也只能是选择

引用 13 楼 z1179675084 的回复:[quote=引用 12 楼 BenRenYiGuaShi 的回复:] [quote=引用 11 楼 z1179675084 的回复:] [quote=引用 9 楼 BenRenYiGuaShi 的回复:] 思路如下既不改变数组顺序，直接利用冒泡的算法循环一次 就行了  int input[]; int MaxNum; MaxNum = max(input[]);  你看看我七楼的回复，明明很简单的事情非要整那么复杂！！！[/quote]很复杂吗？？呵呵。。。都是那个是思想我只是简单写了操作的步骤而已。。。[/quote]  引用 12 楼 BenRenYiGuaShi 的回复:[quote=引用 11 楼 z1179675084 的回复:] [quote=引用 9 楼 BenRenYiGuaShi 的回复:] 思路如下既不改变数组顺序，直接利用冒泡的算法循环一次 就行了  int input[]; int MaxNum; MaxNum = max(input[]);  你看看我七楼的回复，明明很简单的事情非要整那么复杂！！！[/quote]很复杂吗？？呵呵。。。都是那个是思想我只是简单写了操作的步骤而已。。。[/quote] 淡定，好好看下，关键是这个问题没有必要进行排序！[/quote]你笑死我了  。。。 我说排序了吗。。我只说利用冒泡算法的思想，循环一次 你不也循环了一次吗。。。你不是也是利用冒泡算法的思想嘛，，，别开玩笑了，。。

# include <stdio.h> # include <limits.h>  int main() {     int max = INT_MIN;     int input;     int input_round = 0;     int i;     for (i = 0; i < 10; i++)     {         scanf("%d", &input);         if (input > max)         {             max = input;             input_round = i + 1;         }     }     printf("max is %d @ %d\n", max, input_round);      return 0; }

很简单吧！就是基础的冒泡法也能搞定吧！ 而且这个更简单，只要输出最大的，楼主找本书补补基础知识算法！

引用 7 楼 z1179675084 的回复:我的个天你们都要把个简单的问题复杂化，看人家要求，输入10个数，找出最大数季输入次序即可。  #include <stdio.h>  int main() { 	int a[10],i,index = 0; 	for(i = 0;i < 10;i++) 	{ 		printf("please input the %d number\n",i + 1); 		scanf("%d",&a[i]); 		if(a[i] > a[index]) 		{ 			index = i; 		} 	} 	printf("The largest number is the %d value is%d  \n",index + 1,a[index]); 	return 0; }  楼主，叫你用这个不是说排序算法不好，只是有特定的场合，这种场合你去排序，就是脱裤子放屁了。但是作为学习的话那些排序算法最好去了解一下。

引用 5 楼 stereoMatching 的回复:要的只是最大的数字和输入次序吧？为何大家都在排序呢？  pseudo codes, 未测试  #include <algorithm> #include <iostream> #include <limits>  int main() {   int nums[10];   int max = std::numerit_limits<int>::min();   std::cout<<"input 10 numbers"<<std::endl;   for(size_t i = 0; i != 10; ++i){     std::cin>>num[0];     max = std::max(num[0], max);   }      std::cout<<"input order : "<<std::endl;   for(size_t i = 0; i != 10; ++i){     std::cout<<num[0]<<std::endl;   }   std::cout<<"maximum num = \n"<<max<<std::endl; }   ++   //#include <algorithm> #include <iostream> //#include <limits>  int main() {   int nums[10];   int max;   std::cout<<"input 10 numbers"<<std::endl;   for(size_t i = 0; i != 10; ++i){     //std::cin>>num[0];     std::cin>>num[i];     if(!i) max = num[i];     if(max < num[i]) max = num[i];   }      std::cout<<"input order : "<<std::endl;   for(size_t i = 0; i != 10; ++i){     //std::cout<<num[0]<<std::endl;     std::cout<<num[i]<<std::endl;   }   std::cout<<"maximum num = \n"<<max<<std::endl; }

冒泡排序： void deal(int * a,int size) {       int i, j, tmp;          for (i = 0; i < size; i++) {             for (j = size - 1; j > i; j--) {                 if (a[j] < a[j-1]) {                 tmp = a[j-1];                    a[j-1] =  a[j];                     a[j] = tmp;                 }      }     }   }

引用 楼主 u012520627 的回复:依次输入十个自然数，输出最大的数及其输入次序 用这个程序 刚才的没完成需求 #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_SIZE 10  void deal(int * elem,int size) {      int i, j, tmp;          for (i = 0; i < size; i++) {             for (j = size - 1; j > i; j--) {                 if (elem[j] < elem[j-1]) {                 tmp = elem[j-1];                    elem[j-1] =  elem[j];                     elem[j] = tmp;                 }      }    }  } int main() {     int i;     int i_elem[MAX_SIZE];     int elem[MAX_SIZE];     printf("input \n");      for (i = 0; i < MAX_SIZE; i++){         scanf("%d",&i_elem[i]);         elem[i] = i_elem[i];      }     deal(i_elem,MAX_SIZE);                  printf("最大数：%d ", i_elem[MAX_SIZE-1]);                  printf("\n输入次序\n");      for (i = 0; i < MAX_SIZE; i++){           printf("%d ", elem[i]);      }      printf("\n");      return 0; }

#include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_SIZE 10  void deal(int * elem,int size) {      int i, j, tmp;          for (i = 0; i < size; i++) {             for (j = size - 1; j > i; j--) {                 if (elem[j] < elem[j-1]) {                 tmp = elem[j-1];                    elem[j-1] =  elem[j];                     elem[j] = tmp;                 }      }    }  } int main() {     int i;     int i_elem[MAX_SIZE];     printf("input \n");      for (i = 0; i < MAX_SIZE; i++){         scanf("%d",&i_elem[i]);      }     deal(i_elem,MAX_SIZE);                  printf("%d ", i_elem[0]);                  printf("\n");      return 0; }

引用 9 楼 BenRenYiGuaShi 的回复:思路如下既不改变数组顺序，直接利用冒泡的算法循环一次 就行了  int input[]; int MaxNum; MaxNum = max(input[]);  你看看我七楼的回复，明明很简单的事情非要整那么复杂！！！

循环一遍，记录最大位置


Question: 求教： C语言如何对已写入文件中的数据加以修改？

引用 7 楼 zhao4zhong1 的回复:所谓修改删除文件a某位置的内容，其实是读打开文件a，再将‘a中修改删除位置之前的内容＋修改删除的内容＋a中修改删除位置之后的内容’保存到文件b，关闭文件a，删除文件a，将文件b改名为与之前文件a相同的名字，仅此而已。 原来这里面还转到一道弯，系统自动生成文件b？学习了！谢谢赵哥！

多谢各位指点和提供内存对齐的知识！我对代码做了修改：  //change data written in a file  #include <stdio.h> #include <stdlib.h>  #define SIZE 41 #define MAX  81  struct person{     char name[SIZE];     unsigned int age;     char address[MAX];     char job[SIZE]; };  int main(void) {     struct person info;     struct person rec;     //struct person turnout;     FILE * fp;    //long fl;      if((fp = fopen("info.dat","w+b")) == NULL)     {         fprintf(stderr, "Error opening %s", "info.dat");         exit(EXIT_FAILURE);     }     printf("Name: ");     fgets(info.name, SIZE, stdin);     printf("\nAge: ");     scanf("%u", &info.age);     getchar();     printf("\nAddress: ");     fgets(info.address, SIZE, stdin);     printf("\nJob: ");     fgets(info.job, SIZE, stdin);     fwrite(&info, sizeof (struct person), 1, fp);     puts("\nOriginally:");     printf("Name: %s", info.name);     printf("\nAge: %u",info.age);     printf("\nAddress: %s", info.address);     printf("\nJob: %s", info.job);    // fl = ftell(fp);     fseek(fp, -(long)sizeof(struct person), SEEK_CUR);     if(fread(&rec, sizeof (struct person), 1, fp) == 1)     {         puts("\nRec:");         printf("Name: %s", rec.name);         printf("\nAge: %u",rec.age);         printf("\nAddress: %s", rec.address);         printf("\nJob: %s", rec.job);     }     else     {     	fputs("\nError writing data.\n", stdout);     	exit(1);     }     puts("\nAltering ...");     /*printf("\nName: ");     fgets(rec.name, SIZE, stdin);*/     printf("\nAge: ");     scanf("%u", &rec.age);     getchar();     /*printf("\nAddress: ");     fgets(rec.address, SIZE, stdin);     printf("\nJob: ");     fgets(rec.job, SIZE, stdin);*/     //fl = ftell(fp);     fseek(fp, -(long)sizeof(struct person), SEEK_CUR);     if(fwrite(&rec, sizeof (struct person), 1, fp) == 1)     {     	fseek(fp, -(long)sizeof(struct person), SEEK_CUR);     	if(fread(&rec, sizeof (struct person), 1, fp) == 1) 		{     		puts("\nNew:");     		printf("Name: %s", rec.name);     		printf("\nAge: %u", rec.age);     		printf("\nAddress: %s", rec.address);     		printf("\nJob: %s", rec.job); 		}     	else     	{     		fputs("\nError reading data.\n", stdout);     		exit(1);     	}     }     else     {     	fputs("\nError writing data.\n", stdout);     	exit(1);     }      fclose(fp);     puts("\nBye!");      return 0; }  运行结果正常了。

unsigned int age;  scanf("%u", &info.age); 要是定义short  会报警告的   fwrite(&info, sizeof (struct person), 1, fp); 这个不支持直接写结构体吧 你不可以写4句吗 一个一个写进去 这句话有问题

if((fp = fopen("info.dat","wb")) == NULL) //改成，   if((fp = fopen("info.dat","wb+")) == NULL)  // 建议检查每个函数的返回值！

google, 看看别人如何操作文件的

内存对齐造成的  详情请看 http://bbs.csdn.net/topics/390209790


Question: linux下卸载挂载点，还能remove成功么？

我感觉会报6、EIO I/O 存取错误。 剩下的就是你的实验了

相应定义错误查看 man page  相应函数的errno   remove  错误代码： 1、EROFS 欲写入的文件存在于只读文件系统内。 2、EFAULT 参数pathname 指针超出可存取内存空间。 3、ENAMETOOLONG 参数pathname 太长。 4、ENOMEM 核心内存不足。 5、ELOOP 参数pathname 有过多符号连接问题。 6、EIO I/O 存取错误。  你试一下不就知道了 取返回值 之后进行比较  swirch(errno){ case 1: case 2: case 3: case 4: case 5: case 6: }

坚决消灭零恢复.


Question: 有比椭圆最小二乘拟合更优的椭圆拟合算法吗？

谔谔 忘了 百度的,大多数能下的都大同小异。就百度 最小二乘椭圆拟合 就能找得到。

你好  我想问一下 你这个 文档是在哪下的呀  最近在研究这个 不是很懂呢


Question: 关于杭电OJ 1002的探讨

非常感谢   大神啊！！！！！

格式不对要报错.请修改以下4行:       printf("Case %d:\n",c);//printf("case %d:\n",c);     printf("%s + %s = ",s1,s2);	//printf("%s + %s =",s1,s2);    printf("Case %d:\n",c);//printf("case %d:\n",c);   printf("%s + %s = ",s1,s2);//printf("%s + %s =",s1,s2);


Question: 求教 两道题

海量数据操作，看看这里

第一题按字节查表累加，不过数据很大，大概需要用long long 第二题计数排序，开2^32大小的内存计数，最后遍历下查看大于1的即可

问题1） 1.1）程序不能分析自身，如果32Bits程序，整个空间不足4G，计算就不准确了。 1.2）不能分析动态数据，前面计算过了，他后面就给你改了，计算就不准确了。 你要确保不会出现以上两种情况，那么是可以的。否则不能统计准确。 问题2） 开 2^32/4字节的内存，每个数据对应2Bits初始化为0 ，对每个数，对应位置的2Bits 自增，超过2等于2. 最后数数，输出等于2的位置。


Question: STL源码中的 obj * volatile * my_free_list  是什么意思啊

引用 3 楼 supermegaboy 的回复:[quote=引用 1 楼 zhao4zhong1 的回复:] 等价于volatile obj **my_free_list？  连指针基础都未过关[/quote] 不然我后面为啥加“？”

找到答案了哈。  这个声明原来的形式是：obj** my_free_list，这样的话*my_free_list（空闲的内存块指针数组中的一个元素）可能被优化到寄存器中，从而使库代码无法lock住对它的读调用（如果在寄存器中则另一个线程可能会无意中修改该寄存器的值，而在内存中由于另一个线程没有访问权力所以不能修改）。 要声明变量必须在内存中就要用volatile修饰，这里修饰的是*my_free_list，是free_list数组中的一个元素，而不是数组指针，所以volatile放在两个*中间。

引用 4 楼 u011317643 的回复:[quote=引用 3 楼 supermegaboy 的回复:] [quote=引用 1 楼 zhao4zhong1 的回复:] 等价于volatile obj **my_free_list？  连指针基础都未过关[/quote]  你觉得应该怎么理解啊？[/quote]  偶把这个问题交给1楼的未定义行为大师回答。

引用 3 楼 supermegaboy 的回复:[quote=引用 1 楼 zhao4zhong1 的回复:] 等价于volatile obj **my_free_list？  连指针基础都未过关[/quote]  你觉得应该怎么理解啊？

引用 1 楼 zhao4zhong1 的回复:等价于volatile obj **my_free_list？  连指针基础都未过关

引用 1 楼 zhao4zhong1 的回复:等价于volatile obj **my_free_list？  有可能，但是不确定是不是这个意思

等价于volatile obj **my_free_list？


Question: 变量分配内存的时机

只在寄存器中有个名字 而没有具体指定这个栈中变量的具体位置! 当初始化的时候才确定这个名字的变量在哪段内存中存放~

全局量是在main之前就初始化的~

虽然不知道你们在说些什么，但感觉好厉害的样子。

1）地址和内存分配： 1.1）外部变量，和静态变量，编译后地址就是确定的。      ----生成的代码里，只是有个表，列出变量和地址的对应关系。---      程序加载时，分配内存。 1.2）函数局部变量，有 函数参数，和内部定义的变量两种。    函数参数，是编译时确定地址的相对位置，和初始化代码。    函数调用时，分配内存。        函数内部定义的变量有三种，    其中局部静态变量，是一种静态变量，按照静态变量的方式，分配内存，并初始化。                              函数内部定义的自动变量，寄存器变量        编译时确定地址的相对位置，或者寄存器，和初始化代码。     函数调用时，分配内存，或者寄存器，并初始化。    ---有可能用到才会分配内存，并初始化。---     2）初始化 2.1）C外部变量，和静态变量，初始化一般是在加载时初始化的。           C++ 外部变量，和静态变量初始化，有些是在加载时初始化的，     有些初始化代码里初始化的，函数内部的局部静态变量，     可能是在,函数第一次运行时初始化的。  2.2) 函数参数,参数传递时，初始化      函数内部定义的， 自动变量，寄存器变量，函数调用时，代码运行中，初始化。      C代码里没有初始化,不会初始化。      C++ 类对象，没有显式初始化的，可能也会初始化。

楼主你也说了是只申明的，但是你打印人家的地址什么的不是使用这个变量了吗？有地址很奇怪吗？你想验证你的说法，看下面程序  #include <stdio.h>  int main() { 	int a; 	int b; 	int c; 	printf("%0x\n",&a); 	printf("%0x\n",&b);			//屏蔽掉这句试试  	printf("%0x\n",&c); 	return 0; }  全局变量是要你申明了就一定会占用内存； 局部变量的话，编译器可能会做优化，对未使用的变量不分配空间 对于外部变量的话空间是分配了的，只不过你申明的时候不会另外分配空间而已（只是引用源文件中变量的地址）也许这个对你有点用http://blog.csdn.net/z1179675084/article/details/8331952

不同的语言，不同的环境对这句话的理解也是不同的。  单纯从C语言和目前大多数的开发执行环境下，你的理解是完全没有问题的，这句话也是不确切的。  另外，顺便顶一下5楼。

----函数作用域静态函数--- 应为 ---函数作用域静态变量。

C，C++全局变量和静态变量，是在程序加载的时候分配空间的。 C全局变量和静态变量，是在程序加载的时候初始化的。 C++，全局变量，有些加载时候，有些是在程序初始化的时候。  C++静态变量，有些程序加载的时候分配空间的，有些是在程序初始化的时候，有些---函数作用域静态函数---可能是在函数的第一次调用的时候，初始化的， 而 函数参数是在，参数传递时定义空间和初始化的。  函数的局部自动变量和寄存器变量，是在函数的运行时，分配空间和初始化的，  自动变量的相对位置（相对偏移量），是在编译时确定的，寄存器变量是存储在那个寄存器中，还是当作自动变量处理，也是编译时就决定了的。

楼主可以具体看下声明和定义的区别. 相信看完就懂了·！~

引用 楼主 lgbxyz 的回复:有下面这样一句话,大家看看有没有问题  很多时候一个变量，只是声明不分配内存空间，直到具体使用时才初始化，分配内存空间，如外部变量。  我知道 外部变量就是别的文件中定义的全局变量,全局变量在程序编译时已经完成赋值.  那么 完成编译时都完成赋值了,还可能没有分配空间吗? 在vs2008试了一下申请一个全局变量,刚进入main函数这个全局变量就有值,能取到地址。 Linux下也是一样。  "很多时候一个变量，只是声明不分配内存空间，直到具体使用时才初始化"这个使用是指变量区别于定义的时候分配空间和使用时分配空间，使用不是指运行

小伙子,你的想法是正确的

有个技术叫写时拷贝，有点楼主说的这个意思 全局变量是在main函数之前初始化


Question: 帮忙看个数据结构的题目，谢谢啦，在线等

引用 8 楼 u010553752 的回复:求解输出栈出了什么问题，怎么会这样  输出那样的原因是scanf的原因，改用cin、cout方便一些

LinkStack   *S; char e; int i; InitStack_LS(*S); StackEmpty(*S);  请问S指向了哪里？你这样上去就要用*S？我稍微修改了下你的程序，你需要的功能应该是都能实现了，但是不建议这样做，没有什么实用价值，而且说实话你这个程序很混乱。我修改的地方后面都用这个标了//==>  /*1.参照教材编写一个程序，实现链栈的各种基本运算，并设计一个主程序完成如下功能：  （1）初始化栈s； （2）判断栈s是否非空； （3）依次进栈元素s，o，f，t，w，a，r，e； （4）判断栈s是否非空；  （5）输出栈长度；	 （6）输出从栈顶到栈底元素； （7）输出出栈序列；  （8）判断栈s是否非空；  （9）释放栈   我写了这个C程序，怎么运行不起来，好像死循环了，求大神帮忙看看*/ #include <stdio.h> #include <malloc.h> #include<stdlib.h>  #define OK 1 #define ERROR 0  typedef  struct  SLNode{            	char   data; 	struct  SLNode *next; }SLNode,* SLink;  typedef struct Stack { 	SLink  top; 	int  length; }STACK,LinkStack;   int InitStack_LS( LinkStack  &S){    //初始化 	S.top=NULL; 	S.length=0; 	printf("已初始化!\n");  //==> 	return OK; } void StackEmpty(LinkStack &S){ //判断栈s是否非空 	if(S.length==0){		//==> 		printf("空栈!\n"); 	}else{ 		printf("非空栈!\n"); 	}  } int Push(LinkStack  &S,char e){       //入栈 	SLink p; 	p=new SLNode; 	p->data=e; 	p->next=S.top;				 	S.top=p; 	S.length++; 	return OK; }  int Pop(LinkStack  &S,char *e){    //出栈  //==> 	*e=S.top->data; 	SLink p=S.top; 	S.top=S.top->next; 	delete p; 	S.length--; 	return OK; }  int  main(){ 	LinkStack   S; 	char e; 	int i; 	InitStack_LS(S); 	StackEmpty(S); 	for(i=0;i<9;i++){ 		printf("请输入第%d个入栈的字母:",i+1); 		scanf("\n%c",&e);					//==> 		Push(S,e); 	} 	printf("已全部入栈!\n"); 	printf("此链栈的长度为:%d",S.length);      //==> 	printf("\n"); 	for(i=0;i<9;i++){          //输出栈 		int f=Pop(S,&e); 		printf("%d\t%c\n",i+1,e);		//==> 	} 	StackEmpty(S);   //判断栈是否为空 	 	//free(S);  //销毁栈 }

哥哥，这个是C程序？我愣是看不出来C里面还跑出引用来了！

求解输出栈出了什么问题，怎么会这样

请问我的出栈函数有问题吗？怎么运行时起来是这样的

void StackEmpty(LinkStack &S) { // 清空栈S     SLink temp, p = S.top;     while (p != NULL) {         temp = p;         p = p->next;         delete temp;     }     S.top = NULL; }

bool StackEmpty(LinkStack &S){ //判断栈s是否非空     if(S.top==NULL){         printf("空栈!\n");     }else{         printf("非空栈!\n");     }     return S.top == NULL; }

能运行到时现实不了题目的效果，肿么改

楼上的代码已经给你测试通过了，注意46，49,54行给你改了

#include <stdio.h> #include <malloc.h> #include<stdlib.h>  #define OK 1 #define ERROR 0  typedef  struct  SLNode{            	char   data; 	struct  SLNode *next; }SLNode,* SLink;  typedef struct Stack { 	SLink  top; 	int  length; }STACK,LinkStack;   int InitStack_LS( LinkStack  &S){    //初始化 	S.top=NULL; 	S.length=0; 	return OK; 	printf("已初始化!\n"); } void StackEmpty(LinkStack &S){ //判断栈s是否非空 	if(&S==NULL){ 		printf("空栈!\n"); 	}else{ 		printf("非空栈!\n"); 	}  } int Push(LinkStack  &S,char e){       //入栈 	SLink p; 	p=new SLNode; 	p->data=e; 	p->next=S.top; 	S.top=p; 	S.length++; 	return OK; }  int Pop(LinkStack  &S,char e){    //出栈 	e=S.top->data; 	SLink p=S.top; 	S.top=S.top->next; 	delete p; 	S.length--; 	return OK; }  void main(){ 	LinkStack   S; 	char e; 	int i; 	InitStack_LS(S); 	StackEmpty(S); 	for(i=0;i<9;i++){ 		printf("请输入第%d个入栈的字母:",i+1); 		scanf("%c",&e); 		Push(S,e); 	} 	printf("已全部入栈!\n"); 	printf("此链栈的长度为:",S.length); 	printf("\n"); 	for(i=0;i<9;i++){          //输出栈 		int f=Pop(S,e); 		printf("%d\t%c\n",i+1,f); 	} 	StackEmpty(S);   //判断栈是否为空 	//free(S);  //销毁栈 }

用的引用？C++？ LinkStack   *S;//没有赋初值，建议改成LinkStack S;其余地方相应修改


Question: 浙大ACM1002  为什么一直编译错误。。。。

多谢啦~用了C++就编译过去了，不过还是有一些小错误，现在发一下AC了的，再次感谢各位哈~ #include<stdio.h> #include<stdbool.h> void fun (int n,int depth); bool fun_find(int i,int j,int n);  int num=0; int max=0; char map[4][4]; int main(void){  int n; scanf("%d",&n); while(n!=0){ 	for(int i=0;i<n*n;i++) 	scanf(" %c",&map[i/n][i%n]); 	fun(n,0); 	printf("%d\n",max); 	scanf("%d",&n); 	max=0; }	 return 0;	   } void fun (int n,int depth){ if(num>max)max=num; if(depth>=n*n)return ; int i=depth/n,j=depth%n; if(fun_find(i,j,n)) { map[i][j]='o'; num+=1; fun(n,depth+1); map[i][j]='.'; num-=1; } fun(n,depth+1);    } bool fun_find(int i,int j,int n){ if(map[i][j]!='.') return false; for(int a=i-1;a>=0;a--){ if(map[a][j]=='o') return false; if(map[a][j]=='x'||map[a][j]=='X') break; }  for(int c=j-1;c>=0;c--){ if(map[i][c]=='o') return false; if(map[i][c]=='x'||map[i][c]=='X') break; }  return true;  }

看到底下标签是C就觉得那啥啥了，选C++吧少年

LZ程序要选C++编译。

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

编译错误，按提示修改


Question: 求教，关于栈的操作

就是楼上两位说的问题！

1，S->top没有初始化 2，int Pop(stackseq *S) {   if(S->top==-1)      { printf("underflow");        return 0;      }    else      {S->top--;//错了       return S->data[S->top+1];//      }

top没有初始化


Question: 推荐学习C语言的书籍

学习中，谢谢推荐！

学习 了

引用 2 楼 max_min_ 的回复:好好消化下面这基本数，按顺序来！第一本好好啃下，里面的例程有时间的话都敲敲 c和指针 http://download.csdn.net/detail/max_min_/6333711 c陷阱和缺陷 http://download.csdn.net/detail/max_min_/6333741 c语言程序设计 http://download.csdn.net/detail/max_min_/6333663 c专家编程 http://download.csdn.net/detail/max_min_/6333785 c和指针这本书没有学过汇编和其他语言看得懂么？我怕打击信心。

先下载Win-TC，然后参考C:\Win-TC\tcstudy.chm

2L基本列出了。只要这几本认真看过两三本，按说在语法层面上，是不会有问题的。

c语言圣经 the c programming Language

重要是边看边练··！~

仔细看 the c programming Language 如果觉得哪方面需要加强，在看相应的书籍

引用 5 楼 wangdahu888 的回复:当属<<C primer plus>> 楼主才大二吧，上面那些书都是很好的，但是你还是应该把这本书显好好看看，一步步慢慢来。

当属<<C primer plus>>

c语言程序设计  这本书先看吧

C程序设计语言 C标准库 C和指针 陈正冲 石虎 C语言深度剖析 俞甲子 石凡 潘爱民 程序员的自我修养 Uinx 环境高级编程 深入理解计算机体系机构 C语言的495个问题 C陷阱与缺陷


Question: linux内核源码编译错误

哎呀，真巧，前两天刚遇上，要重新配置下kernel，具体： 1) Select “Enable loadable module support”, then “Module signature verification (EXPERIMENTAL)”. Disable it. 2) Then go back to the main menu, select “Cryptographic API” then “In-kernel signature checker (EXPERIMENTAL)” and disable that one too.

换9.04的系统 问题依旧 换12.04的系统 问题解决

编译linux2.6.28内核 没其它东西

你的脚本语言可能有语法错误。 你的系统里是不是有/bin/sh，然后看看其它行是不是有错误

makefile 设置了内核 make -C 跳到内核源码执行 make的路径写对了吗 最外层的那个make


Question: 紧急求助！有懂盘点机（品牌、开发）的吗？？？

需要根据你应用的场合，你的需求来购买合适的盘点机。因为盘点机硬件搭配不同，价格不同。可以根据具体使用情况来选择最合适的。国外的普遍比较贵，使用起来其实并不一定适合中国人的习惯，但是国外的质量确实不错。 国内的普遍比较便宜，那比起国外的不是一般的便宜，其实功能也很够用，盘点机其实就几个比较重要的部位：扫描头质量，WIFI质量。所以只要这两项质量OK，基本上整机质量还是没问题的。 再一个就是看盘点机的驱动是否方便使用。 软件开发使用技术也是千差万别。有的很落后的使用读写TXT，高级点的使用读写本地数据库，再高级点的利用TCP与服务器后台通信。而我们就使用微软最新的WCF技术，通信速度快，稳定，安全，程序开发效率高。 下载一般都是用C#语言进行开发，但是很多人开发出来的程序，运行效率低，卡，崩溃，死机，不稳定。 上层应用程序卡，慢，死机，有可能跟上层应用程序有关，也可能跟盘点机的驱动和系统有关。 盘点机的系统是可以裁剪的，如果系统裁剪少，系统占用的内存多，那么跑上层应用程序就会相对要慢，要卡一点。 如果系统裁剪的好，系统占用内存小，那么就会让出更多的内存跑上层应用程序，那么上层应用程序就会跑起来会快，稳定，效率高。所以选择一款好的盘点机需要从硬件到软件多方面来分析。 如果有需要可以联系我。

不懂  假如我遇到这个问题  我的思考如下    盘点机不就是条形码识别之类的东西吗 一个物资管理系统 C C++都其他语言都能写 一个识别条形码的程序 API 人家做好的 或者自己开发 原理把一些点存在二维空间 按一定的数学排列 解析二维空间的数学排序 得出特定的信息


Question: 求个小程序

引用 1 楼 stereoMatching 的回复: int hour, min, sec, command;     sscanf(strs.c_str(), "%d:%d:%d+%d", &info.wHour, &info.wMinute, &info.wSecond, &command); 太简单了 我怎么没想到这么写 2分钟就搞定了

char const *strs = "0:15:24+1"; sscanf(strs, "%d:%d:%d+%d", &info.wHour, &info.wMinute, &info.wSecond, &command);   忘了删除多余的代码 想要更快的速度可考虑boost::spirit

char数组转CString再取子串


Question: 如何将结构体转化为char数组

引用 8 楼 mgy4938 的回复:用memset就可以了。  请问memset怎么用呢？

引用 11 楼 z1179675084 的回复:楼主C#我不懂，但是我知道fun（char* p）内部无论做了什么，都不会改变p的本质，因为这里只是个形参，所以不管你在函数内部怎么捣鼓，你的要求“我希望在c#项目调用fun（char* p）后，对数组p进行操作。”都不可能实现，除非使用二级指针！  是我2了，忘了是值传递这回事了。 我直接将地址以引用传值出来就ok了

引用 12 楼 z1179675084 的回复: #include <stdio.h> typedef struct Tset  { 	char a; 	char b; }test;  int main() { 	test temp; 	test array[3] = {{'1','2'},{'3','4'},{'5','6'}}; 	test *p1 = array; 	int i; 	//不转换直接访问  	for(i = 0;i < 3;i++) 	{ 		printf("%c\n",p1->a); 		printf("%c\n",p1->b); 		p1++; 	} 	printf("\n"); 	//不转换利用数组访问  	p1 = array; 	for(i = 0;i < 3;i++) 	{ 		printf("%c\n",p1[i].a); 		printf("%c\n",p1[i].b); 	} 	 	char *p2 = (char *)array; 	printf("\n"); 	//转换利用指针访问  	for(i = 0;i < 6;i++) 	{ 		printf("%c\n",*p2++); 	} 	 	//转换通过数组访问  	p2 = (char *)array; 	printf("\n"); 	for(i = 0;i < 6;i++) 	{ 		printf("%c\n",p2[i]); 	} 	return 0; }   这种东西有个前提是你得清楚的知道里面存储的数据类型，内存分布。不然很危险

char *chBuf = NULL; chBuf = new char[nLenth]; memmove(chBuf,&Struct,sizeof(Struct));

强转有风险，使用要谨慎

用memset就可以了。

引用 5 楼 WhiteBird99 的回复:强制类型转换, 同2楼 不过调用者要知道结构体大小吧, 不然怎么取数据...  调试不了是什么意思? 提供两种调试方法: 1. 将dll工程加入到C#的解决方案中 2. 将dll工程设置为指定程序启动时自动启动  还要知道struct 中因对齐填充的byte

引用 5 楼 WhiteBird99 的回复:强制类型转换, 同2楼 不过调用者要知道结构体大小吧, 不然怎么取数据...  调试不了是什么意思? 提供两种调试方法: 1. 将dll工程加入到C#的解决方案中 2. 将dll工程设置为指定程序启动时自动启动  我使用的sizeof，maolloc等对数组赋值的  1、我的dll就是和c#的工程在同一个解决方案中 2、我将c#设置为允许调试费托管代码， 3、将C++设置为混合调试  运行之后就卡住了，显示一直处于加载系统的dll，估计等2小时也加载不好  你说的方式我没太懂

用vs打开dll的工程，attach到运行的主程序上去就能调试dll了

引用 1 楼 u011779875 的回复:个人意见 仅供参考 例如 struct person{     char name[SIZE];     unsigned short age;     char address[MAX];     char job[SIZE]; };  struct person TMD; 用sprintf  这个函数 实现 它很强大的 sprintf(buf,"%s %d %s %s",TMD.name,TMD.age,TMD.address,TMD.job) 结构体太复杂，这样转换写代码太累    引用 2 楼 falcomavin 的回复:指针类型总是可以转换的，假设有结构体st，则 char *p = (char *)&st; 感觉这样可以，但是我的dll调试不了不知道什么原因


Question: 指针的不解

引用 15 楼 super_admi 的回复:再更正： #include <stdlib.h> void Exchange(int *&a, int *&b) {     a = b;//把b指针指向的内存地址赋给a。 }   void main() {     int *a = NULL;     int *b = ( int *) malloc(sizeof(int));     *b = 5;     Exchange(a,b);//但是函数返回后，a依然为NULL，请问这是为什么呢？ }  [quote=引用 3 楼 daxiaoyuyu 的回复:] 更正： #include <stdlib.h> void Exchange(int *a, int *b) {     a = b;//把b指针指向的内存地址赋给a。 }   void main() {     int *a = NULL;     int *b = ( int *) malloc(sizeof(int));     *b = 5;     Exchange(a,b);//但是函数返回后，a依然为NULL，请问这是为什么呢？ } //但是函数返回后，a依然为NULL，请问这是为什么呢？[/quote]  经测试，a不为NULL，*a等于5

再更正： #include <stdlib.h> void Exchange(int *&a, int *&b) {     a = b;//把b指针指向的内存地址赋给a。 }   void main() {     int *a = NULL;     int *b = ( int *) malloc(sizeof(int));     *b = 5;     Exchange(a,b);//但是函数返回后，a依然为NULL，请问这是为什么呢？ } 引用 3 楼 daxiaoyuyu 的回复:更正： #include <stdlib.h> void Exchange(int *a, int *b) {     a = b;//把b指针指向的内存地址赋给a。 }   void main() {     int *a = NULL;     int *b = ( int *) malloc(sizeof(int));     *b = 5;     Exchange(a,b);//但是函数返回后，a依然为NULL，请问这是为什么呢？ } //但是函数返回后，a依然为NULL，请问这是为什么呢？

引用 8 楼 zhao4zhong1 的回复: 引用 楼主 daxiaoyuyu 的回复:指针的不解：我希望用a指针指向b指针指向的内存，为什么下面的做法不可以？ #include <stdlib.h> void Exchange(int *a, int *b) { 	a = b;//把a指针指向的内存地址赋给。 }  void main() { 	int *a = NULL; 	int *b = ( int *) malloc(sizeof(int)); 	*b = 5; 	Exchange(a,b);//但是函数返回后，a依然为NULL，请问这是为什么呢？}  指针也是一种数据类型,int* 看做一种数据类型就可以了，类似下班的代码一样 void exchange(int a, int b) 	{ 		int c = a; 		a = b; 		b = c; 	}

要传二级指针进去

指针变量a在定义时一定要初始化；C语言基础中就是这样规定的，否则要出错；

C只有传值。

问你几个问题?你思考下~ 敢问你   exchange 函数中的  a ,b 内存分配在哪里呢? 函数exchange中  的a ,b 内存分配在哪里? 函数执行过后 a  和  b还存在吗? 你仅仅改变a的意义何在?

引用 2 楼 falcomavin 的回复:因为函数形参是一份copy 要达到目的可以用二级指针或者指针的引用 解法一： void Exchange(int **a, int **b)  {     *a = *b;}  解法二： void Exchange(int *&a, int *&b) {     a = b;} 引用 3 楼 daxiaoyuyu 的回复:更正： #include <stdlib.h> void Exchange(int *a, int *b) {     a = b;//把b指针指向的内存地址赋给a。 }   void main() {     int *a = NULL;     int *b = ( int *) malloc(sizeof(int));     *b = 5;     Exchange(a,b);//但是函数返回后，a依然为NULL，请问这是为什么呢？ } //但是函数返回后，a依然为NULL，请问这是为什么呢？ 还有什么需要更正的呢，楼上的回复你看都不看，人家说的很清晰明了！

错在函数参数传递传的是值的副本,这里指针也是传的是地址值的副本.

c 的本质是传值  个人觉得 林锐的 高质量c/c++ 编程讲得很好

引用 2 楼 falcomavin 的回复:因为函数形参是一份copy 要达到目的可以用二级指针或者指针的引用 解法一： void Exchange(int **a, int **b)  {     *a = *b;}  解法二： void Exchange(int *&a, int *&b) {     a = b;} 解法一： void Exchange(int **a, int **b)  {     *a = *b;} main调用： Exchange(&a,&b);  解法二（老的C编译器不支持，C++编译器应该都支持） void Exchange(int* &a, int* &b) {     a = b;}  main调用： Exchange(a,b);

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

swap(a, b) { t = a a = b  b = t } //没有成功交换  这个楼主能理解吧。那么你的exchange（a,b）和这个是一样的。只不过你的a，b是int*类型.swap（a,b)的a,b是int型的。

引用 2 楼 falcomavin 的回复:因为函数形参是一份copy 要达到目的可以用二级指针或者指针的引用 解法一： void Exchange(int **a, int **b)  {     *a = *b;}  解法二： void Exchange(int *&a, int *&b) {     a = b;} ++用引用或者指针

经常看见 说着指针不解 指针很难  其实 你不懂的东西是 函数参数传递 和 指针 没什么必然联系 指针:真是无妄之灾 函数参数:谢谢你帮我背黑锅了  C函数参数只有值传递  其实学函数的时候 早就将结果你这种写法 swap(a, b) { t = a a = b  b = t } //没有成功交换  你这里的写法是     int *a = NULL;     /*Exchange(a,b);函数调用其实是*/     Exchange.a = main.a //参数传递     Exchange.b = main.b //参数传递     Exchange.a = Exchange.b //函数执行 }//函数调用解释     //以上代码中 针对main.a的赋值只有 = NULL 这一次 其他时候最多也只是把main.c写在赋值符号右边一直没有修改main.a的值

Exchange(a,b);//但是函数返回后，a依然为NULL，请问这是为什么呢？  exchage这个函数传入的a并不是你在main中的a，而是它的一份copy，你在exchange里面改变的是copy的值，main中的a从头到尾都没有变

void Exchange(int **a, int **b) {    // do something } // 调用  Exchange(&a, &b);   ps：指针的地址也是值，地址值也只是作了拷贝那份的赋值操作而已，本身还是没变！


Question: 关于malloc（）的实现

引用 6 楼 z1179675084 的回复:楼主像u-boot了，内核之类的东西一个函数可能有多个的，多找几个啊 仔细找过了，source insight找过，linuxe下grep命令找过，没找着，感到很奇怪，我在怀疑是不是他将malloc定义成一个宏定义，指向别的函数。不如你帮我试试找找

引用 7 楼 realbank 的回复:[quote=引用 6 楼 z1179675084 的回复:] 楼主像u-boot了，内核之类的东西一个函数可能有多个的，多找几个啊 仔细找过了，source insight找过，linuxe下grep命令找过，没找着，感到很奇怪，我在怀疑是不是他将malloc定义成一个宏定义，指向别的函数。不如你帮我试试找找[/quote] http://wuxizazhi.cnki.net/Search/DNBC200922011.html

此处并没有去真正的申请内存，只是形象的让人好理解而已。 一般的，我们写代码时是不是要 将结构体初始化啊，结构体指针 申请内存啊，以便后面的操作。 这里写成这样 就是告诉你已经初始化了，可以操作了。

楼主像u-boot了，内核之类的东西一个函数可能有多个的，多找几个啊

注意你看的是u-boot 的源码。

先google 篇文章看看 malloce 的设计思想

这个可以参考下 http://blog.csdn.net/lxmky/article/details/6909060

这个才是malloc的源码。   void *malloc (unsigned int size)   {       char *caddr;          if (!malloc_ptr)           return NULL;       if ((malloc_ptr + size + sizeof(int)) > malloc_top) {           prom_printf("malloc failed\n");           return NULL;       }       *(int *)malloc_ptr = size;       caddr = malloc_ptr + sizeof(int);       malloc_ptr += size + sizeof(int);       last_alloc = caddr;       malloc_ptr = (char *) ((((unsigned int) malloc_ptr) + 3) & (~3));       return caddr;   }

这个应该不是吧！ 看看这个 http://bbs.csdn.net/topics/280055567


Question: 关于mysql多线程访问串行与并行的问题

引用 1 楼 user-1 的回复:1. InitConnection (4);          //初始化连接池，放入4个mysql句柄 for(int i=0;i<4;i++) { mysql = GetConnection ();  //获取一个MYSQL句柄 Insert (mysql ,"insert children values(6,'yantai',40)"); //执行插入 } 没用过这个库。判断是否为串行，就用一个慢速查询语句，很快返回的就是并发执行。 另外就是看返回的方式，如果是并发执行（异步）则要回调函数来获取返回结果，一般比较少见。 所以假设为串行（同步）。  2.InitConnection (4);     for(int i=0; i<4;i ++) { mysql = GetConnection (); for( int i = 0; i < 5; i ++) { pthread_create(&thread_id [i], NULL, Testinsert ,mysql); } for(int i = 0; i <  5; i ++) { pthread_join(thread_id [i], NULL); } }         那么这四个连接是并行还是串行？四个连接并行？四个连接并行五次？ 如果是串行（同步），这么做可能不安全，一般是一个线程一个数据库连接。  3.InitConnection (4);     for(int i=0; i<1;i ++) { mysql = GetConnection (); for( int i = 0; i < 1; i ++) { pthread_create(&thread_id [i], NULL, Testinsert ,mysql); } for(int i = 0; i <  1; i ++) { pthread_join(thread_id [i], NULL); } }         这应该是4个连接并行一次，这和第一个程序有区别么？ 这个不是并行，原因是大循环里包含了pthread_join，它会等子线程执行完成在继续循环。 应该这样： InitConnection (4);     for(int i=0; i<4;i++){   mysql = GetConnection ();   pthread_create(&thread_id[i], NULL, Testinsert ,mysql); } for(int i = 0; i < 4; i++){   pthread_join(thread_id[i], NULL); } 嗯，谢谢你的回答。非常感谢。


Question: c和指针 操作符

if(a >= 1 && a<= 10) 00F829D5  cmp         dword ptr [a],1   00F829D9  jl          main+48h (0F829F8h)   00F829DB  cmp         dword ptr [a],0Ah   00F829DF  jg          main+48h (0F829F8h)   当然就是顺序了 	if(1 <= a <= 10) 000A29D5  cmp         dword ptr [a],1   000A29D9  jl          main+37h (0A29E7h)   000A29DB  mov         dword ptr [ebp-0D0h],1   000A29E5  jmp         main+41h (0A29F1h)   000A29E7  mov         dword ptr [ebp-0D0h],0   000A29F1  cmp         dword ptr [ebp-0D0h],0Ah   000A29F8  jg          main+61h (0A2A11h)

什么书？不一定吧！

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步对应汇编一行！  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！

比如if(x+y+1>0)在K&R C中程序员无法预测编译器按哪种顺序对这个表达式求值 书上明确写了ANSI C不允许这样做。

对不起我搞错了，那是K&R C而不是现在的ANSI C哎呀其实我也不是很清楚，分就随便给吧

《c和指针》中文版P84下半部分

引用 16 楼 u011779875 的回复:我说书错 是因为 按照C标准的要求  1 + 2 + 3 第一个 + 先和操作数结合 (1 + 2) + 3 i = c = d 右结合 最右边的 = 先和操作数结合 i = (c = d) 只能这么解释 没有二义性 没有第二种可能  如果 把 1 + 2 + 3解释为 1 + 2 + 3 那么 + 是右结合  这是这个表达式巧合 求值结果一样  如果是 1 - 2 + 3 根据右结合 变成 1 - (2 + 3) 那就大错特错了你的理解是有偏差的  你的所谓的结合性 是给程序员规定的 而我们讨论的是编译器优化的问题   正如 1+2+3，编译器可以先计算2+3，再计算1+（2+3）  注意红色的字，那是可以，而不是一定或者必然或者肯定....   编译器的实现 是和它表明告诉人们的标准不一定是重合的  你有点理解偏了  其实书上的意思是在特定的情况满足下 编辑器会进行适当的优化 而这种优化是你所不能理解的 [/quote] 也许 先计算 2 不好理解  fooA()+fooB()+fooC() 这个表达式 函数调用的顺序 可能 先调用fooB 在调用fooC 以上

gcc -E test.c -o test.i  引用 15 楼 lin5161678 的回复:[quote=引用 12 楼 u011779875 的回复:] 预处理的实现是编译器的一部分 不是编译器解决的吗我一直说是编译器解决的  是你说预处理解决的  就算预处理是编译器的一部分  那也是预处理完成之后 编译器的其他部分处理 1+2+3 [/quote]gcc -E test.c -o test.i 可以输出test.i文件中存放着test.c经预处理之后的代码。打开test.i文件，看一看，就明白了。 如果我错了 那我错了 我讨论那个没什么意义 试一试就知道了 我感觉我错误的可能性是比较大的  你赢了

引用 16 楼 u011779875 的回复:你的理解是有偏差的  你的所谓的结合性 是给程序员规定的 而我们讨论的是编译器优化的问题   正如 1+2+3，编译器可以先计算2+3，再计算1+（2+3）  注意红色的字，那是可以，而不是一定或者必然或者肯定....   编译器的实现 是和它表明告诉人们的标准不一定是重合的  你有点理解偏了  其实书上的意思是在特定的情况满足下 编辑器会进行适当的优化 而这种优化是你所不能理解的 编译器优化没那么神秘  这里只是 可以先计算 2 也可以先计算 3 但是 绝对不会 先计算 2+3  因为 对于这表达式的分析 就不会出现 2+3 这个算子 [子表达式] 不存在的东西 不可能对他进行求值的

引用 13 楼 lin5161678 的回复:[quote=引用 12 楼 u011779875 的回复:] 这样就可以知道是在哪个阶段处理的 也许是我记错了或许我还没错呢  但是你也不能说人家书错了啊 我说书错 是因为 按照C标准的要求  1 + 2 + 3 第一个 + 先和操作数结合 (1 + 2) + 3 i = c = d 右结合 最右边的 = 先和操作数结合 i = (c = d) 只能这么解释 没有二义性 没有第二种可能  如果 把 1 + 2 + 3解释为 1 + 2 + 3 那么 + 是右结合  这是这个表达式巧合 求值结果一样  如果是 1 - 2 + 3 根据右结合 变成 1 - (2 + 3) 那就大错特错了  [/quote]你的理解是有偏差的  你的所谓的结合性 是给程序员规定的 而我们讨论的是编译器优化的问题   正如 1+2+3，编译器可以先计算2+3，再计算1+（2+3）  注意红色的字，那是可以，而不是一定或者必然或者肯定....   编译器的实现 是和它表明告诉人们的标准不一定是重合的  你有点理解偏了  其实书上的意思是在特定的情况满足下 编辑器会进行适当的优化 而这种优化是你所不能理解的

引用 12 楼 u011779875 的回复:预处理的实现是编译器的一部分 不是编译器解决的吗我一直说是编译器解决的  是你说预处理解决的  就算预处理是编译器的一部分  那也是预处理完成之后 编译器的其他部分处理 1+2+3

如果 把 1 + 2 + 3解释为 1 + (2 + 3) 那么 + 是右结合

引用 12 楼 u011779875 的回复:这样就可以知道是在哪个阶段处理的 也许是我记错了或许我还没错呢  但是你也不能说人家书错了啊 我说书错 是因为 按照C标准的要求  1 + 2 + 3 第一个 + 先和操作数结合 (1 + 2) + 3 i = c = d 右结合 最右边的 = 先和操作数结合 i = (c = d) 只能这么解释 没有二义性 没有第二种可能  如果 把 1 + 2 + 3解释为 1 + 2 + 3 那么 + 是右结合  这是这个表达式巧合 求值结果一样  如果是 1 - 2 + 3 根据右结合 变成 1 - (2 + 3) 那就大错特错了

引用 11 楼 lin5161678 的回复:[quote=引用 9 楼 u011779875 的回复:] int a; a = 1 + 2 + 3; 011313BE  mov         dword ptr [a],6    你敢说这不是预处理做的 那个6是什么  你敢说不是编译器在预处理阶段做的 虽然我才毕业4个月 但是人总会犯错的 我喜欢承认并解决错误 难道你真的成为了亚里士多德 我看不是吧    你拿出证据 无证据不要瞎说 少年 1+2+3是 编译期常量 编译器把他处理为 6  不是预处理 预处理做的 #include #if 宏展开 处理折行符 处理注释这些事情 1+2+3 原原本本的提交给编译器  你看到的是编译器处理的结果 无法说明是预处理器处理的结果 明白吗? [/quote]预处理的实现是编译器的一部分 不是编译器解决的吗 我记得在linux下 直接打gcc -E test.c -o test.i  这样就可以知道是在哪个阶段处理的 也许是我记错了或许我还没错呢  但是你也不能说人家书错了啊

引用 9 楼 u011779875 的回复:int a; a = 1 + 2 + 3; 011313BE  mov         dword ptr [a],6    你敢说这不是预处理做的 那个6是什么  你敢说不是编译器在预处理阶段做的 虽然我才毕业4个月 但是人总会犯错的 我喜欢承认并解决错误 难道你真的成为了亚里士多德 我看不是吧    你拿出证据 无证据不要瞎说 少年 1+2+3是 编译期常量 编译器把他处理为 6  不是预处理 预处理做的 #include #if 宏展开 处理折行符 处理注释这些事情 1+2+3 原原本本的提交给编译器  你看到的是编译器处理的结果 无法说明是预处理器处理的结果 明白吗?

看书上说如果有表达式1+2+3，编译器可以先计算2+3，再计算1+（2+3）  注意红色的字，那是可以，而不是一定或者必然或者肯定....

引用 7 楼 lin5161678 的回复:[quote=引用 5 楼 u011779875 的回复:] 人家书我感觉没有错  只不过人家的意思是 1+2+3 是写到程序里的  编译器如何处理 你就不得而知了例如int a = 1 + 2+ 3; 它的处理过程是在宏替换就处理完的 你没写过编译器 你怎么知道不可以呢先算 1+（2+3） 有点常识 好不好 1+2+3 和预处理没什么关系 然后 1+2+3 处理为 (1+2)+3是由 优先级结合性决定的  编译器的实现是必须符合这个要求的[/quote] int a; a = 1 + 2 + 3; 011313BE  mov         dword ptr [a],6    你敢说这不是预处理做的 那个6是什么  你敢说不是编译器在预处理阶段做的 虽然我才毕业4个月 但是人总会犯错的 我喜欢承认并解决错误 难道你真的成为了亚里士多德 我看不是吧    你拿出证据 无证据不要瞎说

引用 6 楼 u012453424 的回复:《c和指针》上说的 第几版第几页第几章第几段

引用 5 楼 u011779875 的回复:人家书我感觉没有错  只不过人家的意思是 1+2+3 是写到程序里的  编译器如何处理 你就不得而知了例如int a = 1 + 2+ 3; 它的处理过程是在宏替换就处理完的 你没写过编译器 你怎么知道不可以呢先算 1+（2+3） 有点常识 好不好 1+2+3 和预处理没什么关系 然后 1+2+3 处理为 (1+2)+3是由 优先级结合性决定的  编译器的实现是必须符合这个要求的

引用 4 楼 lin5161678 的回复:引用看书上说如果有表达式1+2+3，编译器可以先计算2+3，再计算1+（2+3） 什么书 错这么离谱 1+2+3 必然是 (1+2)+3 没有第二种可能   书说错 《c和指针》上说的


Question: 关于字符串求助

引用 2 楼 wangdahu888 的回复:楼主并没有说用c/c++实现,我就用erlang来实现了, %% Author: Administrator %% Created: 2013-10-22 % Description: TODO: Add description to abc -module(abc). -author(tiger). -purpose(test). -export(staticN/2]). whatN(H,[H|T],{ACC,L}) -> whatN( H, T,{ ACC+1 ,L }); whatN(I,[H|T],{ACC,L})->whatN( I, T,{ ACC,[H |L ]}); whatN(_I,[],{ACC,L})->{ACC,L}. %%如果要保持输出顺序不变，这里改为{ACC,lists:reverse( L)}. staticN([],L)->L ; staticN([H|T],L)->                      {Num,List}=whatN( H,[ H| T],{ 0,[]}),                           if                            Num >=2-> staticN(List,[{H,Num}|L]);                           Num<2 ->staticN(List ,L )                           end.  =========================================================================  12> abc:staticN([1,2,3,4,2,5,6,6,a,b,e,f,d,e,9,9,y,y,u,4,3,7,9,1],[]). [{e,2},{y,2},{6,2},{4,2},{3,2},{2,2},{9,3},{1,2}]表示没接触过erlang，还是谢谢你！

引用 1 楼 u011779875 的回复:#include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_SIZE 1024 /// ///一个字符串变换的函数，输入的字符串为英文字母，其中连续出现的次数不超过9次，输出为输入的英文字符+连续出现的次数 ，例如 “ABBCCCC”-> “A1B2C4”。 ///求大神帮助 /// void deal(char * elem,int size) {      int i, j, tmp;          for (i = 0; i < size; i++) {             for (j = size - 1; j > i; j--) {                 if (elem[j] < elem[j-1]) {                 tmp = elem[j-1];                    elem[j-1] =  elem[j];                     elem[j] = tmp;                 }      }    }  } int main() {     int i;     int count = 1;     char temp;     char c_elem[MAX_SIZE];     printf("input \n");     gets(c_elem);     int size = strlen(c_elem);     deal(c_elem,size);       for (i = 0; i < size; i++)             if(c_elem[i]!= c_elem[i+1]){              printf("%c%d", c_elem[i],count);              count = 1;             }             else {              count++;             }           //  printf("%c ", c_elem[i]);       return 0; } 哥们你的代码没问题，谢谢啦！分给你了

引用 楼主 yessigoal 的回复:一个字符串变换的函数，输入的字符串为英文字母，其中连续出现的次数不超过9次，输出为输入的英文字符+连续出现的次数 ，例如 “ABBCCCC”-> “A1B2C4”。 求大神帮助 哥们你的代码没问题！！谢谢啦！


Question: 写了个转码函数，偶尔出现malloc：memory corruption异常，帮分析下。。。

仅供参考#include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef WIN32     #include <windows.h>     #include <io.h> #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  _vsnprintf         vsnprintf #endif //Log{ #define MAXLOGSIZE 20000000 #define MAXLINSIZE 16000 #include <time.h> #include <sys/timeb.h> #include <stdarg.h> char logfilename1[]="MyLog1.log"; char logfilename2[]="MyLog2.log"; static char logstr[MAXLINSIZE+1]; char datestr[16]; char timestr[16]; char mss[4]; CRITICAL_SECTION cs_log; FILE *flog; #ifdef WIN32 void Lock(CRITICAL_SECTION *l) {     EnterCriticalSection(l); } void Unlock(CRITICAL_SECTION *l) {     LeaveCriticalSection(l); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } #endif void LogV(const char *pszFmt,va_list argp) {     struct tm *now;     struct timeb tb;      if (NULL==pszFmt||0==pszFmt[0]) return;     _vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,"%03d",tb.millitm);     printf("%s %s.%s %s",datestr,timestr,mss,logstr);     flog=fopen(logfilename1,"a");     if (NULL!=flog) {         fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);         if (ftell(flog)>MAXLOGSIZE) {             fclose(flog);             if (rename(logfilename1,logfilename2)) {                 remove(logfilename2);                 rename(logfilename1,logfilename2);             }         } else {             fclose(flog);         }     } } void Log(const char *pszFmt,...) {     va_list argp;      Lock(&cs_log);     va_start(argp,pszFmt);     LogV(pszFmt,argp);     va_end(argp);     Unlock(&cs_log); } //Log} int main(int argc,char * argv[]) {     int i; #ifdef WIN32     InitializeCriticalSection(&cs_log); #else     pthread_mutex_init(&cs_log,NULL); #endif     for (i=0;i<10000;i++) {         Log("This is a Log %04d from FILE:%s LINE:%d\n",i, __FILE__, __LINE__);     } #ifdef WIN32     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_log); #endif     return 0; } //1-78行添加到你带main的.c或.cpp的那个文件的最前面 //81-85行添加到你的main函数开头 //89-93行添加到你的main函数结束前 //在要写LOG的地方仿照第87行的写法写LOG到文件MyLog1.log中

楼主你根本就没有娶到参数：  void SYSLOG（int priority, const char *format,...） {   va_list args;//定义一个泛用的参数变量，实际是一个char*   char buffer[1024];   va_start(args, format)；//得到format的地址；    vsprintf(buffer, format, args);//此处肯定就要出大问题！     va_end(args);//将args设置为NULL    // 进行转码   charsetconvert(buffer);   // 写log   syslog(priority, buffer); }

引用 1 楼 FancyMouse 的回复:outputbuf = (char *)malloc(outputbuf); 你确定你想干这个？ 手打错了，应该是outputbuf = (char *)malloc(outputlen);

引用 2 楼 logiciel 的回复:请检查以下行： outputbuf = (char *)malloc(outputbuf); 是否要改为： outputbuf = (char *)malloc(outputlen);  以下行： inputbuf = (char *)malloc(inputlen); 改为： inputbuf = (char *)malloc(inputlen+1); 给结尾留个字节。  手打错了，应该是outputbuf = (char *)malloc(outputlen); 这个我查查inputbuf = (char *)malloc(inputlen+1);

引用 3 楼 max_min_ 的回复:outputbuf = (char *)malloc(outputbuf); 楼主可以网上搜下malloc的用法   void *malloc(size_t size);   malloc() allocates size bytes and returns a pointer to the allocated memory  手打错了，应该是outputbuf = (char *)malloc(outputlen);


Question: 有序连表的归并

你写的程序太乱了 错误百出 实在调不起 List 你typedef这个类型了吗  你就用List  你这个函数是这样声明的 void Mergelist(List La,List Lb,List &Lc){ 你却这样调用 Mergelist(La,Lb);  你自己慢慢调试 吧 用#if 0 和#endif 注释掉Mergelist函数 慢慢调 在注释掉main函数里面的一句句来过 就算我帮你这次下次呢


Question: 对于remove()， errno有哪些 ？

C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\unlink.c /*** *unlink.c - unlink a file * *       Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *       defines unlink() - unlink a file * *******************************************************************************/  #include <cruntime.h> #include <oscalls.h> #include <internal.h> #include <io.h> #include <tchar.h>  /*** *int _unlink(path) - unlink(delete) the given file * *Purpose: *       This version deletes the given file because there is no *       distinction between a linked file and non-linked file. * *       NOTE: remove() is an alternative entry point to the _unlink() *       routine* interface is identical. * *Entry: *       _TSCHAR *path - file to unlink/delete * *Exit: *       returns 0 if successful *       returns -1 and sets errno if unsuccessful * *Exceptions: * *******************************************************************************/  int __cdecl _tremove (         const _TSCHAR *path         ) {         ULONG dosretval;          if (!DeleteFile((LPTSTR)path))             dosretval = GetLastError();         else             dosretval = 0;          if (dosretval) {             /* error occured -- map error code and return */             _dosmaperr(dosretval);             return -1;         }          return 0; }  int __cdecl _tunlink (         const _TSCHAR *path         ) {         /* remove is synonym for unlink */         return _tremove(path); }

remove, _wremove Delete a file.  int remove( const char *path );  int _wremove( const wchar_t *path );  Routine Required Header Compatibility  remove <stdio.h> or <io.h> ANSI, Win 95, Win NT  _wremove <stdio.h> or <wchar.h> 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  Each of these functions returns 0 if the file is successfully deleted. Otherwise, it returns –1 and sets errno either to EACCES to indicate that the path specifies a read-only file, or to ENOENT to indicate that the filename or path was not found or that the path specifies a directory. This function fails and returns -1 if the file is open.  Parameter  path  Path of file to be removed  Remarks  The remove function deletes the file specified by path. _wremove is a wide-character version of _remove; the path argument to _wremove is a wide-character string. _wremove and _remove behave identically otherwise. All handles to a file must be closed before it can be deleted.  Generic-Text Routine Mappings  TCHAR.H Routine  _UNICODE & _MBCS Not Defined _MBCS Defined _UNICODE Defined  _tremove remove remove _wremove    Example  /* REMOVE.C: This program uses remove to delete REMOVE.OBJ. */  #include <stdio.h>  void main( void ) {    if( remove( "remove.obj" ) == -1 )       perror( "Could not delete 'REMOVE.OBJ'" );    else       printf( "Deleted 'REMOVE.OBJ'\n" ); }   Output  Deleted 'REMOVE.OBJ'   File Handling Routines  See Also   _unlink

相应定义错误查看 man page  相应函数的errno   remove  错误代码： 1、EROFS 欲写入的文件存在于只读文件系统内。 2、EFAULT 参数pathname 指针超出可存取内存空间。 3、ENAMETOOLONG 参数pathname 太长。 4、ENOMEM 核心内存不足。 5、ELOOP 参数pathname 有过多符号连接问题。 6、EIO I/O 存取错误。
本文来自【C语言中文网】：http://see.xidian.edu.cn/cpp/html/322.html

errno 错误处理机制 数学错误 ：溢出ERANGE 有效值丢失 域错误EDOM  定义错误 ：<math.h>  <stdio.h> <stdlib.h>  <siganl.h>中函数出错  保存的errno


Question: 求大神推荐c语言嵌入式的视频教程或者书籍，还有c语言系统编程的书籍或者视频

1，C++钱能的教材，李春葆的教程 2，至于C++视频教程，就用C++教程网的视频吧，他们还提供下载，我看过，还不错

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步对应汇编一行！  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）

留下你的邮箱 我有很多资料 直接给你发过去 嵌入式方面的知识实在太多 太杂  东西都在我电脑里


Question: 两个一元多项式相加输出总出问题

我知道哪里错了，谢谢你！

/* main2-7.c 检验bo2-7.c的主程序 */  #include"c1.h"  #include"c2-6.h"  #include"bo2-7.c"  void main()  {    polynomial p,q;    int m;    fflash(stdin);     printf("请输入第1个一元多项式的非零项的个数：");    scanf("%d",&m);    CreatPolyn(&p,m);    printf("请输入第2个一元多项式的非零项的个数：");    scanf("%d",&m);    CreatPolyn(&q,m);    AddPolyn(&p,&q);    printf("2个一元多项式相加的结果：\n");    PrintPolyn(p);    printf("请输入第3个一元多项式的非零项的个数：");    scanf("%d",&m);    CreatPolyn(&q,m);    AddPolyn1(&p,&q);    printf("2个一元多项式相加的结果(另一种方法)：\n");    PrintPolyn(p);     DestroyPolyn(&p);  }哪里有问题？

看main函数中输入钱是否fflash(stdin);


Question: 谁帮忙改一下错误

改成这样试试 int path(int (*maze)[10],item move[8]) {    }

参考我写的代码 这句话传参应该写错了吧 你自己想想 int path(int maze[m][n],item move[8])     #include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <stdbool.h> // //实现魔塔地图读取器 ，地图编辑器 编辑好地图后存入txt文件  本程序实现读取 // bool write_map(char *filename,char (*pos)[14]) {     FILE * fd;     int i, j ;     fd = fopen(filename,"w");      for(i = 0 ; i < 14 ; i++)         for(j = 0; j < 14 ;j++)                   fprintf(fd,"%d ",pos[i][j]);//必须有空格 要不读的时候会出问题      fclose(fd);      return true;  } bool read_map(char *filename,char (*pos)[14]) {     FILE * fd;     int i, j ;     fd = fopen(filename,"r");      for(i = 0 ; i < 14 ; i++)         for(j = 0; j < 14 ;j++){                    fscanf(fd,"%d",&pos[i][j]);         }     fclose(fd);      return true; } int main() {     int i ;     int j ;      int8_t pos[14][14] ;     int8_t pos1[14][14] ;    read_map("E:\\write.txt",pos1);      for(i = 0 ; i < 14 ;i++)         for(j = 0 ; j < 14 ;j++){             printf("%d\n",pos1[i][j]);         }    // write_map("E:\\wtite.txt",pos1);      return 0; }

用Codeblocks + gcc我改好后。还是有错： /main.c|119|警告： 传递‘path’的第 1 个参数时在不兼容的指针类型间转换 [默认启用]| /main.c|61|附注： 需要类型‘int (*)[8]’，但实参的类型为‘int (*)[10]’| /main.c|26|警告： 此函数中的‘top’在使用前未初始化 [-Wuninitialized]| ||=== Build finished: 3 errors, 0 warnings ===| #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <string.h> #define m 6 #define n 8 int maze[m+2][n+2]; typedef struct { int x,y; }item; item move[8]={{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}}; typedef struct{ int x,y,d; }datatype; datatype temp; #define FALSE 0 #define TRUE 1 typedef struct node{   int a,b,c;   struct node *next;  }SeqStack; SeqStack * Init_SeqStack() {    SeqStack *top;    top->next=NULL;    return top; } int Push_SeqStack(SeqStack *top,datatype temp) {       SeqStack *p;       p=(SeqStack *)malloc(sizeof(SeqStack));       if(p==NULL)         return FALSE;         p->a=temp.x;         p->b=temp.y;         p->c=temp.d;         p->next=top->next;         top->next=p;         return TRUE; } int IsEmpty(SeqStack *top) {      if(top->next==NULL)          return TRUE;      return FALSE; } int Pop_SeqStack(SeqStack *top,datatype *s) {     SeqStack *p;     if(IsEmpty(top))        return FALSE;     p=top->next;     s->x=p->a;     s->y=p->b;     s->d=p->c;     top->next=p->next;     free(p);     return TRUE; } int path(int maze[m][n],item move[8]) {     SeqStack *s;     int x,y,d,i,j;     s=Init_SeqStack();     temp.x=1;     temp.y=1;     temp.d=-1;     Push_SeqStack(s,temp);     while(!IsEmpty(s))     {            Pop_SeqStack(s,&temp);            x=temp.x;            y=temp.y;            d=temp.d+1;            while(d<8)            {                i=x+move[d].x;                j=y+move[d].y;                if(maze[i][j]==0)                {                       temp.x=x;                       temp.y=y;                       temp.d=d;                       Push_SeqStack(s,temp);                       x=i;                       y=j;                       maze[x][y]=-1;                       if(x==m && y==n)                          return 1;                          else                           d=0;                }                else                   d++;            }     }     return 0;  } int main() {    int i,j,f;    for(i=0;i<8;i++)      for(j=0;j<10;j++)        maze[i][j]=1;        maze[1][1]=0;        maze[2][2]=0;        maze[3][3]=0;        maze[3][4]=0;        maze[3][5]=0;        maze[3][6]=0;        maze[3][7]=0;        maze[4][5]=0;        maze[5][6]=0;        maze[5][7]=0;        maze[5][8]=0;        maze[6][8]=0;        f=path(maze,move);        if(1==f)          printf("迷宫有出路");          else            printf("迷宫没出路");      return 0; }

f=path(maze[m+2][n+2],move[]);  //这种传实参的方式也不对呀, f=path(maze,move)

if(maze[i][j]=0)  // 这里应该是maze[i][j]==0                {                       temp={x,y,d}; //结构体这种初始化方式是错误,改成 temp.x=x ;temp.y=y;temp.d=d


Question: linux c socket读取问题，我实在是搞不明白了。

非常谢谢。  但是如果我直接c_recv_len==-1，这样判断，它又可以

size_t 是无符号数，无符号数没有 -1，和 -1 的二进制内容相同的值是 0xffffffff, 4294967295 这个数是大于 0 的。


Question: 请问c语言能编写操作系统引导程序吗？

引用 4 楼 zjq9931 的回复:可以得，参见：30天自制操作系统。 《30天自制操作系统》

楼主可以下载一个u-boot源码看看，比较不错的bootloader 不过当然了，汇编和c肯定都有的，用什么汇编就看你用在什么架构上了 bootloader也可以是一个小型系统，可能比你想像中要强大一些 如果想针对某一款cpu写一个引导某一款os的bootloader，估计比较简单 楼主可以自己写一个，主要是不需要考虑移植性，加油哦

引用 10 楼 super_admi 的回复:其实楼主问错问题了，你应该问：C语言不能写什么？  这个才是真会C语言的人

那现在的c语言难道就不能调用bios中断吗？那些还原系统都是用什么语言编写的？《30天自制操作系统》 这本书我在今年的夏天在书店看到，当时看的我是热血沸腾，想买，可后来一想我的汇编8086学的不扎实，跟这本书的作者水平差一大截呢，所以也就没有买。请问下高手操作系统的引导程序原理是不是都是一样的？代码固定不变的。另外我想问下bios系统选择加载驱动器后，后面又做了那些工作才进入的操作系统自检程序？

理论上可以但不合适，实际都是用汇编

已经有人说了grub之类的东西，LZ可有去看？

用c语言嵌入汇编，毕竟，像int 18这种指令，要自己写才行，呵呵呵  你要恢复系统，只能尽量往前，在mbr，嵌入自己程序，就像病毒一样

这个书不是国人写的，是日本一个少年写的

引用 13 楼 zhao4zhong1 的回复:[quote=引用 12 楼 king_2007 的回复:] 都说能写，具体的代码呢？我都不知道你们的依据是什么？我说的都是针对x86电脑，请问下如果不依赖操作系统，那么能编写开机启动自检后编写窗体吗？另外我想知道如何控制启动计算机的顺序？如何获取硬盘或者处理器的权限？ 计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构…… [/quote]11年刚学编程的时候就看到这窜东西了= =自己写过一个arm板子的bootloader...要汇编+一点硬件知识...x86架构没写过...国人好像就出过类似的一本书,楼上说了,叫30天什么来着

引用 12 楼 king_2007 的回复:都说能写，具体的代码呢？我都不知道你们的依据是什么？我说的都是针对x86电脑，请问下如果不依赖操作系统，那么能编写开机启动自检后编写窗体吗？另外我想知道如何控制启动计算机的顺序？如何获取硬盘或者处理器的权限？ 计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……

其实楼主问错问题了，你应该问：C语言不能写什么？  然后，我就可以回答： 1.不能写美女肉体； 2.。。。

引用 楼主 king_2007 的回复:请问c语言能编写操作系统引导程序吗？另外我想一开机自检后就进入一个菜单界面该如何编写？用汇编还是c语言？有源代码就更好了。 两者都可以，参考grub或LILO

用汇编

引用 1 楼 u011779875 的回复:系统引导程序 你知道是什么  加载cpu的 rom 里面的8k程序 ，启动boot程序 初始化内存 初始化硬盘 把启动代码拷贝到内存 加载操作系统 boot实现 这里面的东西太多了 不是你想写就能写得 再说必然会用到汇编啊 这个东西是人家厂商做好的 是在实现了读驱动 和写驱动 及读内存和写内存写好的汇编 之上设计的  不是说你想盖楼 就能盖的至少得有砖块吧 +1

是不是所有的还原系统的软件都的调用硬盘中断呢？请问如果有的话，哪里可以查找相关的硬盘中断资料呢？

请问，编写引导程序不依托操作系统可以吗？哪些编写还原软件是不是都是依赖操作系统呢？难道不是靠调用bois中断吗？请问哪里有下载引导程序的源代码的地方？那些还原软件在系统崩溃或者损坏的情况下在重启系统的时候是如何调用系统资源的？

C语言的底层实现 是汇编写的驱动 底层API 又叫系统级的编程  比如内核中的printk等函数  不可能完全用C实现来实现  你要写引导程序 你启动的时候连标准库什么的你都已经用不了了 你必须自己用手写汇编 或者C嵌入汇编写 那些串口等读写的驱动 你还得把你写的程序down到电脑固定的硬盘上  有源代码啊 windows的 你可能很难找到 但是linux和Unix很多 linux内核详解  教你写操作系统 什么磁盘管理啊 内存管理 和IO 文件系统  乱七八糟  最后有教你如何写引导

可以得，参见：30天自制操作系统。


Question: 关于字符串的问题

谢谢啦，我试试

#include<stdio.h> #include<string.h>  int main(void) { 	char a[100], b[100]; 	int i, k, n; 	scanf("%s", a); 	n = strlen(a); 	for(i = 0; i < n; i++) 	{ 		if (a[i] != ',') 		{ 			b[i] = a[i]; 		} 	} 	b[i] = 0;    //这儿需要加上字符串结束标识符哦 	printf("%s\n", b);    //这儿应该就是去掉","之后的字符串哦 }

for(i=0,j=0;i<n;i++)  {if(a[i]!=',')  {b[j]=a[i];     j++; }  }

b没有初始化，所有b[1]可能0    //输入"1,111"  for(i=0;i<n;i++)  {if(a[i]!=',')  {    b[i]=a[i];  }  //else ??

#include<string.h> #include<stdio.h>  int main() {  char a[100],b[100],*p; p = b; int i,n; scanf("%99s",a); n=strlen(a); for(i=0;i<n;i++)  {    if(a[i] != ',')    {      *p++ = a[i];    }  }  *p = 0;   printf("%s\n",b);  return 0; }

#include<string.h> #include<stdio.h>  int main() {  char a[100],b[100],*p; p = b; int i; scanf("%99s",a); n=strlen(a); for(i=0;i<n;i++)  {    if(a[i] != ',')    {      *p++ = a[i];    }  }  *p = 0;   printf("%s\n",b);  return 0; }  格式化，缩进


Question: 关于AOV网的拓扑排序

请看下三楼，有什么合适的方法解决吗？谢谢。

引用 1 楼 user-1 的回复:连数个数都是#P-Complete的。别想了硬搜吧。 好吧，其实我问这个问题是想解决另外一个。关于教学计划安排，因为有学分的限制，只找一种拓扑排序好像不行吧？ 附图

连数个数都是#P-Complete的。别想了硬搜吧。


Question: malloc()分配内存后重指向问题

楼上的同志们不好好看，人家是编译时候就有问题，请问楼主，程序贴对了？（照你这个编译绝对不会有问题）  引用 20 楼 baipv008 的回复:改成：     char* dest = NULL;     char* d;     dest = (char*)malloc(len);      d =dest;  或把.c改成.cpp文件。C里面要求变量声明在开头。 看看你楼上的，人家们说的很对了，尤其18楼，19楼的。

#include"string.h" #include "stdio.h" main() { char*src="hello,world"; int len=strlen(src); char* dest = (char*)malloc(len+1); dest[len]=0;//这个应放前面，不然，len被改掉了          char* d=dest; char* s=&src[len-1]; while(--len!=0)    *d++ = *s--;   *d=0;    printf("%s\n",dest);   return 0; }

分配空间不足，printf会有问题   #include"string.h" #include "stdio.h" main() { 	char*src="hello,world"; 	int len=strlen(src); 	char* dest = (char*)malloc(len+1);         char* d=dest; 	char* s=&src[len-1]; 	while(--len!=0)   		*d++ = *s--;  	*d=0; dest[len]=0;   	printf("%s\n",dest);  	return 0; }

\0 空间没分配，肯定出错

楼主要说你这个程序呢，问题确实有，*d = 0请问这个d指向了哪里，你有为人家分配内存空间吗？另外malloc这个函数哪里来的？起码得malloc.h吧。 但是你说第一个能编译过，第二个竟然编译不过我就奇怪了，这怎么可能呢！！！你确定你贴的第二段程序编译不过？？？

char* dest = (char*)malloc(len+1);    //也要为'\0'申请一个字节的空间哦 程序没有发现什么重大问题，找不到malloc的定义，应该是你没有正确引入头文件哦。

引用 7 楼 u011779875 的回复:加上头文件 #include<stdlib.h> char* dest = (char*)malloc(len+1);  这个是对的 char* dest = (char*)malloc(len); 这个是错得 C语言的编译器不检查  C++的编译器检查   gcc的C可以通过 可能不会报错 C++的编译器直接不通过

引用 8 楼 u012527186 的回复:[quote=引用 5 楼 mujiok2003 的回复:]  #include <string.h> #include <stdio.h> int main() { 	char*src="hello,world"; 	int len=strlen(src); 	char* dest = (char*)malloc(len+1); 	char* d=dest; 	char* s=&src[len-1]; 	while(len)   		*d++ = *s--, --len;  	*d=0;  	printf("%s\n",dest);         free(dest);  	return 0; }   你能解释以下问什么以下语句不行？还是在VC6.0环境下不行。      char* dest = NULL;      dest = (char*)malloc(len);     char* d =dest;//以上三句有点问题，在VC6.0中有问题，但是修改程序如下则没问题 [/quote]  vc 6.0可能谎报了。 vc 6.0问题不少，升级编译器是必需的了。

char* dest = (char*)malloc(len+1); 这句话有问题 strlen算得是处/0 所以开辟要大一个字节 C编译器不检查 但是C++严格检查

写程序的时候 一定要记得写头文件 消除一切warning 心里得对所用的标准库 及它的实现 和易出现的问题 掌握才可以放心大胆的用

引用 8 楼 u012527186 的回复:[quote=引用 5 楼 mujiok2003 的回复:]  #include <string.h> #include <stdio.h> int main() { 	char*src="hello,world"; 	int len=strlen(src); 	char* dest = (char*)malloc(len+1); 	char* d=dest; 	char* s=&src[len-1]; 	while(len)   		*d++ = *s--, --len;  	*d=0;  	printf("%s\n",dest);         free(dest);  	return 0; }   你能解释以下问什么以下语句不行？还是在VC6.0环境下不行。      char* dest = NULL;      dest = (char*)malloc(len);     char* d =dest;//以上三句有点问题，在VC6.0中有问题，但是修改程序如下则没问题 [/quote]环境不行 这个malloc必须头文件的 在VC6.0 你要是写C程序最后用gcc编译器 编辑器随便 所以用VS2010也许 用codeblocks 也行  这个编译器不同 要求不同 所以想要运用自由随便写 还是用gcc的才是王道 你用那个会分不清什么事C什么是C++得

#include<stdlib.h>或者<malloc.h> 用gcc编译运行没问题

引用 5 楼 mujiok2003 的回复: #include <string.h> #include <stdio.h> int main() { 	char*src="hello,world"; 	int len=strlen(src); 	char* dest = (char*)malloc(len+1); 	char* d=dest; 	char* s=&src[len-1]; 	while(len)   		*d++ = *s--, --len;  	*d=0;  	printf("%s\n",dest);         free(dest);  	return 0; }   你能解释以下问什么以下语句不行？还是在VC6.0环境下不行。      char* dest = NULL;      dest = (char*)malloc(len);     char* d =dest;//以上三句有点问题，在VC6.0中有问题，但是修改程序如下则没问题

加上头文件 #include<stdlib.h>

引用 3 楼 u011779875 的回复:俩个函数除了 没有检查dest malloc的返回值是否成功外 没看到别的违规操作   运行应该都是把hello,world倒叙输出  请有VC6.0环境的运行编译以下就知道问题所在了：   #include"string.h" #include "stdio.h" main() { 	char*src="hello,world"; 	int len=strlen(src);  	char* dest = NULL;  	dest = (char*)malloc(len); 	char* d =dest;//以上三句有点问题，在VC6.0中有问题，但是修改程序如下则没问题          char* dest = (char*)malloc(len);         char* d=dest;//修改完后，即可通过编译，实现功能  	char* s=&src[len-1]; 	while(len--!=0)   		*d++ = *s--;  	*d=0;  	printf("%s\n",dest);  	return 0; }

你用的编译器没加头文件 肯定不行啊 因为C++ 和C的函数加载后的名称不同 所以要加相应的头文件

该程序是实现，数的倒转，如“abcd”,变成"dcba" 当用以下程序编译时，  #include"string.h" #include "stdio.h" main() { 	char*src="hello,world"; 	int len=strlen(src);  	char* dest = NULL;  	dest = (char*)malloc(len); 	char* d =dest;//以上三句感觉有点问题  	char* s=&src[len-1]; 	while(len--!=0)   		*d++ = *s--;  	*d=0;  	printf("%s\n",dest);  	return 0; }    编译信息如下（编译环境VC6.0）： Compiling...  : warning C4013: 'malloc' undefined; assuming extern returning int : error C2143: syntax error : missing ';' before 'type' : error C2143: syntax error : missing ';' before 'type' : error C2065: 'd' : undeclared identifier : error C2100: illegal indirection : error C2065: 's' : undeclared identifier  : error C2100: illegal indirection : error C2106: '=' : left operand must be l-value : error C2100: illegal indirection Error executing cl.exe.  Text1.exe - 8 error(s), 1 warning(s)


Question: 一个宏定义小问题

试试不就知道了


Question: 一道笔试题。。求答案

void  fun(void) { int i = 4; (&i+3) = 100; }

感谢大家，结贴了。。

引用 27 楼 halleyzhang3 的回复:开阔思路的题吧，除了前面说到的结束进程、堆栈溢出方法外，我再给一个： int fun(void) { #define printf } good

引用 58 楼 lunat 的回复:void fun() { #define printf(fmt, a, b) puts("Not 1, 2!") } 引用 45 楼 download_wg 的回复: void fun(void) { 	void** p;  	_asm 	{ 		mov p,ebp 	}  	*((int*)*p-1) = 324523; 	*((int*)*p-2) = 1345; }   char ch = 0; 	char *p = &ch; 	printf("%p\n", p); 	p += 88;//前提需要知道这个偏移量 	*(int *)p = 300; 	*(int *)(p + 4) = 400;  个人觉得嵌入汇编最理想的，直接找到帧地址，向上偏移一定字节数即可，58L，最简洁。

//1. void fun(void) {     #define fun() do {\         x = 123;\         y = 456;\     } while (0) }  int main() {     int x = 1;     int y = 2;     fun();     printf("x,y%d %d\n",x,y);          system("pause");     return 0; }   //2. void fun(void) {     /**add begin**/     }     int main()     {         printf("fuck\n");         system("pause");         return 0;     #define main useless     /**add end**/ }  int main() {     int x = 1;     int y = 2;     fun();     printf("x,y%d %d\n",x,y);          system("pause");     return 0; }  //3. 和编译器相关，VC6下应该可以 void fun(void) {     int *shit = *((int **)(&shit + 1));     *--shit = 123;     *--shit = 456; }  int main() {     int x = 1;     int y = 2;     fun();     printf("x,y%d %d\n",x,y);          system("pause");     return 0; }   //4. 和编译器相关，VC6下应该可以 void fun(void) {    __asm    {        mov eax, [ebp]        mov dword ptr [eax - 4], 123        mov dword ptr [eax - 8], 456    } }  int main() {     int x = 1;     int y = 2;     fun();     printf("x,y%d %d\n",x,y);          system("pause");     return 0; }

把字符串常量修改了  #include <stdio.h> void foo() { #pragma comment(linker,"/SECTION:.rdata,RW") 	char* p = "%d, %d\n"; 	p[0] = 0; 	puts("3,4"); }  int main() { 	int x = 1; 	int y = 2; 	foo(); 	printf("%d, %d\n", x , y); }

趁周末有时间，写了一个实现。// 这个示例代码不具有移植性 // #include <stdio.h> //__declspec(noinline)是vc的扩展属性 __declspec(noinline) void   foo() { 	int* vebp; 	//intel 汇编 	__asm mov vebp, ebp 	printf("0x%08x\n", vebp[1]); 	//修改函数返回地址（即ebp[1]),跳过执行printf("%d,%d\n",x, y); 	// printf("%d,%d\n",x, y) 在vc 2013的debug和release分别需要0x1f和0x12个字节 #if _DEBUG 	vebp[1] += 0x1f; #else  	vebp[1] += 0x12; #endif }  int main()  { 	int x = 1; 	int y = 2; 	foo(); 	printf("%d,%d\n",x, y); }

引用 58 楼 lunat 的回复:void fun() { #define printf(fmt, a, b) puts("Not 1, 2!") }  好办法！！

引用 56 楼 zhan0903 的回复:[quote=引用 54 楼 mujiok2003 的回复:] [quote=引用 53 楼 zhan0903 的回复:] [quote=引用 48 楼 mujiok2003 的回复:] [quote=引用 26 楼 max_min_ 的回复:] [quote=引用 25 楼 zhan0903 的回复:] [quote=引用 24 楼 yulitingfeng 的回复:] #include <stdio.h>  #pragma pack(push)  int fun(void) {         int a=0;         int *p;         p=&a;         while(*p!=1)         {          p++;         }         *p=10; }  int main() {         int x=1;         int y=2;         fun();         printf("%d %d\n",x,y); }  #pragma pack(pop) 遍历下就可以吧  运行确实是可以的，但是，，能不能解释下代码？[/quote] 遍历地址值，通过地址修改内容。。[/quote]  这是不可靠的。  int x=1;         int y=2;         fun();         printf("%d %d\n",x,y);可以完全可以优化成fun();printf("%d %d\n", 1, 2);[/quote]  什么意思？编译器进行的优化？[/quote]  vc 2013 release结果:  0FC0FFC  add         byte ptr [eax],al   00FC0FFE  add         byte ptr [eax],al   --- c:\users\bruce\documents\visual studio 2013\projects\consoleapplication1\consoleapplication1\consoleapplication1.cpp  	int a = 1, b = 2; 	foo(); 	printf("%d %d", a, b); 00FC1000  push        2  //不访问b 00FC1002  push        1  //没有访问a 00FC1004  push        0FC2100h   00FC1009  call        dword ptr ds:[0FC2090h]   00FC100F  add         esp,0Ch   [/quote] push 2 push 1 不就是访问了a和b？ 局部变量入栈？[/quote] 这是常量，在代码段中

引用 54 楼 mujiok2003 的回复:[quote=引用 53 楼 zhan0903 的回复:] [quote=引用 48 楼 mujiok2003 的回复:] [quote=引用 26 楼 max_min_ 的回复:] [quote=引用 25 楼 zhan0903 的回复:] [quote=引用 24 楼 yulitingfeng 的回复:] #include <stdio.h>  #pragma pack(push)  int fun(void) {         int a=0;         int *p;         p=&a;         while(*p!=1)         {          p++;         }         *p=10; }  int main() {         int x=1;         int y=2;         fun();         printf("%d %d\n",x,y); }  #pragma pack(pop) 遍历下就可以吧  运行确实是可以的，但是，，能不能解释下代码？[/quote] 遍历地址值，通过地址修改内容。。[/quote]  这是不可靠的。  int x=1;         int y=2;         fun();         printf("%d %d\n",x,y);可以完全可以优化成fun();printf("%d %d\n", 1, 2);[/quote]  什么意思？编译器进行的优化？[/quote]  vc 2013 release结果:  0FC0FFC  add         byte ptr [eax],al   00FC0FFE  add         byte ptr [eax],al   --- c:\users\bruce\documents\visual studio 2013\projects\consoleapplication1\consoleapplication1\consoleapplication1.cpp  	int a = 1, b = 2; 	foo(); 	printf("%d %d", a, b); 00FC1000  push        2  //不访问b 00FC1002  push        1  //没有访问a 00FC1004  push        0FC2100h   00FC1009  call        dword ptr ds:[0FC2090h]   00FC100F  add         esp,0Ch   [/quote] push 2 push 1 不就是访问了a和b？ 局部变量入栈？

引用 61 楼 zhan0903 的回复:[quote=引用 57 楼 mujiok2003 的回复:] [quote=引用 56 楼 zhan0903 的回复:] [quote=引用 54 楼 mujiok2003 的回复:] [quote=引用 53 楼 zhan0903 的回复:] [quote=引用 48 楼 mujiok2003 的回复:] [quote=引用 26 楼 max_min_ 的回复:] [quote=引用 25 楼 zhan0903 的回复:] [quote=引用 24 楼 yulitingfeng 的回复:] #include <stdio.h>  #pragma pack(push)  int fun(void) {         int a=0;         int *p;         p=&a;         while(*p!=1)         {          p++;         }         *p=10; }  int main() {         int x=1;         int y=2;         fun();         printf("%d %d\n",x,y); }  #pragma pack(pop) 遍历下就可以吧  运行确实是可以的，但是，，能不能解释下代码？[/quote] 遍历地址值，通过地址修改内容。。[/quote]  这是不可靠的。  int x=1;         int y=2;         fun();         printf("%d %d\n",x,y);可以完全可以优化成fun();printf("%d %d\n", 1, 2);[/quote]  什么意思？编译器进行的优化？[/quote]  vc 2013 release结果:  0FC0FFC  add         byte ptr [eax],al   00FC0FFE  add         byte ptr [eax],al   --- c:\users\bruce\documents\visual studio 2013\projects\consoleapplication1\consoleapplication1\consoleapplication1.cpp  	int a = 1, b = 2; 	foo(); 	printf("%d %d", a, b); 00FC1000  push        2  //不访问b 00FC1002  push        1  //没有访问a 00FC1004  push        0FC2100h   00FC1009  call        dword ptr ds:[0FC2090h]   00FC100F  add         esp,0Ch   [/quote] push 2 push 1 不就是访问了a和b？ 局部变量入栈？[/quote] 这是常量，在代码段中[/quote] 可否详细解释下？这个没有取a和b的值是不是和编译器优化有关？换一种编译器会不会取a和b的值？[/quote]  寻址方式：立即数

引用 61 楼 zhan0903 的回复:[quote=引用 57 楼 mujiok2003 的回复:] [quote=引用 56 楼 zhan0903 的回复:] [quote=引用 54 楼 mujiok2003 的回复:] [quote=引用 53 楼 zhan0903 的回复:] [quote=引用 48 楼 mujiok2003 的回复:] [quote=引用 26 楼 max_min_ 的回复:] [quote=引用 25 楼 zhan0903 的回复:] [quote=引用 24 楼 yulitingfeng 的回复:] #include <stdio.h>  #pragma pack(push)  int fun(void) {         int a=0;         int *p;         p=&a;         while(*p!=1)         {          p++;         }         *p=10; }  int main() {         int x=1;         int y=2;         fun();         printf("%d %d\n",x,y); }  #pragma pack(pop) 遍历下就可以吧  运行确实是可以的，但是，，能不能解释下代码？[/quote] 遍历地址值，通过地址修改内容。。[/quote]  这是不可靠的。  int x=1;         int y=2;         fun();         printf("%d %d\n",x,y);可以完全可以优化成fun();printf("%d %d\n", 1, 2);[/quote]  什么意思？编译器进行的优化？[/quote]  vc 2013 release结果:  0FC0FFC  add         byte ptr [eax],al   00FC0FFE  add         byte ptr [eax],al   --- c:\users\bruce\documents\visual studio 2013\projects\consoleapplication1\consoleapplication1\consoleapplication1.cpp  	int a = 1, b = 2; 	foo(); 	printf("%d %d", a, b); 00FC1000  push        2  //不访问b 00FC1002  push        1  //没有访问a 00FC1004  push        0FC2100h   00FC1009  call        dword ptr ds:[0FC2090h]   00FC100F  add         esp,0Ch   [/quote] push 2 push 1 不就是访问了a和b？ 局部变量入栈？[/quote] 这是常量，在代码段中[/quote] 可否详细解释下？这个没有取a和b的值是不是和编译器优化有关？换一种编译器会不会取a和b的值？[/quote] 跟编译器有关，跟优化有关。

引用 57 楼 mujiok2003 的回复:[quote=引用 56 楼 zhan0903 的回复:] [quote=引用 54 楼 mujiok2003 的回复:] [quote=引用 53 楼 zhan0903 的回复:] [quote=引用 48 楼 mujiok2003 的回复:] [quote=引用 26 楼 max_min_ 的回复:] [quote=引用 25 楼 zhan0903 的回复:] [quote=引用 24 楼 yulitingfeng 的回复:] #include <stdio.h>  #pragma pack(push)  int fun(void) {         int a=0;         int *p;         p=&a;         while(*p!=1)         {          p++;         }         *p=10; }  int main() {         int x=1;         int y=2;         fun();         printf("%d %d\n",x,y); }  #pragma pack(pop) 遍历下就可以吧  运行确实是可以的，但是，，能不能解释下代码？[/quote] 遍历地址值，通过地址修改内容。。[/quote]  这是不可靠的。  int x=1;         int y=2;         fun();         printf("%d %d\n",x,y);可以完全可以优化成fun();printf("%d %d\n", 1, 2);[/quote]  什么意思？编译器进行的优化？[/quote]  vc 2013 release结果:  0FC0FFC  add         byte ptr [eax],al   00FC0FFE  add         byte ptr [eax],al   --- c:\users\bruce\documents\visual studio 2013\projects\consoleapplication1\consoleapplication1\consoleapplication1.cpp  	int a = 1, b = 2; 	foo(); 	printf("%d %d", a, b); 00FC1000  push        2  //不访问b 00FC1002  push        1  //没有访问a 00FC1004  push        0FC2100h   00FC1009  call        dword ptr ds:[0FC2090h]   00FC100F  add         esp,0Ch   [/quote] push 2 push 1 不就是访问了a和b？ 局部变量入栈？[/quote] 这是常量，在代码段中[/quote] 可否详细解释下？这个没有取a和b的值是不是和编译器优化有关？换一种编译器会不会取a和b的值？

引用 53 楼 zhan0903 的回复:[quote=引用 48 楼 mujiok2003 的回复:] [quote=引用 26 楼 max_min_ 的回复:] [quote=引用 25 楼 zhan0903 的回复:] [quote=引用 24 楼 yulitingfeng 的回复:] #include <stdio.h>  #pragma pack(push)  int fun(void) {         int a=0;         int *p;         p=&a;         while(*p!=1)         {          p++;         }         *p=10; }  int main() {         int x=1;         int y=2;         fun();         printf("%d %d\n",x,y); }  #pragma pack(pop) 遍历下就可以吧  运行确实是可以的，但是，，能不能解释下代码？[/quote] 遍历地址值，通过地址修改内容。。[/quote]  这是不可靠的。  int x=1;         int y=2;         fun();         printf("%d %d\n",x,y);可以完全可以优化成fun();printf("%d %d\n", 1, 2);[/quote]  什么意思？编译器进行的优化？[/quote]  vc 2013 release结果:  0FC0FFC  add         byte ptr [eax],al   00FC0FFE  add         byte ptr [eax],al   --- c:\users\bruce\documents\visual studio 2013\projects\consoleapplication1\consoleapplication1\consoleapplication1.cpp  	int a = 1, b = 2; 	foo(); 	printf("%d %d", a, b); 00FC1000  push        2  //不访问b 00FC1002  push        1  //没有访问a 00FC1004  push        0FC2100h   00FC1009  call        dword ptr ds:[0FC2090h]   00FC100F  add         esp,0Ch

引用 48 楼 mujiok2003 的回复:[quote=引用 26 楼 max_min_ 的回复:] [quote=引用 25 楼 zhan0903 的回复:] [quote=引用 24 楼 yulitingfeng 的回复:] #include <stdio.h>  #pragma pack(push)  int fun(void) {         int a=0;         int *p;         p=&a;         while(*p!=1)         {          p++;         }         *p=10; }  int main() {         int x=1;         int y=2;         fun();         printf("%d %d\n",x,y); }  #pragma pack(pop) 遍历下就可以吧  运行确实是可以的，但是，，能不能解释下代码？[/quote] 遍历地址值，通过地址修改内容。。[/quote]  这是不可靠的。  int x=1;         int y=2;         fun();         printf("%d %d\n",x,y);可以完全可以优化成fun();printf("%d %d\n", 1, 2);[/quote]  什么意思？编译器进行的优化？

问，如何实现函数fun，使得最后的结果是下载整个互联网内容到本机？！

引用 50 楼 qq523176585 的回复:[quote=引用 49 楼 download_wg 的回复:] [quote=引用 47 楼 qq523176585 的回复:] [quote=引用 46 楼 download_wg 的回复:] 看了半天才想通 int arr[1] = {0}; int *p = (int *)(arr[1]);   --不报错、或者告警没想通啊  虽然感觉跟下面这个是一样的 void fun(void) {  	int k; 	int* p =&k; 	*((int*)*(p +1) - 1)  = 100; 	*((int*)*(p +1) - 2)  = 200;  	/*void** p;  	_asm 	{ 		mov p,ebp 	}  	*((int*)*p-1) = 324523; 	*((int*)*p-2) = 1345;*/ }   为什么要报错或者警告呢，你觉得哪里不对？[/quote]  我把东西都丢光了，arr[1]不是该越界么[/quote]   C语言不是不检查越界吗？为什么要报错呢[/quote]  这个我不知道，尴尬了

引用 49 楼 download_wg 的回复:[quote=引用 47 楼 qq523176585 的回复:] [quote=引用 46 楼 download_wg 的回复:] 看了半天才想通 int arr[1] = {0}; int *p = (int *)(arr[1]);   --不报错、或者告警没想通啊  虽然感觉跟下面这个是一样的 void fun(void) {  	int k; 	int* p =&k; 	*((int*)*(p +1) - 1)  = 100; 	*((int*)*(p +1) - 2)  = 200;  	/*void** p;  	_asm 	{ 		mov p,ebp 	}  	*((int*)*p-1) = 324523; 	*((int*)*p-2) = 1345;*/ }   为什么要报错或者警告呢，你觉得哪里不对？[/quote]  我把东西都丢光了，arr[1]不是该越界么[/quote]   C语言不是不检查越界吗？为什么要报错呢

引用 47 楼 qq523176585 的回复:[quote=引用 46 楼 download_wg 的回复:] 看了半天才想通 int arr[1] = {0}; int *p = (int *)(arr[1]);   --不报错、或者告警没想通啊  虽然感觉跟下面这个是一样的 void fun(void) {  	int k; 	int* p =&k; 	*((int*)*(p +1) - 1)  = 100; 	*((int*)*(p +1) - 2)  = 200;  	/*void** p;  	_asm 	{ 		mov p,ebp 	}  	*((int*)*p-1) = 324523; 	*((int*)*p-2) = 1345;*/ }   为什么要报错或者警告呢，你觉得哪里不对？[/quote]  我把东西都丢光了，arr[1]不是该越界么


Question: 二叉树的非递归后序遍历遇到的问题？只能访问叶子节点？！

哈哈，问题解决了！   原来问题出在43行和52行左右，应该在43行的后面加上一句s.Push(*cur);并且在52行的后面加上一句s.Pop(&cur);。这样问题就解决了。按照我以前的写法会造成上一层的根节点被释放，无法留在栈中。所以只能输出最下一层的叶子节点。

1. pre无用且有错 2. s.Pop(&cur); 后面进入else分支,还要重新push进去

补充一下，46行和53行都是我在调试的时候写的，没别的用途。


Question: 问一个排序的问题

也可以在内存中对索引排序， 然后从后到前遍历，计算每一条记录要向后移动多少位置

最好使用堆。如果内存不足，考虑使用内存映射文件。（记得保存行号）

将数字全部读入内存（数字，原文件中的行号），排好序，然后一个一个写入另一个文件（数字后面的数据根据行号从原文件中读取），结束之后删除原文件。应该可行吧？

仅供参考//输出PROG中有但LIST中没有的文本行，即集合PROG-LIST #include <stdio.h> #include <string.h> #include <stdlib.h> #include <search.h> #define MAXCHARS 512 int MAXLINES=10000,MAXLINES2; char *buf,*buf2; char PROG[256]="PROG";//程序Program需要的文件列表 char LIST[256]="LIST";//dir /b /s生成的实际文件列表List FILE *fp,*fl; int i,c,n,L,hh; int ignore_case=0; char ln[MAXCHARS]; int icompare(const void *arg1,const void *arg2) {    return stricmp((char *)arg1,(char *)arg2); } int compare(const void *arg1,const void *arg2) {    return strcmp((char *)arg1,(char *)arg2); } int main(int argc,char **argv) {     if (argc>1) strcpy(PROG,argv[1]);//命令行参数1覆盖PROG     if (argc>2) strcpy(LIST,argv[2]);//命令行参数2覆盖LIST     if (argc>3) ignore_case=1;//若存在命令行参数3，忽略大小写     if ((fl=fopen(LIST,"rt"))==NULL) {         fprintf(stderr,"Can not open %s\n",LIST);         fprintf(stderr,"Usage: %s [PROG] [LIST] [-i]\n",argv[0]);         return 1;     }     if ((fp=fopen(PROG,"rt"))==NULL) {         fclose(fl);         fprintf(stderr,"Can not open %s\n",PROG);         fprintf(stderr,"Usage: %s [PROG] [LIST] [-i]\n",argv[0]);         return 2;     }     buf=(char *)malloc(MAXLINES*MAXCHARS);     if (NULL==buf) {         fclose(fl);         fclose(fp);         fprintf(stderr,"Can not malloc(%d LINES*%d CHARS)!\n",MAXLINES,MAXCHARS);         return 4;     }     n=0;     hh=0;     i=0;     while (1) {         if (fgets(ln,MAXCHARS,fl)==NULL) break;//         hh++;         L=strlen(ln)-1;         if ('\n'!=ln[L]) {//超长行忽略后面内容             fprintf(stderr,"%s Line %d too long(>%d),spilth ignored.\n",LIST,hh,MAXCHARS);             while (1) {                 c=fgetc(fl);                 if ('\n'==c || EOF==c) break;//             }         }         while (1) {//去掉行尾的'\n'和空格             if ('\n'==ln[L] || ' '==ln[L]) {                 ln[L]=0;                 L--;                 if (L<0) break;//             } else break;//         }         if (L>=0) {             strcpy(buf+i,ln);i+=MAXCHARS;             n++;             if (n>=MAXLINES) {                 MAXLINES2=MAXLINES*2;                 if (MAXLINES2==1280000) MAXLINES2=2500000;                 buf2=(char *)realloc(buf,MAXLINES2*MAXCHARS);                 if (NULL==buf2) {                     free(buf);                     fclose(fl);                     fclose(fp);                     fprintf(stderr,"Can not malloc(%d LINES*%d CHARS)!\n",MAXLINES2,MAXCHARS);                     return 5;                 }                 buf=buf2;                 MAXLINES=MAXLINES2;             }         }     }     fclose(fl);     if (ignore_case) qsort(buf,n,MAXCHARS,icompare);     else qsort(buf,n,MAXCHARS,compare);     hh=0;     while (1) {         if (fgets(ln,MAXCHARS,fp)==NULL) break;//         hh++;         L=strlen(ln)-1;         if ('\n'!=ln[L]) {//超长行忽略后面内容             fprintf(stderr,"%s Line %d too long(>%d),spilth ignored.\n",PROG,hh,MAXCHARS);             while (1) {                 c=fgetc(fp);                 if ('\n'==c || EOF==c) break;//             }         }         while (1) {//去掉行尾的'\n'和空格             if ('\n'==ln[L] || ' '==ln[L]) {                 ln[L]=0;                 L--;                 if (L<0) break;//             } else break;//         }         if (L>=0) {             if (ignore_case) {                 if (NULL==bsearch(ln,buf,n,MAXCHARS,icompare)) printf("%s\n",ln);             } else {                 if (NULL==bsearch(ln,buf,n,MAXCHARS,compare)) printf("%s\n",ln);             }         }     }     fclose(fp);     free(buf);     return 0; }

或者你换种方式 你把这个txt文件给它拆分了 你把相应1的索引放在一起 分成一个目录结构在取操作这个目录结构的文件。我感觉大公司也不会都存在1个txt10万条吧  你先对这个10万 通过2分法拆分为100个  之后分别实现这个想法行吧

引用 1 楼 u011779875 的回复:二分法 查找快 hash法什么都快吧 你既然都读出前面的数字数据 那么就要在插入的时候 在此读取插入那行 并插入 在保存就完事了呗 始终保存 谁说C语言不能从中间插入了  fseek 这是什么  可以完成的 在优化下算法 fseek定位指针我知道，往里面写数据会把以前的数据替换掉的，可能我fopen打开文件的方式不对我用的是rb+


Question: 指针赋值问题请教

函数的整体实现有问题 这俩句话根本看不出问题 删除左孩子 是有很多情况的 你没考虑全吧 在判段的时候


Question: 数据采集后 过滤的问题

引用 2 楼 u011779875 的回复:总有一种过滤方法适合你 http://blog.csdn.net/jungsagacity/article/details/7398338 谢谢 ~

这要看趋势了 这个值如果是连续的 且开始与结束的时间很短 而正常取值的时候值很多 那么就好办了取这些值中出现最多的那个值 在取这个值中与最多值偏差为很小的值 在进行取平均值 如果开始 和正常 和结束它们都很短的话 那就需要考虑去掉一些特点值后在进行取平均值