Question: 指向指针的指针 对齐问题

首先你要理解pack（1）是什么意思，他是程序的，内存是一字节对齐，这样你的指针很有可能不在4字节的边界这样就会出错（x86没有这个问题），在一个这个4字节对齐是芯片要求的arm体系结构。   难道我解引一个指针即使使用了pack(1)下还必须4字节对齐。  你这么问感觉不了解pack(1)是什么意思，就因为你pack(1)啦才让程序1字节对齐的啊

void  test(AA_T *p)  {      printf("\n 0x%x", p->pBB ->b1);  }    把pAA的地址扔进去，再试，看咋样

有哪位可以解释一下，为什么将二级指针作为函数形参就出错了。我试了一下  如果不做函数形参执行是不会出错的 我都快疯了。

谢谢各位 。我把问题重新贴一下吧。可能大家没看明白。  在使用pack(1)的情况下，双重指针作为子函数参数传递，子函数内部解引指针出现错误。原因是没有对齐在4字节边界上。 但是不知道为什么使用了pack(1)还会出现这样的错误。请各位看客分析下。 因为的数据要发送到非常窄的链路上，所以我必须pack(1)。但是又出现这样的错误，很难受。  简要的代码结构描述：（下面的代码经过试验，能够复现问题） 平台：ARM9 系统：vxworks6.6  //头文件  #pragma pack(1) typedef struct {      char a;     int  c;     BB_T *pBB; }AA_T;  typedef struct {     char a;     int  c; }BB_T; #pragma pack(0)   //C文件  /* 定义了两个变量*/ AA_T g_struAA;   BB_T g_struBB;   void  test(BB_T **ppstruBB) {     BB_T *pstruBB = NULL;      pstruBB = *ppstruBB;     /* 解引一级指针 */     printf("\n 0x%x ",pstruBB ->c);  /* 输出值 正确下应该是 0x12345678 */}  void  testmain(){ /* 初始化 */     g_struBB.a = 1;    g_struBB.c = 0x12345678;  /* 初始化 */    g_struAA.a = 1;   g_struAA.c = 2;     g_struAA.pBB = &g_struBB;      test(&g_struAA.pBB); }   // 运行结果  直接奔溃。执行到test的解引那个语句的时候出错。 但是去掉pack(1)  和pack(0)就好了。 为什么呢？ 难道我解引一个指针即使使用了pack(1)下还必须4字节对齐。困扰好久，求各位看官多多赐教。

引用 7 楼 nice_cxf 的回复:有些linux系统，指针必须指向4字节的整数倍（32位系统），因此当你按照1字节对齐时，指针指向的位置不能保证4字节的整数倍，所以就出错了 纠正：有些CPU（比如ARM），……

#include <stdio.h> #define field_offset(s,f) (int)(&(((struct s *)(0))->f)) struct AD  { int a; char b[13]; double c;}; #pragma pack(push) #pragma pack(1) struct A1  { int a; char b[13]; double c;}; #pragma pack(2) struct A2  { int a; char b[13]; double c;}; #pragma pack(4) struct A4  { int a; char b[13]; double c;}; #pragma pack(8) struct A8  { int a; char b[13]; double c;}; #pragma pack(16) struct A16 { int a; char b[13]; double c;}; #pragma pack(pop) int main() {     printf("AD.a %d\n",field_offset(AD,a));     printf("AD.b %d\n",field_offset(AD,b));     printf("AD.c %d\n",field_offset(AD,c));     printf("\n");     printf("A1.a %d\n",field_offset(A1,a));     printf("A1.b %d\n",field_offset(A1,b));     printf("A1.c %d\n",field_offset(A1,c));     printf("\n");     printf("A2.a %d\n",field_offset(A2,a));     printf("A2.b %d\n",field_offset(A2,b));     printf("A2.c %d\n",field_offset(A2,c));     printf("\n");     printf("A4.a %d\n",field_offset(A4,a));     printf("A4.b %d\n",field_offset(A4,b));     printf("A4.c %d\n",field_offset(A4,c));     printf("\n");     printf("A8.a %d\n",field_offset(A8,a));     printf("A8.b %d\n",field_offset(A8,b));     printf("A8.c %d\n",field_offset(A8,c));     printf("\n");     printf("A16.a %d\n",field_offset(A16,a));     printf("A16.b %d\n",field_offset(A16,b));     printf("A16.c %d\n",field_offset(A16,c));     printf("\n");     return 0; } //AD.a 0 //AD.b 4 //AD.c 24 // //A1.a 0 //A1.b 4 //A1.c 17 // //A2.a 0 //A2.b 4 //A2.c 18 // //A4.a 0 //A4.b 4 //A4.c 20 // //A8.a 0 //A8.b 4 //A8.c 24 // //A16.a 0 //A16.b 4 //A16.c 24 // //

因为我必须要用1字节对齐。所以我没法改。 可以分析下还有好的方法么？

typedef struct {     int a1;     short a2;    /* 一堆变量 */     BB_T *pBB; }AA_T; 你尝试这把这两个结构体，不论是4字节对齐还是1字节对齐，都先让其定义上做到4字节对齐（调换一下结构体成员的位置，把占用内存字节数最大的成员放在前面）。

刚才上面的回复 &&g_struBB 多打了个 &。

我继续查了下 发现出错的地方是在执行语句 ptestbb  = *ppTest; 的时候出错的。  *ppTest得到的地址已经不正确了，已经不是&&g_struBB 我真不明白为什么不正确。 所以导致接下来执行 printf("\n 0x%x", ptestbb ->b1); 指针飞了。 真搞不懂。 如果不强制1字节对齐就可以。强制1字节对齐就不行。但是我的代码所实现的功能又必须强制1字节对齐。

应该是不影响嘛，我看不出来有什么问题，或许问题不是出在此处？


Question: VS2010里用C++拼接图像  要代码  大神求救

引用 1 楼 bigwatercar 的回复:看把你美的，这拼接很简单的。  所有图像 假设 image[0-n]  申请一个 Σ(0,n) width  Σ(0,n)height  bitmap  然后一个一个bitblt到这个bitmap上就好了啊！！ 不懂呀，具体一点呗，大神 具体的代码和引用的库

引用 3 楼 jmppok 的回复:推荐你用CxImage库            http://blog.csdn.net/jmppok/article/details/18794623  CxImage t_img1,t_img2,t_img3;   需要怎么引用CxImage库啊，我把CxImage库下载下来了，但不知道要引用哪一个

引用 5 楼 bobo928843007 的回复:就简单的把图像接起来？还是全景拍摄那种拼接？ 简单的拼接就可以，航拍，把定时拍的照片拼起来

就简单的把图像接起来？还是全景拍摄那种拼接？

到底是c语言还是c++

推荐你用CxImage库            http://blog.csdn.net/jmppok/article/details/18794623  CxImage t_img1,t_img2,t_img3;  int t_h1,t_w1,t_h2,t_w2,t_h3,t_w3,t_bpp;  t_img1.Load(L"test00222.jpeg");  t_img2.Load(L"test00111.jpeg");  t_h1=t_img1.GetHeight();  t_w1=t_img1.GetWidth();  t_h2=t_img2.GetHeight();  t_w2=t_img2.GetWidth();  t_h3=t_h1;  t_w3=t_w1+t_w2;  t_bpp=t_img1.GetBpp();  t_img3.Create(t_w3,t_h3,t_bpp);  t_img3.MixFrom(t_img1,0,0);  t_img3.MixFrom(t_img2,t_w1,0);  t_img3.Save(L"3.jpeg",CXIMAGE_FORMAT_JPG);

引用 1 楼 bigwatercar 的回复:看把你美的，这拼接很简单的。  所有图像 假设 image[0-n]  申请一个 Σ(0,n) width  Σ(0,n)height  bitmap  然后一个一个bitblt到这个bitmap上就好了啊！！  总长和总高表示的有点儿问题， 反正就那个意思啦


Question: unsigned int a = -1;printf("%d",a);输出为什么是-1？？？？？？

谢谢各位，明白了！

printf Type Field Characters The type character is the only required format field ; it appears after any optional format fields. The type character determines whether the associated argument is interpreted as a character, string, or number. The types C and S, and the behavior of  c and s with printf functions, are Microsoft extensions and are not ANSI-compatible.   Table R.3   printf Type Field Characters  Character Type Output Format  c int or wint_t When used with printf functions, specifies a single-byte character; when used with wprintf functions, specifies a wide character.  C int or wint_t When used with printf functions, specifies a wide character; when used with wprintf functions, specifies a single-byte character.  d int Signed decimal integer.  i int  Signed decimal integer.  o int  Unsigned octal integer.  u int  Unsigned decimal integer.  x int Unsigned hexadecimal integer, using “abcdef.”  X int Unsigned hexadecimal integer, using “ABCDEF.”  e  double Signed value having the form [ – ]d.dddd e [sign]ddd where d is a single decimal digit, dddd is one or more decimal digits, ddd is exactly three decimal digits, and sign is + or –.  E double Identical to the e format except that E rather than e introduces the exponent.  f double Signed value having the form [ – ]dddd.dddd, where dddd is one or more decimal digits. The number of digits before the decimal point depends on the magnitude of the number, and the number of digits after the decimal point depends on the requested precision.  g double Signed value printed in f or e format, whichever is more compact for the given value and precision. The e format is used only when the exponent of the value is less than –4 or greater than or equal to the precision argument. Trailing zeros are truncated, and the decimal point appears only if one or more digits follow it.  G double Identical to the g format, except that E, rather than e, introduces the exponent (where appropriate).  n  Pointer to integer  Number of characters successfully written so far to the stream or buffer; this value is stored in the integer whose address is given as the argument.  p Pointer to void Prints the address pointed to by the argument in the form xxxx:yyyy where xxxx is the segment and yyyy is the offset, and the digits x and y are uppercase hexadecimal digits.  s String  When used with printf functions, specifies a single-byte–character string; when used with wprintf functions, specifies a wide-character string. Characters are printed up to the first null character or until the precision value is reached.  S String When used with printf functions, specifies a wide-character string; when used with wprintf functions, specifies a single-byte–character string. Characters are printed up to the first null character or until the precision value is reached.

引用 2 楼 thefirstz 的回复:printf("%ud\n",a) %u 没有%ud %ud的效果是输出一个无符号整数 然后紧接着输出一个'd'

作为一个C程序员，对  scanf,sscanf,fscanf  printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离手，曲不离口”的。

printf("%ud\n",a)

因为你的printf中用的是一般整数的输出。 无符号输出请用%u


Question: 参数类型是  int&，这是什么意思啊？是整形地址的意思吗

引用！也就是需要对参数本身作操作，而不是拷贝复制的那一份！

参数为引用传递，不同于值传递。 只有在面向对象语言，像C++，C#当中存在。 C语言只有指针传递和值传递。 引用传递类似于C当中的指针传递。

引用，C++语言中才有，C语言没有

别名， 传入是你原变量拷贝


Question: 关于#define的疑问

你用gcc编译器试试，是可以通过的。VS不能通过。最根本的还是应该看看C标准是怎么说的。然后再看看各编译器的说明文档是怎么说的。

Error	1	error C2105: '--' needs l-value	d:\my documents\visual studio 2010\projects\opencvtest\opencvtest\opencvtest.cpp	251	1

处理方式不一样，不用太纠结，编译器就这样按照语法来编译，你可以看看帮助文档，应该有详细的解释。

引用 1 楼 user-4 的回复:因为a不在符号表里面 所以你引用a这个符号是无效的  看不懂=0= 能说具体点吗？

#define只是在相应的地方展开，不是定义

因为a不在符号表里面 所以你引用a这个符号是无效的


Question: 基于linux下服务端创建的多线程id号都是一样的，为什么？

引用 7 楼 lubyam 的回复:[quote=引用 6 楼 qq120848369 的回复:] [quote=引用 5 楼 zhao4zhong1 的回复:] 不要频繁创建销毁线程，请使用线程池。  说的对，且行且珍惜。[/quote] 对[/quote] 对，请珍惜

pthread_self()  获取线程ID

pthread_t 是线程ID。

应该是你看错了，如果两个线程都活着不可能一样啊，

不要频繁创建销毁线程，请使用线程池。

或者是你没成功创建出两个线程

线程ID是每个线程的唯一标识, 不可能相同. 只可能是你打错了.

引用 6 楼 qq120848369 的回复:[quote=引用 5 楼 zhao4zhong1 的回复:] 不要频繁创建销毁线程，请使用线程池。  说的对，且行且珍惜。[/quote] 对

引用 5 楼 zhao4zhong1 的回复:不要频繁创建销毁线程，请使用线程池。  说的对，且行且珍惜。

看起来像打 pid 去了...

贴源代码看看。


Question: 将Name Mangling 后的名称还原为可读的形式？

c++filt

引用 1 楼 user-2 的回复:extern "C" 用于防止name mangling 你说的很对，问题是现在第三方提供的动态链接库，做的时候并没有 extern "C" 规范。所以我才提出了这个问题

extern "C" 用于防止name mangling


Question: 求助！！！uvaoj 489：hangman judge 为何就是无法AC……

我大概知道怎么回事了。 题目没说清楚啊。 我以为是一并输入后，统一输出。 结果竟然是每一回合都输入并分开输出……


Question: C语言里这种表达方式普遍吗？合适吗？

库代码出现这种情况是正常的。  库代码，通常可能不遵守，宏，枚举常量必须大写这个习惯，因为库函数可以直接编写成函数，也可以用宏实现。 统一使用大写，并不能让宏常量，枚举常量，的意义更加明确，从而拉开名字的心理距离。  另外，很多编程约定，都不是针对库的，而是针对使用编译器和库的用户的。  而且，库函数，不需要可以移植，需要移植的时候，在目标系统上实现库函数即可。

不太容易看懂,也就是不太直观,我觉的宏还是不要带括号

_osfile(fh) 我估计是生成了一个变量名，比如  #define _osfile(fh) osfile_##fh int _osfile(as)=100; 第二句就相当于是 int osfile_as=100; 其中_osfile(as)就是连接osfile_和as  ——————————————————————————  使用宏很普遍，这样连接两个字符串也很普遍，但是这样产生变量名，我感觉不是很好。

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

带参数的宏很普遍，但一般宏都要大写，和函数区别开来。 C语言中函数是不能被赋值的(C++某些情况下可以,不过基本没什么意义,一般不会这样用)，看到这种用法就应该想到是宏 写C标准库的都是大神，大神怎么写都是对的~~

每天回帖即可获得10分可用分！小技巧：教您如何更快获得可用分

就像这样： #define max(a,b) ((a) > (b) ? (a) : (b))

他问的是 _osfile(fh) 吧，带参数的宏，用的算是普遍的

有见到过，但不多

函数的错觉啥意思？  这种用法很普遍， 比如 i += 1； 等价于 i = i + 1;  PS： 答题要被采纳了才有分的。。。     PPS: 给点分呗。


Question: 关于   访问超数组上标数据遇到的奇异的问题。（个人猜想是编译器问题）

在比较老一点的编译器，数据顺序存放，并且是按照定义顺序存放，如果数据之间没有缝隙的话--比如VC不采用debug模式，也不用增量编译，你的这状况，恰好会出现。 因为老一点的编译器，内存比较少，也有没有多线程可以使用，所以一般是按照扫描到的变量定义顺序，存储数据。 就像汇编语言定义数据那样，依序存储。 新的编译器，由于各种技术，思想的问题，再加上C,C++语言标准，没有定义数据存储顺序，所以就各种方式的都有。

int count = 0; //初始化为0再看看。

#include <stdio.h> int main() {     int count;     int a[5]={1,2,3,4,5};     printf("%d",a[5]);    //数组越界了     for(count=0;count<6;count++)     {         printf("%d ",a[count]);  //但是，在count=5且输出a[count]时，数组越界     }     return 0; } 数组越界了，讨论这个没有意义啊

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

引用 6 楼 starytx 的回复:不要干越界访问的事情就行了，至于看到的结果，研究起来也没意义对

