Question: 有关动态二维数组释放的问题，求解答。

如楼上说的 楼主释放的时候多释放了一个

引用 2 楼 maspacious 的回复:[quote=引用 1 楼 turingo 的回复:] 两个for循环不一致： for (i=0; i<=LABEL_NUM; ++i) ... for (int i=0; i <=VERTEX_NUM; ++i)  我知道啊。但是看网上说也是应该这么释放啊[/quote] 要释放的内存应该和分配的内存一一对应，分配了多少就释放多少。这边只为t指向内存中的(VERTEX_NUM+1)的LABEL_NUM+1个指针分配了内存。所以你应该释放LABEL_NUM+1个，而不是VERTEX_NUM+1个

仅供参考//在堆中开辟一个4×5的二维int数组 #include <stdio.h> #include <malloc.h> int **p; int i,j; void main() {     p=(int **)malloc(4*sizeof(int *));     if (NULL==p) return;     for (i=0;i<4;i++) {         p[i]=(int *)malloc(5*sizeof(int));         if (NULL==p[i]) return;     }     for (i=0;i<4;i++) {         for (j=0;j<5;j++) {             p[i][j]=i*5+j;         }     }     for (i=0;i<4;i++) {         for (j=0;j<5;j++) {             printf(" %2d",p[i][j]);         }         printf("\n");     }     for (i=0;i<4;i++) {         free(p[i]);     }     free(p); } //  0  1  2  3  4 //  5  6  7  8  9 // 10 11 12 13 14 // 15 16 17 18 19

引用 13 楼 z1179675084 的回复:[quote=引用 12 楼 maspacious 的回复:] [quote=引用 10 楼 z1179675084 的回复:] [quote=引用 9 楼 maspacious 的回复:] [quote=引用 8 楼 z1179675084 的回复:] [quote=引用 7 楼 maspacious 的回复:] [quote=引用 6 楼 z1179675084 的回复:] [quote=引用 3 楼 z1179675084 的回复:]  int row = 2,col = 3;   int **p = (int **)malloc(sizeof(int *) * row);   int *a = (int *)malloc(sizeof(int) * row *col);   int i = 0;   //申请不成功，自己处理   for(i = 0;i < row;i++)   {   	p[i] = a + i * col;   }  释放时候直接free(a) free（p）,至于你那个本身就是错的[/quote]  我知道我释放的时候不正确。但是我的申请没错吧应该。[/quote] 没有，咱俩的申请本质是一样的[/quote]  那按照我这种申请方式 如何释放。。[/quote] 实在抱歉，一开始没好好看你程序，你这个程序没有问题啊[/quote]  ..如果我把行列数改成相同的 释放就不会出错。。。[/quote] 贴你完整的程序出来看一下，不应该出错啊，除非你别的地方还捣鼓什么了，你这个释放本身就是按行的空间释放啊，没有问题的 你加我Q吧，这里不方便1179675084[/quote]  加你了请通过验证

引用 12 楼 maspacious 的回复:[quote=引用 10 楼 z1179675084 的回复:] [quote=引用 9 楼 maspacious 的回复:] [quote=引用 8 楼 z1179675084 的回复:] [quote=引用 7 楼 maspacious 的回复:] [quote=引用 6 楼 z1179675084 的回复:] [quote=引用 3 楼 z1179675084 的回复:]  int row = 2,col = 3;   int **p = (int **)malloc(sizeof(int *) * row);   int *a = (int *)malloc(sizeof(int) * row *col);   int i = 0;   //申请不成功，自己处理   for(i = 0;i < row;i++)   {   	p[i] = a + i * col;   }  释放时候直接free(a) free（p）,至于你那个本身就是错的[/quote]  我知道我释放的时候不正确。但是我的申请没错吧应该。[/quote] 没有，咱俩的申请本质是一样的[/quote]  那按照我这种申请方式 如何释放。。[/quote] 实在抱歉，一开始没好好看你程序，你这个程序没有问题啊[/quote]  ..如果我把行列数改成相同的 释放就不会出错。。。[/quote] 贴你完整的程序出来看一下，不应该出错啊，除非你别的地方还捣鼓什么了，你这个释放本身就是按行的空间释放啊，没有问题的 你加我Q吧，这里不方便1179675084

引用 10 楼 z1179675084 的回复:[quote=引用 9 楼 maspacious 的回复:] [quote=引用 8 楼 z1179675084 的回复:] [quote=引用 7 楼 maspacious 的回复:] [quote=引用 6 楼 z1179675084 的回复:] [quote=引用 3 楼 z1179675084 的回复:]  int row = 2,col = 3;   int **p = (int **)malloc(sizeof(int *) * row);   int *a = (int *)malloc(sizeof(int) * row *col);   int i = 0;   //申请不成功，自己处理   for(i = 0;i < row;i++)   {   	p[i] = a + i * col;   }  释放时候直接free(a) free（p）,至于你那个本身就是错的[/quote]  我知道我释放的时候不正确。但是我的申请没错吧应该。[/quote] 没有，咱俩的申请本质是一样的[/quote]  那按照我这种申请方式 如何释放。。[/quote] 实在抱歉，一开始没好好看你程序，你这个程序没有问题啊[/quote]  ..如果我把行列数改成相同的 释放就不会出错。。。

怎么分配怎么释放！ 分配：从外到里 释放：从里到外

引用 9 楼 maspacious 的回复:[quote=引用 8 楼 z1179675084 的回复:] [quote=引用 7 楼 maspacious 的回复:] [quote=引用 6 楼 z1179675084 的回复:] [quote=引用 3 楼 z1179675084 的回复:]  int row = 2,col = 3;   int **p = (int **)malloc(sizeof(int *) * row);   int *a = (int *)malloc(sizeof(int) * row *col);   int i = 0;   //申请不成功，自己处理   for(i = 0;i < row;i++)   {   	p[i] = a + i * col;   }  释放时候直接free(a) free（p）,至于你那个本身就是错的[/quote]  我知道我释放的时候不正确。但是我的申请没错吧应该。[/quote] 没有，咱俩的申请本质是一样的[/quote]  那按照我这种申请方式 如何释放。。[/quote] 实在抱歉，一开始没好好看你程序，你这个程序没有问题啊

引用 8 楼 z1179675084 的回复:[quote=引用 7 楼 maspacious 的回复:] [quote=引用 6 楼 z1179675084 的回复:] [quote=引用 3 楼 z1179675084 的回复:]  int row = 2,col = 3;   int **p = (int **)malloc(sizeof(int *) * row);   int *a = (int *)malloc(sizeof(int) * row *col);   int i = 0;   //申请不成功，自己处理   for(i = 0;i < row;i++)   {   	p[i] = a + i * col;   }  释放时候直接free(a) free（p）,至于你那个本身就是错的[/quote]  我知道我释放的时候不正确。但是我的申请没错吧应该。[/quote] 没有，咱俩的申请本质是一样的[/quote]  那按照我这种申请方式 如何释放。。

引用 7 楼 maspacious 的回复:[quote=引用 6 楼 z1179675084 的回复:] [quote=引用 3 楼 z1179675084 的回复:]  int row = 2,col = 3;   int **p = (int **)malloc(sizeof(int *) * row);   int *a = (int *)malloc(sizeof(int) * row *col);   int i = 0;   //申请不成功，自己处理   for(i = 0;i < row;i++)   {   	p[i] = a + i * col;   }  释放时候直接free(a) free（p）,至于你那个本身就是错的[/quote]  我知道我释放的时候不正确。但是我的申请没错吧应该。[/quote] 没有，咱俩的申请本质是一样的

引用 6 楼 z1179675084 的回复:[quote=引用 3 楼 z1179675084 的回复:]  int row = 2,col = 3;   int **p = (int **)malloc(sizeof(int *) * row);   int *a = (int *)malloc(sizeof(int) * row *col);   int i = 0;   //申请不成功，自己处理   for(i = 0;i < row;i++)   {   	p[i] = a + i * col;   }  释放时候直接free(a) free（p）,至于你那个本身就是错的[/quote]  我知道我释放的时候不正确。但是我的申请没错吧应该。

引用 3 楼 z1179675084 的回复: int row = 2,col = 3;   int **p = (int **)malloc(sizeof(int *) * row);   int *a = (int *)malloc(sizeof(int) * row *col);   int i = 0;   //申请不成功，自己处理   for(i = 0;i < row;i++)   {   	p[i] = a + i * col;   }  释放时候直接free(a) free（p）,至于你那个本身就是错的

给你一个答案啊

引用 3 楼 z1179675084 的回复: int row = 2,col = 3;   int **p = (int **)malloc(sizeof(int *) * row);   int *a = (int *)malloc(sizeof(int) * row *col);   int i = 0;   //申请不成功，自己处理   for(i = 0;i < row;i++)   {   	p[i] = a + i * col;   }   ？？

引用 1 楼 turingo 的回复:两个for循环不一致： for (i=0; i<=LABEL_NUM; ++i) ... for (int i=0; i <=VERTEX_NUM; ++i)  我知道啊。但是看网上说也是应该这么释放啊


Question: 一元多项式如何冲文件读取数据！

其实我都看不懂你文件的内容。。。 fscanf可以从文件输入。 像scanf一样好用 fgetc也可以。但要转化，吧字符型数字，转化成数值型数字。

文件内容


Question: 求 c书籍推荐

C程序设计语言   第二版

我推荐谈好强拌的