引用 16 楼 supermegaboy 的回复:[quote=引用 13 楼 u011636566 的回复:] 贴子标题已经明确标出了，这是一个在数组越界访问时出现的一个状况，不过因为这个状况有规律可循，所以决定有意思就发了上来。多谢前几位网友的解答。至于那些仅仅为了说明这是个越界访问，研究没意义的网友，我不置可否。反正我认为，对于出现的状况能搞懂其原理是再好不过的了。至于那些说越界方法会出现不可预料的结果的网友，我想说，我知道这个理论，不过目前这个现象明显不是不可预料的，是有规律的，所以我发了上来，让有经验的网友指教。综上所述：感谢第一类网友的帮助，请第二类网友看准帖子标题在选择是否浏览，不要浪费大家时间，请第三类网友斟酌发言意义。  其实认为“出现不可预料结果”的朋友也是正确的，你的理解有误。那个count值其实只是在你的编译器的当前环境下出现的结果，不同编译器或者即使同一个编译器的不同环境下结果就可能不一样了。[/quote]  不错，我在标题中也有标出猜想是编译器问题。不过还是想了解更透彻点，所以贴了上来。

引用 1 楼 supermegaboy 的回复:这不是奇异问题，只不过由于你使用的编译器把count排在a之前，且在当前对齐系数下count与a之间没有空隙所致，a[5]访问到的其实是count。 ++ 这个明显是很正常现象，只要越界访问，什么事情都会出。。

引用 13 楼 u011636566 的回复:贴子标题已经明确标出了，这是一个在数组越界访问时出现的一个状况，不过因为这个状况有规律可循，所以决定有意思就发了上来。多谢前几位网友的解答。至于那些仅仅为了说明这是个越界访问，研究没意义的网友，我不置可否。反正我认为，对于出现的状况能搞懂其原理是再好不过的了。至于那些说越界方法会出现不可预料的结果的网友，我想说，我知道这个理论，不过目前这个现象明显不是不可预料的，是有规律的，所以我发了上来，让有经验的网友指教。综上所述：感谢第一类网友的帮助，请第二类网友看准帖子标题在选择是否浏览，不要浪费大家时间，请第三类网友斟酌发言意义。  其实认为“出现不可预料结果”的朋友也是正确的，你的理解有误。那个count值其实只是在你的编译器的当前环境下出现的结果，不同编译器或者即使同一个编译器的不同环境下结果就可能不一样了。

其实电脑开机后物理内存的每个字节都是可读写的，区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。

都越界了， 什么样的结果都要接受啊。

不要干越界访问的事情就行了，至于看到的结果，研究起来也没意义

回复zhao4zhong1：多谢这位网友，你说的更深一点，并且也多次回答我的问题，感谢下~

回复supermegaboy：不错，的确是count 的数值。多谢~

1楼正解 初始化一下count  或者改变一下你的数组最后一个元素的值  你就会发现其中的秘密！！！ 所以说，在一个函数内部，只要定义一个变量的指针， 就能用这个指针访问修改所有变量的值

会输出乱码么？应该是一个数字吧？

你换个编译器试试？


Question: 为什么队列不应该反向遍历？

书上这种说法漏了一个条件，用单链表易于实现单端队列，不便于实现双端队列。所谓“队列绝不反向遍历”，是由于单端队列只会从一端插入元素，另一端取出，这种情形用单链表是很容易实现的。


Question: 语法分析器的编写

结贴结贴结贴

LEX+YACC FLEX+BISON

引用 9 楼 caozhy 的回复:int 就是 i-n-t-分隔符 数字就是 数字(+)-分隔符   while((ch=getchar())!=EOF) 　　switch(state) 　　　　case 1 :if ch=="/",state=2,break; 　　　　case 2: if ch=="*",state=3 　　　　　　　　else state=1;break; 　　　　case 3:.......... 　　　　case 4:..........   http://www.cnblogs.com/yanlingyin/archive/2012/04/17/2451717.html 我看了这篇文章，这篇文章写的就是没法改变，要是想改变要怎么办呢？

引用 9 楼 caozhy 的回复:int 就是 i-n-t-分隔符 数字就是 数字(+)-分隔符 还是不理解， 如果我有int和double，还有可能有integer，do等，那么我应该怎么确定待比较的字符串要和哪些进行比较呢？ 还有就是状态应该怎么用代码表示呢？各个状态在代码中是什么呢？

int 就是 i-n-t-分隔符 数字就是 数字(+)-分隔符

引用 7 楼 caozhy 的回复:[quote=引用 6 楼 qilinno 的回复:] [quote=引用 4 楼 caozhy 的回复:] 不知道你说的“不能自定义语法”是什么意思。  词法分析无非就是构造NFA DFA，任何一本编译原理上都有。 但是有些地方还是想不太明白，就是我可以分析出<数字>0这种的词法，但是int这种的怎么分析呢？简单的比较？   还有就是我在网上看到的大多数都是直接定义好的，没见到词法分析的代码，都是直接拿定义好的词法用的[/quote]  如果你不懂NFA，根本看不懂词法分析的代码。[/quote] 我看过NFA了，但是要怎么分析int这种的关键字呢，要怎么做才能让它能用？

引用 6 楼 qilinno 的回复:[quote=引用 4 楼 caozhy 的回复:] 不知道你说的“不能自定义语法”是什么意思。  词法分析无非就是构造NFA DFA，任何一本编译原理上都有。 但是有些地方还是想不太明白，就是我可以分析出<数字>0这种的词法，但是int这种的怎么分析呢？简单的比较？   还有就是我在网上看到的大多数都是直接定义好的，没见到词法分析的代码，都是直接拿定义好的词法用的[/quote]  如果你不懂NFA，根本看不懂词法分析的代码。

引用 4 楼 caozhy 的回复:不知道你说的“不能自定义语法”是什么意思。  词法分析无非就是构造NFA DFA，任何一本编译原理上都有。 但是有些地方还是想不太明白，就是我可以分析出<数字>0这种的词法，但是int这种的怎么分析呢？简单的比较？   还有就是我在网上看到的大多数都是直接定义好的，没见到词法分析的代码，都是直接拿定义好的词法用的

引用 2 楼 user-3 的回复:编译原理，递归下降分析 但是有些地方还是想不太明白，就是我可以分析出<数字>0这种的词法，但是int这种的怎么分析呢？简单的比较？

引用 1 楼 caozhy 的回复:你说的这个是词法分析而不是语法分析 对不起，是写错了， 请问下要怎么做呢？

编译原理，递归下降分析

你说的这个是词法分析而不是语法分析


Question: 写一个用逗号分割string对象的split函数

已经实现，感谢版主  void splitdou(string s,vector<string>& ret)   {   	size_t last = 0; 	size_t index=s.find_first_of(',',last); 	while (index!=std::string::npos) 	{ 		ret.push_back(s.substr(last,index-last)); 		last=index+1; 		index=s.find_first_of(',',last); 	} 	if (index-last>0) 	{ 		ret.push_back(s.substr(last,index-last)); 	} }

使用find找到分隔符，取出子串 重复以上过程


Question: vs2012用什么函数接收键盘的相应？

#include <conio.h> #include <windows.h>  void ConPrintAt(int x, int y, char *CharBuffer, int len) {    DWORD count;    COORD coord = {x, y};    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    SetConsoleCursorPosition(hStdOut, coord);    WriteConsole(hStdOut, CharBuffer, len, &count, NULL); } void HideTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = FALSE;       SetConsoleCursorInfo(hStdOut, &cciCursor);    } }  void ShowTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = TRUE;       SetConsoleCursorInfo(hStdOut, &cciCursor);    } } void GetWH(int *w,int *h) {     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     CONSOLE_SCREEN_BUFFER_INFO csbi;     if (GetConsoleScreenBufferInfo(hStdOut, &csbi)) {         *w=csbi.srWindow.Right;         *h=csbi.srWindow.Bottom;     } else {         *w=80;         *h=25;     } } void ClearConsole() {    //Get the handle to the current output buffer...    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    //This is used to reset the carat/cursor to the top left.    COORD coord = {0, 0};    //A return value... indicating how many chars were written    //   not used but we need to capture this since it will be    //   written anyway (passing NULL causes an access violation).    DWORD count;    //This is a structure containing all of the console info    // it is used here to find the size of the console.    CONSOLE_SCREEN_BUFFER_INFO csbi;    //Here we will set the current color    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //This fills the buffer with a given character (in this case 32=space).       FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       //This will set our cursor position for the next print statement.       SetConsoleCursorPosition(hStdOut, coord);    } }  //This will set the position of the cursor int main() {     unsigned short k;     int x,y,w,h;  	SetConsoleOutputCP(437);     ClearConsole();     GetWH(&w,&h);     x=w/2;y=h/2;     HideTheCursor();     ConPrintAt(x,y,"\xdb",1);     while (1) {         Sleep(50);         k=getch();         if (27==k) break;//按Esc键退出         if (0==k||0xe0==k) k|=getch()<<8;//非字符键         switch (k) {             case 0x48e0:case 0x04800://上                 if (y>0) {                     ConPrintAt(x,y," ",1);                     y--;                     ConPrintAt(x,y,"\xdb",1);                 }             break;             case 0x50e0:case 0x05000://下                 if (y<h) {                     ConPrintAt(x,y," ",1);                     y++;                     ConPrintAt(x,y,"\xdb",1);                 }             break;             case 0x4be0:case 0x04b00://左                 if (x>0) {                     ConPrintAt(x,y," ",1);                     x--;                     ConPrintAt(x,y,"\xdb",1);                 }             break;             case 0x4de0:case 0x04d00://右                 if (x<w-1) {                     ConPrintAt(x,y," ",1);                     x++;                     ConPrintAt(x,y,"\xdb",1);                 }             break;         } //      cprintf("%04x pressed.\r\n",k);      }     ClearConsole();     ShowTheCursor();     return 0; }

如果是MFC，则就是，keydown事件。 如果不是MFC，那就用getch这个函数。

引用 9 楼 fd214333890 的回复:[quote=引用 6 楼 zhao4zhong1 的回复:] [quote=引用 4 楼 fd214333890 的回复:] [quote=引用 3 楼 zhao4zhong1 的回复:] #include <conio.h> #include <windows.h> int main() {     int k;      while (1) {         if (kbhit()) {             k=getch();             if (0==k || 0xE0==k) k=k<<8|getch();             if (27==k) break;//按Esc键退出             cprintf("\r\n%04X\r\n",k);         }         Sleep(200);         cprintf(".");     }     return 0; }  我怎么用vs那个kbhit()感觉没用啊[/quote] 你是用于Console项目吗？[/quote] 用的是win32应用程序。[/quote] Win32需要处理WM_KEYUP消息。 WM_KEYUP The WM_KEYUP message is posted to the window with the keyboard focus when a nonsystem key is released. A nonsystem key is a key that is pressed when the alt key is not pressed, or a keyboard key that is pressed when a window has the keyboard focus.   WM_KEYUP  nVirtKey = (int) wParam;    // virtual-key code  lKeyData = lParam;          // key data    Parameters nVirtKey  Value of wParam. Specifies the virtual-key code of the nonsystem key.  lKeyData  Value of lParam. Specifies the repeat count, scan code, extended-key flag, context code, previous key-state flag, and transition-state flag, as shown in the following table. Value Description  0–15 Specifies the repeat count for the current message. The value is the number of times the keystroke is auto-repeated as a result of the user holding down the key. The repeat count is always one for a WM_KEYUP message.  16–23 Specifies the scan code. The value depends on the original equipment manufacturer (OEM).  24 Specifies whether the key is an extended key, such as the right-hand alt and ctrl keys that appear on an enhanced 101- or 102-key keyboard. The value is 1 if it is an extended key; otherwise, it is 0.  25–28 Reserved; do not use.  29 Specifies the context code. The value is always 0 for a WM_KEYUP message.  30 Specifies the previous key state. The value is always 1 for a WM_KEYUP message.  31 Specifies the transition state. The value is always 1 for a WM_KEYUP message.    Return Values An application should return zero if it processes this message.   Default Action The DefWindowProc function sends a WM_SYSCOMMAND message to the top-level window if the f10 key or the alt key was released. The wParam parameter of the message is set to SC_KEYMENU.   Remarks For enhanced 101- and 102-key keyboards, extended keys are the right alt and ctrl keys on the main section of the keyboard; the ins, del, home, end, page up, page down and arrow keys in the clusters to the left of the numeric keypad; and the divide (/) and enter keys in the numeric keypad. Other keyboards may support the extended-key bit in the lKeyData parameter.   QuickInfo   Windows NT: Requires version 3.1 or later.   Windows: Requires Windows 95 or later.   Windows CE: Requires version 1.0 or later.   Header: Declared in winuser.h.  See Also Keyboard Input Overview, Keyboard Input Messages, DefWindowProc, WM_KEYDOWN, WM_SYSCOMMAND

hook  WH_KEYBOARD_LL

引用 9 楼 fd214333890 的回复:[quote=引用 6 楼 zhao4zhong1 的回复:] [quote=引用 4 楼 fd214333890 的回复:] [quote=引用 3 楼 zhao4zhong1 的回复:] #include <conio.h> #include <windows.h> int main() {     int k;      while (1) {         if (kbhit()) {             k=getch();             if (0==k || 0xE0==k) k=k<<8|getch();             if (27==k) break;//按Esc键退出             cprintf("\r\n%04X\r\n",k);         }         Sleep(200);         cprintf(".");     }     return 0; }  我怎么用vs那个kbhit()感觉没用啊[/quote] 你是用于Console项目吗？[/quote] 用的是win32应用程序。[/quote] The _kbhit function checks the console for a recent keystroke.  这个只能在console 里面用。。。

引用 6 楼 zhao4zhong1 的回复:[quote=引用 4 楼 fd214333890 的回复:] [quote=引用 3 楼 zhao4zhong1 的回复:] #include <conio.h> #include <windows.h> int main() {     int k;      while (1) {         if (kbhit()) {             k=getch();             if (0==k || 0xE0==k) k=k<<8|getch();             if (27==k) break;//按Esc键退出             cprintf("\r\n%04X\r\n",k);         }         Sleep(200);         cprintf(".");     }     return 0; }  我怎么用vs那个kbhit()感觉没用啊[/quote] 你是用于Console项目吗？[/quote] 用的是win32应用程序。

The _kbhit function checks the console for a recent keystroke. If the function returns a nonzero value, a keystroke is waiting in the buffer. The program can then call _getch or _getche to get the keystroke. ------------------------------------- _kbhit函数，检查控制台最近的一个按键状态，如果这个函数返回非0值，则输入缓冲区里面有一个按键信息等待读取，可以用_getch或getche函数读取按键信息。

引用 4 楼 fd214333890 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] #include <conio.h> #include <windows.h> int main() {     int k;      while (1) {         if (kbhit()) {             k=getch();             if (0==k || 0xE0==k) k=k<<8|getch();             if (27==k) break;//按Esc键退出             cprintf("\r\n%04X\r\n",k);         }         Sleep(200);         cprintf(".");     }     return 0; }  我怎么用vs那个kbhit()感觉没用啊[/quote] 你是用于Console项目吗？

引用 楼主 fd214333890 的回复:我再做一个游戏，因为要用到键盘，所以需要键盘的消息。但是我用#include<conio.h>里的_kbhit()不行啊。。。连点反应都没有。。。。有没有人知道该用什么？ MSDN里面的例子。 不断的输出一段东西。知道按任意键，停止。   #include <conio.h> #include <stdio.h>  void main( void ) {    /* Display message until key is pressed. */    while( !_kbhit() )       _cputs( "Hit me!! " );     /* Use _getch to throw key away. */    printf( "\nKey struck was '%c'\n", _getch() );    _getch(); }

引用 3 楼 zhao4zhong1 的回复:#include <conio.h> #include <windows.h> int main() {     int k;      while (1) {         if (kbhit()) {             k=getch();             if (0==k || 0xE0==k) k=k<<8|getch();             if (27==k) break;//按Esc键退出             cprintf("\r\n%04X\r\n",k);         }         Sleep(200);         cprintf(".");     }     return 0; }  我怎么用vs那个kbhit()感觉没用啊


Question: 写的栈程序代码，编译通不过。

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

引用 7 楼 bobo928843007 的回复:[quote=引用 5 楼 Forthe2012 的回复:] [quote=引用 3 楼 bobo928843007 的回复:] STACK   [quote=引用 1 楼 user-6 的回复:] 语法都不对啊，你确定 struct Stack 前面没有typedef？ +1  STACK 是Stack的结构体变量，不是变量类型，怎么能STACK  S呢！[/quote] 还有本科其实我是法学的。。[/quote]你干嘛转行呢[/quote]  不喜欢法学。

先学关键字和基本语法吧。 就像学英语，你基本单词和基本的句子都看不懂。照着抄了一遍Obama演讲稿，肯定好多错误。

#include <stdio.h> #include<stdlib.h> typedef struct Node { 	int data; 	struct Node * pNext; }NODE,*PNODE; typedef struct Stack { 	PNODE pTop; 	PNODE pBottom; }STACK,*PSTACK; void init(PSTACK); void push(PSTACK,int); void traverse(PSTACK); int main() {     STACK S;     init(&S);     push(&S,1);     push(&S,2);     push(&S,3);     push(&S,4);     push(&S,5);     push(&S,6);     traverse(&S);     return 0; } void init(PSTACK pS) { 	pS->pTop=(PNODE)malloc(sizeof(NODE)); 	if(NULL==pS->pTop) 	{ 		printf("动态内存分配失败！\n"); 		exit(-1); 	} 	else{ 		pS->pBottom=pS->pTop; 		pS->pTop->pNext=NULL; 	} } void push(PSTACK pS,int val) { 	PNODE pNew=(PNODE)malloc(sizeof(NODE)); 	pNew->data=val; 	pNew->pNext=pS->pTop; 	pS->pTop=pNew; 	return; } void traverse(PSTACK pS) { 	PNODE p=pS->pTop; 	while(p!=pS->pBottom) 	{ 		printf("%d ",p->data); 		p=p->pNext; 	} 	printf("\n"); 	return; }   楼主写代码要细心啊

引用 5 楼 Forthe2012 的回复:[quote=引用 3 楼 bobo928843007 的回复:] STACK   [quote=引用 1 楼 user-6 的回复:] 语法都不对啊，你确定 struct Stack 前面没有typedef？ +1  STACK 是Stack的结构体变量，不是变量类型，怎么能STACK  S呢！[/quote] 还有本科其实我是法学的。。[/quote]你干嘛转行呢

引用 4 楼 Forthe2012 的回复:[quote=引用 1 楼 user-6 的回复:] 语法都不对啊，你确定 struct Stack 前面没有typedef？ 谢谢，我决定照版主的 换个编译器。 然后请教一下怎么学数据结构？我把链表、排序、二叉树、栈，或看视频 或看书，或看别人的代码（我下了个C程序105例），主要代码大体敲了一遍。好歹排序是我边背边理解着自己敲下来了，但马上就忘了。二叉树遍历啥的纯背。图的代码我一看吓了一跳，就先没弄。我知道后面还有红黑树啥的，觉得学起来好痛苦。。以后打算JAVA，但觉得不如先深入一门语言。  引用 2 楼 caozhy 的回复:所以一定要用一个好的编译器。好的编译器（比如VC++2010以上）给出的错误提示明确而一目了然。垃圾的编译器（比如VC6.0和gnucc 3.x，以及BCB的早期版本，错误提示一塌糊涂） 。[/quote]这个要理解，不理解背不下来的，通过画结构图来理解，一点一点的分析。

引用 3 楼 bobo928843007 的回复:STACK   [quote=引用 1 楼 user-6 的回复:] 语法都不对啊，你确定 struct Stack 前面没有typedef？ +1  STACK 是Stack的结构体变量，不是变量类型，怎么能STACK  S呢！[/quote] 还有本科其实我是法学的。。

引用 1 楼 user-6 的回复:语法都不对啊，你确定 struct Stack 前面没有typedef？ 谢谢，我决定照版主的 换个编译器。 然后请教一下怎么学数据结构？我把链表、排序、二叉树、栈，或看视频 或看书，或看别人的代码（我下了个C程序105例），主要代码大体敲了一遍。好歹排序是我边背边理解着自己敲下来了，但马上就忘了。二叉树遍历啥的纯背。图的代码我一看吓了一跳，就先没弄。我知道后面还有红黑树啥的，觉得学起来好痛苦。。以后打算JAVA，但觉得不如先深入一门语言。  引用 2 楼 caozhy 的回复:所以一定要用一个好的编译器。好的编译器（比如VC++2010以上）给出的错误提示明确而一目了然。垃圾的编译器（比如VC6.0和gnucc 3.x，以及BCB的早期版本，错误提示一塌糊涂） 。

STACK   引用 1 楼 user-6 的回复:语法都不对啊，你确定 struct Stack 前面没有typedef？ +1  STACK 是Stack的结构体变量，不是变量类型，怎么能STACK  S呢！

语法都不对啊，你确定 struct Stack 前面没有typedef？


Question: 求支持cbc模式的blowfish加密算法（单个c文件）

在网上找到C语言版本了，有C/C++/Java三个版本 http://blog.csdn.net/ishow99/article/details/4270854 需要注意的是，它的解密函数的输入是字符串格式的十六进制（例如："0913BFD01E9F7BC7D7AECF93C7FB4988"），在内部会把2个字符转成其对应的一个字节的数值（例如："09" --> 0x09）


Question: 将一个字符串拷贝到一维的指针数组中，指定的位置

memcpy(               recv_s2++i2*512,               recv_s2,               510               );  这样吗？ 好像不行啊。也报错，不过还没找到错误的原因。我以为这样可以呢 大侠们。帮我看看吧

用memcpy

你应该用memcpy吧

显然是buffer不够大啊。 从s1+i2*512 这开始，放不下你的recv_s2 或者recv_s2中的510字节

谢谢大侠们啦。 这个问题是不是很有实用性啊


Question: 通过GDB调试C和C++程序，得出的结果有些疑问，请教大家。

引用 9 楼 lgmsyy 的回复:[quote=引用 8 楼 myepoch 的回复:] 你多实验几次，地址一定是变化的。这个可以保证。 恩，我实验了几次，确实变化了。那请问下gdb $1 = (unsigned char *) 0x7ffffff875a0 "BM\312=\a"    BM\312=\a 这个打印出来的是什么意思。是图片的什么信息吗[/quote]  打印出来的是什么，你试下就知道了。  另外，同样的内容，放在不同的地方，意义可能是不一样 的。所以不要只拿“内容”说事！？！

引用 9 楼 lgmsyy 的回复:[quote=引用 8 楼 myepoch 的回复:] 你多实验几次，地址一定是变化的。这个可以保证。 恩，我实验了几次，确实变化了。那请问下gdb $1 = (unsigned char *) 0x7ffffff875a0 "BM\312=\a"    BM\312=\a 这个打印出来的是什么意思。是图片的什么信息吗[/quote]  你的 unsigned char *pImage;  不就是字符数组(字符串)的指针么？ 打印的就是它的内容，遇到0截断

引用 8 楼 myepoch 的回复:你多实验几次，地址一定是变化的。这个可以保证。 恩，我实验了几次，确实变化了。那请问下gdb $1 = (unsigned char *) 0x7ffffff875a0 "BM\312=\a"    BM\312=\a 这个打印出来的是什么意思。是图片的什么信息吗

你多实验几次，地址一定是变化的。这个可以保证。

引用 5 楼 dbzhang800 的回复:[quote=引用 4 楼 lgmsyy 的回复:] [quote=引用 2 楼 gigglesun 的回复:] 打印的不是一个标量，打印的是地址，下次运行和这次运行打出来的都不会一样，何况C/C++ BM\312=\a" 打印出来的又是什么呢？？？ [/quote] 字符串，0 前面的部分[/quote]  gdb $1 = (unsigned char *) 0x7ffffff875a0 "BM\312=\a"   1.假如 0x7ffffff875a0  是地址，那么 "BM\312=\a"  是什么，这个和图片有什么关系。 2.如果是地址，为什么每次运行都是一样的地址

引用 2 楼 gigglesun 的回复:打印的不是一个标量，打印的是地址，下次运行和这次运行打出来的都不会一样，何况C/C++  但我每次运行都的确是一样的啊？？？

引用 4 楼 lgmsyy 的回复:[quote=引用 2 楼 gigglesun 的回复:] 打印的不是一个标量，打印的是地址，下次运行和这次运行打出来的都不会一样，何况C/C++ BM\312=\a" 打印出来的又是什么呢？？？ [/quote] 字符串，0 前面的部分

引用 2 楼 gigglesun 的回复:打印的不是一个标量，打印的是地址，下次运行和这次运行打出来的都不会一样，何况C/C++ BM\312=\a" 打印出来的又是什么呢？？？

正常情况！太正常了

打印的就是地址呀！


Question: ADT实现多种数据类型之使用void *的疑问

引用 6 楼 u014541584 的回复:[quote=引用 5 楼 supermegaboy 的回复:] [quote=引用 3 楼 u014541584 的回复:] 况且联合很有局限性，没void *自由灵活  错误。用void*存在类型转换，而除了普通指针到void*等少数情况外，C/C++是不保证转换到void*后再转换回原来的类型仍能保证其值不变。说白了，用void*存在安全隐患。  联合没有这样的问题。[/quote] 但是adt是无法访问函数实现细节的，所以联合不行[/quote]  无论联合也好，void*也好，栈的底层结构都是被封装起来的，用户本来就不需要知道细节，这是ADT的本来目的。你应该是不熟悉作为联合如何实现栈，以为需要访问细节。

引用 5 楼 supermegaboy 的回复:[quote=引用 3 楼 u014541584 的回复:] 况且联合很有局限性，没void *自由灵活  错误。用void*存在类型转换，而除了普通指针到void*等少数情况外，C/C++是不保证转换到void*后再转换回原来的类型仍能保证其值不变。说白了，用void*存在安全隐患。  联合没有这样的问题。[/quote] 但是adt是无法访问函数实现细节的，所以联合不行

引用 3 楼 u014541584 的回复:况且联合很有局限性，没void *自由灵活  错误。用void*存在类型转换，而除了普通指针到void*等少数情况外，C/C++是不保证转换到void*后再转换回原来的类型仍能保证其值不变。说白了，用void*存在安全隐患。  联合没有这样的问题。

说错了，是无法用联合

况且联合很有局限性，没void *自由灵活

引用 1 楼 supermegaboy 的回复:这个方法不好，用联合更好。 我知道不好，但也要讨论下，就事而论吧

这个方法不好，用联合更好。


Question: 为什么the standard C library这么说fgetc和getc的区别？

因为getc往往是用宏实现的，而fgetc是函数实现的。前者优化得更好，所以性能更强。 不过如果你是读标准输入，因为人输入速度比计算机慢得多，所以没什么差别。 此外fgetc可以读地址，也允许i++这样的参数。因为getc是宏实现的，它可能会多次引用参数


Question: 怎样编译各运行包括多个文件的程序

建工程 把.cpp 跟.h的文件拉到工程里 在用到****.h的.cpp文件开头加入#include“*****.h”  （用“ ”而不能用<>） 如果需要用到其他文件里面的函数的话，在文件开头声明使用外部函数 extern 【函数返回值】 【  函数名】【（形参）】；

VC适合初学者，因为有ide. linux下推荐code::blocks

初学者可以从cmake入手,请搜"cmake"

什么意思？没看懂

引用 4 楼 u014517899 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] 搜“跟我一起写makefile”  好吧  我承认没看懂   对于一个刚开始自学c语言的我来说  难！    哦对了  问题错了个字，应是：怎样运行和编译包括多个文件的程序[/quote] 你不知道有IDE这个东西？你不知道可以在IDE里建立工程，makefile什么的给你一次到位？

引用 5 楼 u014517899 的回复:[quote=引用 2 楼 N_sev7 的回复:] 在我们刚一开始学习编程的时候或许我们的工程里面基本上都是一个.cpp和一个.h， 随着工程的规模以及功能的分割等原因我们可能会创建多个CPP.....   不是真的是我上面那样的问题吧   嗯  是滴  今天看到全局变量的时候，书上有这样的例子  但我不知道编译和运行包含多个文件程序的方法，求指教[/quote] 给你推荐个连接，去看看吧http://bbs.csdn.net/topics/360195917

引用 4 楼 u014517899 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] 搜“跟我一起写makefile”  好吧  我承认没看懂   对于一个刚开始自学c语言的我来说  难！    哦对了  问题错了个字，应是：怎样运行和编译包括多个文件的程序[/quote] 有时候学习就需要有“霸王硬上弓”的精神！

引用 2 楼 N_sev7 的回复:在我们刚一开始学习编程的时候或许我们的工程里面基本上都是一个.cpp和一个.h， 随着工程的规模以及功能的分割等原因我们可能会创建多个CPP.....   不是真的是我上面那样的问题吧   嗯  是滴  今天看到全局变量的时候，书上有这样的例子  但我不知道编译和运行包含多个文件程序的方法，求指教

引用 3 楼 zhao4zhong1 的回复:搜“跟我一起写makefile”  好吧  我承认没看懂   对于一个刚开始自学c语言的我来说  难！    哦对了  问题错了个字，应是：怎样运行和编译包括多个文件的程序

搜“跟我一起写makefile”


Question: 求推荐一个数据结构

直接用map<string,int>即可


Question: 通过nm命令和通过readelf命令，我想查找到SO中提供的函数

搜“Name Mangling in C++”

引用 1 楼 zhao4zhong1 的回复:搜“Name Mangling in C++” 还是没说明    通过nm命令和通过readelf命令 得出的函数有什么不同


Question: C语言程序求高手解答，答案是对的，但是通过不了oj

不应使用连续的if 而应使用 if else if else if else

引用 1 楼 zhao4zhong1 的回复:不应使用连续的if 而应使用 if else if else if else 照你的改了还是通过不了在线测试系统。问题应该不在这儿吧


Question: 类似于N皇后问题，菜鸟不知道错在哪，错的有点多

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

仅供参考#include <stdio.h> int d[8][8]; int n; void queen8(int L) {     int x,y;      if (8==L) {         n++;         printf("%d\n",n);         for (y=0;y<8;y++) {             for (x=0;x<8;x++) { //              printf("%d",d[y][x]);                 if (d[y][x]) printf("■");                 else         printf("□");             }             printf("\n");         }         return;     }     for (x=0;x<8;x++) {         for (y=0;y<L;y++) {             if  (              d[y][x      ]              || (x-(L-y)>=0 && d[y][x-(L-y)])              || (x+(L-y)< 8 && d[y][x+(L-y)]))                 break;         }         if (y>=L) {             d[L][x]=1;             queen8(L+1);             d[L][x]=0;         }     } } int main() {     int y,x;     for (y=0;y<8;y++) {         for (x=0;x<8;x++) {             d[y][x]=0;         }     }     queen8(0);     return 0; }

引用 2 楼 wangting627 的回复:int main(int a,int b)  这写法。。 你要不嫌不规范   就把a,b弄成全局变量 简单易懂不会错

int main(int a,int b)  这写法。。

唉，帮都没法帮，错误提示说的这么明白了


Question: 同一个结构体，为什么C++和C输出的结果不同，

不是乱七八糟的代码，其实写的挺清楚了。 不过有个笔误，需要将 printf("%hhu",sEyePoint[0]);   --》  printf("%hhu",xingzhuang[0]); 引用 10 楼 user-3 的回复:struct XingZhuang             {     int    leftTop;         int    rightTop;        int    leftBottom;      int    rigthBottom;        float  pai;  };  struct XingZhuang  xingzhuang[100];  nSample = _TestXingZhuang(xingzhuang);  printf("%hhu",xingzhuang[0]);   什么乱七八糟的代码，贴出完整代码。 另外printf 结构体xingzhuang的第一个元素是什么意思???

引用 3 楼 zhao4zhong1 的回复:两者的对齐设置可能不同。  你好，那我想在进一步咨询下 1.影响运算的过程或者结果吗？ 2.两者的对齐设置不同？？？这个没每明白什么意思

两者的对齐设置可能不同。