引用 10 楼 haofang666777 的回复:[quote=引用 8 楼 max_min_ 的回复:] [quote=引用 5 楼 haofang666777 的回复:] [quote=引用 4 楼 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语言的书吧！ 这几本书都买了，不过一直还都没有看，毕竟白天要工作，晚上一直在看sip协议， 这几本书有讲这些变量吗？？好像没有吧，其他还没看，c陷阱与缺陷烦了一下目录，印象里没有这方面的内容。。[/quote]  基础知道了！那些东西也不会很难的！而且那个也只是你例举出来的一二，后面可能还会遇到很多这些东西的，而且这些非标准东西，书上都只是顺带提下而已，也没有详细讲 至于你说的__attribute__ 可以参考 http://blog.csdn.net/ithomer/article/details/6566739 利用好网络[/quote] 谢谢啊 现在就是看到一个搜一个，不过更喜欢从书本中学习洗净书本里讲的相对系统些，网络也的确很全。[/quote] 像这些知识都是比较少，用的不是很普遍的话，使用者不是特别多的话，书上就比较少系统的讲这些知识点了，只是大致简单说其一二而已！所以把基础打牢，把你买的几本书都看完，消化掉，然后再相对的搜索相关这些知识点，就比较好把握了！

引用 8 楼 max_min_ 的回复:[quote=引用 5 楼 haofang666777 的回复:] [quote=引用 4 楼 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语言的书吧！ 这几本书都买了，不过一直还都没有看，毕竟白天要工作，晚上一直在看sip协议， 这几本书有讲这些变量吗？？好像没有吧，其他还没看，c陷阱与缺陷烦了一下目录，印象里没有这方面的内容。。[/quote]  基础知道了！那些东西也不会很难的！而且那个也只是你例举出来的一二，后面可能还会遇到很多这些东西的，而且这些非标准东西，书上都只是顺带提下而已，也没有详细讲 至于你说的__attribute__ 可以参考 http://blog.csdn.net/ithomer/article/details/6566739 利用好网络[/quote] 谢谢啊 现在就是看到一个搜一个，不过更喜欢从书本中学习洗净书本里讲的相对系统些，网络也的确很全。

http://product.china-pub.com/3767800 http://product.china-pub.com/30181  引用 6 楼 haofang666777 的回复:书籍求推荐啊！！ Linux内核设计与实现，深入理解Linux内核，还有楼上的linux内核源码详解 Unix环境高级编程，深入理解计算机体系结构？？ 先谢啦 [quote=引用 3 楼 turingo 的回复:] 这跟书籍没什么关系，__attribute__是非标准的用法，倒是建议你看看Linux内核方面的书籍，这样比你直接看源代码要直观一些，容易理解一些。  [quote=引用 楼主 haofang666777 的回复:] 最近在读源代码 但是又很多东西是之前没有接触过的，想找本书 系统的学一下 ， 举例如下 __attribute__((format(printf, 5, 0))) #ifdef AST_DEVMODE #if defined(LOW_MEMORY) #define localtime_r __dont_use_localtime_r_use_ast_localtime_instead__ pthread_once(&ts->once, ts->key_init); if (!(buf = pthread_getspecific(ts->key)))  其实就是些 #define #undef 对应的变量  还有一些函数， 之前也就看过c primer plus， c++ primer （刚开始学的C++,工作了 用的C）之类的 这种看着有点费劲。 什么方面的书籍有介绍这类东西，有没有系统介绍的书籍，求推荐[/quote][/quote]

引用 5 楼 haofang666777 的回复:[quote=引用 4 楼 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语言的书吧！ 这几本书都买了，不过一直还都没有看，毕竟白天要工作，晚上一直在看sip协议， 这几本书有讲这些变量吗？？好像没有吧，其他还没看，c陷阱与缺陷烦了一下目录，印象里没有这方面的内容。。[/quote]  基础知道了！那些东西也不会很难的！而且那个也只是你例举出来的一二，后面可能还会遇到很多这些东西的，而且这些非标准东西，书上都只是顺带提下而已，也没有详细讲 至于你说的__attribute__ 可以参考 http://blog.csdn.net/ithomer/article/details/6566739 利用好网络

另对老谭没感情，他的书就免了， 不是一时兴起，是要成年累月的学的， 希望有从入门和精通之类的书籍都推荐一下

书籍求推荐啊！！ Linux内核设计与实现，深入理解Linux内核，还有楼上的linux内核源码详解 Unix环境高级编程，深入理解计算机体系结构？？ 先谢啦 引用 3 楼 turingo 的回复:这跟书籍没什么关系，__attribute__是非标准的用法，倒是建议你看看Linux内核方面的书籍，这样比你直接看源代码要直观一些，容易理解一些。  [quote=引用 楼主 haofang666777 的回复:] 最近在读源代码 但是又很多东西是之前没有接触过的，想找本书 系统的学一下 ， 举例如下 __attribute__((format(printf, 5, 0))) #ifdef AST_DEVMODE #if defined(LOW_MEMORY) #define localtime_r __dont_use_localtime_r_use_ast_localtime_instead__ pthread_once(&ts->once, ts->key_init); if (!(buf = pthread_getspecific(ts->key)))  其实就是些 #define #undef 对应的变量  还有一些函数， 之前也就看过c primer plus， c++ primer （刚开始学的C++,工作了 用的C）之类的 这种看着有点费劲。 什么方面的书籍有介绍这类东西，有没有系统介绍的书籍，求推荐[/quote]

引用 4 楼 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语言的书吧！ 这几本书都买了，不过一直还都没有看，毕竟白天要工作，晚上一直在看sip协议， 这几本书有讲这些变量吗？？好像没有吧，其他还没看，c陷阱与缺陷烦了一下目录，印象里没有这方面的内容。。

这跟书籍没什么关系，__attribute__是非标准的用法，倒是建议你看看Linux内核方面的书籍，这样比你直接看源代码要直观一些，容易理解一些。  引用 楼主 haofang666777 的回复:最近在读源代码 但是又很多东西是之前没有接触过的，想找本书 系统的学一下 ， 举例如下 __attribute__((format(printf, 5, 0))) #ifdef AST_DEVMODE #if defined(LOW_MEMORY) #define localtime_r __dont_use_localtime_r_use_ast_localtime_instead__ pthread_once(&ts->once, ts->key_init); if (!(buf = pthread_getspecific(ts->key)))  其实就是些 #define #undef 对应的变量  还有一些函数， 之前也就看过c primer plus， c++ primer （刚开始学的C++,工作了 用的C）之类的 这种看着有点费劲。 什么方面的书籍有介绍这类东西，有没有系统介绍的书籍，求推荐

C标准库 C陷阱与缺陷 深入理解计算机体系结构 程序员的自我修养 linux内核源码详解 Unix环境高级编程

引用 6 楼 haofang666777 的回复:书籍求推荐啊！！ Linux内核设计与实现，深入理解Linux内核，还有楼上的linux内核源码详解 Unix环境高级编程，深入理解计算机体系结构？？ 先谢啦 [quote=引用 3 楼 turingo 的回复:] 这跟书籍没什么关系，__attribute__是非标准的用法，倒是建议你看看Linux内核方面的书籍，这样比你直接看源代码要直观一些，容易理解一些。  [quote=引用 楼主 haofang666777 的回复:] 最近在读源代码 但是又很多东西是之前没有接触过的，想找本书 系统的学一下 ， 举例如下 __attribute__((format(printf, 5, 0))) #ifdef AST_DEVMODE #if defined(LOW_MEMORY) #define localtime_r __dont_use_localtime_r_use_ast_localtime_instead__ pthread_once(&ts->once, ts->key_init); if (!(buf = pthread_getspecific(ts->key)))  其实就是些 #define #undef 对应的变量  还有一些函数， 之前也就看过c primer plus， c++ primer （刚开始学的C++,工作了 用的C）之类的 这种看着有点费劲。 什么方面的书籍有介绍这类东西，有没有系统介绍的书籍，求推荐[/quote][/quote] 这个看下gcc编译器的手册就可以了。  至于c语言基础，《C Primer Plus》已经足够，也并不难，静下心来就可以。 至于进一步的理解，楼上也有推介。  我也加2本： 《C专家编程》 《C语言接口与实现》

大学看过谭的书,我还是推荐看c语言程序涉及(ansi c),C专家编程之类的

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

引用 1 楼 Idle_Cloud 的回复:你列的书就比较系统了。如果看得费劲，可以先看本谭浩强的，很简单，但是内容比较片面，很多没讲。 。。。这类看着费劲，不是指c primer plus 和c++ primer；c primer plus 看了一遍 c++ primer 已经度过3遍 3遍一遍有一遍的收获， 我说费解是指 那些 ifdef 还有那些生涩的函数，c++ primer 和c primer plus都没有设计 ，我主要是想了解这方面的内容， 前面没说明白，敬请谅解。


Question: 两个小程序的区别

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

表示有点想法，坐等大神

引用 6 楼 ForestDB 的回复:Return value Number of receiving arguments successfully assigned, or EOF if read failure occurs before the first receiving argument was assigned.  EOF is true as it is non-zero.  你无法退出循环

scanf 的返回值 1、格式参数中的格式项用完-----正常结束; 2、发生格式项与输入域不匹配时---非正常结束;   函数也是具有返回值的，功能相似。如果错误或者读到文件结尾，返回EOF（-1），否则返回实际转换并赋值的输入项的数目  EOF是-  1返回的是匹配的数 scanf("%d %d",&a,&b) 当不匹配0个就返回0了 比如你输出0.1 0.1 结束  这个是和EOF -1比较是出错的情况  问题的答案往往不是关键 关键是解决问题的思路 菜鸟飘过

报错的程序是无法退出循环吧

1 报错程序： 遇到EOF， 程序继续循环 2 AC程序：   遇到EOF， 程序结束循环

报错的程序因为超时

题目是不是说要求多行输入输出的？？


Question: C中涉及printf 和运算优先级的一个小问题

的确有正在看正在消化。。。。谢谢。。。。

先看这个帖子再说

置顶帖有说明  不管能不能看懂  反正记住 这写法是错误的可以了

//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 | //+------------------+-----------------------------------------+---------------+

引用 4 楼 zhao4zhong1 的回复:不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  好好看看C语言中符号的优先级

请看ansi c标准6.5.2.2.10 The order of evaluation of the function designator, the actual arguments, and subexpressions within the actual arguments is unspecified, but there is a sequence point before the actual call. 这种行为是unspecified, 不同编译器下的实现可能不同, 结果不一样. 所以不要写出这样的代码.


Question: 想向诸位讨教关于c文件操作的问题

推荐看C标准库和UNIX系统编程。

引用 5 楼 turingo 的回复:带缓冲区的操作方式读写的时候大多在缓冲区中进行，这样操作IO的次数会变少，效率当然比较高。  引用 4 楼 niannixv 的回复:引用 楼主 niannixv 的回复:c的文件操作分为流式文件操作和I/O文件操作，两者本质区别在哪里？性能优劣各是什么？如果我在移动设备上开发，应该选择哪一种？ 引用 1 楼 turingo 的回复:C的文件操作都需要通过I/O操作，区别只是在于直接读写还是通过缓冲区缓冲，移动设备上建议用带缓冲区的操作方式，也就是通过fopen/fclose/fread/fwrite等函数来操作。  引用 楼主 niannixv 的回复:c的文件操作分为流式文件操作和I/O文件操作，两者本质区别在哪里？性能优劣各是什么？如果我在移动设备上开发，应该选择哪一种？多谢！能不能具体说下“用带缓冲区的操作方式”的原因？“直接读写”主要用于哪里？“带缓冲区的操作方式读写的时候大多在缓冲区中进行这样操作IO的次数会变少，效率当然比较高。”对于写文件，是不是意味着，只在fclose时候，才把缓冲区的数据写到i/o设备上？对于读文件操作，是不是意味着，无论你fread的字节数是多少，系统都会把整个文件读到缓冲区？（PS:问的是不是太多，只是看你等级应该是高手，所以忍不住多问几句，想彻底搞清楚，希望见谅）

引用 2 楼 ForestDB 的回复:“c的文件操作分为流式文件操作和I/O文件操作” 哪里讲的？可能说的不准确，那么c的文件操作可以分类吗？如果有，怎么表述这个分类

“c的文件操作分为流式文件操作和I/O文件操作” 哪里讲的？

APUE


Question: 对flash.bin文件做处理，如果出错，就打不开，怎么搞

做个checksum什么的。  个人建议，仅供参考。

能不能提个具体方案，要达到一个目的就是，如果错一个字节.bin文件就打不来，无法下载到flash中去，没错字节能正常下载到flash中还可以使用

md5sum check


Question: 使用C语言开发办公自动化系统好吗？一般需要设计几个模块，界面怎么实现呀？

个人感觉用DELPHI比较合适。  引用 楼主 u012474809 的回复:做毕业设计老师给的题目，但是学的是C语言，感觉这个用java开发比较好，用C语言实现好吗？

VBA for Office帮助大全.chm 在Office内置的帮助里面搜索界面不够爽，而且没有书签功能。 这个是我重新整合到一起的chm。查起来方便多了！ http://download.csdn.net/detail/zhao4zhong1/1383274

VBA for Office

看看相关论文


Question: 函数参数传递

声明什么就传递什么是编译器在帮助你防止出错的机制，除非你明确的进行类类型转换

引用 2 楼 worldy 的回复:就是这样，传人是地址的副本，不管传值还是传指针事实上就是在栈中分配适当数量存储器，存储传人的值，那肯定就是某个东西的副本。。。。不是值就是地址  还有一个麻烦解答下,谢谢！~  既然 传指针也是传副本也就是传一个值,那为什么当我传入一个地址的副本的时候,假设形参是int类型的就会报错呢？我认为既然都是一个副本值,地址只不过是一个特殊的值(比如可能int 类型的值为1,而指针的副本的012314一个比较特殊的值),为什么会报错.

是的引用实际上改变了缺省的按值传递参数的传递机制，在按值传递时函数操纵的是实参的本地拷贝。如果参数是引用时函数接收的是实参的左值而不是值的拷贝，这意味着函数知道实参在内存中的位置因而能够改变它的值或取它的地址。

我认为正确，可以把指针类型看成和int等类似的基本数据类型，也就是传值而已。


Question: signal(),while(1).我不明白为什么：被注释的语句和它上面的语句会产生一样的输出结果

引用 1 楼 zhao4zhong1 的回复:SIGNAL Section: Linux Programmer's Manual (2) Updated: 2000-04-28  --------------------------------------------------------------------------------    NAME signal - ANSI C signal handling    SYNOPSIS #include <signal.h>  typedef void (*sighandler_t)(int);   sighandler_t signal(int signum, sighandler_t handler);     DESCRIPTION The signal() system call installs a new signal handler for the signal with number signum. The signal handler is set to sighandler which may be a user specified function, or either SIG_IGN or SIG_DFL.  Upon arrival of a signal with number signum the following happens. If the corresponding handler is set to SIG_IGN, then the signal is ignored. If the handler is set to SIG_DFL, then the default action associated with the signal (see signal(7)) occurs. Finally, if the handler is set to a function sighandler then first either the handler is reset to SIG_DFL or an implementation-dependent blocking of the signal is performed and next sighandler is called with argument signum.   Using a signal handler function for a signal is called "catching the signal". The signals SIGKILL and SIGSTOP cannot be caught or ignored.       RETURN VALUE The signal() function returns the previous value of the signal handler, or SIG_ERR on error.      PORTABILITY The original Unix signal() would reset the handler to SIG_DFL, and System V (and the Linux kernel and libc4,5) does the same. On the other hand, BSD does not reset the handler, but blocks new instances of this signal from occurring during a call of the handler. The glibc2 library follows the BSD behaviour.  If one on a libc5 system includes <bsd/signal.h> instead of <signal.h> then signal is redefined as __bsd_signal and signal has the BSD semantics. This is not recommended.   If one on a glibc2 system defines a feature test macro such as _XOPEN_SOURCE or uses a separate sysv_signal function, one obtains classical behaviour. This is not recommended.   Trying to change the semantics of this call using defines and includes is not a good idea. It is better to avoid signal altogether, and use sigaction(2) instead.       NOTES The effects of this call in a multi-threaded process are unspecified.  The routine handler must be very careful, since processing elsewhere was interrupted at some arbitrary point. POSIX has the concept of "safe function". If a signal interrupts an unsafe function, and handler calls an unsafe function, then the behavior is undefined. Safe functions are listed explicitly in the various standards. The POSIX 1003.1-2003 list is   _Exit() _exit() abort() accept() access() aio_error() aio_return() aio_suspend() alarm() bind() cfgetispeed() cfgetospeed() cfsetispeed() cfsetospeed() chdir() chmod() chown() clock_gettime() close() connect() creat() dup() dup2() execle() execve() fchmod() fchown() fcntl() fdatasync() fork() fpathconf() fstat() fsync() ftruncate() getegid() geteuid() getgid() getgroups() getpeername() getpgrp() getpid() getppid() getsockname() getsockopt() getuid() kill() link() listen() lseek() lstat() mkdir() mkfifo() open() pathconf() pause() pipe() poll() posix_trace_event() pselect() raise() read() readlink() recv() recvfrom() recvmsg() rename() rmdir() select() sem_post() send() sendmsg() sendto() setgid() setpgid() setsid() setsockopt() setuid() shutdown() sigaction() sigaddset() sigdelset() sigemptyset() sigfillset() sigismember() signal() sigpause() sigpending() sigprocmask() sigqueue() sigset() sigsuspend() sleep() socket() socketpair() stat() symlink() sysconf() tcdrain() tcflow() tcflush() tcgetattr() tcgetpgrp() tcsendbreak() tcsetattr() tcsetpgrp() time() timer_getoverrun() timer_gettime() timer_settime() times() umask() uname() unlink() utime() wait() waitpid() write().   According to POSIX, the behaviour of a process is undefined after it ignores a SIGFPE, SIGILL, or SIGSEGV signal that was not generated by the kill(2) or the raise(3) functions. Integer division by zero has undefined result. On some architectures it will generate a SIGFPE signal. (Also dividing the most negative integer by -1 may generate SIGFPE.) Ignoring this signal might lead to an endless loop.   See sigaction(2) for details on what happens when SIGCHLD is set to SIG_IGN.   The use of sighandler_t is a GNU extension. Various versions of libc predefine this type; libc4 and libc5 define SignalHandler, glibc defines sig_t and, when _GNU_SOURCE is defined, also sighandler_t.     CONFORMING TO ANSI C      SEE ALSO kill(1), alarm(2), kill(2), pause(2), sigaction(2), sigqueue(2), sigvec(2), killpg(3), raise(3), sigsetops(3), signal(7)  -------------------------------------------------------------------------------- 1.按照逻辑，似乎程序A应该一直停留在while()语句中，是不可能有机会再次执行到语句：if()，也就没有可能使用signal()函数捕获信号并发送至sig_usr()处理了。 2.然而，程序A是可以捕获信号:SIGINT，并将其发送到sig_usr()函数处理   那么问题就是：为什么程序A可以执行到语句if()


Question: 文件读取：读出来了一些乱码。

http://webdesign.about.com/od/textedit/a/aa122006.htm  Change the format to plain text TextEdit defaults to a rich text format, so you need to switch it to plain text to write HTML Open the Format tab Choose "Make Plain Text" You can also hit Shift-Apple-T to switch to plain text

引用 13 楼 ForestDB 的回复:当然有啊 你还能截图？等我下午去机房吧 ，在这里是win的

当然有啊 你还能截图？

引用 11 楼 ForestDB 的回复:打开文件另存为“纯文本文件”。 在 mac中没有这个纯文本文件

打开文件另存为“纯文本文件”。

引用 8 楼 ForestDB 的回复:rtf的内容本来就是 {\rtf1\ansi\ansicpg936\cocoartf1187\cocoasubrtf370 ... 这样的  可以将rtf用文本编辑器打开看。 看 ，能看到。但是无法去掉

引用 7 楼 turingo 的回复:纯文本文件是不可能的。  [quote=引用 6 楼 lc10915819 的回复:] [quote=引用 2 楼 turingo 的回复:] rtf文件本身就包含许多格式信息，比如字体颜色表格什么的，不是纯文本文件，直接读有乱码很正常。  [quote=引用 楼主 lc10915819 的回复:]  #include <stdio.h>  int main(int argc, const char * argv[]) {     FILE *fp;     int ch;     fp = fopen("/Users/lichan/Desktop/name.rtf", "rb");                  while ((ch=getc(fp)) != EOF)         {             putchar(ch);          }                    return 0; }       文件内容：lichgan isdadafadad  读出来的内容： {\rtf1\ansi\ansicpg936\cocoartf1187\cocoasubrtf370 {\fonttbl\f0\fswiss\fcharset0 Helvetica;} {\colortbl;\red255\green255\blue255;} \paperw11900\paperh16840\margl1440\margr1440\vieww10800\viewh8400\viewkind0 \pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural  \f0\fs24 \cf0 lichgan isdadafadad}  请问这是怎么回事呢？[/quote]  而且我是用文本编辑，已经去掉了那些格式修饰符，但是还是能读出来[/quote][/quote]  哪有什么办法去掉这修饰么？

纯文本文件是不可能的。  引用 6 楼 lc10915819 的回复:[quote=引用 2 楼 turingo 的回复:] rtf文件本身就包含许多格式信息，比如字体颜色表格什么的，不是纯文本文件，直接读有乱码很正常。  [quote=引用 楼主 lc10915819 的回复:]  #include <stdio.h>  int main(int argc, const char * argv[]) {     FILE *fp;     int ch;     fp = fopen("/Users/lichan/Desktop/name.rtf", "rb");                  while ((ch=getc(fp)) != EOF)         {             putchar(ch);          }                    return 0; }       文件内容：lichgan isdadafadad  读出来的内容： {\rtf1\ansi\ansicpg936\cocoartf1187\cocoasubrtf370 {\fonttbl\f0\fswiss\fcharset0 Helvetica;} {\colortbl;\red255\green255\blue255;} \paperw11900\paperh16840\margl1440\margr1440\vieww10800\viewh8400\viewkind0 \pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural  \f0\fs24 \cf0 lichgan isdadafadad}  请问这是怎么回事呢？[/quote]  而且我是用文本编辑，已经去掉了那些格式修饰符，但是还是能读出来[/quote]

引用 2 楼 turingo 的回复:rtf文件本身就包含许多格式信息，比如字体颜色表格什么的，不是纯文本文件，直接读有乱码很正常。  [quote=引用 楼主 lc10915819 的回复:]  #include <stdio.h>  int main(int argc, const char * argv[]) {     FILE *fp;     int ch;     fp = fopen("/Users/lichan/Desktop/name.rtf", "rb");                  while ((ch=getc(fp)) != EOF)         {             putchar(ch);          }                    return 0; }       文件内容：lichgan isdadafadad  读出来的内容： {\rtf1\ansi\ansicpg936\cocoartf1187\cocoasubrtf370 {\fonttbl\f0\fswiss\fcharset0 Helvetica;} {\colortbl;\red255\green255\blue255;} \paperw11900\paperh16840\margl1440\margr1440\vieww10800\viewh8400\viewkind0 \pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural  \f0\fs24 \cf0 lichgan isdadafadad}  请问这是怎么回事呢？[/quote]  而且我是用文本编辑，已经去掉了那些格式修饰符，但是还是能读出来

直接改文件的后缀名？  引用 4 楼 lc10915819 的回复:[quote=引用 2 楼 turingo 的回复:] rtf文件本身就包含许多格式信息，比如字体颜色表格什么的，不是纯文本文件，直接读有乱码很正常。  [quote=引用 楼主 lc10915819 的回复:]  #include <stdio.h>  int main(int argc, const char * argv[]) {     FILE *fp;     int ch;     fp = fopen("/Users/lichan/Desktop/name.rtf", "rb");                  while ((ch=getc(fp)) != EOF)         {             putchar(ch);          }                    return 0; }       文件内容：lichgan isdadafadad  读出来的内容： {\rtf1\ansi\ansicpg936\cocoartf1187\cocoasubrtf370 {\fonttbl\f0\fswiss\fcharset0 Helvetica;} {\colortbl;\red255\green255\blue255;} \paperw11900\paperh16840\margl1440\margr1440\vieww10800\viewh8400\viewkind0 \pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural  \f0\fs24 \cf0 lichgan isdadafadad}  请问这是怎么回事呢？[/quote]  引用 2 楼 turingo 的回复:rtf文件本身就包含许多格式信息，比如字体颜色表格什么的，不是纯文本文件，直接读有乱码很正常。  [quote=引用 楼主 lc10915819 的回复:]  #include <stdio.h>  int main(int argc, const char * argv[]) {     FILE *fp;     int ch;     fp = fopen("/Users/lichan/Desktop/name.rtf", "rb");                  while ((ch=getc(fp)) != EOF)         {             putchar(ch);          }                    return 0; }       文件内容：lichgan isdadafadad  读出来的内容： {\rtf1\ansi\ansicpg936\cocoartf1187\cocoasubrtf370 {\fonttbl\f0\fswiss\fcharset0 Helvetica;} {\colortbl;\red255\green255\blue255;} \paperw11900\paperh16840\margl1440\margr1440\vieww10800\viewh8400\viewkind0 \pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural  \f0\fs24 \cf0 lichgan isdadafadad}  请问这是怎么回事呢？[/quote]  我其实已经把rtf文件格式改成了text格式，但是还是带出来一样的内容，这事怎么回事呢[/quote]

引用 2 楼 turingo 的回复:rtf文件本身就包含许多格式信息，比如字体颜色表格什么的，不是纯文本文件，直接读有乱码很正常。  [quote=引用 楼主 lc10915819 的回复:]  #include <stdio.h>  int main(int argc, const char * argv[]) {     FILE *fp;     int ch;     fp = fopen("/Users/lichan/Desktop/name.rtf", "rb");                  while ((ch=getc(fp)) != EOF)         {             putchar(ch);          }                    return 0; }       文件内容：lichgan isdadafadad  读出来的内容： {\rtf1\ansi\ansicpg936\cocoartf1187\cocoasubrtf370 {\fonttbl\f0\fswiss\fcharset0 Helvetica;} {\colortbl;\red255\green255\blue255;} \paperw11900\paperh16840\margl1440\margr1440\vieww10800\viewh8400\viewkind0 \pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural  \f0\fs24 \cf0 lichgan isdadafadad}  请问这是怎么回事呢？[/quote]  引用 2 楼 turingo 的回复:rtf文件本身就包含许多格式信息，比如字体颜色表格什么的，不是纯文本文件，直接读有乱码很正常。  [quote=引用 楼主 lc10915819 的回复:]  #include <stdio.h>  int main(int argc, const char * argv[]) {     FILE *fp;     int ch;     fp = fopen("/Users/lichan/Desktop/name.rtf", "rb");                  while ((ch=getc(fp)) != EOF)         {             putchar(ch);          }                    return 0; }       文件内容：lichgan isdadafadad  读出来的内容： {\rtf1\ansi\ansicpg936\cocoartf1187\cocoasubrtf370 {\fonttbl\f0\fswiss\fcharset0 Helvetica;} {\colortbl;\red255\green255\blue255;} \paperw11900\paperh16840\margl1440\margr1440\vieww10800\viewh8400\viewkind0 \pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural  \f0\fs24 \cf0 lichgan isdadafadad}  请问这是怎么回事呢？[/quote]  我其实已经把rtf文件格式改成了text格式，但是还是带出来一样的内容，这事怎么回事呢

引用 2 楼 turingo 的回复:rtf文件本身就包含许多格式信息，比如字体颜色表格什么的，不是纯文本文件，直接读有乱码很正常。  [quote=引用 楼主 lc10915819 的回复:]  #include <stdio.h>  int main(int argc, const char * argv[]) {     FILE *fp;     int ch;     fp = fopen("/Users/lichan/Desktop/name.rtf", "rb");                  while ((ch=getc(fp)) != EOF)         {             putchar(ch);          }                    return 0; }       文件内容：lichgan isdadafadad  读出来的内容： {\rtf1\ansi\ansicpg936\cocoartf1187\cocoasubrtf370 {\fonttbl\f0\fswiss\fcharset0 Helvetica;} {\colortbl;\red255\green255\blue255;} \paperw11900\paperh16840\margl1440\margr1440\vieww10800\viewh8400\viewkind0 \pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural  \f0\fs24 \cf0 lichgan isdadafadad}  请问这是怎么回事呢？[/quote]  ++

rtf文件本身就包含许多格式信息，比如字体颜色表格什么的，不是纯文本文件，直接读有乱码很正常。  引用 楼主 lc10915819 的回复: #include <stdio.h>  int main(int argc, const char * argv[]) {     FILE *fp;     int ch;     fp = fopen("/Users/lichan/Desktop/name.rtf", "rb");                  while ((ch=getc(fp)) != EOF)         {             putchar(ch);          }                    return 0; }       文件内容：lichgan isdadafadad  读出来的内容： {\rtf1\ansi\ansicpg936\cocoartf1187\cocoasubrtf370 {\fonttbl\f0\fswiss\fcharset0 Helvetica;} {\colortbl;\red255\green255\blue255;} \paperw11900\paperh16840\margl1440\margr1440\vieww10800\viewh8400\viewkind0 \pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural  \f0\fs24 \cf0 lichgan isdadafadad}  请问这是怎么回事呢？

文本模式和二进制模式读出来的内容一样。把rtf格式转化为 text格式还是这个样子。

引用 17 楼 lm_whales 的回复:用RichEdit控件读取，存储为文本格式即可。  使用 touch  filename 吧。看来只有这样了。楼上的都给分。

用RichEdit控件读取，存储为文本格式即可。

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


Question: 新手提问。。关于printf输出

对无符号数，右移补0。 对有符号数，正数（最高位为0）右移补0；负数（最高位为1）右移补1。

引用 3 楼 zhao4zhong1 的回复:#include <stdio.h> unsigned char ui;   signed char si; char main() {     ui=(unsigned char)0x80u;     si=(  signed char)0x80;     printf("ui=%u\n",ui);     printf("si=%d\n",si);     ui=ui>>1;     si=si>>1;     printf("ui=%u\n",ui);     printf("si=%d\n",si);      printf("--------------\n");     ui=(unsigned char)0x80u;     si=(  signed char)0x80;     printf("ui=%u\n",ui);     printf("si=%d\n",si);     ui=((  signed char)ui)>>1;     si=((unsigned char)si)>>1;     printf("ui=%u\n",ui);     printf("si=%d\n",si);      printf("==============\n");      ui=(unsigned char)0x80u;     si=(  signed char)0x80;     printf("ui=%u\n",ui);     printf("si=%d\n",si);     ui=ui<<1;     si=si<<1;     printf("ui=%u\n",ui);     printf("si=%d\n",si);      printf("--------------\n");     ui=(unsigned char)0x80u;     si=(  signed char)0x80;     printf("ui=%u\n",ui);     printf("si=%d\n",si);     ui=((  signed char)ui)<<1;     si=((unsigned char)si)<<1;     printf("ui=%u\n",ui);     printf("si=%d\n",si);      return 0; } //ui=128 //si=-128 //ui=64 //si=-64 //-------------- //ui=128 //si=-128 //ui=192 //si=64 //============== //ui=128 //si=-128 //ui=0 //si=0 //-------------- //ui=128 //si=-128 //ui=0 //si=0  被大神这么一搞，我又有点晕了~~ 看这例子，左移的情况都是补零，但右移时要复杂很多，能否费心费力，解释下，有没有好的理解 方式呢~书上说的不太看懂

楼主所言甚是 #include<stdio.h>  int main(void) { 	unsigned i = 0xcffffff3; 	long j=0xcffffff3; 	int k=0xcffffff3; 	printf("num:\t%x\n",0xcffffff3 >> 2); 	printf("i:\t%x\n",i >> 2); 	printf("j:\t%x\n",j >> 2); 	printf("k:\t%x\n",k >> 2);     return 0; }

是正确的，根据输出结果来看，这样的判断是对的

对啊 无符号 补0 有符号补1啊


Question: 关于二元数组寻找的问题，新手求教@-@(100分)

//给定n个数,他们的构成情况是A或者B后面跟上一个小于500000的数。如(A100,B111) //要求：找出所有二元数组(Ai,Bj)如果(Ai>Bj)：即A后面跟的数字大于B后面跟的数字。 //则A的计分不变,B的计分=B+i(也就是A后面跟上的这个数i的值)。 //而如果(Ai<Bj)则A的计分=A+j的数字,B的计分不变,A,B初始计分为0； //输入输出举例： //  输入：4 A1 B2 A3 B5 //  输出：A=12 B=3 //      原因：组成所有二元数组有 //          (A1,B2)此时A+2 //          (A1,B5)此时A+5 //          (A3,B2)此时B+3 //          (A3,B5)此时A+5 //          最后得分A=12 B=3 //  输入：5 A1 A3 B2 B4 B5 //  输出：A=20 B=3 #include <stdio.h> #define MAXN 100 int n,i,j,d; int A,B; int a[MAXN],an; int b[MAXN],bn; char s[10]; int main() {     n=0;     scanf("%d",&n);     if (n<1 || MAXN<n) {         printf("1<=n<=100\n");         return 1;     }     an=0;     bn=0;     for (i=0;i<n;i++) {         scanf("%s",s);         if (1==sscanf(s,"A%d",&d)) a[an++]=d;         if (1==sscanf(s,"B%d",&d)) b[bn++]=d;     }     A=0;B=0;     for (i=0;i<an;i++) {         for (j=0;j<bn;j++) {             if (a[i]>b[j]) B+=a[i];             if (a[i]<b[j]) A+=b[j];         }     }     printf("A=%d B=%d\n",A,B);     return 0; }

1）分割，转换 2）求和

[quote=引用 3 楼 turingo 的回复:] 题目看不太懂！  题目已经修正~

引用 2 楼 user-4 的回复:不是很懂意思！说明白点  给定n个数，他们的构成情况是A或者B后面跟上一个小于500000的数。如（A100，B111）   要求：找出所有二元数组（Ai,Bj）    如果（Ai >Bj）：即A后面跟的数字大于B后面跟的数字 。 则A的计分不变，B的计分=B+i(也就是A后面跟上的这个数i的值)。而如果（Ai<Bj）则A的计分=A+j的数字，B的计分不变，A，B初始计分为0；   输入输出举例：   输入：  4  （n=4）  A1 B2 A3 B5   输出：   A的分数=12   B的分数=3  原因：   组成所有二元数组有（A1，B2）此时A+2;  (A1，B5),此时A+5  (A3，B2),  此时B+3  (A3，B5)；C此时A+5；  最后得分A=12，B=3；     输入：  5 （n=5） A1 A3 B2 B4 B5    输出：A=20  B=3

题目看不太懂！  引用 楼主 zw627092693 的回复:n个数-分别由A或者B加上一个小于五十万的数构成。  如（A10，B5）。 现在要求找出全部（Ai,Bj）.如果i>j 则sumA+=j;  如果j>i.sumB+=i; 如果是首字母相同不做处理 eg：输入：4 A1 B2 A3 B5 输出：A=12 B=3 理由：（A1，B2）---> A+2 (A1，B5) ---> A+5 (A3，B2) ---> B+3 (A3，B5) ---> A+5 ps:超时问题。。。。

不是很懂意思！说明白点

大神人呢@-@


Question: 在源程度中调用自己编写的头文件，如何实现

引用 1 楼 xlshu 的回复:no such file or directory 头文件应该保存到什么位置才能找到？  个人习惯，一般与源文件同目录，也可单独放， #include "\pathname\filename.h" 也可

#include <ceshitou.h> 改成 #include "ceshitou.h"  VS把这个头文件添加到工程里面去，把文件拖进去就好 VC++把文件包含到include文件夹中在调用

1.如果文件 ceshitou.h 和被调用它的*.c文件在同一文件夹下，将 #include <ceshitou.h> 改为 #include "ceshitou.h" ； 2.如果文件 ceshitou.h 和被调用它的*.c文件不在同一文件夹下，比如路径为d:\MyCHead\ceshitou.h ，则将 #include <ceshitou.h> 改为 #include "d:\MyCHead\ceshitou.h" ；  注：头文件包含的形式：a.#include <stdio.h> /*stdio.h为IDE自带的头文件库中的头文件*/                       b.#include "school.h" /*school.h为用户自定义的头文件*/ 所以，如果将 #include <stdio.h> 写成 #include "stdio.h",程序编译的效率会降低，因为在编译时，IDE会先在当前目录找 #include "stdio.h" ,但是找不到，所以又会在IDE的库文件系统目录中找，头文件库里存在，编译通过，若当前*.c文件目录和库文件中都不存在，就会报错。

#3正解 <>只能从标准目录查找 ""范围比较广

改成 void main() { mytou();   }

是不是用VS呢，如果是这样的话可能是你没把这个头文件添加到工程里面去，把文件拖进去就好了

The #include Directive The #include directive tells the preprocessor to treat the contents of a specified file as if those contents had appeared in the source program at the point where the directive appears. You can organize constant and macro definitions into include files and then use #include directives to add these definitions to any source file. Include files are also useful for incorporating declarations of external variables and complex data types. You only need to define and name the types once in an include file created for that purpose.  Syntax  #include "path-spec"  #include <path-spec>  The path-spec is a filename optionally preceded by a directory specification. The filename must name an existing file. The syntax of the path-spec depends on the operating system on which the program is compiled.  Both syntax forms cause replacement of that directive by the entire contents of the specified include file. The difference between the two forms is the order in which the preprocessor searches for header files when the path is incompletely specified.  Syntax Form Action  Quoted form This form instructs the preprocessor to look for include files in the same directory of the file that contains the #include statement, and then in the directories of whatever files that include (#include) that file. The preprocessor then searches along the path specified by the /I compiler option, then along paths specified by the INCLUDE environment variable.  Angle-bracket form This form instructs the preprocessor to search for include files first along the path specified by the /I compiler option, then along the path specified by the INCLUDE environment variable.    The preprocessor stops searching as soon as it finds a file with the given name. If you specify a complete, unambiguous path specification for the include file between two sets of double quotation marks (" "), the preprocessor searches only that path specification and ignores the standard directories.  If the filename enclosed in double quotation marks is an incomplete path specification, the preprocessor first searches the “parent” file’s directory. A parent file is the file containing the #include directive. For example, if you include a file named file2 within a file named file1, file1 is the parent file.  Include files can be “nested”; that is, an #include directive can appear in a file named by another #include directive. For example, file2, above, could include file3. In this case, file1 would still be the parent of file2 but would be the “grandparent” of file3.  When include files are nested, directory searching begins with the directories of the parent file and then proceeds through the directories of any grandparent files. Thus, searching begins relative to the directory containing the source currently being processed. If the file is not found, the search moves to directories specified by the /I compiler option. Finally, the directories specified by the INCLUDE environment variable are searched.   The following example shows file inclusion using angle brackets:  #include <stdio.h>  This example adds the contents of the file named STDIO.H to the source program. The angle brackets cause the preprocessor to search the directories specified by the INCLUDE environment variable for STDIO.H, after searching directories specified by the /I compiler option.  The following example shows file inclusion using the quoted form:  #include "defs.h"  This example adds the contents of the file specified by DEFS.H to the source program. The double quotation marks mean that the preprocessor searches the directory containing the parent source file first.  Nesting of include files can continue up to 10 levels. Once the nested #include is processed, the preprocessor continues to insert the enclosing include file into the original source file.  Microsoft Specific   To locate includable source files, the preprocessor first searches the directories specified by the /I compiler option. If the /I option is not present or fails, the preprocessor uses the INCLUDE environment variable to find any include files within angle brackets. The INCLUDE environment variable and /I compiler option can contain multiple paths separated by semicolons (;). If more than one directory appears as part of the /I option or within the INCLUDE environment variable, the preprocessor searches them in the order in which they appear.  For example, the command  CL /ID:\MSVC\INCLUDE MYPROG.C  causes the preprocessor to search the directory D:\MSVC\INCLUDE for include files such as STDIO.H. The commands  SET INCLUDE=D:\MSVC\INCLUDE CL MYPROG.C  have the same effect. If both sets of searches fail, a fatal compiler error is generated.  If the filename is fully specified for an include file with a path that includes a colon (for example, F:\MSVC\SPECIAL\INCL\TEST.H), the preprocessor follows the path.  For include files specified as #include "path-spec", directory searching begins with the directory of the parent file and then proceeds through the directories of any grandparent files. Thus, searching begins relative to the directory containing the source file containing the #include directive being processed. If there is no grandparent file and the file has not been found, the search continues as if the filename were enclosed in angle brackets.  END Microsoft Specific


Question: 关于不同数据类型的问题

1）定义三种类型的表 2）根据类型采用不同的表 3）数据可以全部采用字符串输入 好吧C用宏

C++可以用模版  C用宏。。。


Question: 菜鸟求助？调用子函数，如何传递参数？

引用 15 楼 zhao4zhong1 的回复:计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括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、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495听君一席话胜读十年书啊

还有这个东西，版主已经贴出来了，也可以达到相同的效果  fflush(stdin)刷新标准输入缓冲区，把输入缓冲区里的东西丢弃[非标准] fflush(stdout)刷新标准输出缓冲区，把输出缓冲区里的东西打印到标准输出设备上

哈哈，我是这样理解的： 首先你要知道一个输入缓冲区的概念 键盘输入的东西会放在输入缓冲区内 你调用scanf()会从输入缓冲区中提取数据，调用到回车、空格等字符的时候就会停止提取 getchar()也从输入缓冲区提取数据，每次提取一个数据，包括回车、空格都会提取  咱们前边代码用了scanf()调用了一下输入缓冲区后，缓冲区遗留一个“回车符”， 再用getchar()调用时，会把“回车符”提取出来，你输入的“Y”和“N”只能再次使用getchar调用  如有理解错误请指正，谢谢

int main(void) {         int a;     printf("请输入你的年龄:\n");     in_age(scanf("%d\n",&a));     in_age(a);//这样就可以了啊。     return 0; }

可以使用fgets(buf, sizeof(buf), stdin); sscanf(buf, "%d", &hoge);  比 scanf("%d", &hoge); 安全

引用 13 楼 wutian5856 的回复:我也是菜鸟，学习中，有不对的地方请大牛们指出哈哈哈  看到这个问题，我也在我本地尝试了一下，确实发现楼主问题，那叫一个迷茫啊，上网查资料，看别人的回帖等等，昨天晚上搞了一个晚上，越搞越迷糊，今天早上重新看了一下，发现豁然开朗，然后自己尝试了一把，最后终于把代码改好了（发现版主已经贴上了，但是还是贴上让大家指正一下吧） 我粘上代码让大家指正    #include <stdio.h> #include <conio.h>   void in_age(int age) {         char choose;     if(age >= 18)     {         printf("该网站你可以进入\n");     }     else     {         printf("如果想进入请输入Y，不想进入请输入N:"); 	  getchar();//最后确认是这个地方有问题，scanf函数在输入缓冲区中调用后，会留一个回车符                    //在输入缓冲区,就是这个回车符搞的鬼， 	  choose = getchar(); 	  printf("\nchoose = %c\n",choose);         if('Y' == choose)         {             printf("SUCCESS\n");         }         else         {               printf("FALSE\n");          }     } }   int main(void) {         int a;     printf("请输入你的年龄:");     scanf("%d",&a);     printf("a = %d\n",a);     in_age(a);     return 0; }     是的，问下  else     {         printf("如果想进入请输入Y，不想进入请输入N:");   getchar();//最后确认是这个地方有问题，scanf函数在输入缓冲区中调用后，会留一个回车符                    //在输入缓冲区,就是这个回车符搞的鬼，   choose = getchar();   printf("\nchoose = %c\n",choose);    getchar();   choose = getchar(); 得到字符用choose = getchar()就行，为和加 上面那句 getchar();，不过我试了，没这句不行。getchar 把空格 清掉了吗，这个函数不是得到字符的，如何清掉空格的？？不解。

int main(void) {        int a;     printf("请输入你的年龄:\n");     in_age(scanf("%d",&a));     getchar();     //fflush(stdout);  // 两个选一个，只要在下一次输入之前操作这些就好了     in_age(12);     return 0; }

引用 7 楼 u011779875 的回复:或者这样写  getchar(); //把最后的/n  接收走 choose = getchar();  你学标准输入输出流  需要懂得 全缓冲 无缓冲 和行缓冲 三种缓冲方式 百度看看 我在讲就多了  llush 必须用吗？ 我写的吧fllush给//了，就不行了。回车没回收，还在。不用fllush，怎么写？ #include <stdio.h> void in_age(int age) {	 	char choose; 	if(age >= 18) 	{ 		printf("该网站你可以进入\n"); 	} 	else 	{ 		printf("如果想进入请输入Y，不想进入请输入N\n"); 		//fflush(stdin); 		choose = getchar(); 		if('Y' == choose) 		{ 			printf("SUCCESS\n"); 		} 		else 		{   			printf("FALSE\n");  		} 	} }  int main(void) {	 	int a; 	printf("请输入你的年龄:\n"); 	in_age(scanf("%d",&a)); 	//in_age(12); 	return 0; }

引用 8 楼 max_min_ 的回复:[quote=引用 4 楼 linbounconstraint 的回复:] [quote=引用 1 楼 u011779875 的回复:] scanf("%d\n",&a); 你加换行做什么  scanf("%d",&a);  嗯，行是行。这样in_age里的else，直接就跳出来了，怎么回事？ [/quote]  那是因为你在第一次输入年龄的时候，有一个回车符还在输入缓冲区中！ 当后面输入的时候直接赋值给choose了，所以没有输入！ fllush是刷新缓冲区！ 也可以用getchar()吃点那个没有用的回车符！ [/quote]  fllush 必须用吗？ 我写的吧fllush给//了，就不行了。回车没回收，还在。不用fllush，怎么写？ #include <stdio.h> void in_age(int age) {	 	char choose; 	if(age >= 18) 	{ 		printf("该网站你可以进入\n"); 	} 	else 	{ 		printf("如果想进入请输入Y，不想进入请输入N\n"); 		//fflush(stdin); 		choose = getchar(); 		if('Y' == choose) 		{ 			printf("SUCCESS\n"); 		} 		else 		{   			printf("FALSE\n");  		} 	} }  int main(void) {	 	int a; 	printf("请输入你的年龄:\n"); 	in_age(scanf("%d",&a)); 	//in_age(12); 	return 0; }

引用 7 楼 u011779875 的回复:或者这样写  getchar(); //把最后的/n  接收走 choose = getchar();  你学标准输入输出流  需要懂得 全缓冲 无缓冲 和行缓冲 三种缓冲方式 百度看看 我在讲就多了  嗯，上网看了scanf，缓冲，溢出的有点懵。还是不知道咋下手？lz能在我代码上写出来，贴出来吗？谢谢。

引用 4 楼 linbounconstraint 的回复:[quote=引用 1 楼 u011779875 的回复:] scanf("%d\n",&a); 你加换行做什么  scanf("%d",&a);  嗯，行是行。这样in_age里的else，直接就跳出来了，怎么回事？ [/quote]  那是因为你在第一次输入年龄的时候，有一个回车符还在输入缓冲区中！ 当后面输入的时候直接赋值给choose了，所以没有输入！ fllush是刷新缓冲区！ 也可以用getchar()吃点那个没有用的回车符！

fflush(stdin);   choose = getchar(); 改成这句话 把输入缓存区的\n干掉

引用 3 楼 u011779875 的回复:int a;           scanf("%d\n",&a);   in_age(a);   要这么写   in_age(scanf("%d\n",&a));  你这么写传入的是scanf的返回值  这就是链式操作 man 3 scanf 你看看 说明 返回值 是匹配成功的个数吧 把那个英文放到翻译看看 看明白  char c;  scanf("%c",&choose); 你这么接受 会出问题的  scanf 会把你上个缓冲区里面的回车放进去 接收到c里面的是回车  你应该这么写 char c; c = getchar();

引用 1 楼 u011779875 的回复:scanf("%d\n",&a); 你加换行做什么  scanf("%d",&a);  嗯，行是行。这样in_age里的else，直接就跳出来了，怎么回事？

把分都给我得 了 结贴 我回答了很多问题 没一个结贴的 人都不见了


Question: 今天遇到的2个题目,我承认我才疏学浅,第二个做没做出来......

不能用C库？？？？ 那C语言考个毛啊，出题的人脑子有问题吧。考什么，考算法吗

可以尝试kmp算法

第二题很简单啊：直接贴代码int main() {	 	char* p = "123 123 1234 12345 3123 6123 132"; 	char* tem = "123"; 	int number = 0; 	while(*p) 	{ 		if (*p == *tem) 		{ 			int count = 0; 			int flag = 1; 			while (*(tem + count) != '\0' && *(p + count) != '\0') 			{ 				if (*(p + count) != *(tem + count)) 				{ 					flag = 0; 					break; 				} 				count++; 			} 			if (flag == 1) 			{ 				number++; 				p = p + count; 			}else 				p++; 		}else 			p++; 	} 	return 0;   } 楼主看可否满足条件

好有难度啊！！！

第一个题目的方法  把元素弄数组里，直接打出来就ok了   #include <stdio.h> #include <string.h>  #define N 129  int main(){ 	int i,j,a[N]={0}; 	char str[N];  	scanf("%[^\n]%*c",str);  	for(i=0;str[i]!='\0';++i){ 		++a[str[i]]; 	}  	for(i=0;i<N;++i){ 		for(j=0;j<a[i];++j){ 			printf("%c",i); 		} 	} 	printf("\n"); 	return 0; }

引用 2 楼 nice_cxf 的回复:1楼大概没仔细看，要求一层循环，这种题目不清楚要考什么，感觉没啥意义。。。 考的就是代码优化，大家都会暴力解决还要你做什么，越节约资源的人越是大牛

这个问题我觉得完全可以参考数据结构（C语言）版书籍，上面在讲表这一数据结构时，有讲到从长串中如何最低时间复杂度来查找子串，用的就是KMP算法，它也就是优化指针回遡，通过一个next函数，在查找子串较长时比较明显

33L 的 “aaaaa” “aaa”   不能通过哦   引用 33 楼 kou753852951 的回复:#include <stdio.h> void fun(char *a, char *b) { 	int num=0; 	char *s=b; 	int f=0; 	while(*a) 	{ 		if(*a == *s) 		{ 		//	printf("%c %c\n",*a,*s); 			if(*(s+1) == '\0') 			{ 				++num; 				s=b; 			} 			else 				++s; 		 ++f;			 		} 		else 		{ 		//	printf("%c %c\n",*a,*s); 			s=b; 			if(f != 0) 			{ 				a-=f; 				f=0;	 			}				 		} 		a++;										 	} 	printf("%d",num); 			 }  int main() { 	char *a="abdxabdxabca"; 	char *b="abdxabc";	 	fun(a,b); 	getch(); }  终极版，均可通过！ 下面 是自己又更新的代码： #include "stdio.h"   int main(int argc, char* argv[]) { 	const char *str="aaaa"; 	const char *t="aaa"; 	const char *p=t; 	int i=0; 	int j=0; 	int count=0; 	int count1=0; 	while (*str) 	{  		if(*str==*t) 		{ 			t++;  			if(*t==NULL) 			{ 				count++; 			} 		} 		else  		{ 			t=p; 			str=str-count1; 			count1=0; 		} 		str++; 		count1++;   	} 	printf("%d",count); 	return 0; }

int main(int argc, char* argv[]) { 	const char *str="AAB"; 	const char *t="AB"; 	const char *p=t; 	int i=0; 	int j=0; 	int count=0; 	while (*str) 	{ 		if(*str==*t) 		{ 			t++;  			if(*t==NULL) 			{ 				count++; 			} 		} 		else  		{ 			t=p; 			str--; 		} 		str++;   	} 	printf("%d",count); 	return 0; } 改进了一下 刚才的代码 若果 AAB AB 找不出来··

感觉第2题 挺简单的··int main(int argc, char* argv[]) { 	const char *str="good foor foo"; 	const char *t="oo"; 	const char *p=t; 	int i=0; 	int j=0; 	int count=0; 	while (*str) 	{ 		if(*str==*t) 		{ 			t++; 			if(*t==NULL) 			{ 				count++; 			} 		} 		else  			t=p; 		*str++; 	} 	printf("%d",count); 	return 0; }

第二题感觉在KMP算法上稍微改改就好了。

应用数据结构中串的模式匹配应该可以把

#include <stdio.h>  int main() { 	int Count = 0; //存放查找到的次数 	int i; //存放现查到的位置 	int cnow = 0;//存放现照到第几个字符 	char bche[] = "abcabccdabc";//存放用来查找的字符串 	char che[] = "abc";//存放需要查找的字符串 	for(i = 0;bche[i] != 0;i ++) 	{ 		if(che[cnow] != 0) 		{ 			if(bche[i] == che[cnow]) 			{ 				cnow ++; 			} 			else 			{ 				cnow = 0; 			}  		} 		else 		{ 			Count ++; 			cnow = 0; 			i--;  		} 		if(bche[i+1] == 0 && che[cnow] == 0) 			Count ++; 			 	} 	return 0; }

引用 10 楼 qq523176585 的回复:暂时只能想到这个，mark一下  #include <stdio.h>  int main(void) { 	const char *str1 = "lamp hamp bamp namp amp apm"; 	const char *str2 = "amp"; 	int count = 0; 	int n; 	while(*str1) 	{ 		for(n=0; *(str1+n) == *(str2+n); n++) 		{ 			if (!*(str2+n+1)) 			{ 				count++; 			} 		 		} 		str1++; 	}  	printf("字符串str1包含 %d 个字符串str2 !\n",count); 	return 0;   }    这个真的不错  我想的是输入一个字符串用数组的方式存储，然后for循环一一比对。你这个方法更好

数据结构里面有个kmp算法，可以做第二个

// stringMatch.cpp : 定义控制台应用程序的入口点。 //  #include "stdafx.h" #include "iostream" using namespace std;  int StringMatch(char *p, char* s) { 	int count = 0; 	char *head = s; 	while (*p != '\0') 		{ 			if (*p == *s) 				s++; 			else 				s = head; 			p++;  			if (*s == '\0') 			{ 				count++; 				s = head; 			}	  		}  	return count; } int main(int argc, char* argv[]) { 	char string[100];//带匹配字符串 	char pattrn[100];//模式串 	 	cin >> string; 	cin >> pattrn;  	cout << "匹配数" << StringMatch(string, pattrn); 	return 0; }

引用 18 楼 WhiteBird99 的回复:第一题,没说清楚字符串内容.那么就认为全是ASCII字符,采用字典的方式进行计数,读到0为结束符. 构造一个数组,索引就是字符的ASCII码,例,从字符串中读到'A',数组索引为'A'的值+1. 读到0结束时,将数组每个元素代表的ASCII从头到尾按计数个数打一遍.  第二题,没想到一个循环怎么做.楼上几位的应该行,我先看看 有点作弊的思路：把两个循环硬合成一个，用一个flag表明自己在哪个的循环里。

copy,copy


Question: 关于单链表的问题~ 编译没错 但无法实现功能~  求帮忙~~

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试是程序员必须掌握的技能之一。


Question: #if （？） 在宏定义中的问题    急！！！

const int auto[10] = {      .      .      .    #if （a == 0）       x = 0,    #else       x = 1,    #endif      .      .      . }  这不行  可以这样  const int auto[10] = {      .      .      .       .      .      . }   1)  .... i=8; x=auto[i]; if （a == 0）x = 0,    else       x = 1;  2) const int auto[10] = {      .      .      . };  ......  int tmp[10]={....}; for(int i=0;i<10;i++)tmp[i]=auto[i];   if(a== 0)tmp[8] =0;else tmp[8]=1;

引用 4 楼 zhao4zhong1 的回复:Code Generation 不懂 可以解说下哈

引用 13 楼 ForestDB 的回复:一个是预编译，一个是编译，两个阶段的事。楼主说 a的值通过输入 获取  那么 这个已经是运行期的事情了

一个是预编译，一个是编译，两个阶段的事。

早就说了 不可能 别白费心思了

分清程序代码的编译与执行, 它们是不同阶段的东西. 宏是编译期使用的东西, 代码执行是不用宏的, 宏在编译的时候已经被替换成对应的代码了.执行期是看不见的, 而编译的时候, 同理, 需要执行的时候才能确定的东西, 是不能拿到编译期用的.  总之要理解, 宏就是代码替换, 在编译的时候就替换掉了, 执行的时候看不见.

google 运行时和编译时  引用 10 楼 sanye8879cd 的回复:[quote=引用 6 楼 AnYidan 的回复:] #define a (1)   #if （a == 0）       x = 0,    #else       x = 1,    #endif  a是变量 不可直接赋值[/quote]  google 运行时和编译时

引用 6 楼 AnYidan 的回复:#define a (1)   #if （a == 0）       x = 0,    #else       x = 1,    #endif  a是变量 不可直接赋值

引用 7 楼 kfbyj 的回复:预编译期确实确定不了a的值。。所以肯定有问题的。 有没有其他好的方法推荐一下

引用 5 楼 jerry_dqh 的回复:[quote=引用 2 楼 sanye8879cd 的回复:] [quote=引用 1 楼 lin5161678 的回复:] 常量表达式.... 别闹  预编译阶段 怎么可能让你确定 运行期才能知道的变量的值 对的，现在做到了一个很大的宏，但是其中有细微的差别需要一个变量来判断选用哪个X，有什么其他的方法吗？号头大哦...[/quote] 需要确定你这个变量能在编译器确定吗？[/quote] 不能  这个是需要输入确定的...或者不用预编译，有没有什么方法？

#define MY_MACRO(a) \ if （a == 0）       \       x = 0,       \ else               \      x = 1,         \ endif

晕，这不就是带参数的宏定义么...  #define MY_MACRO(a) \ #if （a == 0）       \       x = 0,         \ #else               \      x = 1,         \ #endif

预编译期确实确定不了a的值。。所以肯定有问题的。

引用 2 楼 sanye8879cd 的回复:[quote=引用 1 楼 lin5161678 的回复:] 常量表达式.... 别闹  预编译阶段 怎么可能让你确定 运行期才能知道的变量的值 对的，现在做到了一个很大的宏，但是其中有细微的差别需要一个变量来判断选用哪个X，有什么其他的方法吗？号头大哦...[/quote] 需要确定你这个变量能在编译器确定吗？

Code Generation

没有 不可能做到的

引用 1 楼 lin5161678 的回复:常量表达式.... 别闹  预编译阶段 怎么可能让你确定 运行期才能知道的变量的值 对的，现在做到了一个很大的宏，但是其中有细微的差别需要一个变量来判断选用哪个X，有什么其他的方法吗？号头大哦...


Question: 关于递归，请各位谈谈看法

当年去某一公司面试的时候我也跟对方的工程师说了递归开销大，对方告诉我，其实对现在的计算能力来说，其实也不算很大

简单，但是很慢

引用 17 楼 true_casey 的回复:递归慢，容易栈溢出，不易调试，就一个好处，易读，可读性好，自己个儿权衡。。。。。我也觉得是自己个的事。。。

无量天尊,递归是我的最爱呀,语意清晰,简洁!!!

引用 12 楼 N_sev7 的回复:[quote=引用 8 楼 max_min_ 的回复:] 同意，尽量少用！除非特别需求！ 高端谈不上~ 除非特别需求！ 高端谈不上    ++[/quote]

引用 14 楼 wangdahu888 的回复:无量天尊,递归是我的最爱呀,语意清晰,简洁!!!

引用 8 楼 max_min_ 的回复:同意，尽量少用！除非特别需求！ 高端谈不上~ 除非特别需求！ 高端谈不上    ++

引用 9 楼 baichi4141 的回复:自我感觉很高端就很高端呗，有啥可在意的。 代码效率低开销大自然有他哭的，如果效率不太低开销不太大，难道你还想规定无论任何情况一概禁用递归？  递归写起来比非递归要简单，性能差别大看脑子，性能差别不大看心情，就这样 哎，可能是每个人对自己精心写出来的代码在前提是程序功能无误的情况下很难容忍按照别人的想法去修改吧！

递归只是保持了和数学思想的一致性，以及数学般的简洁！递归都能用非递归解决，但是代码会上升。  在效率，代码量以及可理解性三者的折中上，因人而异吧，有些看中效率，有些为了简洁，思想观点的差异，一般没有标准可言！

同意，尽量少用！除非特别需求！ 高端谈不上~

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

引用 3 楼 N_sev7 的回复:[quote=引用 1 楼 nice_cxf 的回复:] 递归用了也谈不上什么高端，如果递归层数不深，写递归程序看起来要简单些，用了也就用了 即使是在递归层数不深的情况下，如果循环就可以解决了，还有用递归的必要吗？[/quote] 任何递归都可以用迭代解决，但是有些时候，如果用迭代写代码会变得很长很难理解的话，为什么不用呢？ 递归用了也就用了，不用也没啥，只是一种方法而已

引用 2 楼 user-13 的回复:递归的特点就是思路比较清晰、好理解。但是如果递归次数太多的话对栈空间损耗过大，甚至程序崩溃出错。小问题的话可以使用一下。另外，递归也确实谈不上什么高端，只是一种程序设计方法而已。 是啊，不过就有些人在自己的代码里面老用递归，即使循环能解决的还是用递归，然后讲解代码的时候就给人一种自己很高端一样的感觉，而且不管你怎么说，他都始终坚持能用递归就用递归，可能就和我的原则不一样，能不用递归就坚决不用递归...

引用 1 楼 nice_cxf 的回复:递归用了也谈不上什么高端，如果递归层数不深，写递归程序看起来要简单些，用了也就用了 即使是在递归层数不深的情况下，如果循环就可以解决了，还有用递归的必要吗？


Question: 几个简单C的程序，不知道怎么回事，大家看看。。

浮点数不能直接跟0比较吧吧吧

着重查看一下log()函数的描述，man log

有啥问题么? c中的log(x)是以e为底的, 以10为底的是log10(x),


Question: 请教：字符串中字符倒序排列，不借用另一字符串

C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\strrev.c /*** *strrev.c - reverse a string in place * *       Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *       defines _strrev() - reverse a string in place (not including *       '\0' character) * *******************************************************************************/  #include <cruntime.h> #include <string.h>  /*** *char *_strrev(string) - reverse a string in place * *Purpose: *       Reverses the order of characters in the string.  The terminating *       null character remains in place. * *Entry: *       char *string - string to reverse * *Exit: *       returns string - now with reversed characters * *Exceptions: * *******************************************************************************/  char * __cdecl _strrev (         char * string         ) {         char *start = string;         char *left = string;         char ch;          while (*string++)                 /* find end of string */                 ;         string -= 2;          while (left < string)         {                 ch = *left;                 *left++ = *string;                 *string-- = ch;         }          return(start); }

C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\intel\strrev.asm         page    ,132         title   strrev - reverse a string in place ;*** ;strrev.asm - reverse a string in place ; ;       Copyright (c) Microsoft Corporation. All rights reserved. ; ;Purpose: ;       defines _strrev() - reverse a string in place (not including ;       '\0' character) ; ;*******************************************************************************          .xlist         include cruntime.inc         .list  page ;*** ;char *_strrev(string) - reverse a string in place ; ;Purpose: ;       Reverses the order of characters in the string.  The terminating ;       null character remains in place. ; ;       Algorithm: ;       char * ;       _strrev (string) ;             char *string; ;             { ;             char *start = string; ;             char *left = string; ;             char ch; ; ;             while (*string++) ;                     ; ;             string -= 2; ;             while (left < string) ;                     { ;                     ch = *left; ;                     *left++ = *string; ;                     *string-- = ch; ;                     } ;             return(start); ;             } ; ;       NOTE: There is a check for an empty string in the following code. ;       Normally, this would fall out of the "cmp si,di" instruction in the ;       loop portion of the routine.  However, if the offset of the empty ;       string is 0 (as it could be in large model), then the cmp does not ;       catch the empty string and the routine essentially hangs (i.e., loops ;       moving bytes one at a time FFFFh times).  An explicit empty string ;       check corrects this. ; ;Entry: ;       char *string - string to reverse ; ;Exit: ;       returns string - now with reversed characters ; ;Uses: ; ;Exceptions: ; ;*******************************************************************************          CODESEG          public  _strrev _strrev proc \         uses edi esi, \         string:ptr byte          mov     edi,[string]    ; di = string         mov     edx,edi         ; dx=pointer to string; save return value          mov     esi,edi         ; si=pointer to string         xor     eax,eax         ; search value (null)         or      ecx,-1          ; cx = -1 repne   scasb                   ; find null         cmp     ecx,-2          ; is string empty? (if offset value is 0, the         je      short done      ; cmp below will not catch it and we'll hang).          sub     edi,2           ; string is not empty, move di pointer back                                 ; di points to last non-null byte  lupe:         cmp     esi,edi         ; see if pointers have crossed yet         jae     short done      ; exit when pointers meet (or cross)          mov     ah,[esi]        ; get front byte...         mov     al,[edi]        ;   and end byte         mov     [esi],al        ; put end byte in front...         mov     [edi],ah        ;   and front byte at end         add     esi,1           ; front moves up...         sub     edi,1           ;   and end moves down         jmp     short lupe      ; keep switching bytes  done:         mov     eax,edx         ; return value: string addr          ret                     ; _cdecl return  _strrev endp         end

版本1 void reverse(char *str) { 	int i; 	int j = strlen(str); 	char temp; 	for (i=0; i<j;i++,j--) 	{ 		temp = str[i]; 		str[i] = str[j-1]; 		str[j-1] = temp; 	} } 版本2 void reverse(char *str) { 	int i; 	int j = strlen(str); 	char temp; 	for (i=0; i<j/2;i++) 	{ 		temp = str[i]; 		str[i] = str[j-i-1]; 		str[j-i-1] = temp; 	} } 版本3 void reverse(char *str) { 	char temp; 	char *last_char; 	 	for (last_char = str; *last_char != '\0'; last_char++) 		; 	last_char--;  	while (str < last_char) 	{ 		temp = *str; 		*str++ = *last_char; 		*last_char-- = temp; 	} } 版本4 void reverse(char *str) { 	char temp; 	char *last_char; 	 	for (last_char = str; *last_char != '\0'; last_char++) 		; 	last_char--; 	while(str<last_char) 	{ 		*str = *str ^ *last_char; 		*last_char = *str ^ *last_char; 		*str = *str ^ *last_char;; 		str++; 		last_char--; 	} }

i <= strlen(str)/2, j > strlen(str)/2 改成 (i <= strlen(str)/2) && (j > strlen(str)/2)

试试这个： j = strlen(str); for(i = 0; i <= j / 2; i++) {     temp = str[i];     str[i] = str[j - i];     str[j - i] = temp; }


Question: 已知矩形四边长及其坐标。求矩形内其他任意一点的坐标？

结了吧，感谢各位。已经解决了！

你这信息太少，给出原题：

引用 7 楼 d383137359 的回复:[quote=引用 6 楼 ri_aje 的回复:] 第一题没有唯一 解，因为矩形可以旋转。 第二题无解，平面两点只够定出直线的，信息不足定不出矩形。  恩，你理解到我第一题的意思的。 我就是说有没有什么关于 这打转的公式， 比如转向偏向的夹角之内的公式，计算出这几个顶点的坐标？  第二题应该条件更充分，已知两个点了，我想是不是对任意一个点都可以够成一个三角形。会不会更好算呢[/quote] 第一题该说的都说完了。 第二题你要是有解法，最好发上来让大家看看，说不定你那里想漏了呢。我是没看出解法，不过我也可能想错了。

引用 6 楼 ri_aje 的回复:第一题没有唯一 解，因为矩形可以旋转。 第二题无解，平面两点只够定出直线的，信息不足定不出矩形。  恩，你理解到我第一题的意思的。 我就是说有没有什么关于 这打转的公式， 比如转向偏向的夹角之内的公式，计算出这几个顶点的坐标？  第二题应该条件更充分，已知两个点了，我想是不是对任意一个点都可以够成一个三角形。会不会更好算呢

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

提示：线段(x1,y1)-(x2,y2)的中点坐标为((x1+x2)/2,(y1+y2)/2)

引用 3 楼 user-4 的回复:1. 已知矩形四边的边长和矩形中心的坐标，求矩形四个顶点以及四条边中心点的坐标，如下图： 小学数学题 2. 已知矩形四边的边长和矩形中两点的坐标，求矩形四个顶点以及四条边中心点的坐标，如下图： 提出错了  1.  第一题的小学题还真不会做。尴尬，求方法。 2. 题没错，第二题就是知道两点的坐标。

引用 1 楼 lm_whales 的回复:图形比较小时，近似看作平面图形计算，大时按照球面坐标计算。 高精度，归化到椭球面计算。 能说详细点吗？或有没有什么资料链接，贴链接我自己去看方法也可以、感谢！


Question: 别运行，写结果

引用 26 楼 ForestDB 的回复:32 > 31 x86下基本按>> 0处理了 可以去看x86指令集 shift right指令有个32的mask 意思是只要是基于X86架构的系统下不管哪个编译器，都会处理为移0位么？

我以前用BYTE测试过  直接被转换为int来处理了

如果第一个操作数为 int 或 uint（32 位数），则移位数由第二个操作数的低五位给出（第二个操作数 & 0x1f）。

SAL/SAR/SHL/SHR—Shift INSTRUCTION SET REFERENCE, M-Z 4-398 Vol. 2B  Instruction Operand Encoding Description Shifts the bits in the first operand (destination operand) to the left or right by the number of bits specified in the second operand (count operand). Bits shifted beyond the destination operand boundary are first shifted into the CF flag, then discarded. At the end of the shift operation, the CF flag contains the last bit shifted out of the destination operand. The destination operand can be a register or a memory location. The count operand can be an immediate value or the CL register. The count is masked to 5 bits (or 6 bits if in 64-bit mode and REX.W is used). The count range is limited to 0 to 31 (or 63 if 64-bit mode and REX.W is used). A special opcode encoding is provided for a count of 1. The shift arithmetic left (SAL) and shift logical left (SHL) instructions perform the same operation; they shift the bits in the destination operand to the left (toward more significant bit locations). For each shift count, the most significant bit of the destination operand is shifted into the CF flag, and the least significant bit is cleared (see Figure 7-7 in the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 1). Opcode Instruction Op/ En 64-Bit Mode Compat/ Leg Mode Description REX.W + D1 /4 SHL r/m64,1 M1 Valid N.E. Multiply r/m64 by 2, once. D3 /4 SHL r/m32, CL MC Valid Valid Multiply r/m32 by 2, CL times. REX.W + D3 /4 SHL r/m64, CL MC Valid N.E. Multiply r/m64 by 2, CL times. C1 /4 ib SHL r/m32, imm8 MI Valid Valid Multiply r/m32 by 2, imm8 times. REX.W + C1 /4 ib SHL r/m64, imm8 MI Valid N.E. Multiply r/m64 by 2, imm8 times. D0 /5 SHR r/m8,1 M1 Valid Valid Unsigned divide r/m8 by 2, once. REX + D0 /5 SHR r/m8**, 1 M1 Valid N.E. Unsigned divide r/m8 by 2, once. D2 /5 SHR r/m8, CL MC Valid Valid Unsigned divide r/m8 by 2, CL times. REX + D2 /5 SHR r/m8**, CL MC Valid N.E. Unsigned divide r/m8 by 2, CL times. C0 /5 ib SHR r/m8, imm8 MI Valid Valid Unsigned divide r/m8 by 2, imm8 times. REX + C0 /5 ib SHR r/m8**, imm8 MI Valid N.E. Unsigned divide r/m8 by 2, imm8 times. D1 /5 SHR r/m16, 1 M1 Valid Valid Unsigned divide r/m16 by 2, once. D3 /5 SHR r/m16, CL MC Valid Valid Unsigned divide r/m16 by 2, CL times C1 /5 ib SHR r/m16, imm8 MI Valid Valid Unsigned divide r/m16 by 2, imm8 times. D1 /5 SHR r/m32, 1 M1 Valid Valid Unsigned divide r/m32 by 2, once. REX.W + D1 /5 SHR r/m64, 1 M1 Valid N.E. Unsigned divide r/m64 by 2, once. D3 /5 SHR r/m32, CL MC Valid Valid Unsigned divide r/m32 by 2, CL times. REX.W + D3 /5 SHR r/m64, CL MC Valid N.E. Unsigned divide r/m64 by 2, CL times. C1 /5 ib SHR r/m32, imm8 MI Valid Valid Unsigned divide r/m32 by 2, imm8 times. REX.W + C1 /5 ib SHR r/m64, imm8 MI Valid N.E. Unsigned divide r/m64 by 2, imm8 times. NOTES: * Not the same form of division as IDIV; rounding is toward negative infinity. ** In 64-bit mode, r/m8 can not be encoded to access the following byte registers if a REX prefix is used: AH, BH, CH, DH. ***See IA-32 Architecture Compatibility section below. Op/En Operand 1 Operand 2 Operand 3 Operand 4 M1 ModRM:r/m (r, w) 1 NA NA MC ModRM:r/m (r, w) CL NA NA MI ModRM:r/m (r, w) imm8 NA NA SAL/SAR/SHL/SHR—Shift INSTRUCTION SET REFERENCE, M-Z Vol. 2B 4-399 The shift arithmetic right (SAR) and shift logical right (SHR) instructions shift the bits of the destination operand to the right (toward less significant bit locations). For each shift count, the least significant bit of the destination operand is shifted into the CF flag, and the most significant bit is either set or cleared depending on the instruction type. The SHR instruction clears the most significant bit (see Figure 7-8 in the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 1); the SAR instruction sets or clears the most significant bit to correspond to the sign (most significant bit) of the original value in the destination operand. In effect, the SAR instruction fills the empty bit position’s shifted value with the sign of the unshifted value (see Figure 7-9 in the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 1). The SAR and SHR instructions can be used to perform signed or unsigned division, respectively, of the destination operand by powers of 2. For example, using the SAR instruction to shift a signed integer 1 bit to the right divides the value by 2. Using the SAR instruction to perform a division operation does not produce the same result as the IDIV instruction. The quotient from the IDIV instruction is rounded toward zero, whereas the “quotient” of the SAR instruction is rounded toward negative infinity. This difference is apparent only for negative numbers. For example, when the IDIV instruction is used to divide -9 by 4, the result is -2 with a remainder of -1. If the SAR instruction is used to shift -9 right by two bits, the result is -3 and the “remainder” is +3; however, the SAR instruction stores only the most significant bit of the remainder (in the CF flag). The OF flag is affected only on 1-bit shifts. For left shifts, the OF flag is set to 0 if the most-significant bit of the result is the same as the CF flag (that is, the top two bits of the original operand were the same); otherwise, it is set to 1. For the SAR instruction, the OF flag is cleared for all 1-bit shifts. For the SHR instruction, the OF flag is set to the most-significant bit of the original operand. In 64-bit mode, the instruction’s default operation size is 32 bits and the mask width for CL is 5 bits. Using a REX prefix in the form of REX.R permits access to additional registers (R8-R15). Using a REX prefix in the form of REX.W promotes operation to 64-bits and sets the mask width for CL to 6 bits. See the summary chart at the beginning of this section for encoding data and limits. IA-32 Architecture Compatibility The 8086 does not mask the shift count. However, all other IA-32 processors (starting with the Intel 286 processor) do mask the shift count to 5 bits, resulting in a maximum count of 31. This masking is done in all operating modes (including the virtual-8086 mode) to reduce the maximum execution time of the instructions. Operation IF 64-Bit Mode and using REX.W THEN countMASK ← 3FH; ELSE countMASK ← 1FH; FI tempCOUNT ← (COUNT AND countMASK); tempDEST ← DEST; WHILE (tempCOUNT ≠ 0) DO IF instruction is SAL or SHL THEN CF ← MSB(DEST); ELSE (* Instruction is SAR or SHR *) CF ← LSB(DEST); FI; IF instruction is SAL or SHL THEN DEST ← DEST ∗ 2; ELSE SAL/SAR/SHL/SHR—Shift INSTRUCTION SET REFERENCE, M-Z 4-400 Vol. 2B IF instruction is SAR THEN DEST ← DEST / 2; (* Signed divide, rounding toward negative infinity *) ELSE (* Instruction is SHR *) DEST ← DEST / 2 ; (* Unsigned divide *) FI; FI; tempCOUNT ← tempCOUNT – 1; OD; (* Determine overflow for the various instructions *) IF (COUNT and countMASK) = 1 THEN IF instruction is SAL or SHL THEN OF ← MSB(DEST) XOR CF; ELSE IF instruction is SAR THEN OF ← 0; ELSE (* Instruction is SHR *) OF ← MSB(tempDEST); FI; FI; ELSE IF (COUNT AND countMASK) = 0 THEN All flags unchanged; ELSE (* COUNT not 1 or 0 *) OF ← undefined; FI; FI; Flags Affected The CF flag contains the value of the last bit shifted out of the destination operand; it is undefined for SHL and SHR instructions where the count is greater than or equal to the size (in bits) of the destination operand. The OF flag is affected only for 1-bit shifts (see “Description” above); otherwise, it is undefined. The SF, ZF, and PF flags are set according to the result. If the count is 0, the flags are not affected. For a non-zero count, the AF flag is undefined.

引用 25 楼 N_sev7 的回复:其实本来想移31位，判断符号位是否大于0  结果不管怎么运行都是大于0, 这里没看懂... 我vc6情况很正确啊...

引用 22 楼 CCDDzclxy 的回复:我想知道，lz是在何种情况下遇到这个坑的？我正常些代码，根本不会全移掉啊，清零的话，与或一下也行啊，是个什么样的思路？？ 想a>>NumShift;NumShift这个参数经过一些列的参数传递之后一个地方的值为32，其实本来想移31位，判断符号位是否大于0  结果不管怎么运行都是大于0,...因为a>>32位之后的数还是a 不过正像楼上很大大牛说的，这应该是一种未定义的行为，在不同的系统环境和编译环境下的结果是不一样的

他还真是个坑，VC6 是0 VC9，VC10是256 估计，要么是新表准做了改动，要么就是未定义的。

这和实现有关，如果编译器认为 移位和除以2等价，就会算作 0 ，否则直接在生成对应的移位指令。 那就可能不移位。 也许新标准就是不移位。

引用 31 楼 N_sev7 的回复:[quote=引用 26 楼 ForestDB 的回复:] 32 > 31 x86下基本按>> 0处理了 可以去看x86指令集 shift right指令有个32的mask 意思是只要是基于X86架构的系统下不管哪个编译器，都会处理为移0位么？[/quote] 看28L  这个得看编译器的行为 如果编译器将>>翻译成了shitf指令，那么shift指令的行为就是这样的了。

引用 27 楼 CCDDzclxy 的回复:[quote=引用 25 楼 N_sev7 的回复:] 其实本来想移31位，判断符号位是否大于0  结果不管怎么运行都是大于0, 这里没看懂... 我vc6情况很正确啊... [/quote] 移31位没问题，问题是移了32位

我在VS下运行了，结果是256，发现只要是移32的倍数，其结果都一样啊，是不是跟编译器有关？

#include <stdio.h> unsigned char ui;   signed char si; char main() {     ui=(unsigned char)0x80u;     si=(  signed char)0x80;     printf("ui=%u\n",ui);     printf("si=%d\n",si);     ui=ui>>1;     si=si>>1;     printf("ui=%u\n",ui);     printf("si=%d\n",si);      printf("--------------\n");     ui=(unsigned char)0x80u;     si=(  signed char)0x80;     printf("ui=%u\n",ui);     printf("si=%d\n",si);     ui=((  signed char)ui)>>1;     si=((unsigned char)si)>>1;     printf("ui=%u\n",ui);     printf("si=%d\n",si);      printf("==============\n");      ui=(unsigned char)0x80u;     si=(  signed char)0x80;     printf("ui=%u\n",ui);     printf("si=%d\n",si);     ui=ui<<1;     si=si<<1;     printf("ui=%u\n",ui);     printf("si=%d\n",si);      printf("--------------\n");     ui=(unsigned char)0x80u;     si=(  signed char)0x80;     printf("ui=%u\n",ui);     printf("si=%d\n",si);     ui=((  signed char)ui)<<1;     si=((unsigned char)si)<<1;     printf("ui=%u\n",ui);     printf("si=%d\n",si);      return 0; } //ui=128 //si=-128 //ui=64 //si=-64 //-------------- //ui=128 //si=-128 //ui=192 //si=64 //============== //ui=128 //si=-128 //ui=0 //si=0 //-------------- //ui=128 //si=-128 //ui=0 //si=0

引用 14 楼 lin5161678 的回复:[quote=引用 13 楼 N_sev7 的回复:] 可能你非常熟悉C的标准，所以对其中哪些行为是未定义的都比较清楚 理论上这样的代码不应该出现在代码里面， 但是有时候不是程序员所能控制的，比如a >> NumShift这样的语句， 当这个NumShift为32时  在Windows下用VC编译，移位的结果还是原来的数据，讨论这样的问题只是想让大家对此有所了解，不至于以后真的遇到这样的问题了不知道应该怎么处理 其实 哪怕是windows 下Vc编译 移位结果依然可能是 0   我也做不到对哪些是未定义行为都比较清楚 了解常见的几个而已  我之前说的 常识指的是  对于一段代码 当别人告诉你 那是未定义行为的时候  你索要运行结果 这行为做得不好  因为当未定义行为成立的时候 运行结果什么也说明不了 你需要确定的是 是不是真的是未定义行为  不是未定义行为 打那个人的脸  是未定义行为 默默把这段代码加入黑名单  以后写代码的时候 谨慎的不让这段代码出现 [/quote] 好的，多谢指教了！

编译都不看警告的么？ warning C4293: '>>' : shift count negative or too big, undefined behavior

这段代码实在是没有任何意义。 在VS2012下：warning C4293: “>>”: Shift 计数为负或过大，其行为未定义  也就是说这个右移操作根本没有执行，b直接由a的值赋值，即256。

未定义行为, 在我这10来个编译器测试的结果是, 大部分结果是 255, 有2个编译器(Android, RVDS)结果是 0, 我猜想 mips , ppc 上也该是0, 不过懒得点板子了...

引用 7 楼 lin5161678 的回复:>> 数值太大 实现定义  结果依赖实现  结果没有意义   >> N 可能被优化为  >> (N%32)解释很合理

b>>32；这里编译器会做什么？


Question: 数组内容修改后，返回主函数如何实现

测试完毕，地址传也测试成功了，不过直接写行。

传地址就好了  //调用 test_func(a);  // 原型 void test_func(int *a); //实现作操作

直接修改原数组，不用传递给主函数

指针

#include <stdio.h>  void changeArray(int *arr);  int main() { 	int a[10],i; 	for (i=0;i<10;i++) 		a[i]=i; 	printf("调用函数之前:\n"); 	for (i=0;i<10;i++) 		printf("%d\t",a[i]); /*******************1#**************/ 	changeArray(a); /*******************1#**************/ 	printf("调用函数之后:\n"); 	for (i=0;i<10;i++) 		printf("%d\t",a[i]); 	return 0; }  void changeArray(int *arr) { 	int i=0; 	while(i<10) 	{ 		*(arr+i)+=10;  		i++; 	} }  /*修改(使每个元素增加10)*/


Question: make_float2 是在哪里声明和定义的

thrust中


Question: socket抓包

#define ETH_P_PPP_DISC  0x8863          /* PPPoE discovery messages     */ #define ETH_P_PPP_SES   0x8864          /* PPPoE session messages       */

引用 3 楼 u010423430 的回复:[quote=引用 1 楼 zhao4zhong1 的回复:] 参考winpcap源代码。 看windows 程序设计 对理解如何写抓包的c程序，会有帮助么？ [/quote] 没有帮助。建议看一下网络协议（至少要了解一下）和winpcap库。

引用 1 楼 zhao4zhong1 的回复:参考winpcap源代码。 看windows 程序设计 对理解如何写抓包的c程序，会有帮助么？

建议从网卡上直接抓取。即可以借助libpcap库（linux下），windows下可以借助winpcap

参考winpcap源代码。


Question: C++红外线编程

谢谢各位的回复。  我想自己做一块单片机来接收、编码、解码红外线发射器发射来的信号  具体需要哪些硬件，怎么配置  谢谢

引用 2 楼 truelance 的回复:每个开关需要分配一个中断和I/O地址

每个开关需要分配一个中断和I/O地址

你想用什么做接口？ 板卡？ 串口？ U口？.....你必须先规划好物理要怎么做 通常，最简单的办法是，下位机使用单片机对检测信号进行处理，然后通过串口传送给电脑


Question: 设计一种没有外部碎片的内存管理方案

引用 9 楼 true_casey 的回复:不懂什么叫外部碎片、、、、、、　 管理空间： 伙伴系统 +　ＳＬＡＢ？？？？？？ 定长定界就考虑：ＨＡＳＨ　链 自己管理的称为内部的， 其他，比如系统管理的称为外部， 这不是一个概念，只是一个习惯，可能只是自己的习惯。  他的意思是基本上，碎片都是自己管理的那一部分产生的，而系统分配函数则基本不会产生碎片，都是分配大块内存，回收大块内存。 你这个，第一个讲的是系统分配内存的方法，或者策略。  第二个讲的是算法。 虽然，解决他的那个问题，是绰绰有余的。  但是，第一个有点杀鸡用牛刀的味道， 这是操作系统，和编译系统的库函数里，分配内存的方法。 自己从0开始，也是可以的。  不过，分配小块内存，比如 char 较多时，并且分配，释放频繁时，会产生叫较多的碎片。  所以，这种时候，用内存池分配单一元素，碎片就比较少一点，而且基本都在内存池内部。 内存池，用于不确定大小的数组分配，就不是很合适，不如直接用库函数，等系统提供的分配机制。  第二个HASH 比较实用，链就有点不够具体的了。

想要避免内存碎片到是可以, 好肯定要合并小碎片, 移动内存数据, 这个效率就大大降低了.  性能与碎片需要你自己去平衡, 现在采用的基本都是性能优先.

引用 楼主 zhuangdaizi 的回复:如题？？求教设计一种没有外部碎片的内存管理方案  完全可以，你可以申请一大片内存A，然后重载new，在你的内存中分配,当然你得做好这片内存的发放和收回，还得重载delete，进程结束前，释放A

内存池还是很好实现的, 但要制造一个业界顶尖的需要学学jemalloc这种。

引用 楼主 zhuangdaizi 的回复:如题？？求教设计一种没有外部碎片的内存管理方案  如果有，其内部碎片一定惊人

最可靠的是，垃圾回收，和handle 机制，对象在内存时可移动的。当碎片较多时，移动对象，集中起来，进行整理，把碎片聚零为整，这个就是CLR的机制了，.net 就是这么干的，java 好象也是。

每个对象大小相同，一次分配一个对象。（不分配数组） 然后，内存池，就几乎不会产生外部碎片了。

只能尽量减少吧！不能完全避免的！ 内存池是是应该考虑的

你可以试试，呵呵。除非加强条件，比如最小分配单位是page


Question: 求查此程序在最后为什么会执行错误

soga ,通过这个问题学到了挺多，谢各位大神们

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试是程序员必须掌握的技能之一。

这个一般只能自己单步调试。或者谁有功夫，给你调试一下。

最后一句好像确实没用，前面那句是做成循环链表的语句

h -> next = L -> next;  p = h -> next;  你是要干嘛呢？表示没看懂

引用 4 楼 u010461582 的回复:[quote=引用 3 楼 buyong 的回复:] 这个一般只能自己单步调试。或者谁有功夫，给你调试一下。 表示调试无果，问了一个大神，说是不要随便写while（p），事实也证明确实是这个的问题，大神可否解释下为什嘛[/quote] while(p != NULL) // p 为某指针类型的判断  while( p ) //针对 p为bool类型来判断的

表示已经找到问题了，谢谢各位的讨论。 我找到的问题是，所建立的链表是循环链表，当链表中只剩下一个元素的时候，p = p -> next = p -> next -> next.可以看到Delete函数陷入了死循环这就程序就无法跳出Delete函数了的说，所以出现的错误。 解决方案有两个，一个就是被我/*   */里面的该法，另一种就是让循环在还剩一个节点的时候跳出，条件改成while(p -> next != p)循环结束后，再输出p -> data.这样就对啦。            此乃渣渣领悟的拙见（不对，这个见解是大神想出来的，表述是渣渣的），有什嘛问题望大神们不吝赐教。

引用 3 楼 buyong 的回复:这个一般只能自己单步调试。或者谁有功夫，给你调试一下。 表示调试无果，问了一个大神，说是不要随便写while（p），事实也证明确实是这个的问题，大神可否解释下为什嘛


Question: 在自己pthread_create的线程里面执行pthread_cancel合理吗

蛇咬自己尾巴干啥呢？甚至更严重！

仅供参考//循环向a函数每次发送200个字节长度（这个是固定的）的buffer, //a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理， //在处理的时候每次从新buffer中取两个字节打印 #ifdef WIN32     #pragma warning(disable:4996) #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef WIN32     #include <windows.h>     #include <process.h>     #include <io.h>     #define  MYVOID             void     #define  vsnprintf          _vsnprintf #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  MYVOID             void * #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); } void sleep_ms(int ms) {     Sleep(ms); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } void sleep_ms(int ms) {     usleep(ms*1000); } #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} #define ASIZE    200 #define BSIZE    240 #define CSIZE      2 char Abuf[ASIZE]; char Cbuf[CSIZE]; CRITICAL_SECTION cs_HEX ; CRITICAL_SECTION cs_BBB ; struct FIFO_BUFFER {     int  head;     int  tail;     int  size;     char data[BSIZE]; } BBB; int No_Loop=0; void HexDump(int cn,char *buf,int len) {     int i,j,k;     char binstr[80];      Lock(&cs_HEX);     for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%03d %04x -",cn,i);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             Log("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         Log("%s\n",binstr);     }     Unlock(&cs_HEX); } int GetFromRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      lent=0;     Lock(cs);     if (fbuf->size>=len) {         lent=len;         if (fbuf->head+lent>BSIZE) {             len1=BSIZE-fbuf->head;             memcpy(buf     ,fbuf->data+fbuf->head,len1);             len2=lent-len1;             memcpy(buf+len1,fbuf->data           ,len2);             fbuf->head=len2;         } else {             memcpy(buf     ,fbuf->data+fbuf->head,lent);             fbuf->head+=lent;         }         fbuf->size-=lent;     }     Unlock(cs);     return lent; } MYVOID thdB(void *pcn) {     char        *recv_buf;     int          recv_nbytes;     int          cn;     int          wc;     int          pb;      cn=(int)pcn;     Log("%03d thdB              thread begin...\n",cn);     while (1) {         sleep_ms(10);         recv_buf=(char *)Cbuf;         recv_nbytes=CSIZE;         wc=0;         while (1) {             pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);             if (pb) {                 Log("%03d recv %d bytes\n",cn,pb);                 HexDump(cn,recv_buf,pb);                 sleep_ms(1);             } else {                 sleep_ms(1000);             }             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef WIN32     pthread_exit(NULL); #endif } int PutToRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      Lock(cs);     lent=len;     if (fbuf->size+lent>BSIZE) {         lent=BSIZE-fbuf->size;     }     if (fbuf->tail+lent>BSIZE) {         len1=BSIZE-fbuf->tail;         memcpy(fbuf->data+fbuf->tail,buf     ,len1);         len2=lent-len1;         memcpy(fbuf->data           ,buf+len1,len2);         fbuf->tail=len2;     } else {         memcpy(fbuf->data+fbuf->tail,buf     ,lent);         fbuf->tail+=lent;     }     fbuf->size+=lent;     Unlock(cs);     return lent; } MYVOID thdA(void *pcn) {     char        *send_buf;     int          send_nbytes;     int          cn;     int          wc;     int           a;     int          pa;      cn=(int)pcn;     Log("%03d thdA              thread begin...\n",cn);     a=0;     while (1) {         sleep_ms(100);         memset(Abuf,a,ASIZE);         a=(a+1)%256;         if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop         send_buf=(char *)Abuf;         send_nbytes=ASIZE;         Log("%03d sending %d bytes\n",cn,send_nbytes);         HexDump(cn,send_buf,send_nbytes);         wc=0;         while (1) {             pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);             Log("%03d sent %d bytes\n",cn,pa);             HexDump(cn,send_buf,pa);             send_buf+=pa;             send_nbytes-=pa;             if (send_nbytes<=0) break;//             sleep_ms(1000);             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef WIN32     pthread_exit(NULL); #endif } int main() { #ifdef WIN32     InitializeCriticalSection(&cs_log);     InitializeCriticalSection(&cs_HEX );     InitializeCriticalSection(&cs_BBB ); #else     pthread_t threads[2];     int threadsN;     int rc;     pthread_mutex_init(&cs_log,NULL);     pthread_mutex_init(&cs_HEX,NULL);     pthread_mutex_init(&cs_BBB,NULL); #endif     Log("Start===========================================================\n");      BBB.head=0;     BBB.tail=0;     BBB.size=0;  #ifdef WIN32     _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);     _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2); #else     threadsN=0;     rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);     rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1); #endif      if (!access("No_Loop",0)) {         remove("No_Loop");         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     while (1) {         sleep_ms(1000);         if (No_Loop) break;//         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     sleep_ms(3000);     Log("End=============================================================\n"); #ifdef WIN32     DeleteCriticalSection(&cs_BBB );     DeleteCriticalSection(&cs_HEX );     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_BBB);     pthread_mutex_destroy(&cs_HEX);     pthread_mutex_destroy(&cs_log); #endif     return 0; }


Question: 把字符数组"I love baofeng" 转换为"baofeng love I",不另外申请内存

引用 12 楼 rocktyt2 的回复:我觉得单词应该用代码来分割而不是写死位置，这样和直接输出结果有什么区别？[/quote]  小改一下就行了   void reverse (char *first, char *last) {   while ((first!=last)&&(first!=--last)) {     swap(*first, *last);     ++first;   } }  void reverse_sentence(char *first, char *last) {     reverse(first, last);     char *space = first;     while(space != last){         if(*space == ' '){             reverse(first, space);             first = space;             ++first;         }         ++space;     } }  int main() {     char strs[] = "I love baofeng";     reverse_sentence(strs, strs + sizeof(strs) / sizeof(char) - 1);     printf("%s\n", strs);      return 0; }

引用 11 楼 stereoMatching 的回复:算了，送佛送到西  //#include <cstdio> #include <stdio.h>  #define swap(a,b)  {char temp = a; a = b; b = temp;}  void reverse (char *first, char *last) {   while ((first!=last)&&(first!=--last)) {     swap(*first, *last);     ++first;   } }  int main() {     char strs[] = "I love baofeng";     printf("%s\n", strs);     reverse(strs, strs + sizeof(strs) / sizeof(char) - 1);     printf("%s\n", strs);     reverse(strs, strs + 7);     reverse(strs + 8, strs + 12);     printf("%s\n", strs);      return 0; } 我觉得单词应该用代码来分割而不是写死位置，这样和直接输出结果有什么区别？

引用 8 楼 pathletboy 的回复:[quote=引用 4 楼 luoyihu 的回复:] [quote=引用 2 楼 pathletboy 的回复:] 其实是这样解答的~ #include <stdio.h>   int main(void) { char srcStr[15] = "I love baofeng"; strcpy(srcStr, "baofeng love I"); printf("%s", srcStr); return 0; }  第5行strcpy(srcStr, "baofeng love I"); 这里面的静态字符串 "baofeng love I" 申请新的内存空间了吧[/quote]  没申请，编译时候就在code段了。[/quote] 这个应该对吧。。。

接5楼的reverse  #include <algorithm> #include <iostream>  void reverse (char *first, char *last) {   while ((first!=last)&&(first!=--last)) {     std::swap(*first, *last);     ++first;   } }  int main() {     char strs[] = "I love baofeng";     std::cout<<strs<<std::endl;     std::reverse(strs, strs + sizeof(strs) / sizeof(char) - 1);     std::cout<<strs<<std::endl;     reverse(strs, strs + 7);     reverse(strs + 8, strs + 12);     std::cout<<strs<<std::endl;       return 0; }   swap和输出的部分自己转成c的形式吧，这个应该懂吧？

引用 4 楼 luoyihu 的回复:[quote=引用 2 楼 pathletboy 的回复:] 其实是这样解答的~ #include <stdio.h>   int main(void) { char srcStr[15] = "I love baofeng"; strcpy(srcStr, "baofeng love I"); printf("%s", srcStr); return 0; }  第5行strcpy(srcStr, "baofeng love I"); 这里面的静态字符串 "baofeng love I" 申请新的内存空间了吧[/quote]  没申请，编译时候就在code段了。

先整个字符串反转，然后根据空格的位置，依次反转每个单词。

参考http://blog.csdn.net/turingo/article/details/8124432  引用 楼主 luoyihu 的回复:这是去年暴风影音校园招聘时的笔试题,不知道今年还有没有.困扰我一年了,不知道是不是这样解答的  #include<stdio.h> #define swap(a,b)  {(a)=(a)+(b); (b)=(a)-(b); (a)=(a)-(b);} void main() { 	char srcStr[15] = "I love baofeng"; 	int i = 0;	// 计数  	printf("%s\n",srcStr ); 	for( i = 0; i < 7; i++ ) 	{ 		swap( srcStr[i], srcStr[i+7] ); 		printf("%s\n",srcStr ); 	}	// "baofengI love "  	swap( srcStr[7], srcStr[13] );	// "baofeng  loveI"(注意,中间是两个空格) 	printf("%s\n",srcStr );  	for( i=0; i<4; i++ ) 	{ 		swap( srcStr[i+8], srcStr[i+9] ); 		printf("%s\n",srcStr ); 	} 	printf("%s",srcStr ); }  当然,变量i可以不申请,把for循环一条一条的写出来.我这里不想那么麻烦,就这样写了

关键的reverse其实可以很简单  void reverse (char *first, char *last) {   while ((first!=last)&&(first!=--last)) {     swap(*first, *last);     ++first;   } }   char strs[] = "I love baofeng"; reverse(strs, strs + sizeof(strs) / sizeof(char));

引用 2 楼 pathletboy 的回复:其实是这样解答的~ #include <stdio.h>   int main(void) { char srcStr[15] = "I love baofeng"; strcpy(srcStr, "baofeng love I"); printf("%s", srcStr); return 0; }   第5行strcpy(srcStr, "baofeng love I"); 这里面的静态字符串 "baofeng love I" 申请新的内存空间了吧

引用 1 楼 gsw945 的回复:#include<stdio.h> #include<string.h> //翻转函数，将字符数组元素首尾互换 void swapstr(char *head,char *tail) { 	while(head < tail){ 		char c = *head; 		*head = *tail; 		*tail = c;  		tail--; 		head++; 	} }  int main(void) { 	char str[128] = {0}; 	 	printf("please input a sentence:\n"); //	scanf("%s",str); //此处建议使用fgets()函数，fgets()能够接收到空格和回车 	fgets(str,128,stdin); //去掉接收到的回车符 	str[strlen(str)-1] = '\0';  	char *p,*head,*tail;  	p = head = tail =&str[0]; 	 	while(*tail != '\0'){ 		tail++; 	} 	tail -= sizeof(char);//定位最后一个字符的位置 	swapstr(head,tail);//将整句话按照字母翻转  	while(*p != '\0'){ //翻转字符数组中的单词 		if(*p == ' '){ 			tail = p - sizeof(char); 			swapstr(head,tail); 			head = ++p; 		} //此处用while()或者if(),if版本参见源码 		while(*head == ' '){ 			head++; 		}  		p++; 	} //最后一个单词的翻转 	if(*p == '\0'){ 		tail = p - sizeof(char); 		swapstr(head,tail); 	} 	 	puts(str); 	 	return 0; }  /*非本人原创代码，借鉴于此，仅供参考，稍微修改即可满足此题*/    这个不是要翻转字符串的 I love baofeng 到 baofeng love I 而且人家要求不能申请行的内存空间

我勒个去,给分给错了 对不起stereoMatching了

写得很烂，求大神贴更简单的方法 #include <stdio.h>   void reverse(char *str) { 	char temp; 	char *last_char; 	 	for (last_char = str; *last_char != '\0'; last_char++) 		; 	last_char--;  	while (str < last_char) 	{ 		temp = *str; 		*str++ = *last_char; 		*last_char-- = temp; 	} }  void reverse2(char *str) { 	char temp; 	char *last_char;  	if (*(str+1) == '\0') 	{ 		return; 	} 	 	for (last_char = str; *last_char != ' '; last_char++) 		; 	last_char--;  	while (str < last_char) 	{ 		temp = *str; 		*str++ = *last_char; 		*last_char-- = temp; 	} }  int main() { 	char s[] = "I love baofeng"; 	char *p ; 	int i = 0; 	reverse(s); 	while (1) 	{ 		p = &s[i]; 		reverse2(p); 		while (s[i] != ' ' && s[i] != '\0') 		{ 			i++; 		} 		while ( s[i] == ' ') 		{//跳过空格 			i++;  		}  		if (s[i] == '\0') 		{ 			break; 		}  	} 	printf("%s\n",s); 	return 0; }


Question: MFC基于对话框,设置鼠标图形

你说的是模态对话框么。。。。

系统API. SetCursor是可以改变全局光标的, 但是呢, 程序都有动态修改功能,所以就不能保证移动到其它程序区域还有效.  最直接的办法就是修改系统主题.

编程只能决定你的鼠标在哪个对话框中显示什么样的，移出的话就是相对其他应用程序的类型了，想做到你的要求，直接改变系统的光标类型呗

呵呵,各位不好意思哈,只要鼠标按下不放 就能保证设置的鼠标图标不变.


Question: C语言，栈的实现，报错。

2013-10-17  Anonymous 9:45:11  #include <stdio.h> #include <malloc.h>  #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10  typedef struct {     char *base;     char *top;     int stacksize; }OPTR;  int InitStack(OPTR *S)//运算符 {     S->base = (char *)malloc(STACK_INIT_SIZE * sizeof(char));     if(!S->base) return 0;     S->top = S->base;     S->stacksize = STACK_INIT_SIZE;     return 1; }   int StackEmpty(OPTR *S) {     if(S->base == S->top) return 1;     else return 0; }   int Push1(OPTR *S,char e) {     if(S->top - S->base >= S->stacksize)     {         S->base = (char *)realloc(S->base,(S->stacksize + STACKINCREMENT) * sizeof(char));         if(!S->base) return 0;         S->top = S->base + S->stacksize;         S->stacksize += STACKINCREMENT;     }     *S->top++ = e;     return 1; }    int Pop1(OPTR *S,char *e) {     if(S->top == S->base) return 0;     e = *--S->top;     return e; }   这样照着改

引用的问题，C里面没有引用

函数定义参数可以直接写地址吗？ Status InitStack(SqStack &S) 不应该是SqStack * S

引用 1 楼 xiaoliang1201 的回复:楼主这是用哪种语言写的？？？C语言函数传参是没有引用传递的。只有值传递和地址传递。+++++++++++

把文件格式改为*.cpp，引用是C++中的，C语言里没有引用； 如果不想改，那就用指针吧，把运算符“.”改为“->”，在调用的时候，改为传地址，而不是被引用的值。


Question: 公司的代码 我不懂   顺便考考大家

引用 7 楼 max_min_ 的回复:没有delete 应该是在整个过程中，对象都会使用的！就没有delete也无伤大雅，只是习惯不太好而已！ 至于5楼说的内存泄露，不敢苟同！ 为什么用static话，局部代码看不出来，可能是1楼说的原因！ 引用 8 楼 zmlovelx 的回复:这个析构是public的有点危险呀。 引用 10 楼 akirya 的回复:1 static 是防止跟其他文件的pa重名 2 内存泄漏了

1 static 是防止跟其他文件的pa重名 2 内存泄漏了

还有更简单的  A* A::shareA() {     static A pa;     return &pa; }

修正一些地方  namespace {   std::unique_ptr<A> pa; }   A* A::shareA() {     if(pa == nullptr)     {                 pa.reset(new A);     }     return pa.get(); }

看来就只有一个实例而已，不希望memory leak的话就用std::unique_ptr吧 不支援c++11可以用boost::scoped_ptr,都不行大不了自己写一个   static std::unique_ptr<A> pa; //same as /* namespace {   std::unique_ptr<A> pa; } */  A* A::shareA() {     if(pa == NULL)     {                 pa.reset(new A);     }     return pa.get(); }   这里名字取shareA是挺怪的 让users误以为该自己负责reference count的部分

引用 7 楼 max_min_ 的回复:没有delete 应该是在整个过程中，对象都会使用的！就没有delete也无伤大雅，只是习惯不太好而已！ 至于5楼说的内存泄露，不敢苟同！ 为什么用static话，局部代码看不出来，可能是1楼说的原因！的确始终存在一个指针指向这个对象  不过 这个对象最终没有由程序自己做delete 释放内存 而是 指望操作系统做资源回收的工作  这种现象已经可以被称之为 内存泄露了

这个析构是public的有点危险呀。

#include <iostream> using namespace std;  class A { public:     A();     ~A(); 	char * GetCurChar();     static char* str; 	static int count; };  A::A() { 	count++;     cout<<"实例化第"<<count<<"个对象"<<endl; } A::~A() { 	count--; 	if(count == 0) 	{ 		delete[] str; 		cout<<"释放字符串空间 最后一个实例化对象析构"<<endl; 	}     cout<<"剩余"<<count<<"个对象"<<endl; }  char* A::GetCurChar() { 	if(str == NULL) 	{ 		str = new char[1024]; 		strcpy(str,"hello world!\n"); 		cout<<"分配内存\n"<<endl; 	} 	return str; }  //********************************************************main********************************************//  int A::count = 0; char *A::str = NULL;  int main() { 	A a1; 	cout<<a1.GetCurChar()<<endl; 	A a2; 	cout<<a2.GetCurChar()<<endl; 	A a3; 	cout<<a3.GetCurChar()<<endl; 	A a4; 	cout<<a4.GetCurChar()<<endl; 	A a5; 	cout<<a5.GetCurChar()<<endl; 	A a6; 	cout<<a6.GetCurChar()<<endl; 	return 0; }

我现在手上也有一份同样模式的代码  类里面的static 成员变量是所有实例化对象所共享的  而且代码中也只为这个静态变量分配了一份内存  要是把对它的析构放到析构函数里面就会出问题  当一个对象析构 那么先前实例化出来的对象就没法用了

引用 10 楼 akirya 的回复:1 static 是防止跟其他文件的pa重名 2 内存泄漏了 static A * pa = NULL 这个是在另一个.CPP文件定义的全局变量,我百度static  如果用来声明全局变量,那么这个全局变量的作用域只能是这个.cpp文件. 这里的作用是不是像百度上面说的, 还有这个是游戏客户端的部分代码来的

引用 12 楼 SKATE11 的回复:这个不能用析构函数来释放内存的  那样每个对象析构一次释放一次 但是shareA()里面只分配了一份 会出问题的  最好弄个计数器计算实例化对象的个数++++

这个单利实现（如果算是单利的话）少见，构造和析构都是公有的，没法控制对象个数啊。如果全靠使用者自律的话，还用sharedA干嘛，直接都走pa不是更省事。

引用 11 楼 bedynamic 的回复:[quote=引用 7 楼 max_min_ 的回复:] 没有delete 应该是在整个过程中，对象都会使用的！就没有delete也无伤大雅，只是习惯不太好而已！ 至于5楼说的内存泄露，不敢苟同！ 为什么用static话，局部代码看不出来，可能是1楼说的原因！ 引用 8 楼 zmlovelx 的回复:这个析构是public的有点危险呀。 引用 10 楼 akirya 的回复:1 static 是防止跟其他文件的pa重名 2 内存泄漏了 [/quote]

公司里有的代码，架构写得的确不错， 有的代码写得也的确不怎么样  当然，也许自己水平有限，不排除有眼不识泰山

存在内存泄露  用内存泄露工具检测是不会通过的  代码的意思也就是 反正这个对象才整个程序运行期都只会new一次 泄露就泄露吧 无所谓 这点内存花得起  或者 反正都是 整个程序运行期都得存在的东西 没必要做delete 让操作系统自己delete就行   鄙视这推卸责任的心态

A::~A(){       std::cout<<"~~AAA";//为什么不需要delete pa所指的对象??  而且整个程序运行过程中始终不见这个析构函数的执行  很奇怪?     getchar(); } 如果在对象析构里删除，会有问题，因为不知道这个对象是不是最后一个对象，可能有其他地方用到了这个单实例对象，一般来说，会有一条特别的成员函数用于删除，或者在程序结束前再删除。

引用 2 楼 weiwenyulai 的回复:[quote=引用 1 楼 user-12 的回复:] 单例模式(singleton pattern) 我百度了一下 其中 从具体实现角度来说，就是以下三点：一是单例模式的类只提供私有的构造函数，二是类定义中含有一个该类的静态私有对象，三是该类提供了一个静态的共有的函数用于创建或获取它本身的静态私有对象  明显我所提供的代码不满足第一 二点. static A* pa = NULL; //这里的pa 不属于类成员  是另一个文件的全局变量的    是不是我公司的代码不规范???  还有像这种例子非常多  为什么从来没见过有析构函数调用的?[/quote]  只要A的用户都是通过A:::shareA()来用使用的， 这是就单例。你说的其它条件只是借助C++语法来保证单例的唯一性。

引用 1 楼 user-12 的回复:单例模式(singleton pattern) 我百度了一下 其中 从具体实现角度来说，就是以下三点：一是单例模式的类只提供私有的构造函数，二是类定义中含有一个该类的静态私有对象，三是该类提供了一个静态的共有的函数用于创建或获取它本身的静态私有对象  明显我所提供的代码不满足第一 二点. static A* pa = NULL; //这里的pa 不属于类成员  是另一个文件的全局变量的    是不是我公司的代码不规范???  还有像这种例子非常多  为什么从来没见过有析构函数调用的?


Question: 求大神分析openssH源码中的收发包函数~~

引用 1 楼 Idle_Cloud 的回复:这个的封装是会有很多层，你可以搜索socket，反向搜索看看能不能找到，因为通信终究是要使用socket那一套函数。 这个封装的太多了，看不懂啊~~

引用 2 楼 lileilei2b 的回复:[quote=引用 1 楼 Idle_Cloud 的回复:] 这个的封装是会有很多层，你可以搜索socket，反向搜索看看能不能找到，因为通信终究是要使用socket那一套函数。 这个封装的太多了，看不懂啊~~[/quote]  一层一层的慢慢的向里面看，先不要太看重实现细节，理清楚框架思路先！拿笔画画！  ps：尽量不要重复发贴


Question: 结构中伸缩性数组为什么显示指针转换错误

引用 4 楼 xiaobaiwupen 的回复:[quote=引用 2 楼 relaxisland 的回复:] 楼上说的对 不过在 内存分配之前，做如下操作， 不会爆掉？  fp->a=i; 不会吧  只是动态数组的内存空间没有分配 之前定义结构的时候int a 已经说明了 结构至少要有一个整数型内存空间[/quote] 只是说明了要有  可是你没有给  你不觉得fp 在分配内存之前是野指针吗？ 如果不分配内存就能往里面塞东西的话 那么后面也就没必要malloc

引用 2 楼 relaxisland 的回复:楼上说的对 不过在 内存分配之前，做如下操作， 不会爆掉？  fp->a=i; 不会吧  只是动态数组的内存空间没有分配 之前定义结构的时候int a 已经说明了 结构至少要有一个整数型内存空间

lz 用的 c++ 的 compiler

楼上说的对 不过在 内存分配之前，做如下操作， 不会爆掉？  fp->a=i;

fp=(struct book *)malloc(sizeof(struct book)+n*sizeof(int));  malloc返回的是void*，要强制转换下。


Question: 如何把一个自定义（编写）的函数变成一个独立的文件

A.C： FILE *fp1;   fp1=fopen("c:\\test.txt","rw");  for (i=0;i<10;i++)  {      fscanf(fp1,"%d",&a[i]);  printf("%d",a[i]);  }      fclose(fp1); #include <stdio.h>  int a[11],i,k,x;  void xiugai()  {  scanf("%d%d",&k,&x);  for (i=10-1;i>k;i--)  a[i+1]=a[i];  a[k-1]=x;  }   void myp()  {  for (i=0;i<10;i++)   printf("%d",a[i]);   }  void main()  { #include "A.C" printf("输入更改的位数，和更改的内容");   xiugai();  myp();  }

写成函数，单独放在一个c 文件中，为其建立头文件，并将它们添加到你目前的 project 中，

例如 独立的文件 叫做 special.c #include <stdio.h>  void special_deal() { FILE *fp1;   fp1=fopen("c:\\test.txt","rw");  for (i=0;i<10;i++)  {      fscanf(fp1,"%d",&a[i]);  printf("%d",a[i]);  }      fclose(fp1);printf("输入更改的位数，和更改的内容");  } 之后你头文件引用 在主函数中 在主函数文件中加入 #include "special.h" void main()  {   special_deal();        xiugai();  myp();  }

静态库 动态库的封装  管理.c文件 和.h文件  或者只能用 函数宏来实现 或者把它封装成一个函数


Question: 无法打开源文件

引用 13 楼 china_jeffery 的回复:这个不是错误，只要编译不报错就行了  代码没错误，但调试不了。

这个不是错误，只要编译不报错就行了

引用 5 楼 turingo 的回复:直接安装带有mingw的那个版本。[/quote] 谢谢！

path设置对吗？

直接安装带有mingw的那个版本。  引用 4 楼 lm_whales 的回复:[quote=引用 3 楼 turingo 的回复:] 推荐用Code::Blocks(http://www.codeblocks.org/)。  [quote=引用 楼主 Explorer_day 的回复:]    如图，不管什么头文件都无法打开，在网上查了好久也解决不了。本人菜鸟一个，望前辈们赐教。[/quote] 请问 gdb 怎么装  [/quote]

引用 3 楼 turingo 的回复:推荐用Code::Blocks(http://www.codeblocks.org/)。  [quote=引用 楼主 Explorer_day 的回复:]    如图，不管什么头文件都无法打开，在网上查了好久也解决不了。本人菜鸟一个，望前辈们赐教。[/quote] 请问 gdb 怎么装

推荐用Code::Blocks(http://www.codeblocks.org/)。  引用 楼主 Explorer_day 的回复:   如图，不管什么头文件都无法打开，在网上查了好久也解决不了。本人菜鸟一个，望前辈们赐教。

引用 楼主 Explorer_day 的回复:   如图，不管什么头文件都无法打开，在网上查了好久也解决不了。本人菜鸟一个，望前辈们赐教。 intellisense先关掉一下

这可能是编译环境有问题，建议重装一下VC

换个VC版本试试

打开方式不对。  用别的环境打开试试

实在搞不懂 留下qq 远程帮你看一下 或者帮你装个codeblocks

VC6： 工程、设置、C/C++、分类：Preprocessor、附加包含路径：填写附加头文件所在目录 逗号间隔多项 工程、设置、Link、分类：Input、附加库路径：填写附加依赖库所在目录 分号间隔多项 工程、设置、Link、分类：Input、对象/库模块：填写附加依赖库的名字.lib 空格间隔多项 VS20xx： 项目、属性、C/C++、附加包含目录：填写附加头文件所在目录 分号间隔多项 项目、属性、链接器、常规、附加库目录：填写附加依赖库所在目录 分号间隔多项 项目、属性、链接器、输入、附加依赖项：填写附加依赖库的名字.lib 空格或分号间隔多项

引用 2 楼 u012071720 的回复:这可能是编译环境有问题，建议重装一下VC  都已经重装两遍了，解决不了。