你想说明的是，是不是初始化的时候，分配的值是不同的？？  引用 1 楼 zhao4zhong1 的回复:#include <stdio.h> #define field_offset(s,f) (int)(&(((struct s *)(0))->f)) struct AD  { int a; char b[13]; double c;}; #pragma pack(push) #pragma pack(1) struct A1  { int a; char b[13]; double c;}; #pragma pack(2) struct A2  { int a; char b[13]; double c;}; #pragma pack(4) struct A4  { int a; char b[13]; double c;}; #pragma pack(8) struct A8  { int a; char b[13]; double c;}; #pragma pack(16) struct A16 { int a; char b[13]; double c;}; #pragma pack(pop) int main() {     printf("AD.a %d\n",field_offset(AD,a));     printf("AD.b %d\n",field_offset(AD,b));     printf("AD.c %d\n",field_offset(AD,c));     printf("\n");     printf("A1.a %d\n",field_offset(A1,a));     printf("A1.b %d\n",field_offset(A1,b));     printf("A1.c %d\n",field_offset(A1,c));     printf("\n");     printf("A2.a %d\n",field_offset(A2,a));     printf("A2.b %d\n",field_offset(A2,b));     printf("A2.c %d\n",field_offset(A2,c));     printf("\n");     printf("A4.a %d\n",field_offset(A4,a));     printf("A4.b %d\n",field_offset(A4,b));     printf("A4.c %d\n",field_offset(A4,c));     printf("\n");     printf("A8.a %d\n",field_offset(A8,a));     printf("A8.b %d\n",field_offset(A8,b));     printf("A8.c %d\n",field_offset(A8,c));     printf("\n");     printf("A16.a %d\n",field_offset(A16,a));     printf("A16.b %d\n",field_offset(A16,b));     printf("A16.c %d\n",field_offset(A16,c));     printf("\n");     return 0; } //AD.a 0 //AD.b 4 //AD.c 24 // //A1.a 0 //A1.b 4 //A1.c 17 // //A2.a 0 //A2.b 4 //A2.c 18 // //A4.a 0 //A4.b 4 //A4.c 20 // //A8.a 0 //A8.b 4 //A8.c 24 // //A16.a 0 //A16.b 4 //A16.c 24 // //

今天最后一顶

有人知道这是为什么吗？

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

引用 5 楼 mujiok2003 的回复:引用如果在 C      中printf("%hhu",sEyePoint[0]);得出结果64 如果在 C++ 中printf("%hhu",sEyePoint[0]);得出结果32  sEyePoint是什么？ 写错了，应该是xingzhuang【0】


Question: cs模式升级探测程序

还要考虑异常，不要出现还没更新完，版本号已经改了的情况

1. 获取版本号。这个就是存储和读取问题 2. socket通信

server端自己开个线程一段时间就检测一次阿，如果出现新的版本就通知客户端是否升级， 是的话，就升级呗

文件读写都没问题 socket那块忘了怎么用了 有没有大神提供个例子参考下


Question: 急求 UNIX C fopen 277次，第277次fopen core dump，很奇怪！

会不会是打开关闭太频繁，受不了了。

fp1 = fopen(); 打开的指针判断一下有效不有效。。。

fopen 失败时返回的 FILE *是 NULL，这时调用 fclose 会出现段错误。

顶上去！


Question: 正弦信号C语言拓展，基于CORTEX-M3

引用 11 楼 u012586257 的回复:可以啊，主循环里加键检测。不同键就乘不同的系数。可以保留这个内存里的数值表输出时用，另建一个常数表做原始数据。有键按下，则重新计算内存表数据。为了保证一定精度，可以改掉输出时的 <<6，你是16位DAC吧？要确认下计算后数据不会溢出 乘以不同系数之后，有的数值确实在示波器上不能正确的显示出来，16位的DAC可以在参数中存在负数么？为啥我改了负数示波器上显示时负数都被取反成正数了呢？最初的正弦波数据不是以0为基准的，所以乘以倍数后输出信号就错位了，前一段在一个水平线上，后一段则在另一个水平线上，我尝试参数以0为最初值，但那样就有负数了。。。。。。负数让我很纠结啊。。。。。。

引用 7 楼 u012586257 的回复:参数中少了一个}，如果你没少，那可能是多了个；吧 你好，这个要是加上键盘控制怎么弄啊？按KEY1输出一组参数，按KEY2输出另一组参数，以此类推，，，， 为啥我自己整的总是不行呢，达不到自己想要的结果。大神帮帮忙啊！！！

引用 2 楼 u012586257 的回复:想要不同幅值，在输出到DAC之前乘一个系数变换一下就好 你好，这个要是加上键盘控制怎么弄啊？按KEY1输出一组参数，按KEY2输出另一组参数，以此类推，，，， 为啥我自己整的总是不行呢，达不到自己想要的结果。大神帮帮忙啊！！！

引用 1 楼 KenZhang1031 的回复:你把你失败的代码贴上来看看。 你好，这个要是加上键盘控制怎么弄啊？按KEY1输出一组参数，按KEY2输出另一组参数，以此类推，，，， 为啥我自己整的总是不行呢，达不到自己想要的结果。大神帮帮忙啊！！！

参数中少了一个}，如果你没少，那可能是多了个；吧

引用 5 楼 u014627978 的回复:[quote=引用 1 楼 KenZhang1031 的回复:] 你把你失败的代码贴上来看看。  错误程序的代码里参数太多了，我整了300个，然后把volatile uint16_t GusSinTable[45] 改成了volatile uint16_t GusSinTable[300]， 最后面的 for (i = 0; i < 45; i++)  改成了  for (i = 0; i < 300; i++),  300个参数里就是有大于1000的四位数，其它就没啥了。调试时总提示说在参数中少一个“}”，我就不明白了~~~谢谢[/quote]按你描述看，没问题

引用 1 楼 KenZhang1031 的回复:你把你失败的代码贴上来看看。  错误程序的代码里参数太多了，我整了300个，然后把volatile uint16_t GusSinTable[45] 改成了volatile uint16_t GusSinTable[300]， 最后面的 for (i = 0; i < 45; i++)  改成了  for (i = 0; i < 300; i++),  300个参数里就是有大于1000的四位数，其它就没啥了。调试时总提示说在参数中少一个“}”，我就不明白了~~~谢谢

引用 2 楼 u012586257 的回复:想要不同幅值，在输出到DAC之前乘一个系数变换一下就好   方法挺好，可是我这个新手不知道怎么在输出之前变换系数啊，，，，，其实我主要是想输出 f(t)=(t-a)^2*exp[-2(t-a)/65]sin(0.2*pi*t),,,a<t<65+a,这样一个信号。，，，，，，，，谢谢

想要不同幅值，在输出到DAC之前乘一个系数变换一下就好

你把你失败的代码贴上来看看。


Question: C语言怎么导出文档？

doxygen


Question: windows添加账户调用什么api

组策略编辑器gpedit.msc


Question: C基础题

楼上的，谁告诉你们楼主的意思是用printf输出3位小数了……

格式控制字符串修改一下就行了。

其实这个问题不简单。。扩充一下就是二进制整形表示除法操作 如何实现小数点后的精确取位

//Round(1.234,2) = 1.23 //Round(1.234,0) = 1.0 //Round(123.4,-1) = 120.0 double Round(double dVal, short iPlaces) {     double dRetval;     double dMod = 0.0000001;     if (dVal<0.0) dMod=-0.0000001;     dRetval=dVal;     dRetval+=(5.0/pow(10.0,iPlaces+1.0));     dRetval*=pow(10.0,iPlaces);     dRetval=floor(dRetval+dMod);     dRetval/=pow(10.0,iPlaces);     return(dRetval); }  double round(double dVal, short iPlaces) //iPlaces>=0 {     unsigned char s[20];     double dRetval;      sprintf(s,"%.*lf",iPlaces,dVal);     sscanf(s,"%lf",&dRetval);     return (dRetval); }

不错，是这个样子的。。。

这个是保留两位小数的例子，可以自己扩展一下： If you just want to round the number for output purposes, then the "%.2f" format string is indeed the correct answer. However, if you actually want to round the floating point value for further computation, something like the following works:  #include <math.h>  float val = 37.777779;  float rounded_down = floorf(val * 100) / 100;   /* Result: 37.77 */ float nearest = floorf(val * 100 + 0.5) / 100;  /* Result: 37.78 */ float rounded_up = ceilf(val * 100) / 100;      /* Result: 37.78 */ Notice that there are three different rounding rules you might want to choose: round down (ie, truncate after two decimal places), rounded to nearest, and round up. Usually, you want round to nearest.  As several others have pointed out, due to the quirks of floating point representation, these rounded values may not be exactly the "obvious" decimal values, but they will be very very close.  For much (much!) more information on rounding, and especially on tie-breaking rules for rounding to nearest, see the Wikipedia article on Rounding： http://en.wikipedia.org/wiki/Rounding

前面所有楼的答案都是输出结果的前三位小数，不是结果保留三位小数。

这么基本的问题多看教材把

引用 6 楼 u013163178 的回复:scanf("%d %d",&a,&b); printf("%3f",a/b); 正解。 不过最好判断下b!=0

作为一个C程序员，对  scanf,sscanf,fscanf  printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离手，曲不离口”的。

printf("%.3f", ...);

答案： printf("%.3f", a/b);  %f是输出float类型的方法，在前面加“.”再加一个数字，表示小数点后保留的位数。

我去。。。  float a,b; scanf("%f %f",&a,&b); printf("%.3f",a/b);

.3f，格式控制里。。。


Question: 函数能否返回(*)[4]这样的指针

#include<stdio.h> //给每个成员的值都+1 int (*fun(int (*ptr)[4]))[4] {     int i;     int (*p)[4];     p= ptr;     for(i =0; i<4; i++)         (*p[i])++;     return p; } int main(void) {     int a[4] ={2,5,3,6};     printf("%d\n",**fun(&a));      return 0; }  上面这段代码就返回了一个(*)[4]类型的指针，请注意函数原型是如何声明的！

这样的语句也是合法的 return (int *)100;

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步对应汇编一行！  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式的值【比如printf("%p\n",...)】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=...】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “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 //char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组指向了一个指针，该指针指向一个函数，该函数的无参数，返回一个指针，该指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*x000)[5];//返回值     char (*(x00)())[5];//函数原型，参数为空，返回值为指针     char (*(*x0)())[5];//数组的元素，是个函数指针     char (*(*x[3])())[5];//是个数组，大小为3      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf("typeid(x).name() is %s\n",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]

char (*func())[4]

你可以返回一个任意类型的指地, 然后 强制转换即可.

可以，返回的指针只是一个地址，具体还是取决于你怎么用它。不过返回来后，是个二级指针吧

你甚至可写下面的语句 （int *）100


Question: 还是不会正整数读法 直接求码！！！

#include <stdio.h> #include <string.h> char hznum[100]; char hzunit[15][3]={"","十","百","千","万","十","百","千","亿","十","百","千","万","十","百"}; char hzdigit[10][3]={"零","一","二","三","四","五","六","七","八","九"}; char numstr[20]; char *ReadNumByHZ(double v) {     char *p,*d;     int u,i;      sprintf(numstr,"%.15lg",v);     printf("%s\n",numstr);     if ('-'==numstr[0]) {         sprintf(hznum,"不支持读负数");         return hznum;     }     p=strchr(numstr,'e');     if (NULL!=p) {         sprintf(hznum,"不支持读太大或太小的数");         return hznum;     }     d=NULL;     p=strchr(numstr,'.');     if (NULL!=p) {         p[0]=0;         d=p+1;     }     u=strlen(numstr);     hznum[0]=0;     for (i=0;i<u;i++) {         if ('0'==numstr[i] && 0!=((u-1-i)%4)) {             sprintf(hznum,"%s%s",hznum,hzdigit[numstr[i]-'0']);         } else {             sprintf(hznum,"%s%s%s",hznum,hzdigit[numstr[i]-'0'],hzunit[u-1-i]);         }     }     printf("%s\n",hznum);     u=strlen(hznum);     for (i=0;i<u;i+=2) {         if (0==strncmp(hznum+i,"零零",4)) {//多个连续的“零”改成一个“零”             memmove(hznum+i,hznum+i+2,u-i-2+1);             i-=2;             u-=2;         }     }     printf("%s\n",hznum);     if (0==strcmp(hznum+u-2,"零")) {//末尾“零”去掉         hznum[u-2]=0;         u-=2;     }     printf("%s\n",hznum);     for (i=0;i<u;i+=2) {         if (0==strncmp(hznum+i,"零万",4) || 0==strncmp(hznum+i,"零亿",4)) {//“万”“亿”前是“零”去掉             memmove(hznum+i,hznum+i+2,u-i-2+1);             u-=2;         }     }     printf("%s\n",hznum);     if (NULL!=d) {         sprintf(hznum,"%s点",hznum);         i=0;         while (1) {             if (0==d[i]) break;             sprintf(hznum,"%s%s",hznum,hzdigit[d[i]-'0']);             i++;         }     }     printf("%s\n",hznum);     return hznum; } void main() {     printf("\n%s\n",ReadNumByHZ(130040600090.012)); } //130040600090.012 //一千三百零零亿四千零六十零万零零九十零 //一千三百零亿四千零六十零万零九十零 //一千三百零亿四千零六十零万零九十 //一千三百亿四千零六十万零九十 //一千三百亿四千零六十万零九十点零一二 // //一千三百亿四千零六十万零九十点零一二  #include <afx.h> #include <stdio.h> CString ChineseCapitalMoney(double Num) {     CString szChMoney,szNum;     int iLen, iNum, iAddZero=0;     TCHAR* hzUnit[18]={_T("分"),_T("角"),_T("元"),_T("拾"),_T("佰"),_T("仟"),_T("万"),_T("拾"),_T("佰"),_T("仟"),_T("亿"),_T("拾"),_T("佰"),_T("仟"),_T("万"),_T("拾"),_T("佰"),_T("仟")};     TCHAR* hzNum[10]={_T("零"),_T("壹"),_T("贰"),_T("叁"),_T("肆"),_T("伍"),_T("陆"),_T("柒"),_T("捌"),_T("玖")};     if (-0.01<Num && Num<0.01) return _T("零元整");     szNum.Format(_T("%18.0f"), Num*100); // 最小到分     szNum.TrimLeft();     iLen=szNum.GetLength();     if(iLen>15 || iLen==0 || Num<0) return _T(""); // 数据错误返回      for(int i=0;i<iLen;i++) {         iNum=_ttoi((LPCTSTR)szNum.Mid(i,1));         if (iNum==0) {             iAddZero++;         } else {             if (iAddZero>0) szChMoney+=_T("零");             szChMoney+=hzNum[iNum];             iAddZero=0;         }         if (iNum!=0 || iLen-i==3 || iLen-i==11 || ((iLen-i+1)%8==0 && iAddZero<4)) szChMoney+=hzUnit[iLen-i-1];     }     if (szNum.Right(2)==_T("00")) szChMoney+=_T("整"); // 没有角和分     return szChMoney; } void main() {     double d;     CString s;      d=-1.0            ;printf("%16.2f %s\n",d,ChineseCapitalMoney(d));     d=0.0             ;printf("%16.2f %s\n",d,ChineseCapitalMoney(d));     d=1234501234567.89;printf("%16.2f %s\n",d,ChineseCapitalMoney(d));     d=1000000000000.01;printf("%16.2f %s\n",d,ChineseCapitalMoney(d));     d=1000000000001.00;printf("%16.2f %s\n",d,ChineseCapitalMoney(d));     d= 130040600090.01;printf("%16.2f %s\n",d,ChineseCapitalMoney(d)); } //           -1.00 //            0.00 零元整 //1234501234567.89 壹万贰仟叁佰肆拾伍亿零壹佰贰拾叁万肆仟伍佰陆拾柒元捌角玖分 //1000000000000.01 壹万亿元零壹分 //1000000000001.00 壹万亿零壹元整 // 130040600090.01 壹仟叁佰亿零肆仟零陆拾万零玖拾元零壹分

1楼同学能不能给几行例子？

可以给你提供思路：1，把这个整数转化成字符数组，然后对每一位的数字进行读取，用到switch case。 2,，计算出每位 的数字，可以通过取余的方法，当然可以用你想的到的方法。


Question: 如何在apache代码中添加一个函数来处理表单信息

自己在顶一下。

楼主可能需要的cgi程序，google下看怎么写，编译成executable文件放到apache相应的目录下。 PS：都写好页面了，页面所用语言不可以处理这个吗？

发错版块了吧，另外我很惊奇这是怎么做到的？


Question: bash命令为什么可以-version啊

引用 7 楼 It_way 的回复:[quote=引用 6 楼 u013666035 的回复:] [quote=引用 5 楼 u013344873 的回复:] http://ftp.gnu.org/gnu/bash/  [DIR] Parent Directory                                   -    [DIR] bash-2.05b-patches/           02-Aug-2003 07:07    -    [DIR] bash-3.0-patches/             14-Feb-2005 15:35    -    [DIR] bash-3.1-patches/             12-Apr-2006 11:30    -    [DIR] bash-3.2-patches/             17-Mar-2010 10:15    -    [DIR] bash-4.0-patches/             20-Mar-2010 17:50    -    [DIR] bash-4.1-patches/             04-May-2011 22:20    -    [DIR] bash-4.2-patches/             31-Mar-2014 16:55    -    [DIR] bash-4.3-patches/             28-Mar-2014 11:20    -    [   ] bash-1.14.0-1.14.1.diff.gz    08-Jul-1994 03:00   27K   [TXT] bash-1.14.1-1.14.2.diff       23-Aug-1994 03:00  304K   [TXT] bash-1.14.2-1.14.3.diff       04-Jan-1995 03:00  105K   [   ] bash-1.14.3-1.14.4.diff.gz    19-Apr-1995 03:00   11K   [   ] bash-1.14.4-1.14.5.diffs      18-Jul-1995 03:00  116K   [   ] bash-1.14.5-1.14.6.diff.gz    19-Dec-1995 03:00   13K   [   ] bash-1.14.5.diffs-from-GNU-CD 18-Jul-1995 03:00  2.6K   [   ] bash-1.14.6-1.14.7.diff.gz    29-Aug-1996 03:00  587    [   ] bash-1.14.7.tar.gz            29-Aug-1996 03:00  1.4M   [   ] bash-2.0-2.01.diff.gz         05-Jun-1997 03:00  334K   [   ] bash-2.0.tar.gz               31-Dec-1996 03:00  1.3M   [   ] bash-2.01-2.01.1.diff.gz      02-Oct-1997 03:00   62K   [   ] bash-2.01.1-2.02.diff.gz      18-Apr-1998 03:00  523K   [   ] bash-2.01.1.tar.gz            02-Oct-1997 03:00  1.3M   [   ] bash-2.01.tar.gz              05-Jun-1997 03:00  1.3M   [   ] bash-2.02-2.02.1.diff.gz      23-Jul-1998 20:14  9.2K   [   ] bash-2.02.1-2.03.diff.gz      19-Feb-1999 16:42  187K   [   ] bash-2.02.1.tar.gz            23-Jul-1998 20:14  1.4M   [   ] bash-2.02.tar.gz              18-Apr-1998 03:00  1.4M   [   ] bash-2.03.tar.gz              19-Feb-1999 16:13  1.5M   [   ] bash-2.04-2.05.diff.gz        09-Apr-2001 13:41  511K   [   ] bash-2.04.tar.gz              21-Mar-2000 11:04  1.6M   [   ] bash-2.05-2.05a.diff.gz       16-Nov-2001 14:55  685K   [   ] bash-2.05.tar.gz              09-Apr-2001 13:40  1.7M   [   ] bash-2.05a-2.05b.diff.gz      17-Jul-2002 14:56  573K   [   ] bash-2.05a.tar.gz             16-Nov-2001 14:55  1.7M   [   ] bash-2.05b-3.0.diff.gz        03-Aug-2004 16:07  968K   [   ] bash-2.05b-3.0.diff.gz.sig    03-Aug-2004 16:07   65    [   ] bash-2.05b.tar.gz             17-Jul-2002 14:56  1.9M   [   ] bash-3.0.16.tar.gz            07-Dec-2005 15:03  2.3M   [   ] bash-3.0.16.tar.gz.sig        07-Dec-2005 15:03   65    [   ] bash-3.0.tar.gz               03-Aug-2004 16:07  2.3M   [   ] bash-3.0.tar.gz.sig           03-Aug-2004 16:07   65    [   ] bash-3.1.tar.gz               08-Dec-2005 11:51  2.4M   [   ] bash-3.1.tar.gz.sig           08-Dec-2005 11:51   65    [   ] bash-3.2.48.tar.gz            17-Mar-2009 12:31  2.4M   [   ] bash-3.2.48.tar.gz.sig        17-Mar-2009 12:31   65    [   ] bash-3.2.tar.gz               11-Oct-2006 12:11  2.4M   [   ] bash-3.2.tar.gz.sig           11-Oct-2006 12:11   65    [   ] bash-4.0-rc1.tar.gz           12-Jan-2009 11:54  3.8M   [   ] bash-4.0-rc1.tar.gz.sig       12-Jan-2009 11:55   65    [   ] bash-4.0.tar.gz               20-Feb-2009 15:09  5.9M   [   ] bash-4.0.tar.gz.sig           20-Feb-2009 15:09   65    [   ] bash-4.1.tar.gz               31-Dec-2009 21:51  6.3M   [   ] bash-4.1.tar.gz.sig           31-Dec-2009 21:51   65    [   ] bash-4.2.tar.gz               13-Feb-2011 15:50  6.7M   [   ] bash-4.2.tar.gz.sig           13-Feb-2011 15:50   65    [   ] bash-4.3.tar.gz               26-Feb-2014 09:25  7.6M   [   ] bash-4.3.tar.gz.sig           26-Feb-2014 09:25   72    [   ] bash-doc-2.0.tar.gz           31-Dec-1996 03:00  933K   [   ] bash-doc-2.01.tar.gz          05-Jun-1997 03:00  940K   [   ] bash-doc-2.02.tar.gz          18-Apr-1998 03:00  1.0M   [   ] bash-doc-2.03.tar.gz          19-Feb-1999 16:16  1.0M   [   ] bash-doc-2.04.tar.gz          21-Mar-2000 11:05  887K   [   ] bash-doc-2.05.tar.gz          09-Apr-2001 13:41  860K   [   ] bash-doc-2.05a.tar.gz         16-Nov-2001 14:53  889K   [   ] bash-doc-2.05b.tar.gz         17-Jul-2002 14:56  1.7M   [   ] bash-doc-3.0.tar.gz           03-Aug-2004 16:07  1.9M   [   ] bash-doc-3.0.tar.gz.sig       03-Aug-2004 16:07   65    [   ] bash-doc-3.1.tar.gz           08-Dec-2005 11:52  2.0M   [   ] bash-doc-3.1.tar.gz.sig       08-Dec-2005 11:52   65    [   ] bash-doc-3.2.tar.gz           11-Oct-2006 12:12  2.1M   [   ] bash-doc-3.2.tar.gz.sig       11-Oct-2006 12:12   65    [   ] bashref.texi.gz               21-Mar-2000 11:05   64K   [   ] readline-5.0.5.tar.gz         07-Dec-2005 15:03  1.7M   [   ] readline-5.0.5.tar.gz.sig     07-Dec-2005 15:03   65    [   ] readline-5.1.tar.gz           08-Dec-2005 11:53  1.9M   [   ] readline-5.1.tar.gz.sig       08-Dec-2005 11:53   65       http://ftp.gnu.org/gnu/bash/  这个是gnu的，不是redhat的，redhat的bash源码在什么地方啊[/quote]  这个问题不是象在问： 这个是 windows 平台的 ISO C， 有 linux 平台的 ISO C 吗？[/quote]  这个类比不怎么恰当。 ISO C不给出参考实现。 GNU的软件官方给下载的，发行版也可能往上面打补丁。

引用 6 楼 u013666035 的回复:[quote=引用 5 楼 u013344873 的回复:] http://ftp.gnu.org/gnu/bash/  [DIR] Parent Directory                                   -    [DIR] bash-2.05b-patches/           02-Aug-2003 07:07    -    [DIR] bash-3.0-patches/             14-Feb-2005 15:35    -    [DIR] bash-3.1-patches/             12-Apr-2006 11:30    -    [DIR] bash-3.2-patches/             17-Mar-2010 10:15    -    [DIR] bash-4.0-patches/             20-Mar-2010 17:50    -    [DIR] bash-4.1-patches/             04-May-2011 22:20    -    [DIR] bash-4.2-patches/             31-Mar-2014 16:55    -    [DIR] bash-4.3-patches/             28-Mar-2014 11:20    -    [   ] bash-1.14.0-1.14.1.diff.gz    08-Jul-1994 03:00   27K   [TXT] bash-1.14.1-1.14.2.diff       23-Aug-1994 03:00  304K   [TXT] bash-1.14.2-1.14.3.diff       04-Jan-1995 03:00  105K   [   ] bash-1.14.3-1.14.4.diff.gz    19-Apr-1995 03:00   11K   [   ] bash-1.14.4-1.14.5.diffs      18-Jul-1995 03:00  116K   [   ] bash-1.14.5-1.14.6.diff.gz    19-Dec-1995 03:00   13K   [   ] bash-1.14.5.diffs-from-GNU-CD 18-Jul-1995 03:00  2.6K   [   ] bash-1.14.6-1.14.7.diff.gz    29-Aug-1996 03:00  587    [   ] bash-1.14.7.tar.gz            29-Aug-1996 03:00  1.4M   [   ] bash-2.0-2.01.diff.gz         05-Jun-1997 03:00  334K   [   ] bash-2.0.tar.gz               31-Dec-1996 03:00  1.3M   [   ] bash-2.01-2.01.1.diff.gz      02-Oct-1997 03:00   62K   [   ] bash-2.01.1-2.02.diff.gz      18-Apr-1998 03:00  523K   [   ] bash-2.01.1.tar.gz            02-Oct-1997 03:00  1.3M   [   ] bash-2.01.tar.gz              05-Jun-1997 03:00  1.3M   [   ] bash-2.02-2.02.1.diff.gz      23-Jul-1998 20:14  9.2K   [   ] bash-2.02.1-2.03.diff.gz      19-Feb-1999 16:42  187K   [   ] bash-2.02.1.tar.gz            23-Jul-1998 20:14  1.4M   [   ] bash-2.02.tar.gz              18-Apr-1998 03:00  1.4M   [   ] bash-2.03.tar.gz              19-Feb-1999 16:13  1.5M   [   ] bash-2.04-2.05.diff.gz        09-Apr-2001 13:41  511K   [   ] bash-2.04.tar.gz              21-Mar-2000 11:04  1.6M   [   ] bash-2.05-2.05a.diff.gz       16-Nov-2001 14:55  685K   [   ] bash-2.05.tar.gz              09-Apr-2001 13:40  1.7M   [   ] bash-2.05a-2.05b.diff.gz      17-Jul-2002 14:56  573K   [   ] bash-2.05a.tar.gz             16-Nov-2001 14:55  1.7M   [   ] bash-2.05b-3.0.diff.gz        03-Aug-2004 16:07  968K   [   ] bash-2.05b-3.0.diff.gz.sig    03-Aug-2004 16:07   65    [   ] bash-2.05b.tar.gz             17-Jul-2002 14:56  1.9M   [   ] bash-3.0.16.tar.gz            07-Dec-2005 15:03  2.3M   [   ] bash-3.0.16.tar.gz.sig        07-Dec-2005 15:03   65    [   ] bash-3.0.tar.gz               03-Aug-2004 16:07  2.3M   [   ] bash-3.0.tar.gz.sig           03-Aug-2004 16:07   65    [   ] bash-3.1.tar.gz               08-Dec-2005 11:51  2.4M   [   ] bash-3.1.tar.gz.sig           08-Dec-2005 11:51   65    [   ] bash-3.2.48.tar.gz            17-Mar-2009 12:31  2.4M   [   ] bash-3.2.48.tar.gz.sig        17-Mar-2009 12:31   65    [   ] bash-3.2.tar.gz               11-Oct-2006 12:11  2.4M   [   ] bash-3.2.tar.gz.sig           11-Oct-2006 12:11   65    [   ] bash-4.0-rc1.tar.gz           12-Jan-2009 11:54  3.8M   [   ] bash-4.0-rc1.tar.gz.sig       12-Jan-2009 11:55   65    [   ] bash-4.0.tar.gz               20-Feb-2009 15:09  5.9M   [   ] bash-4.0.tar.gz.sig           20-Feb-2009 15:09   65    [   ] bash-4.1.tar.gz               31-Dec-2009 21:51  6.3M   [   ] bash-4.1.tar.gz.sig           31-Dec-2009 21:51   65    [   ] bash-4.2.tar.gz               13-Feb-2011 15:50  6.7M   [   ] bash-4.2.tar.gz.sig           13-Feb-2011 15:50   65    [   ] bash-4.3.tar.gz               26-Feb-2014 09:25  7.6M   [   ] bash-4.3.tar.gz.sig           26-Feb-2014 09:25   72    [   ] bash-doc-2.0.tar.gz           31-Dec-1996 03:00  933K   [   ] bash-doc-2.01.tar.gz          05-Jun-1997 03:00  940K   [   ] bash-doc-2.02.tar.gz          18-Apr-1998 03:00  1.0M   [   ] bash-doc-2.03.tar.gz          19-Feb-1999 16:16  1.0M   [   ] bash-doc-2.04.tar.gz          21-Mar-2000 11:05  887K   [   ] bash-doc-2.05.tar.gz          09-Apr-2001 13:41  860K   [   ] bash-doc-2.05a.tar.gz         16-Nov-2001 14:53  889K   [   ] bash-doc-2.05b.tar.gz         17-Jul-2002 14:56  1.7M   [   ] bash-doc-3.0.tar.gz           03-Aug-2004 16:07  1.9M   [   ] bash-doc-3.0.tar.gz.sig       03-Aug-2004 16:07   65    [   ] bash-doc-3.1.tar.gz           08-Dec-2005 11:52  2.0M   [   ] bash-doc-3.1.tar.gz.sig       08-Dec-2005 11:52   65    [   ] bash-doc-3.2.tar.gz           11-Oct-2006 12:12  2.1M   [   ] bash-doc-3.2.tar.gz.sig       11-Oct-2006 12:12   65    [   ] bashref.texi.gz               21-Mar-2000 11:05   64K   [   ] readline-5.0.5.tar.gz         07-Dec-2005 15:03  1.7M   [   ] readline-5.0.5.tar.gz.sig     07-Dec-2005 15:03   65    [   ] readline-5.1.tar.gz           08-Dec-2005 11:53  1.9M   [   ] readline-5.1.tar.gz.sig       08-Dec-2005 11:53   65       http://ftp.gnu.org/gnu/bash/  这个是gnu的，不是redhat的，redhat的bash源码在什么地方啊[/quote]  这个问题不是象在问： 这个是 windows 平台的 ISO C， 有 linux 平台的 ISO C 吗？

引用 5 楼 u013344873 的回复:http://ftp.gnu.org/gnu/bash/  [DIR] Parent Directory                                   -    [DIR] bash-2.05b-patches/           02-Aug-2003 07:07    -    [DIR] bash-3.0-patches/             14-Feb-2005 15:35    -    [DIR] bash-3.1-patches/             12-Apr-2006 11:30    -    [DIR] bash-3.2-patches/             17-Mar-2010 10:15    -    [DIR] bash-4.0-patches/             20-Mar-2010 17:50    -    [DIR] bash-4.1-patches/             04-May-2011 22:20    -    [DIR] bash-4.2-patches/             31-Mar-2014 16:55    -    [DIR] bash-4.3-patches/             28-Mar-2014 11:20    -    [   ] bash-1.14.0-1.14.1.diff.gz    08-Jul-1994 03:00   27K   [TXT] bash-1.14.1-1.14.2.diff       23-Aug-1994 03:00  304K   [TXT] bash-1.14.2-1.14.3.diff       04-Jan-1995 03:00  105K   [   ] bash-1.14.3-1.14.4.diff.gz    19-Apr-1995 03:00   11K   [   ] bash-1.14.4-1.14.5.diffs      18-Jul-1995 03:00  116K   [   ] bash-1.14.5-1.14.6.diff.gz    19-Dec-1995 03:00   13K   [   ] bash-1.14.5.diffs-from-GNU-CD 18-Jul-1995 03:00  2.6K   [   ] bash-1.14.6-1.14.7.diff.gz    29-Aug-1996 03:00  587    [   ] bash-1.14.7.tar.gz            29-Aug-1996 03:00  1.4M   [   ] bash-2.0-2.01.diff.gz         05-Jun-1997 03:00  334K   [   ] bash-2.0.tar.gz               31-Dec-1996 03:00  1.3M   [   ] bash-2.01-2.01.1.diff.gz      02-Oct-1997 03:00   62K   [   ] bash-2.01.1-2.02.diff.gz      18-Apr-1998 03:00  523K   [   ] bash-2.01.1.tar.gz            02-Oct-1997 03:00  1.3M   [   ] bash-2.01.tar.gz              05-Jun-1997 03:00  1.3M   [   ] bash-2.02-2.02.1.diff.gz      23-Jul-1998 20:14  9.2K   [   ] bash-2.02.1-2.03.diff.gz      19-Feb-1999 16:42  187K   [   ] bash-2.02.1.tar.gz            23-Jul-1998 20:14  1.4M   [   ] bash-2.02.tar.gz              18-Apr-1998 03:00  1.4M   [   ] bash-2.03.tar.gz              19-Feb-1999 16:13  1.5M   [   ] bash-2.04-2.05.diff.gz        09-Apr-2001 13:41  511K   [   ] bash-2.04.tar.gz              21-Mar-2000 11:04  1.6M   [   ] bash-2.05-2.05a.diff.gz       16-Nov-2001 14:55  685K   [   ] bash-2.05.tar.gz              09-Apr-2001 13:40  1.7M   [   ] bash-2.05a-2.05b.diff.gz      17-Jul-2002 14:56  573K   [   ] bash-2.05a.tar.gz             16-Nov-2001 14:55  1.7M   [   ] bash-2.05b-3.0.diff.gz        03-Aug-2004 16:07  968K   [   ] bash-2.05b-3.0.diff.gz.sig    03-Aug-2004 16:07   65    [   ] bash-2.05b.tar.gz             17-Jul-2002 14:56  1.9M   [   ] bash-3.0.16.tar.gz            07-Dec-2005 15:03  2.3M   [   ] bash-3.0.16.tar.gz.sig        07-Dec-2005 15:03   65    [   ] bash-3.0.tar.gz               03-Aug-2004 16:07  2.3M   [   ] bash-3.0.tar.gz.sig           03-Aug-2004 16:07   65    [   ] bash-3.1.tar.gz               08-Dec-2005 11:51  2.4M   [   ] bash-3.1.tar.gz.sig           08-Dec-2005 11:51   65    [   ] bash-3.2.48.tar.gz            17-Mar-2009 12:31  2.4M   [   ] bash-3.2.48.tar.gz.sig        17-Mar-2009 12:31   65    [   ] bash-3.2.tar.gz               11-Oct-2006 12:11  2.4M   [   ] bash-3.2.tar.gz.sig           11-Oct-2006 12:11   65    [   ] bash-4.0-rc1.tar.gz           12-Jan-2009 11:54  3.8M   [   ] bash-4.0-rc1.tar.gz.sig       12-Jan-2009 11:55   65    [   ] bash-4.0.tar.gz               20-Feb-2009 15:09  5.9M   [   ] bash-4.0.tar.gz.sig           20-Feb-2009 15:09   65    [   ] bash-4.1.tar.gz               31-Dec-2009 21:51  6.3M   [   ] bash-4.1.tar.gz.sig           31-Dec-2009 21:51   65    [   ] bash-4.2.tar.gz               13-Feb-2011 15:50  6.7M   [   ] bash-4.2.tar.gz.sig           13-Feb-2011 15:50   65    [   ] bash-4.3.tar.gz               26-Feb-2014 09:25  7.6M   [   ] bash-4.3.tar.gz.sig           26-Feb-2014 09:25   72    [   ] bash-doc-2.0.tar.gz           31-Dec-1996 03:00  933K   [   ] bash-doc-2.01.tar.gz          05-Jun-1997 03:00  940K   [   ] bash-doc-2.02.tar.gz          18-Apr-1998 03:00  1.0M   [   ] bash-doc-2.03.tar.gz          19-Feb-1999 16:16  1.0M   [   ] bash-doc-2.04.tar.gz          21-Mar-2000 11:05  887K   [   ] bash-doc-2.05.tar.gz          09-Apr-2001 13:41  860K   [   ] bash-doc-2.05a.tar.gz         16-Nov-2001 14:53  889K   [   ] bash-doc-2.05b.tar.gz         17-Jul-2002 14:56  1.7M   [   ] bash-doc-3.0.tar.gz           03-Aug-2004 16:07  1.9M   [   ] bash-doc-3.0.tar.gz.sig       03-Aug-2004 16:07   65    [   ] bash-doc-3.1.tar.gz           08-Dec-2005 11:52  2.0M   [   ] bash-doc-3.1.tar.gz.sig       08-Dec-2005 11:52   65    [   ] bash-doc-3.2.tar.gz           11-Oct-2006 12:12  2.1M   [   ] bash-doc-3.2.tar.gz.sig       11-Oct-2006 12:12   65    [   ] bashref.texi.gz               21-Mar-2000 11:05   64K   [   ] readline-5.0.5.tar.gz         07-Dec-2005 15:03  1.7M   [   ] readline-5.0.5.tar.gz.sig     07-Dec-2005 15:03   65    [   ] readline-5.1.tar.gz           08-Dec-2005 11:53  1.9M   [   ] readline-5.1.tar.gz.sig       08-Dec-2005 11:53   65       http://ftp.gnu.org/gnu/bash/  这个是gnu的，不是redhat的，redhat的bash源码在什么地方啊

引用 2 楼 luciferisnotsatan 的回复:这些就是一个个参数，可能bash代码里也认-version  bash源代码的官方下载地址是什么啊

引用 1 楼 zhao4zhong1 的回复:Linux不是号称都有对应的源代码吗？看看不就明白了。  csdn下载里找了个3.2版的源码，搜了下，确实有  不过没找到2.05版的，有没有官方的下载地址啊

这些就是一个个参数，可能bash代码里也认-version

Linux不是号称都有对应的源代码吗？看看不就明白了。


Question: 阻塞套接字和非阻塞套接字的奇怪问题，大侠进。

引用 6 楼 zyb522 的回复:首先非常感谢各位的回复，但是请大家看好帖子的内容啊，我搞socket这块有一段时间了，对EAGAIN等errno的处理等等早就明白了，现在的问题是，问什么连接同一个server，可以从阻塞的套接字接收到数据，而非阻塞的就一直返回-1, errno == EAGAIN，我只是接收几个字符串。 说明server端没有数据可读。

http://bbs.csdn.net/topics/390374955 参考MSDN98\SAMPLES\VC98\SDK\NETDS\WINSOCK\SIMPLE\*.*

非阻塞我个人感觉是不是应该去check errno != EAGAIN的情况呢 我不太清楚

引用 1 楼 max_min_ 的回复:在非阻塞模式下 返回EAGAIN是正常情况的！没有可读数据而已！继续recv就好！  我就是继续recv的  我把recv放到while（1）当中recv的，只要是EAGAIN，就直接continue ，

我这问题难道太简单了，大侠都不屑？？？


Question: 为何不加f的时候累加的0.2会有那么大的精度误差？

不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！ #include <stdio.h> #include <stdlib.h> #include <string.h> float f; double d; void showf() {     char bs[65];     char b[65];     unsigned char *p;     char e[12];     char *t;     int ex;      printf("\nf=%.6f\n",f);     p=(unsigned char *)&f;     printf("hex=%02X %02X %02X %02X\n",p[3],p[2],p[1],p[0]);     ltoa(*(long *)&f,b,2);     sprintf(bs,"%032s",b);     printf("bin=%s\n",bs);     printf("bin=%.1s %.8s   %s\n",bs,bs+1,bs+9);     strncpy(e,bs+1,8);e[8]=0;     ex=strtol(e,&t,2);     printf("    %c %-4d-127 1.%s\n",(bs[0]=='0')?'+':'-',ex,bs+9);     ex-=127;     printf("    %c %-8d 1.%s\n",(bs[0]=='0')?'+':'-',ex,bs+9); } void showd() {     char bs[65];     char b[65];     unsigned char *p;     char e[12];     char *t;     int ex;      printf("\nd=%.15lf\n",d);     p=(unsigned char *)&d;     printf("hex=%02X %02X %02X %02X %02X %02X %02X %02X\n",p[7],p[6],p[5],p[4],p[3],p[2],p[1],p[0]);     _i64toa(*(__int64 *)&d,b,2);     sprintf(bs,"%064s",b);     printf("bin=%s\n",bs);     printf("bin=%.1s %.11s   %s\n",bs,bs+1,bs+12);     strncpy(e,bs+1,11);e[11]=0;     ex=strtol(e,&t,2);     printf("    %c %-6d-1023 1.%s\n",(bs[0]=='0')?'+':'-',ex,bs+12);     ex-=1023;     printf("    %c %-11d 1.%s\n",(bs[0]=='0')?'+':'-',ex,bs+12); } int main() {      for (f=0.0f;f<=2.2f;f+=0.2f) showf();     printf("------------\n");     f=2.0f;showf();     printf("-----------------------------------\n");     for (d=0.0 ;d<=2.2 ;d+=0.2 ) showd();     printf("------------\n");     d=2.0 ;showd();      return 0; } // //f=0.000000 //hex=00 00 00 00 //bin=00000000000000000000000000000000 //bin=0 00000000   00000000000000000000000 //  + 0   -127 1.00000000000000000000000 //  + -127     1.00000000000000000000000 // //f=0.200000 //hex=3E 4C CC CD //bin=00111110010011001100110011001101 //bin=0 01111100   10011001100110011001101 //  + 124 -127 1.10011001100110011001101 //  + -3       1.10011001100110011001101 // //f=0.400000 //hex=3E CC CC CD //bin=00111110110011001100110011001101 //bin=0 01111101   10011001100110011001101 //  + 125 -127 1.10011001100110011001101 //  + -2       1.10011001100110011001101 // //f=0.600000 //hex=3F 19 99 9A //bin=00111111000110011001100110011010 //bin=0 01111110   00110011001100110011010 //  + 126 -127 1.00110011001100110011010 //  + -1       1.00110011001100110011010 // //f=0.800000 //hex=3F 4C CC CD //bin=00111111010011001100110011001101 //bin=0 01111110   10011001100110011001101 //  + 126 -127 1.10011001100110011001101 //  + -1       1.10011001100110011001101 // //f=1.000000 //hex=3F 80 00 00 //bin=00111111100000000000000000000000 //bin=0 01111111   00000000000000000000000 //  + 127 -127 1.00000000000000000000000 //  + 0        1.00000000000000000000000 // //f=1.200000 //hex=3F 99 99 9A //bin=00111111100110011001100110011010 //bin=0 01111111   00110011001100110011010 //  + 127 -127 1.00110011001100110011010 //  + 0        1.00110011001100110011010 // //f=1.400000 //hex=3F B3 33 34 //bin=00111111101100110011001100110100 //bin=0 01111111   01100110011001100110100 //  + 127 -127 1.01100110011001100110100 //  + 0        1.01100110011001100110100 // //f=1.600000 //hex=3F CC CC CE //bin=00111111110011001100110011001110 //bin=0 01111111   10011001100110011001110 //  + 127 -127 1.10011001100110011001110 //  + 0        1.10011001100110011001110 // //f=1.800000 //hex=3F E6 66 68 //bin=00111111111001100110011001101000 //bin=0 01111111   11001100110011001101000 //  + 127 -127 1.11001100110011001101000 //  + 0        1.11001100110011001101000 // //f=2.000000 //hex=40 00 00 01 //bin=01000000000000000000000000000001 //bin=0 10000000   00000000000000000000001 //  + 128 -127 1.00000000000000000000001 //  + 1        1.00000000000000000000001 //------------ // //f=2.000000 //hex=40 00 00 00 //bin=01000000000000000000000000000000 //bin=0 10000000   00000000000000000000000 //  + 128 -127 1.00000000000000000000000 //  + 1        1.00000000000000000000000 //----------------------------------- // //d=0.000000000000000 //hex=00 00 00 00 00 00 00 00 //bin=0000000000000000000000000000000000000000000000000000000000000000 //bin=0 00000000000   0000000000000000000000000000000000000000000000000000 //  + 0     -1023 1.0000000000000000000000000000000000000000000000000000 //  + -1023       1.0000000000000000000000000000000000000000000000000000 // //d=0.200000000000000 //hex=3F C9 99 99 99 99 99 9A //bin=0011111111001001100110011001100110011001100110011001100110011010 //bin=0 01111111100   1001100110011001100110011001100110011001100110011010 //  + 1020  -1023 1.1001100110011001100110011001100110011001100110011010 //  + -3          1.1001100110011001100110011001100110011001100110011010 // //d=0.400000000000000 //hex=3F D9 99 99 99 99 99 9A //bin=0011111111011001100110011001100110011001100110011001100110011010 //bin=0 01111111101   1001100110011001100110011001100110011001100110011010 //  + 1021  -1023 1.1001100110011001100110011001100110011001100110011010 //  + -2          1.1001100110011001100110011001100110011001100110011010 // //d=0.600000000000000 //hex=3F E3 33 33 33 33 33 34 //bin=0011111111100011001100110011001100110011001100110011001100110100 //bin=0 01111111110   0011001100110011001100110011001100110011001100110100 //  + 1022  -1023 1.0011001100110011001100110011001100110011001100110100 //  + -1          1.0011001100110011001100110011001100110011001100110100 // //d=0.800000000000000 //hex=3F E9 99 99 99 99 99 9A //bin=0011111111101001100110011001100110011001100110011001100110011010 //bin=0 01111111110   1001100110011001100110011001100110011001100110011010 //  + 1022  -1023 1.1001100110011001100110011001100110011001100110011010 //  + -1          1.1001100110011001100110011001100110011001100110011010 // //d=1.000000000000000 //hex=3F F0 00 00 00 00 00 00 //bin=0011111111110000000000000000000000000000000000000000000000000000 //bin=0 01111111111   0000000000000000000000000000000000000000000000000000 //  + 1023  -1023 1.0000000000000000000000000000000000000000000000000000 //  + 0           1.0000000000000000000000000000000000000000000000000000 // //d=1.200000000000000 //hex=3F F3 33 33 33 33 33 33 //bin=0011111111110011001100110011001100110011001100110011001100110011 //bin=0 01111111111   0011001100110011001100110011001100110011001100110011 //  + 1023  -1023 1.0011001100110011001100110011001100110011001100110011 //  + 0           1.0011001100110011001100110011001100110011001100110011 // //d=1.400000000000000 //hex=3F F6 66 66 66 66 66 66 //bin=0011111111110110011001100110011001100110011001100110011001100110 //bin=0 01111111111   0110011001100110011001100110011001100110011001100110 //  + 1023  -1023 1.0110011001100110011001100110011001100110011001100110 //  + 0           1.0110011001100110011001100110011001100110011001100110 // //d=1.600000000000000 //hex=3F F9 99 99 99 99 99 99 //bin=0011111111111001100110011001100110011001100110011001100110011001 //bin=0 01111111111   1001100110011001100110011001100110011001100110011001 //  + 1023  -1023 1.1001100110011001100110011001100110011001100110011001 //  + 0           1.1001100110011001100110011001100110011001100110011001 // //d=1.800000000000000 //hex=3F FC CC CC CC CC CC CC //bin=0011111111111100110011001100110011001100110011001100110011001100 //bin=0 01111111111   1100110011001100110011001100110011001100110011001100 //  + 1023  -1023 1.1100110011001100110011001100110011001100110011001100 //  + 0           1.1100110011001100110011001100110011001100110011001100 // //d=2.000000000000000 //hex=3F FF FF FF FF FF FF FF //bin=0011111111111111111111111111111111111111111111111111111111111111 //bin=0 01111111111   1111111111111111111111111111111111111111111111111111 //  + 1023  -1023 1.1111111111111111111111111111111111111111111111111111 //  + 0           1.1111111111111111111111111111111111111111111111111111 // //d=2.200000000000000 //hex=40 01 99 99 99 99 99 99 //bin=0100000000000001100110011001100110011001100110011001100110011001 //bin=0 10000000000   0001100110011001100110011001100110011001100110011001 //  + 1024  -1023 1.0001100110011001100110011001100110011001100110011001 //  + 1           1.0001100110011001100110011001100110011001100110011001 //------------ // //d=2.000000000000000 //hex=40 00 00 00 00 00 00 00 //bin=0100000000000000000000000000000000000000000000000000000000000000 //bin=0 10000000000   0000000000000000000000000000000000000000000000000000 //  + 1024  -1023 1.0000000000000000000000000000000000000000000000000000 //  + 1           1.0000000000000000000000000000000000000000000000000000 //

引用 14 楼 RisJazz 的回复:吾晓得侬港萨了。  最后一次循环。 当x加到 2.0的时候， 为什么 x < 2.0 判断为真。 浮点数计算有精度损失，在工程项目中，遇到判断浮点数边界的时候，一般会加一个精度阈值。  要判断一个浮点数是否小于 2.0 ，一般这么写：  const double THRESHOLD = 1.0e-10; // 判断数值精确到10的-10次方。 if (x < 2.0 + THRESHOLD)  你的意思我明白了。 还是浮点数在计算时的精度损失导致了一系列误差的出现。  我纠结的是： 1. 为何精度损失是会变小 2. 双精度精确到小数点后15位，10的-10次方是小数点后10位，这个计算时的精度损失到底是怎么一种逻辑和机制导致精度损失，而且小到小数点后10位到15位之间呢？  感谢你的解惑：-）

引用 13 楼 handsomekyle 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] http://bbs.csdn.net/topics/390676437   计算机小数并不能完全精确地表示十进制小数，但是在判断的时候或者计算的时候，立即数2.0和0.2为step累加到2.0两个数的区别在哪里呢？为何会比立即数小呢？[/quote] 2.0可以精确表示 0.2不行

引用 3 楼 zhao4zhong1 的回复:http://bbs.csdn.net/topics/390676437   计算机小数并不能完全精确地表示十进制小数，但是在判断的时候或者计算的时候，立即数2.0和0.2为step累加到2.0两个数的区别在哪里呢？为何会比立即数小呢？

引用 10 楼 handsomekyle 的回复:加f导致强制转换的问题倒明白，关键是如果不加f的话，都是double型，却会打印出2.000000是为何呢？  呃，你是说小数点后几位吗？   double x = 2.0; printf("%.1\n", x);        // 打印小数点后一位。 printf("%.15\n", x);      // 打印小数点后15位。 printf("%5.15\n", x);     // 打印小数点前5位，小数点后15位。

引用 7 楼 zhao4zhong1 的回复:C++ Integer Constants Integer constants are constant data elements that have no fractional parts or exponents. They always begin with a digit. You can specify integer constants in decimal, octal, or hexadecimal form. They can specify signed or unsigned types and long or short types.  Syntax  integer-constant :  decimal-constant integer-suffixopt octal-constant integer-suffixopt hexadecimal-constant integer-suffixopt 'c-char-sequence'  decimal-constant :  nonzero-digit decimal-constant digit  octal-constant :  0 octal-constant octal-digit  hexadecimal-constant :  0x hexadecimal-digit 0X hexadecimal-digit hexadecimal-constant hexadecimal-digit  nonzero-digit : one of  1 2 3 4 5 6 7 8 9  octal-digit : one of  0 1 2 3 4 5 6 7  hexadecimal-digit : one of  0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F  integer-suffix :  unsigned-suffix long-suffixopt long-suffix unsigned-suffixopt  unsigned-suffix : one of  u U  long-suffix : one of  l L  64-bit integer-suffix :  i64  To specify integer constants using octal or hexadecimal notation, use a prefix that denotes the base. To specify an integer constant of a given integral type, use a suffix that denotes the type.  To specify a decimal constant, begin the specification with a nonzero digit. For example:  int i = 157;   // Decimal constant int j = 0198;  // Not a decimal number; erroneous octal constant int k = 0365;  // Leading zero specifies octal constant, not decimal  To specify an octal constant, begin the specification with 0, followed by a sequence of digits in the range 0 through 7. The digits 8 and 9 are errors in specifying an octal constant. For example:  int i = 0377;   // Octal constant int j = 0397;   // Error: 9 is not an octal digit  To specify a hexadecimal constant, begin the specification with 0x or 0X (the case of the “x” does not matter), followed by a sequence of digits in the range 0 through 9 and a (or A) through f (or F). Hexadecimal digits a (or A) through f (or F) represent values in the range 10 through 15. For example:  int i = 0x3fff;   // Hexadecimal constant int j = 0X3FFF;   // Equal to i  To specify an unsigned type, use either the u or U suffix. To specify a long type, use either the l or L suffix. For example:  unsigned uVal = 328u;             // Unsigned value long lVal = 0x7FFFFFL;            // Long value specified                                    //  as hex constant unsigned long ulVal = 0776745ul;  // Unsigned long value  赵老师，你发的这些好像没有讲到，为什么我不加f的时候，while判断的时候却判断出了2.0也给打印出来了。。

引用 9 楼 RisJazz 的回复:立即数写成 2.0 默认是double类型， 一般是64位浮点数。 立即数写成 2.0f 默认是float类型， 一般是32位浮点数。 你的变量x是double类型的，执行 x = x + 0.2f 的时候，会将float型的0.2f  强转为double类型的 0.2， 32位转64位， 少了32位的数据，该怎么办呢？ 这是一个未定义的行为，高级一点的系统会将缺少的32位数据全部置0，但大多数系统会保留后的32位存储地址内的随机值。  简单来说 0.2f 是float类型， 强转为double类型会出现精度损失。 0.2 是 double类型，与x类型一致，没有出现精度损失。 加f导致强制转换的问题倒明白，关键是如果不加f的话，都是double型，却会打印出2.000000是为何呢？

太专业级的问题了，顶一下

常量也有类型。 C++ Floating-Point Constants Floating-point constants specify values that must have a fractional part. These values contain decimal points (.) and can contain exponents.  Syntax  floating-constant :  fractional-constant exponent-partopt floating-suffixopt digit-sequence exponent-part floating-suffixopt  fractional-constant :  digit-sequenceopt . digit-sequence digit-sequence .  exponent-part :  e signopt digit-sequence E signopt digit-sequence  sign : one of  + –  digit-sequence :  digit digit-sequence digit  floating-suffix :one of  f l F L  Floating-point constants have a “mantissa,” which specifies the value of the number, an “exponent,” which specifies the magnitude of the number, and an optional suffix that specifies the constant’s type. The mantissa is specified as a sequence of digits followed by a period, followed by an optional sequence of digits representing the fractional part of the number. For example:  18.46 38.  The exponent, if present, specifies the magnitude of the number as a power of 10, as shown in the following example:  18.46e0      // 18.46 18.46e1      // 184.6  If an exponent is present, the trailing decimal point is unnecessary in whole numbers such as 18E0.  Floating-point constants default to type double. By using the suffixes f or l (or F or L — the suffix is not case sensitive), the constant can be specified as float or long double, respectively.  Although long double and double have the same representation, they are not the same type. For example, you can have overloaded functions like  void func( double );  and   void func( long double );

x=x+0.2f; 不加f，编译器对0.2是使用double型的，加了告诉编译器，这是个float。然后你的x是double，float的0.2要转为double，误差就更大了。

include\float.h ... #define DBL_DIG         15                      /* # of decimal digits of precision */ #define DBL_EPSILON     2.2204460492503131e-016 /* smallest such that 1.0+DBL_EPSILON != 1.0 */ #define DBL_MANT_DIG    53                      /* # of bits in mantissa */ #define DBL_MAX         1.7976931348623158e+308 /* max value */ #define DBL_MAX_10_EXP  308                     /* max decimal exponent */ #define DBL_MAX_EXP     1024                    /* max binary exponent */ #define DBL_MIN         2.2250738585072014e-308 /* min positive value */ #define DBL_MIN_10_EXP  (-307)                  /* min decimal exponent */ #define DBL_MIN_EXP     (-1021)                 /* min binary exponent */ #define _DBL_RADIX      2                       /* exponent radix */ #define _DBL_ROUNDS     1                       /* addition rounding: near */  #define FLT_DIG         6                       /* # of decimal digits of precision */ #define FLT_EPSILON     1.192092896e-07F        /* smallest such that 1.0+FLT_EPSILON != 1.0 */ #define FLT_GUARD       0 #define FLT_MANT_DIG    24                      /* # of bits in mantissa */ #define FLT_MAX         3.402823466e+38F        /* max value */ #define FLT_MAX_10_EXP  38                      /* max decimal exponent */ #define FLT_MAX_EXP     128                     /* max binary exponent */ #define FLT_MIN         1.175494351e-38F        /* min positive value */ #define FLT_MIN_10_EXP  (-37)                   /* min decimal exponent */ #define FLT_MIN_EXP     (-125)                  /* min binary exponent */ #define FLT_NORMALIZE   0 #define FLT_RADIX       2                       /* exponent radix */ #define FLT_ROUNDS      1                       /* addition rounding: near */ ...

因为0.2默认类型就是double类型，而double类型的精确度可以在15位，所以前面那个不会出现精度问题。后面那个你显示给0.2设成了float，而float的精度在7、8之间，所以过了7位或8位后面的就会不精确。当你用double+floatj时，系统会自动给你把float转成double这样就造成7、8位乱显数字问题。所以现在了以上结果。

不加后缀f的浮点型字面值一般表示的是double类型，加 f 的表示单精度类型，单精度类型只保证6个有效位数，所以后边出现了一串没有意义的数字


Question: C语言的问题

c/s模式啊

服务:Messenger 描述:传输客户端和服务器之间的 NET SEND 和 警报器服务消息。此服务与 Windows Messenger 无关。如果服务停止，警报器消息不会被传输。如果服务被禁用，任何直接依赖于此服务的服务将无法启动。

通信。。。。

我前段时间刚好做过这么一个小项目。因为这个涉及的代码也不算少所以就不贴了 给你一个思路，然后自己去一步步学。  我是这样的，首先使用MFC制作一个发送简单界面----->使用网络编程知识使得两台主机可以连接，相互发送信息----->再制造一个接受信息的界面，简单的实现你要的功能就是，当接收到信息就使用MessageBox，弹出一个窗口就行了。很简单的。

netsend

引用 楼主 u014616839 的回复:各位大神，在局域网里如何实现用A电脑给B电脑发出指令后，B电脑自动弹窗提醒。  这就涉及到你具体的运行平台了吧！windows || Linux || Other 不同平台下的消息处理的API应该不一样吧 如果是Windows下，那先了解网络编程，然后知道需要给系统发送一个什么样的消息能让系统自动弹出一个对话框（ShowWindow？？！！） 还是自己一步一步学吧


Question: LINUX 下  JNI C++ 第三方动态链接库so 编译的问题

楼主这个问题解决了么，我也遇到这个问题了。

引用 9 楼 buyong 的回复:http://baike.baidu.com/link?url=miZhS63xkMQgqq-7A5WGvjcaCnxq-R4ZJTS0M7tXnXyv4lqly73D-Vqz4B0Xcz25Iwkf2oVpDpCPn3D8phiYFa  这是基本的，我需要咨询的是，可能是我在编译的时候，尤其是依赖关系上，哪个参数没有些对造成的。 首先对自己编写的Hello.cpp编译成so g++  -fPIC -D_REENTRANT -I/usr/jdk1.8/include -I/usr/jdk1.8/include/linux -c Hello.cpp g++  -shared Hello.o -o libHello.so   然后因为Hello.cpp调用了第三方库，所以进行了以下关联。 g++ Hello.cpp -fPIC -shared -L. -lVerifyResult  我这么编译为什么总是提示我 ‘_InitInfo’在此作用域中尚未声明  其中 VerifyResult是第三方库,_InitInfo是第三方库提供的对外接口 Hello.cpp是我自己编写的C++程序，内容是调用 libVerifyResult.so 中提供的函数  另外，我已经将libVerifyResult.so放到了当前目录，并且在/usr/lib下也放置了。

在cpp文件里include头文件，然后使用dlopen试试吧

不能解决的话，今天准备结贴了。

帮忙顶一个下

今天最后一顶

引用 4 楼 OExpress 的回复:system.load(libxxx.so);  我单独百年些CPP成寻，调用这个库，是没有问题的，而且直接可以用，也不需要什么load,open之类的，现在我是 要通过JNI方式调用，现在就是不知到编译的时候，依赖关系怎么写。查了下，也实验了。就是不行

system.load(libxxx.so);

关键的问题是，我如何与第三方提供的SO建立关联。

引用 1 楼 thefirstz 的回复:使用nm命令看看libHello.so里面的符号是不是对 先确保带有main函数的Hello.cpp可以调用第三方库  是这样的，我通过C++程序直接调用SO，是没问题的，现在我需要在写个C++程序，但是要符合JNI规范，目的上让JAVA调用。  我觉得我是编译哪里有了问题。


Question: c语言贪吃蛇代码求分析？

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

1. 先找到main 2. 然后顺序往下看 3. 遇到函数就看函数体内容 4. 直到看完 5. 理解不了的地方加断点，调试，看内存变量

是一个贪吃蛇代码，运行环境VC++6.0（亲测完美运行）*/ /*该程序在dos系统下运行，不需要graphics.h头文件*/ /*该程序由C语言小方贡献，谢谢您的支持*/ //这是原版代码，提问时一些符号不让输入。。。。。。 #include <windows.h> #include <stdlib.h> #include <time.h> #include <stdio.h> #include <string.h> #include <conio.h> #define N 21  int apple[3]; char score[3]; char tail[3];   void gotoxy(int x, int y)    //输出坐标  {         COORD pos;         pos.X = x;          pos.Y = y;         SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos); }  void color(int b)         //颜色函数  {     HANDLE hConsole = GetStdHandle((STD_OUTPUT_HANDLE)) ;      SetConsoleTextAttribute(hConsole,b) ; }   int Block(char head[2])   //判断出界  {         if ((head[0] < 1) || (head[0] > N) || (head[1] < 1) || (head[1] > N))                 return 1;         return 0; }  int Eat(char snake[2])   //吃了苹果  {         if ((snake[0] == apple[0]) && (snake[1] == apple[1]))        {                 apple[0] = apple[1] = apple[2] = 0;                 gotoxy(N+44,10);                 color(13);                 printf("%d",score[0]*10);                 color(11);                 return 1;            }         return 0; }  void Draw(char **snake, int len)    //蛇移动  {         if (apple[2]) {                 gotoxy(apple[1] * 2, apple[0]);//apple[1] 这里为什么要乘以2？？？？？？                 color(12);                 printf("●");                 color(11);         }         gotoxy(tail[1] * 2, tail[0]);         if (tail[2])           {  color(14);                 printf("★");                 color(11);          }     else          printf("■");         gotoxy(snake[0][1] * 2, snake[0][0]);         color(14);         printf("★");         color(11);         putchar('\n'); }  char** Move(char **snake, char dirx, int *len)   //控制方向  {         int i, full = Eat(snake[0]);         memcpy(tail, snake[(*len)-1], 2);         for (i = (*len) - 1; i > 0; --i)                  memcpy(snake[i], snake[i-1], 2);         switch (dirx)            {             case 'w': case 'W': --snake[0][0]; break;               case 's': case 'S': ++snake[0][0]; break;            case 'a': case 'A': --snake[0][1]; break;            case 'd': case 'D': ++snake[0][1]; break;            default: ;          }           if (full)               {                  snake = (char **)realloc(snake, sizeof(char *) * ((*len) + 1));                 snake[(*len)] = (char *)malloc(sizeof(char) * 2);                 memcpy(snake[(*len)], tail, 2);                 ++(*len);                 ++score[0];                 if(score[3] < 16)                  ++score[3];                 tail[2] = 1;            }            else                  tail[2] = 0;                 return snake; }  void init(char plate[N+2][N+2], char ***snake_x, int *len)  //初始化  {         int i, j;         char **snake = NULL;          *len = 3;         score[0] = score[3] =3;         snake = (char **)realloc(snake, sizeof(char *) * (*len));         for (i = 0; i < *len; ++i)                 snake[i] = (char *)malloc(sizeof(char) * 2);                          for (i = 0; i < 3; ++i)                  {                 snake[i][0] = N/2 + 1;                 snake[i][1] = N/2 + 1 + i;              }                        for (i = 1; i <= N; ++i)                  for (j = 1; j <= N; ++j)                          plate[i][j] = 1;                                   apple[0] = rand()%N + 1; apple[1] = rand()%N + 1;         apple[2] = 1;          for (i = 0; i < N + 2; ++i)                  {                 gotoxy(0, i);                 for (j = 0; j < N + 2; ++j)                          {                         switch (plate[i][j])                                  {                              case 0:                                   color(12);printf("□");color(11); continue;                         case 1: printf("■"); continue;                              default: ;                              }                     }                    putchar('\n');             }          for (i = 0; i < (*len); ++i)        {                 gotoxy(snake[i][1] * 2, snake[i][0]);                 printf("★");             }          putchar('\n');         *snake_x = snake; }  void Manual() {         gotoxy(N+30,2);         color(10);         printf("按 W S A D 移动方向");         gotoxy(N+30,4);         printf("按 space 键暂停");          gotoxy(N+30,8);         color(11);         printf("历史最高分为: ");         color(12);         gotoxy(N+44,8);         printf("%d",score[1]*10);         color(11);         gotoxy(N+30,12);         printf("你现在得分为: 0");          }  int File_in()     //取记录的分数  {    FILE *fp;    if((fp = fopen("C:\\tcs.txt","a+")) == NULL)    {             gotoxy(N+18, N+2);      printf("文件不能打开\n");          exit(0);    }    if((score[1] = fgetc(fp)) != EOF);    else    score[1] = 0;    return 0; }  int File_out()    //存数据  {                  FILE *fp;         if(score[1] > score[0])          {gotoxy(10,10);         color(12);         puts("闯关失败 加油耶");         gotoxy(0,N+2);          return 0;         }         if((fp = fopen("C:\\tcs.txt","w+")) == NULL)         {                 printf("文件不能打开\n");                 exit(0);         }     if(fputc(--score[0],fp)==EOF)            printf("输出失败\n");     gotoxy(10,10);         color(12);         puts("恭喜您打破记录");          gotoxy(0,N+2);         return 0; }   void Free(char **snake, int len)    //释放空间  {         int i;         for (i = 0; i < len; ++i)                  free(snake[i]);         free(snake); }  int main(void) {         int len;         char ch = 'g';         char a[N+2][N+2] = {{0}};         char **snake;         srand((unsigned)time(NULL));         color(11);         File_in();         init(a, &snake, &len);         Manual();         while (ch != 0x1B)   // 按 ESC 结束           {                  Draw(snake, len);                 if (!apple[2]) {                         apple[0] = rand()%N + 1;                         apple[1] = rand()%N + 1;                         apple[2] = 1;                 }                 Sleep(200-score[3]*10);                 setbuf(stdin, NULL);                 if (kbhit())                    {                         gotoxy(0, N+2);                         ch = getche();                     }                  snake = Move(snake, ch, &len);                   if (Block(snake[0])==1)                    {                         gotoxy(N+2, N+2);                         puts("你输了");                         File_out();                         Free(snake, len);                         getche();                         exit(0);                    }                                 }         Free(snake, len);         exit(0); }//能不能给分析一下？我看不懂，。。。。。。


Question: c函数参数，求教

参考：  func( Type para1, Type para2, Type para3, ... ) {        /****** Step 1 ******/        va_list ap;        va_start( ap, para3 ); //一定要“...”之前的那个参数**ap指向para后的第一个可变参数              /****** Step 2 ******/        //此时ap指向第一个可变参数        //调用va_arg取得里面的值              Type xx = va_arg( ap, Type );               //Type一定要相同，如:        //char *p = va_arg( ap, char *);        //int i = va_arg( ap, int );        //如果有多个参数继续调用va_arg        /****** Step 3 ******/        va_end(ap); //For robust!  }

va_arg, va_end, va_start Access variable-argument lists.  type va_arg( va_list arg_ptr, type );  void va_end( va_list arg_ptr );  void va_start( va_list arg_ptr );   (UNIX version)  void va_start( va_list arg_ptr, prev_param );   (ANSI version)  Routine Required Header Optional Headers Compatibility  va_arg <stdio.h> and <stdarg.h> <varargs.h>1 ANSI, Win 95, Win NT  va_end <stdio.h> and <stdarg.h> <varargs.h>1 ANSI, Win 95, Win NT  va_start <stdio.h> and <stdarg.h> <varargs.h>1 ANSI, Win 95, Win NT    1 Required for UNIX V compatibility.  For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  va_arg returns the current argument; va_start and va_end do not return values.  Parameters  type  Type of argument to be retrieved  arg_ptr  Pointer to list of arguments  prev_param  Parameter preceding first optional argument (ANSI only)  Remarks  The va_arg, va_end, and va_start macros provide a portable way to access the arguments to a function when the function takes a variable number of arguments. Two versions of the macros are available: The macros defined in STDARG.H conform to the ANSI C standard, and the macros defined in VARARGS.H are compatible with the UNIX System V definition. The macros are:  va_alist  Name of parameter to called function (UNIX version only)  va_arg  Macro to retrieve current argument  va_dcl  Declaration of va_alist (UNIX version only)  va_end  Macro to reset arg_ptr  va_list  typedef for pointer to list of arguments defined in STDIO.H  va_start  Macro to set arg_ptr to beginning of list of optional arguments (UNIX version only)  Both versions of the macros assume that the function takes a fixed number of required arguments, followed by a variable number of optional arguments. The required arguments are declared as ordinary parameters to the function and can be accessed through the parameter names. The optional arguments are accessed through the macros in STDARG.H or VARARGS.H, which set a pointer to the first optional argument in the argument list, retrieve arguments from the list, and reset the pointer when argument processing is completed.  The ANSI C standard macros, defined in STDARG.H, are used as follows:   All required arguments to the function are declared as parameters in the usual way. va_dcl is not used with the STDARG.H macros.   va_start sets arg_ptr to the first optional argument in the list of arguments passed to the function. The argument arg_ptr must have va_list type. The argument prev_param is the name of the required parameter immediately preceding the first optional argument in the argument list. If prev_param is declared with the register storage class, the macro’s behavior is undefined. va_start must be used before va_arg is used for the first time.   va_arg retrieves a value of type from the location given by arg_ptr and increments arg_ptr to point to the next argument in the list, using the size of type to determine where the next argument starts. va_arg can be used any number of times within the function to retrieve arguments from the list.   After all arguments have been retrieved, va_end resets the pointer to NULL.  The UNIX System V macros, defined in VARARGS.H, operate somewhat differently:   Any required arguments to the function can be declared as parameters in the usual way.   The last (or only) parameter to the function represents the list of optional arguments. This parameter must be named va_alist (not to be confused with va_list, which is defined as the type of va_alist).   va_dcl appears after the function definition and before the opening left brace of the function. This macro is defined as a complete declaration of the va_alist parameter, including the terminating semicolon; therefore, no semicolon should follow va_dcl.   Within the function, va_start sets arg_ptr to the beginning of the list of optional arguments passed to the function. va_start must be used before va_arg is used for the first time. The argument arg_ptr must have va_list type.   va_arg retrieves a value of type from the location given by arg_ptr and increments arg_ptr to point to the next argument in the list, using the size of type to determine where the next argument starts. va_arg can be used any number of times within the function to retrieve the arguments from the list.   After all arguments have been retrieved, va_end resets the pointer to NULL.  Example  /* VA.C: The program below illustrates passing a variable  * number of arguments using the following macros:  *      va_start            va_arg              va_end  *      va_list             va_dcl (UNIX only)  */  #include <stdio.h> #define ANSI            /* Comment out for UNIX version     */ #ifdef ANSI             /* ANSI compatible version          */ #include <stdarg.h> int average( int first, ... ); #else                   /* UNIX compatible version          */ #include <varargs.h> int average( va_list ); #endif  void main( void ) {    /* Call with 3 integers (-1 is used as terminator). */    printf( "Average is: %d\n", average( 2, 3, 4, -1 ) );     /* Call with 4 integers. */    printf( "Average is: %d\n", average( 5, 7, 9, 11, -1 ) );     /* Call with just -1 terminator. */    printf( "Average is: %d\n", average( -1 ) ); }  /* Returns the average of a variable list of integers. */ #ifdef ANSI             /* ANSI compatible version    */ int average( int first, ... ) {    int count = 0, sum = 0, i = first;    va_list marker;     va_start( marker, first );     /* Initialize variable arguments. */    while( i != -1 )    {       sum += i;       count++;       i = va_arg( marker, int);    }    va_end( marker );              /* Reset variable arguments.      */    return( sum ? (sum / count) : 0 ); } #else       /* UNIX compatible version must use old-style definition.  */ int average( va_alist ) va_dcl {    int i, count, sum;    va_list marker;     va_start( marker );            /* Initialize variable arguments. */    for( sum = count = 0; (i = va_arg( marker, int)) != -1; count++ )       sum += i;    va_end( marker );              /* Reset variable arguments.      */    return( sum ? (sum / count) : 0 ); } #endif   Output  Average is: 3 Average is: 8 Average is: 0   Argument Access Routines  See Also   vfprintf

搜索c可变行参


Question: AVS编码器中插入子函数实现前背景划分

都没有大神知道吗？


Question: 在设计计算机图形学演示系统时，运行出现- 黑屏 direct draw init failed（00000000）！

引用 1 楼 N_sev7 的回复:推荐个网址，可以去认真看看，都是英文，我实在看不下去了 http://forum-en.msi.com/index.php?topic=17211.0  谢谢大神啦！我去看看

用了什么第三方库。 用的是dx几？  初步怀疑用的东西太老你的显卡不支持导致dx初始化错误。


Question: C语言遍历文件，怎么子文件夹也被打印出来了？

_A_SUBDIR==filefind.attrib  wrong!  _A_SUBDIR==(filefind.attrib & _A_SUBDIR)

system("dir /b /a-d c:\\*.* >d:\\allfiles.txt"); //读文件d:\\allfiles.txt的内容即C:\\下所有文件的名字 system("dir /b /a-d /s c:\\*.* >d:\\allfilesinsub.txt"); //读文件d:\\allfilesinsub.txt的内容即C:\\下所有文件的名字包含子目录 system("dir /b /ad  c:\\*.* >d:\\alldirs.txt"); //读文件d:\\alldirs.txt的内容即C:\\下所有子目录的名字 请记住，能用shell命令获取文件、文件夹信息或者操作文件、文件夹最好用shell命令获取或者操作，而不要用各种API获取或者操作，因为当遇到非法文件夹名或非法文件名或非法文件长度、非法文件日期、压缩文件、链接文件、稀疏文件……等各种意料之外的情况时，API会处理的不全面或陷入死循环，而shell命令不会。

可以是你判断文件夹的访问有问题 在 if(_A_SUBDIR==filefind.attrib) 这里下断点, 看是目录是这个条件是否进入就知道了

#include <vector> #include <algorithm> #include <stdio.h> #include <string> #include <string.h> #include <io.h> #include <windows.h> using namespace std; //////////////////////////////////////////// void string_replace(string & strBig, const string & strsrc, const string &strdst) {     string::size_type pos=0;     string::size_type srclen=strsrc.size();     string::size_type dstlen=strdst.size();     while( (pos=strBig.find(strsrc, pos)) != string::npos)     {         strBig.replace(pos, srclen, strdst);         pos += dstlen;     } } //////////////////////////////////////////// void filesearch(string path) {     string s;     ///////////////////////////////////////////     struct _finddata_t filefind;     string curr=path+"\\*.*";     int done =0,handle;     if(!(handle=_findfirst(curr.c_str(),&filefind)))     {         return ;     }     while(!(done=_findnext(handle,&filefind)))     {         if(strcmp(filefind.name,"..")==0)         {             continue;         }         if(_A_SUBDIR==filefind.attrib)    ///你这都判断了，如果是子目录，就打印，所以为啥不打印呢？？？         {             curr=path+"\\"+filefind.name;             filesearch(curr);             continue;         }         s=curr;         string_replace(s,"*.*",filefind.name);         FILE *fp;         fp=fopen("1.txt","a+");         fprintf(fp,"%s\n",s.c_str());         fclose(fp);     }     _findclose(handle); }   int main() {     FILE *f;     f=fopen("1.txt","w");     fclose(f);     filesearch("f:");     system("start 1.txt");     return 0; }


Question: 菜鸟求助，一个关于scanf和缓冲区的问题

#include <stdio.h> int main() {     int num,r;     char c;     while (1) {         printf("Enter a number:");         fflush(stdout);         rewind(stdin);         r=scanf("%d%c", &num,&c);         if (r==2) {             if ('\n'==c) break;         }         printf("Format error!\n");     }     printf("%d entered.",num);     return 0; } //Enter a number:a //Format error! //Enter a number:10a //Format error! //Enter a number:10 //10 entered. //

你输入字母b后，那么缓冲区就有了这个字符b。scanf函数发现缓冲区有东西了，就去读取。但发现是一个字符b，而自己需要的是数字。那么scanf就返回了，但它只是返回，并不把这个b清除。所以字符b还是留在缓冲区。所以当再次回到循环判断语句时，scanf又会去读取这个字符b。又出错。一直循环下去。 你可以在printf语句下面加多一句fflush(stdin);把缓冲区的东西清除掉，就能正常工作了。


Question: 请教下如何用VC编一个可以在全屏幕内画图的程序？

MFC有划线的功能，可以做成类似qq截图功能的绘画

GetWindowDC(NULL)  hWnd  [in] Handle to the window with a device context that is to be retrieved. If this value is NULL, GetWindowDC retrieves the device context for the entire screen.   使用这样获取到的DC就可以在整个屏幕上绘制你想绘制的东西了.

LineTo The LineTo function draws a line from the current position up to, but not including, the specified point.   BOOL LineTo(   HDC hdc,    // device context handle   int nXEnd,  // x-coordinate of line's ending point   int nYEnd   // y-coordinate of line's ending point );   Parameters hdc  Handle to a device context.  nXEnd  Specifies the x-coordinate of the line's ending point.  nYEnd  Specifies the y-coordinate of the line's ending point.  Return Values If the function succeeds, the return value is nonzero.  If the function fails, the return value is zero.   Windows NT: To get extended error information, callGetLastError.  Remarks The coordinates of the line's ending point are specified in logical units.   The line is drawn by using the current pen and, if the pen is a geometric pen, the current brush.   If LineTo succeeds, the current position is set to the specified ending point.   QuickInfo   Windows NT: Requires version 3.1 or later.   Windows: Requires Windows 95 or later.   Windows CE: Unsupported.   Header: Declared in wingdi.h.   Import Library: Use gdi32.lib.  See Also Lines and Curves Overview, Line and Curve Functions, MoveToEx, Polyline, PolylineTo

#include <windows.h> LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {     PAINTSTRUCT ps;     HDC hdc;     HFONT hfont,ohfont;     RECT r;     COLORREF oc;      switch(message) {     case WM_CLOSE://按Alt+F4退出         PostQuitMessage(0);         break;     case WM_PAINT:         BeginPaint(hWnd, &ps);         hdc = ps.hdc; // the device context to draw in         GetClientRect(hWnd, &r); // Obtain the window's client rectangle         hfont = CreateFont(240, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "华文楷体");         ohfont=SelectObject(hdc,hfont);         oc=SetTextColor(hdc,0x00C080FF);         SetBkMode(hdc, TRANSPARENT);         TextOut(hdc,r.left+r.right/2-720, r.top+r.bottom/2-120,"最短画图程序",12);         SelectObject(hdc,ohfont);         SetTextColor(hdc,oc);         DeleteObject(hfont);         EndPaint(hWnd, &ps);         break;     default:         return DefWindowProc(hWnd, message, wParam, lParam);     }     return 0; } int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {     MSG msg             = {0};     WNDCLASS wc         = {0};     HBRUSH hbrh;     hbrh=CreateSolidBrush(0x00000000);     wc.lpfnWndProc      = WndProc;     wc.hInstance        = hInstance;     wc.hbrBackground    = hbrh;     wc.lpszClassName    = "minwindowsapp";     wc.hCursor          = LoadCursor(NULL,IDC_ARROW);     if( FAILED(RegisterClass(&wc)) ) return 1;      if(FAILED(CreateWindow(wc.lpszClassName,                         "Minimal Windows Application",                         WS_POPUP|WS_VISIBLE,                         0,                         0,                         GetSystemMetrics(SM_CXSCREEN),                         GetSystemMetrics(SM_CYSCREEN),                         0,                         0,                         hInstance,                         NULL)))         return 2;      while( GetMessage( &msg, NULL, 0, 0 ) > 0 ) {         DispatchMessage( &msg );     }     DeleteObject(hbrh);     return 0; }


Question: 新手问个linux c问题,求指教,谢谢了

好吧,懂了,就是我想的那样

man 2 signal

是不是调用了signal之后,那个被注册的信号就被阻塞了?