Question: 数组初始化问题，非常不科学的现象！！

引用 17 楼 lelieven 的回复:水平太差，不懂这么高深的问题，惭愧啊，惭愧！  你这人反话正说，小人一个。 我给你直话直说：  你意思就是这个问题太简单，让你这个“大牛”都不屑对吧？  我拿你和 15楼作比较吧：  你只会说： “你基础差！” “太高深” 这样的话，你看看人家15楼的，多实在，一个问题三四句话解释的一清二楚，哪像你只知道说简单，却说不出个道道，还老装B，鄙视你这种货色！    其实你技术能力、学习能力一定比我差，从你说话就看得出你这人水平不高。

引用 17 楼 lelieven 的回复:水平太差，不懂这么高深的问题，惭愧啊，惭愧！[/quote]  我发现你这人特喜欢装B，你瞧瞧人家15楼，哎……你哪点比得上人家？你以为你牛？装逼就会让别人认为你牛？难怪好多其他行业的人瞧不起我们程序员，说程序员最爱装13，就是因为你这样的人害了整个行业的名声

引用 13 楼 u011642451 的回复:[quote=引用 11 楼 lelieven 的回复:] [quote=引用 楼主 u011642451 的回复:] 我非常疑惑的一个问题：  unsigned short Arry[256] = {2047};  这样定义数组 Arry 并初始化，想将所有元素都初始化为 2047，可是，结果却是第一个元素为 2047，其余的所有元素都是 0， 这不科学！！  谁帮我解释一下！语法就是这样，是你基础太差！[/quote]  [/quote]水平太差，不懂这么高深的问题，惭愧啊，惭愧！

引用 15 楼 cjfdqchwh 的回复:其实这个问题，即使是有经验的程序员也容易犯，本人曾经犯过这个错。  以前一直以为 int a[256]={0};是把a的所有元素初始化为0，int a[256]={2047};是把a所有的元素初始化为2047. 其实不是这样的。如果初始化时指定的的元素个数比数组大小少，剩下的元素都回被初始化为 0。例如       int   Arry[8]={1,2,3,4}; 那么等效的是       int Arry[8]={1,2,3,4,0,0,0,0};  您的回复最赞！那些装13的，只会说我基础差，意思就是他厉害呗，结果他又说不出个道道来，鄙视这个货色

既然这个问题你都说简单，却不能够一两句明白话说个明白，那就不要装13说我基础差什么什么的，我不懂，我不装13

引用 11 楼 lelieven 的回复:[quote=引用 楼主 u011642451 的回复:] 我非常疑惑的一个问题：  unsigned short Arry[256] = {2047};  这样定义数组 Arry 并初始化，想将所有元素都初始化为 2047，可是，结果却是第一个元素为 2047，其余的所有元素都是 0， 这不科学！！  谁帮我解释一下！语法就是这样，是你基础太差！[/quote]

引用 10 楼 AfterSeptember 的回复:别捉急了，找本书看一下不会少块肉的。 我手边一本《C++ Primer》，经常翻阅……  您既然懂这个问题，就指教一下呗

引用 楼主 u011642451 的回复:我非常疑惑的一个问题：  unsigned short Arry[256] = {2047};  这样定义数组 Arry 并初始化，想将所有元素都初始化为 2047，可是，结果却是第一个元素为 2047，其余的所有元素都是 0， 这不科学！！  谁帮我解释一下！语法就是这样，是你基础太差！

别捉急了，找本书看一下不会少块肉的。

引用 7 楼 derekrose 的回复:楼主，要相信科学  你能帮我解释一下，这是为什么吗？这么初始化怎么就不行了呢？

引用 7 楼 derekrose 的回复:楼主，要相信科学 所以，我正等着你告诉我什么是科学呀

楼主，要相信科学

引用 3 楼 lin5161678 的回复:[quote=引用 1 楼 user-8 的回复:] 如果有全部初始化，也可以，你写 unsigned short Arry[256] = {2047,2047,....2047}; 总共256个就可以了  通常做法是memset进行初始化memset没这么申请 不可能初始化出 2047的[/quote]  这是为什么呢？为什么不能初始化为 2047，或 2046 等等呢？

引用 2 楼 xyzinfernity 的回复:数组的基础语法你都没看？这怎么不科学了？ 你既然看了，那你讲讲看呀！

貌似只有{0}是指全部初始化为0，其它就不是这样了

引用 1 楼 user-8 的回复:如果有全部初始化，也可以，你写 unsigned short Arry[256] = {2047,2047,....2047}; 总共256个就可以了  通常做法是memset进行初始化memset没这么申请 不可能初始化出 2047的

数组的基础语法你都没看？这怎么不科学了？


Question: C#新手求解！

来错地方了，斑竹删帖啊。


Question: 指针数组作为参数的问题

1楼说的对，直接把sizeof(str)打印出来看一下就清楚了，

首先指针类型的长度（sizeof）都是4（32位系统）。但是str和p都是指针数组，即数组中的每个元素都是一个指针，那么sizoef(str)/sizeof(char *) = (5 * 4) / 4 = 5

数组做参数时与指针相同 所以sizeof(str)/sizeof(char *) = sizeof(char **)/sizeof(char *) = 1


Question: 求帮忙理解程序

通常不这样定义，而且那个3也没有什么意义。可以用int*代替，再加上一个表示数组元素个数的参数

调用的时候知道传入的长度为3的int数组，和使用int js(int *n)是一样的效果。 如果你在使用的时候传一个长度大于3的int数组给它，也不会报错或警告


Question: 指针变量自增

引用 12 楼 oYinGui1 的回复:看你的指针是什么类型的，然后再sizeof一下。 恩

引用 9 楼 cfjtaishan 的回复:指针类型变量的自增或自减跳过（或者说偏移的内存单元）跟该指针变量的类型有关的。 头像很帅呀

引用 14 楼 bijiaoben 的回复:[quote=引用 楼主 u011642451 的回复:] char *pCh;  pCh++;  short *pS;  pS++;  long *pL;   pL++;  double *pD; pD++;  请问，这些指针值++，是加1， 还是加多少？ 指针的类型决定了指针自增时候的步长。楼主还可以用结构体类型的指针试试看，效果更加明显[/quote] 恩，我现在明白了。 再请问您： 这是不是 C/C++ 的规则？是不是所有C/C++编译器都支持这个规则？

引用 楼主 u011642451 的回复:char *pCh;  pCh++;  short *pS;  pS++;  long *pL;   pL++;  double *pD; pD++;  请问，这些指针值++，是加1， 还是加多少？ 指针的类型决定了指针自增时候的步长。楼主还可以用结构体类型的指针试试看，效果更加明显

根据指针的类型增加相应的空间的。你可以把地址输出，自己对比下就知道了。

引用 18 楼 cjfdqchwh 的回复:指针变量自增，是按照指针变量的类型来自增的。  楼主你想呀： 指针变量存放的是一个地址值，如果指向一个 double 类型的数组的地址： double Double_arry[]; double *p = &Double_arry;  p++ 等效于 p = p + sizeof(double);  楼上正解

看你的指针是什么类型的，然后再sizeof一下。

引用 6 楼 lin5161678 的回复:+ sizeof *指针名 哦，原来如此

引用 3 楼 a345485527 的回复:对指针进行加减操作，加的是指针指向类型的字节数 恩，讲的很明了

指针类型变量的自增或自减跳过（或者说偏移的内存单元）跟该指针变量的类型有关的。

指针增加其实是内存中位置的变化，我觉得计算机组成原理可以帮你理解指针增加是怎么回事

+sizeof(指针指向的类型)，比如char*,一次加1，int*一次加4。自己定义一些不同类型的数组，然后在定义对应的一个指针指向数组，调试一下就明白了

+ sizeof *指针名

想快速知道答案 自己测试一下  先真正得到答案 看c和指针

我想说的已经被3楼说完了

对指针进行加减操作，加的是指针指向类型的字节数

1 2 4 8

为什么，我已经写了测试程序，发现指针自增，是有“智能”……反正就这个意思


Question: 越是简单的问题，越是看不出来！！！

嗯  谢谢。以后错误都自己断点调试了。真得很好用

断点输出是正常的，整个运行就没有第一行的7个*。

xcode是用gdb调试吗？我没用过。

#include <stdio.h> /* Parameter: level => the level count of the upside down triangle */ void print(int level) {     int i, space, star, totalLevel = level*2 - 1;          for(i = 0; i < totalLevel; ++i){         /* figure out how many leading spaces and stars in this level */         if(i < level) space = i;         else space = totalLevel-1 - i;         star = (level - space) * 2 - 1;                  /* print leading spaces */         for(; space > 0; --space) putchar(' ');                  /* print stars */         for(; star > 0; --star)   putchar('*');                  /* new line */         putchar('\n');     } }  int main() {     int level = 4;          print(level);          return 0; }

引用 1 楼 user-4 的回复:vs2005测试通过，输出正常    我用的xcode   但是输出不行

引用 2 楼 zhao4zhong1 的回复:代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试是程序员必须掌握的技能之一。  嗯，谢谢提醒。  但是我打断点运行显示i=0时   下面的for循环j=0 到j=7  中间运行了7次啊

输出这么一个图形你for,用了3次，而且还嵌套。写代码要养成良好习惯。

vs2005测试通过，输出正常


Question: 关于“为节省内存进行连续图像的压缩”

引用 11 楼 linfeng_hebut 的回复:这里有个限制条件不能忽视，我需要能确定最终的结果大小。 比如对这50帧连续二值图像，不管它的信息冗余度多大，我都可以用7个byte类型的原图像大小的空间来存储全部信息。 但是7个图像大小仍太大，我想压到2或者3个，how？   你用固定一幅图像的大小，放50帧原始图压缩后的结果，99.9%的情况下都够了。  如果你非说要保证100%的情况下都要够，那7个图像大小就是极限了。

另外JPG格式的无损压缩，据说，可以吧一帧数据，压缩到%50 有损压缩更高。JPG是有损压缩，和无损压缩的结合。

帧间差别大，就换个帧重新处理后面各帧的数据 帧间差别不大，保存首帧，帧内信息冗余大的话，首帧也可以压缩 然后对后面各帧，只对帧差进行压缩  RLE+ 种行编码 压缩率应该很高。 只用RLE，估计效果也很好。

引用 3 楼 linfeng_hebut 的回复:呃……都很精干啊！ RLE学习了一下，思想不错，可觉得我这种情况不适用。至于mpeg，还是算了吧 希望有人启发一下思路，我现在是缩到了7帧，8帧图像作为一组，得到的二进制数进行十进制转换，8位的和最大255.那么50帧图像就是分7组。在取图像值时再反换算。 还有没有其他的更好思路呢？  不是很明白你说的？ 是不是就是把原来保存到1个byte中的0，1， 保存到 一个bit中？ 如果这个理解没错的话，这个不算图像压缩吧，理论上应该就是这么保存的吧。  mpeg理解起来太难了， 可以与RLE结合 做一个类似的， 但是效果可能要取决于实际数据吧  第一帧的数据 都保存 （如果有大片的黑白，可以采用RLE） 第二帧数据， 保存 跟 第一帧的差分，并且采用RLE的方法 #如果只有极少部分像素变化，应该还是比较有效 第三帧，第四帧，以此类推   问题的关键是， 前后帧之间差别大不大。

错了是MPEG 动态图像

这个采用Jpeg存储就差不多了。 看看Jpeg是怎么压缩的。 你只要保存变化就可以了

引用 4 楼 baipv008 的回复:如果是二值图，自己写个游程码压缩估计就行。（简单说就是一串N个0用两个值(0,N)表示就行。1同理） 这种方法和RLE类似都不能事先知道压缩结果是多大吧 我做的这个库需要静态分配内存，需要能确定压缩结果的size

mpeg .

RLE GIF89a


Question: -----获取网卡的包数------

ifconfig里面有，参考下源码吧

引用 5 楼 u012889234 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] Performance Data Helper You can use the performance data provided by applications, services, and drivers to determine system bottlenecks and fine-tune system and application performance. The easiest way to display the performance data is to use the Performance Monitor application located in the Administrative Tools group.   If you need to collect performance data for your application, the easiest way to do this is to use the interface provided by the Performance Data Helper (PDH) interface. Applications that need more control over performance data collection can use the registry interface directly. This is the method that is used by the functions in PDH.DLL and by the Performance Monitor. It is more efficient for the Performance Monitor to use the registry interface, because it displays counters grouped by object. If you are retrieving individual counters, rather than a group of counters from a particular object, it is just as efficient to use the PDH interface.   This overview discusses both interfaces.   The PDH Interface  The Registry Interface  In addition, this overview discusses how to add your own performance counters, by creating an extensible performance DLL. For more information, see Adding Performance Counters.[/quote] 参考Microsoft SDK\samples\winbase\WinNT\PerfTool\Pdh\StatList\*.*

netstat -s

引用 3 楼 zhao4zhong1 的回复:Performance Data Helper You can use the performance data provided by applications, services, and drivers to determine system bottlenecks and fine-tune system and application performance. The easiest way to display the performance data is to use the Performance Monitor application located in the Administrative Tools group.   If you need to collect performance data for your application, the easiest way to do this is to use the interface provided by the Performance Data Helper (PDH) interface. Applications that need more control over performance data collection can use the registry interface directly. This is the method that is used by the functions in PDH.DLL and by the Performance Monitor. It is more efficient for the Performance Monitor to use the registry interface, because it displays counters grouped by object. If you are retrieving individual counters, rather than a group of counters from a particular object, it is just as efficient to use the PDH interface.   This overview discusses both interfaces.   The PDH Interface  The Registry Interface  In addition, this overview discusses how to add your own performance counters, by creating an extensible performance DLL. For more information, see Adding Performance Counters.

引用 2 楼 u012889234 的回复:刚工作。。。。怎么？

刚工作。。。。怎么？

楼主工作了没


Question: 表示整数的高2字节和低2字节

union {   int32_t int_member;   uint8_t char_member[4]; }  然后搞个宏判断大小端。

引用 2 楼 turingo 的回复:unsigned int a = 56505; unsigned short int b = (a >> 16) & 0xffff; //高2字节 unsigned short int c = a & 0xffff; //低2字节  [quote=引用 楼主 xiadun 的回复:] 有一个32位整数如：65606 如何表示它的高2字节和低2字节[/quote] ++  地址要分大小端 简单的移位运算，就不需要了分大小端。 平台自己会处理好这个问题的。

int i=65606; printf("%04X %04X",((unsigned short *)&i)[1],((unsigned short *)&i)[0]);//小端内存 printf("%04X %04X",((unsigned short *)&i)[0],((unsigned short *)&i)[1]);//大端内存

引用 2 楼 turingo 的回复:unsigned int a = 56505; unsigned short int b = (a >> 16) & 0xffff; //高2字节 unsigned short int c = a & 0xffff; //低2字节  [quote=引用 楼主 xiadun 的回复:] 有一个32位整数如：65606 如何表示它的高2字节和低2字节[/quote] unsigned int a = 56505; unsigned short int b = *(（unsigned short*）&a); //高2字节 unsigned short int c = *((（unsigned short*）&a) + 1); //高2字节

unsigned int a = 56505; unsigned short int b = (a >> 16) & 0xffff; //高2字节 unsigned short int c = a & 0xffff; //低2字节  引用 楼主 xiadun 的回复:有一个32位整数如：65606 如何表示它的高2字节和低2字节

要分大小端吧


Question: cvi+数据库连接

怎么解决的呢朋友，是否设置odbc？那怎么获取数据库的内容呢？

自己解决了。。


Question: 帮忙看一下，哪里错了

楼主，你学我这样整一下代码，错在哪里 一目了然。。。

///////////////////////////////////////////////////// #include<stdio.h>  #include<malloc.h> #include<string.h> #include<stdlib.h>  #define Booklength 100 #define BookHnum 100 #define ReaderHnum 100  typedef struct {     char bookID[10];     char bookname[81];     int namenext;     char author[10];     int authornext;     char press[81];     int pressnext;     int storenum;     int borrownum; }Booktype;  typedef struct {     Booktype booklen[Booklength];     int len; }Bookfile;  // typedef struct {     char bookID[10];     int Rnum; }BookIDtype;  typedef struct {     BookIDtype BookID[10];     int len; }BookIDfile;   // typedef struct {     char bookname[81];     int head;     int Rnamelen; }Booknametype;  typedef struct {      Booknametype Lhf1[BookHnum];      int len1; }Booknamefile;     // typedef struct {     char author[10];     int head;     int Rauthorlen; }Authortype;  typedef struct {     Authortype Lhf2[BookHnum];     int len2; }Bookauthorfile;  // typedef struct {     char press[10];      int head;     int Rpresslen; }presstype;  typedef struct {     presstype Lhf3[BookHnum];     int len3; }pressfile;  // typedef struct {     char name[10];     char readerID[10]; }Readertype;  typedef struct {     Readertype reader[ReaderHnum];     int len; }Readerfile;  typedef struct  {     char readerID[10];     char bookID[10];     char data1[10];     char data2[10]; }Borrowtype;  typedef struct {       Borrowtype Borrowbook[Booklength];     int len; }Borrowfile;  void AddBaserecord(Bookfile &file) {     int i;     i=++file.len;      printf("书号 书名 作者名 出版社 藏书量\n");      scanf("%s%s",file.booklen[i].bookID,file.booklen[i].bookname);      scanf("%s%s",file.booklen[i].author,file.booklen[i].press);      scanf("%s",&file.booklen[i].storenum);      file.booklen[i].borrownum=0; }  void changeBaserecord(Bookfile &file,BookIDfile &f) {     int i,j,k;     char str[10];     i=file.len;      strcpy(str,file.booklen[i].bookID);          j=file.len;     k=1;     while(j>=1)     {         if(strcpy(str,f.BookID[i].bookID)>0)         {             k=j+1;             break;         }         j++;     }      if(f.len>0)         for(j=f.len;j>=k;j--)             f.BookID[j+1]=f.BookID[j];          strcpy(f.BookID[i].bookID,str);     f.BookID[i].Rnum=i;     f.len++; }  void changeBookname(Bookfile &file,Booknamefile&f) {     int i,j,k,m;     char str[20];          i=file.len;     strcpy(str,file.booklen[i].bookname);          j=0;     k=0;     while(j<f.len1)     {         if(strcpy(str,f.Lhf1[i].bookname)==0)         {             k=j;break;         }         j++;     }      if(k!=0)     {         file.booklen[i].authornext=f.Lhf1[k].head;         f.Lhf1[k].head=i;         f.Lhf1[k].Rnamelen++;     }     else      {         m=++f.len1;         file.booklen[i].namenext=0;         f.Lhf1[k].head=i;         f.Lhf1[k].Rnamelen=1;         strcpy(f.Lhf1[m].bookname,str);     } }  void changeauthor(Bookfile &file,Bookauthorfile&f) {     int i,j,k,m;     char str[10];     i=file.len ;     strcpy(str,file.booklen[i].author);          j=0;k=0;      while(j<f.len2)     {         if(strcpy(str,f.Lhf2[i].author)==0)         {             k=j;             break;         }         j++;     }     if(k!=0)     {         file.booklen[i].namenext=f.Lhf2[k].head;         f.Lhf2[k].head=i;         f.Lhf2[k].Rauthorlen++;     }     else      {         m=++f.len2;         file.booklen[i].authornext=0;         f.Lhf2[k].head=i;         f.Lhf2[k].Rauthorlen=1;         strcpy(f.Lhf2[m].author,str);     } }  void changepress(Bookfile &file,pressfile&f) {     int i,j,k,m;     char str[10];     i=file.len ;         strcpy(str,file.booklen[i].press);     j=0;k=0;     while(j<f.len3)     {         if(strcpy(str,f.Lhf3[i].press)==0)         {             k=j;             break;         }         j++;     }     if(k!=0)     {         file.booklen[i].pressnext=f.Lhf3[k].head;         f.Lhf3[k].head=i;         f.Lhf3[k].Rpresslen++;     }     else      {         m=++f.len3;         file.booklen[i].pressnext=0;         f.Lhf3[k].head=i;         f.Lhf3[k].Rpresslen=1;         strcpy(f.Lhf3[m].press,str);     } }  void createbook(Bookfile &file,BookIDfile &f,Booknamefile &f1,Bookauthorfile &f2,pressfile &f3) {     system(＂cls＂);     char i;     while(i='y')     {               AddBaserecord(file);         changeBaserecord(file,f);         changeBookname(file,f1);         changeauthor(file,f2);          changepress(file,f3);          printf("继续？y  or n");         scanf("%c",&i);     } }  int IDsearch(BookIDfile &f,char key[]) {     int low,high,mid;     low=0;     high=f.len;     while(low<high)     {         mid=(mid+high)/2;         if(strcmp(key,f.BookID[mid].bookID)==0)         {             return f.BookID[mid].Rnum;         }         else if(strcmp(key,f.BookID[mid].bookID)<0)         {             high=mid-1;         }         else             low=mid+1;     }     return 0; } ///////////////////////////////////////////////////////////////

int main() { 	int j,k=1,m; 	char x='z'; 	    Bookfile bf; 		BookIDfile bif; 		Booknamefile f1; 		Bookauthorfile f2; 		pressfile f3;         Readerfile rf; 		Borrowfile bbf;  while(k<=5) { 	 printf("图书管理系统\n"); 	 printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"); 	 printf("1读者管理\n "); 	 printf(" 2图书管理\n "); 	 printf(" 3借还系统\n "); 	 printf(" 4退出系统\n ");      printf(" 5读出所有文件\n"); 	 printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"); 	 scanf("%d",&k); 	 switch(k) 	 { 	 case 1:readerrecord(rf); 		 break; 	 case 2:printf("图书管理子系统\n");system(＂cls＂);      printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");      printf("1图书输入\n ");      printf(" 2图书查询\n");      printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");      scanf("%d",&j);      if(j==1)      createbook(bf,bif,f1,f2,f3);      else searchbook(bf,bif,f1,f2,f3);break; 	 case 3: 		 printf("借还系统\n");      printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");      printf("1借书\n ");      printf(" 2还书\n");      printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");      scanf("%d",&j);      if(j==1)      borrowrecord(bf,bif,bbf,rf);      else back(bf,bif,bbf,rf);break; 	 case 4: 		 printf("退出系统\n"); 		 creatfile(bf,bif,f1,f2,f3,rf,bbf);break; 	case 5:	 readfile(bf,bif,f1,f2,f3,rf,bbf);return 0; 		   	 } }  return 0; }

几点建议： 1、用代码格式来写，一个文件一个代码块，比如： //test.cpp//main.cpp 2、请输出错误信息，我们并不想再运行一遍，最好再写出运行到哪里出错，自己先设断点调试下。 3、如果是逻辑错误，请写出预期输出，和实际输出，好做分析。

编译到哪里错了？ 运行到哪里错了？


Question: stdout与\n的问题.

for (;;); 这是要干嘛

标准输出是行缓冲，\n换行刷新缓冲区

在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。

引用 4 楼 qq120848369 的回复:标准C的IO库输出到终端默认行缓冲。默认实现定义 没默认行缓冲

标准C的IO库输出到终端默认行缓冲。

#include <stdio.h>  int main() { printf("hello,yaoyao"); fflush(stdout); for (;;); return 0; }


Question: CE搜索内存数据的原理

支持一下，，

搜索是带有过滤条件的

有参考价值，mask一下。

为什么看到你们这群大神，我总有一种无力感！！！想问一下   你们都从事这一行业多久了？


Question: c语言读取txt文件

才大一,学个鸟的C语言 等毕业再说

反正看了3楼代码觉得自己又涨姿势

scanf遇到换行时不就结束了吗，难道就为了获得第一个字符？

#include<stdio.h> int main(){   FILE *fp;   int data,max,min;     fp=fopen("data.txt","r");/*假定文件名为data.txt   fscanf(fp,"%d",&max);   min=max;   while(!feof(fp)){     fscanf(fp,"%d",&data);     if(max<data)max=data;     if(min>data)min=data;   }   printf("max=%d\n",max);   printf("min=%d\n",min);   return 0; }

fsacnf() 方法不好, 因为你并不知道文件到底有多在,  LZ, 给你个思路, 先确定文件大小, 分配读取次数(如果文件小,这步可以不做), 读取一次, 排序一次, 读完为止 (  少年 不要做伸手党 要自己去实现才能有提升)

3#写的很详细，不知道scanf能不能自动换行, 其实像这样的用fstream可以很容易实现,在网上一搜，例程也有很多的。

哪里比较困难？

设置一个数组 然后打开文件 之后可以用fsacnf()或者其他的函数读取出其中的数据 存入数组中 然后遍历数组 比较 找出最大最小值  少年 不要做伸手党 要自己去实现才能有提升


Question: 新年第一帖：有关\r和\n的区别

引用 3 楼 mcmay 的回复:[quote=引用 1 楼 thefirstz 的回复:] \r指return，光标会回到该行的最前面，\n指newline，光标会前进到下一行，但位置不一定是最前面，而是上一行光标所在的那个位置，对于以前的打印机，如果想从新一行开头重新打印，就需要这两个一起使用 现在不同的操作系统对两者的处理不同，有的只需要\n，有的需要两者合用 谢谢，thefirstz。光标不一定在最前面，那在哪里？没有一个固定的位置吗？如何验证这一点呢？[/quote] 比如上一行的光标在第40个字符处，\n会让光标还在下一行的第40字符处，不会回到第一个字符即行开始的地方

引用 1 楼 thefirstz 的回复:\r指return，光标会回到该行的最前面，\n指newline，光标会前进到下一行，但位置不一定是最前面，而是上一行光标所在的那个位置，对于以前的打印机，如果想从新一行开头重新打印，就需要这两个一起使用 现在不同的操作系统对两者的处理不同，有的只需要\n，有的需要两者合用 谢谢，thefirstz。光标不一定在最前面，那在哪里？没有一个固定的位置吗？如何验证这一点呢？

楼上正解，具体情况具体分析，C语言里有时也同时使用

引用 6 楼 user-6 的回复:\r 本行的行首！ \n 换行！ 版主正解！我是学了后面的，忘了前面的，该打！

引用 6 楼 user-6 的回复:\r 本行的行首！ \n 换行！ 版主高手一针见血

控制符，还是看当前编译器的说明比较好

引用 5 楼 mcmay 的回复:[quote=引用 4 楼 thefirstz 的回复:] [quote=引用 3 楼 mcmay 的回复:] [quote=引用 1 楼 thefirstz 的回复:] \r指return，光标会回到该行的最前面，\n指newline，光标会前进到下一行，但位置不一定是最前面，而是上一行光标所在的那个位置，对于以前的打印机，如果想从新一行开头重新打印，就需要这两个一起使用 现在不同的操作系统对两者的处理不同，有的只需要\n，有的需要两者合用 谢谢，thefirstz。光标不一定在最前面，那在哪里？没有一个固定的位置吗？如何验证这一点呢？[/quote] 比如上一行的光标在第40个字符处，\n会让光标还在下一行的第40字符处，不会回到第一个字符即行开始的地方[/quote] 我试验了一下，好像光标还是去到了下一行的行首。 #include <stdio.h> #include <stdlib.h>  int main(int argc, char *argv[]) {   printf("This is a test of the escape sequence of \'\\n\'.\n");   getch();   //system("PAUSE");   return 0; }[/quote]  现在不同的操作系统对两者的处理不同，有的只需要\n，有的需要两者合用

\r 本行的行首！ \n 换行！

引用 4 楼 thefirstz 的回复:[quote=引用 3 楼 mcmay 的回复:] [quote=引用 1 楼 thefirstz 的回复:] \r指return，光标会回到该行的最前面，\n指newline，光标会前进到下一行，但位置不一定是最前面，而是上一行光标所在的那个位置，对于以前的打印机，如果想从新一行开头重新打印，就需要这两个一起使用 现在不同的操作系统对两者的处理不同，有的只需要\n，有的需要两者合用 谢谢，thefirstz。光标不一定在最前面，那在哪里？没有一个固定的位置吗？如何验证这一点呢？[/quote] 比如上一行的光标在第40个字符处，\n会让光标还在下一行的第40字符处，不会回到第一个字符即行开始的地方[/quote] 我试验了一下，好像光标还是去到了下一行的行首。 #include <stdio.h> #include <stdlib.h>  int main(int argc, char *argv[]) {   printf("This is a test of the escape sequence of \'\\n\'.\n");   getch();   //system("PAUSE");   return 0; }


Question: 数值转换问题

整数部分和小数部分分开处理 整数部分迭代进行除2的运算  小数部分迭代的进行乘2的运算 关于如何用栈处理数制转换可以看一下严蔚敏的那本数据结构关于栈那块的内容

引用 2 楼 Benjaminzhou93 的回复:14.14 14 / 2 = 7 ... 0 把 0 压栈 7  / 2 = 3 ... 1 把 1 压栈 3  / 2 = 1 ... 1 把 1 压栈 1  / 2 = 0 ... 1 把 1 压栈  依次出栈得出整数部分二进制数 1110  0.14 * 2 = 0.28 得出二进制小数第 1 位 0 0.28 * 2 = 0.56 得出二进制小数第 2 位 0 0.56 * 2 = 1.12 得出二进制小数第 3 位 1 0.12 * 2 = 0.24 得出二进制小数第 4 位 0 0.48 * 2 = 0.96 得出二进制小数第 5 位 0 0.96 * 2 = 1.92 得出二进制小数第 6 位 1 0.92 * 2 = 0.84 得出二进制小数第 7 位 0 0.84 * 2 = 0.68 得出二进制小数第 8 位 0 0.68 * 2 = 1.36 得出二进制小数第 9 位 1 。。。  需要精度更高的继续计算1110.001001001。。。。  小学体育老师教的（数学老师兼职体育）请勿见怪

14.14 14 / 2 = 7 ... 0 把 0 压栈 7  / 2 = 3 ... 1 把 1 压栈 3  / 2 = 1 ... 1 把 1 压栈 1  / 2 = 0 ... 1 把 1 压栈  依次出栈得出整数部分二进制数 1110  0.14 * 2 = 0.28 得出二进制小数第 1 位 0 0.28 * 2 = 0.56 得出二进制小数第 2 位 0 0.56 * 2 = 1.02 得出二进制小数第 3 位 1 0.02 * 2 = 0.04 得出二进制小数第 4 位 0 0.04 * 2 = 0.08 得出二进制小数第 5 位 0 0.08 * 2 = 0.16 得出二进制小数第 6 位 0 0.16 * 2 = 0.32 得出二进制小数第 7 位 0 0.32 * 2 = 0.64 得出二进制小数第 8 位 0 0.64 * 2 = 1.28 得出二进制小数第 9 位 1 。。。  需要精度更高的继续计算1110.001000001。。。。


Question: 不会对不起

引用 6 楼 max_min_ 的回复:学习那个光谷神奇， 去超市捏方便面!关谷神奇吧，版主大人？

学习那个光谷神奇， 去超市捏方便面!

神马情况？～

不明觉厉。。


Question: 今天我们学校校园招聘的题目，求给个标准的带有解释的代码，谢谢！

数据结构里面有讲，翻翻书吧

搜一搜就有了

找字串的算法吧，我记得数据结构的书应该有讲。

数据结构与算法上没讲？

好吧  沙发坐等答案  求知识啊


Question: 数制转换

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <locale.h> int main() {     int i,v;     char bs[33];     char b[33];     char hs[9];     char h[9];     char s[4];     char *e;  // 十进制整数转二进制串；     i=1024;     ltoa(i,b,2);     sprintf(bs,"%032s",b);     printf("i=%d,bs=%s\n",i,bs); // 十进制整数转十六进制串；     i=1024;     ltoa(i,h,16);     sprintf(hs,"%08s",h);     printf("i=%d,hs=%s\n",i,hs); // 十六进制字符串转成十进制数     strcpy(hs,"00000400");     sscanf(hs,"%x",&i);     printf("hs=%s,i=%d\n",hs,i); // 二进制字符串转化为十六进制字符串；     strcpy(bs,"00000000000000000000010000000000");     i=strtol(bs,&e,2);     ltoa(i,h,16);     sprintf(hs,"%08s",h);     printf("bs=%s,hs=%s\n",bs,hs); // 二进制字符串转化为十进制数；     strcpy(bs,"00000000000000000000010000000000");     i=strtol(bs,&e,2);     printf("bs=%s,i=%d\n",bs,i); // 十六进制字符串转成二进制串     strcpy(hs,"00000400");     sscanf(hs,"%x",&i);     ltoa(i,b,2);     sprintf(bs,"%032s",b);     printf("hs=%s,bs=%s\n",hs,bs); // ASC\GBK字符串转十六进制串     strcpy(s,"a汉");     i=0;     while (1) {         if (0==s[i]) break;         sprintf(hs+i*2,"%02X",(unsigned char)s[i]);         i++;     }     setlocale(LC_ALL,"chs");     printf("s=%s,hs=%s\n",s,hs); // 十六进制字符串转成汉字（GBK）及字符(ASC)     strcpy(hs,"61BABA");     i=0;     while (1) {         if (1!=sscanf(hs+i*2,"%2x",&v)) break;         s[i]=(char)v;         i++;     }     s[i]=0;     printf("hs=%s,s=%s\n",hs,s);      return 0;  } //i=1024,bs=00000000000000000000010000000000 //i=1024,hs=00000400 //hs=00000400,i=1024 //bs=00000000000000000000010000000000,hs=00000400 //bs=00000000000000000000010000000000,i=1024 //hs=00000400,bs=00000000000000000000010000000000 //s=a汉,hs=61BABA //hs=61BABA,s=a汉

问题呢？？？


Question: 8皇后

虽然解决了还是说说你们的看法吧，这n++和++n是不是不能随便用啊

刚看

问题解决啦，应该是n+1


Question: 杭电2092 关于整数解得 不知道怎么错的

如下修改可AC #include<stdio.h> #include<math.h> int main() {   int a,b,t;   int n;//double n;   while(scanf("%d%d",&a,&b)&&!(a==0&&b==0))//while(scanf("%d%d",&a,&b)&&a>-10000&&a<10000&&b>-10000&&b<10000&&!(a==0&&b==0))   {     t=a*a-4*b;     n=(int)sqrt((double)t);//n=sqrt((double)t);     if(n<0||t!=(n*n)||(a+n)%2==1)//if(t<0||n!=(int)n||(a+(int)n)%2==1)       printf("No\n");     else       printf("Yes\n");   }   return 0; }

晕啊   小菜鸟表示看不懂

引用数学解法： 根据一元二次方程根和系数的关系以及根公式：  求根公式起始就是：  可以认为你所求的x,y就是两个根，两根之和以及两根乘积为已知，带入以上公式，就能得到答案。 无论答案是整数，还是实数，甚至是虚数都没有问题。 这是用word写的？ 是word写的。

你输入3组样例，能得到正确结果么？不能的话单步调试

引用 3 楼 KenZhang1031 的回复:数学解法： 根据一元二次方程根和系数的关系以及根公式：  求根公式起始就是：  可以认为你所求的x,y就是两个根，两根之和以及两根乘积为已知，带入以上公式，就能得到答案。 无论答案是整数，还是实数，甚至是虚数都没有问题。 这是用word写的？

引用 1 楼 Benjaminzhou93 的回复:n + m = x n * m = y  n(x-n) = y  -n^2 + nx -y = 0 deta = x^2 - 4( -1 * (-y)) // 大于等于0时有解 deta = x^2 -4y  因解为整数得 (-x + deta^1/2) / 2y 为整数 或 (-x - deta^1/2) / 2y 为整数 a是-1呵呵


Question: c语言中很简单的问题。。   关于结构体数组成员在调用函数如何比较大小

楼上的有用，拿结构体中的一个成员作为对比对象，这样也行。

struct foo { int a; int b; };  foo a[10];  for (int i = 0; i < 9; i++) { if (a[i].a > a[i + 1].a) { foo tmp; tmp = a[i]; a[i] = a[i + 1]; a[i + 1] = tmp; } }

楼主先动手，我们来帮手。

整数怎么排序，结构也这么做，就成了，只是比较方式不同而已。

就是个如何比较的问题，会比较就会排序了，你这又不能，基数排序。

自己先想想撒，写出个带bug的程序也好啊，哥们再帮你调试，不能就两字"大神"就行把问题解决撒。。 而且这是简单的问题~~~~

大神

如何做不到？

和一般的数组冒泡排序一样啊，照着做就行了，先写下试试

按照你的业务逻辑，定义一个大小的概念。

很简单的问题就自己动手做一下吧，要不然你还是问“很简单”的问题

这么说吧: 1）先实现一个整数排序，冒泡，选择，插入。。。。。任何一种。 2）然后把数据类型，替换为结构 把 数据比较用的 < ,<=，>,>=,== != 等运算符; 替换为一个，比较函数，效果等价于，那些运算符。 就可以简单排序了，  3）进一步，改成通过函数指针，比较。 4）再进一步，函数指针，当成参数传递。  至于 C++，可以用模板，functor ----函数对象，实现比较；  如果可以使用库函数，只需要实现比较函数既可以了。


Question: 如何定义成宏？

引用 2 楼 zhao4zhong1 的回复:CComboBox * pCombo = (CComboBox *)this->GetDlgItem(IDC_COMBOPARAM1);  int index = pCombo->GetCurSel();  int *i2pv[]={&EFF,&FF,&I1,&IM,&ISC,&PM,&VM,&VOC};  m_min1 = m_item.item[*i2pv[index%8]][MIN];  m_max1 = m_item.item[*i2pv[index%8]][MAX];   是这样定义的 enum ITEM{ISC=0,VOC,PM,FF,I1,EFF,IM,VM,RS,RSH,IREV,ENVTEMP,SURFTEMP};

直接用数组index，比如直接这样：  m_min1 = m_item.item[index][MIN];  m_max1 = m_item.item[index][MAX];  也就是让你的index和什么VOC VM对应起来就可以了

//如果这样定义： int EFF,FF,I1,IM,ISC,PM,VM,VOC; //那么 CComboBox * pCombo = (CComboBox *)this->GetDlgItem(IDC_COMBOPARAM1); int index = pCombo->GetCurSel(); int *i2pv[]={&EFF,&FF,&I1,&IM,&ISC,&PM,&VM,&VOC}; m_min1 = m_item.item[*i2pv[index%8]][MIN]; m_max1 = m_item.item[*i2pv[index%8]][MAX];  //-------------------------------------------------------------------- //如果这样定义： enum ITEM{ISC=0,VOC,PM,FF,I1,EFF,IM,VM,RS,RSH,IREV,ENVTEMP,SURFTEMP}; //            0   1  2  3  4   5  6  7  8   9   10      11       12 //那么 CComboBox * pCombo = (CComboBox *)this->GetDlgItem(IDC_COMBOPARAM1); int index = pCombo->GetCurSel(); //          EFF  FF  I1  IM  ISC  PM  VM  VOC int i2e[]={   5,  3,  4,  6,   0,  2,  7,   1}; m_min1 = m_item.item[ i2e [index%8]][MIN]; m_max1 = m_item.item[ i2e [index%8]][MAX];

引用 3 楼 u013251402 的回复:[quote=引用 2 楼 zhao4zhong1 的回复:] CComboBox * pCombo = (CComboBox *)this->GetDlgItem(IDC_COMBOPARAM1);  int index = pCombo->GetCurSel();  int *i2pv[]={&EFF,&FF,&I1,&IM,&ISC,&PM,&VM,&VOC};  m_min1 = m_item.item[*i2pv[index%8]][MIN];  m_max1 = m_item.item[*i2pv[index%8]][MAX];   是这样定义的 enum ITEM{ISC=0,VOC,PM,FF,I1,EFF,IM,VM,RS,RSH,IREV,ENVTEMP,SURFTEMP};[/quote] 这样不是更加简单了，你只要和case的index对应上就行了


Question: C语言 实现http代理 访问上网

在哪下C语言安装包？

引用 1 楼 truexf 的回复:hook winsock api 引用 3 楼 u013241177 的回复:Libevent也可以很多库都可以实现  ++

学习c中。。。。。

Libevent也可以很多库都可以实现

hook winsock api

引用 4 楼 user-7 的回复:收到客户端请求，发给下游，收到下游应答，回给客户端。 能在具体一点么，主要是 我想在本地写一个 代理服务器  采用C/S模式，服务器端监听接受上网数据，之后发给客户端，客户端在转发到外网上去

收到客户端请求，发给下游，收到下游应答，回给客户端。


Question: 为什么程序之只能运行一般，就自动退出

引用 7 楼 zhuobattle 的回复:你要消耗一个回车，否则下面的输入自然自动结束了。代码如上，添加一个getchar()按照你的成功了，我动了，谢谢你

引用 8 楼 zhao4zhong1 的回复:在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。懂了，解决了。谢谢你

引用 6 楼 zhuobattle 的回复: int main() { 	char str1; 	char str2[10]; 	puts("Please enter a character "); 	str1=getchar();        //获取字符 	getchar();//消耗一个回车,注意添加这行。 	putchar(str1);//输出获得的字符 	puts("Please enter string");//        提示输入字符串 	gets_s(str2,10);                 //从输入流中抓取字符串 	puts(str2);               //输出获得的字符串 	return 0; } 我明白了，可是为什么我的输入的字符会输出2次呢，那个X我只输出可一次

这个程序实际上不是crash

引用 3 楼 u013163178 的回复:引用 1 楼 zhao4zhong1 的回复:崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处。在调试的时候就出现这个提示输入  那你就输入啊 继续跟踪

char str2[10]; gets_s(str2,10);


Question: C语言中怎么把已经存入TXT中的信息在程序开始运行时通过语句输出。

FILE* FP;

引用 3 楼 user-3 的回复:写和读不差不多嘛，呵呵，会写文件就会读文件啦  嗯  现在会了

引用 楼主 u013173634 的回复:现在再学C语言，遍一个学生管理系统。 输入程序运行输入数据都保存到txt文本里了，但是我想再程序开始运行还没输入数据前把txt已有的数据输出。  这个是什么意思啊？  我也是在学  很多不是很懂，能说明白点吗？

system("type xxx.txt&pause"); ?

写和读不差不多嘛，呵呵，会写文件就会读文件啦


Question: 大神们，C语言里怎么用WMP控件播放音乐

我想实现在编辑框输入MP3的地址，然后点击播放按钮wmp就播放那个MP3

这个不是MFC


Question: 有没有专做网站验证码识别破解的同学

引用 2 楼 user-2 的回复:一般网站都会有几套验证码，要破解的话肯定要有针对性，当然，万能的人工破解可以搞定一切。  啥人工破解？

图像识别啊，还有就是人工代答。网游中很多


Question: 怎样 编写一个程序 可以使之读出随机文件

那就一起读出来然后随机访问啊      读硬盘上的东西是磁头在扫磁片，你也可以用手把磁头拿起来 然后放到一个你想放的位置。。。 如果你不怕你的硬盘被你弄坏了的话

洗牌算法参考下面：#include <stdio.h> #include <stdlib.h> #include <time.h> int d[6]; int i,n,a,b,t; int c,j; void main() {     srand(time(NULL));     printf("shuffle 0..n-1 demo\n");     for (n=1;n<=5;n++) {/* 测试1～5个元素 */         printf("_____n=%d_____\n",n);         j=1;         for (c=1;c<=n;c++) j=j*c;/* j为n! */         j*=n*2;         for (c=1;c<=j;c++) {/* 测试n*2*n!次 */             for (i=0;i<n;i++) d[i]=i;/* 填写0～n-1 */             for (i=n;i>0;i--) {/* 打乱0～n-1 */                 a=i-1;b=rand()%i;                 if (a!=b) {t=d[a];d[a]=d[b];d[b]=t;}             }             printf("%04d:",c);             for (i=0;i<n;i++) printf("%d",d[i]);             printf("\n");         }     }     printf("shuffle 1..n demo\n");     for (n=1;n<=5;n++) {/* 测试1～5个元素 */         printf("_____n=%d_____\n",n);         j=1;         for (c=1;c<=n;c++) j=j*c;/* j为n! */         j*=n*2;         for (c=1;c<=j;c++) {/* 测试n*2*n!次 */             for (i=1;i<=n;i++) d[i]=i;/* 填写1～n */             for (i=n;i>1;i--) {/* 打乱1～n */                 a=i;b=rand()%i+1;                 if (a!=b) {t=d[a];d[a]=d[b];d[b]=t;}             }             printf("%04d:",c);             for (i=1;i<=n;i++) printf("%d",d[i]);             printf("\n");         }     } }

文本模式得按序读入，起码要读要最大的随机编码。数据量大的话考虑用2进制模式，自己制定一个格式头，记录每笔数据的偏离值和大小，那么就可以随机读取...

把你的程序代码贴出来吧. 你的思路没有问题. 顺序读取题目到数据t中. 然后再随机出索引读取.


Question: MFC编程，输出的问题

你可以使用一个Lable控件  这样免得重绘了 你如果用当前这个方法的话需要使用重绘将之前显示的文本给覆盖掉 然后再显示出当前你想显示的文本 找一下有没有Label控件 用那个的话可以更容易一些   推荐看一下 孙鑫的 《VC++深入详解》 我当时就是看这本书 很多东西讲的还是很细的

就是OnDraw,其他对话框只是把显示的数据传给view


Question: 一个关于指针关的问题

引用 10 楼 a345485527 的回复:[quote=引用 9 楼 u013160932 的回复:] [quote=引用 8 楼 u013160932 的回复:] [quote=引用 7 楼 a345485527 的回复:] 举个简单的例子  typedef struct { 	int val; }A,*pA;  int main() { 	//下3行正常运行， 	A a; 	a.val=123; 	printf("%d\n",a.val);  	pA ptr;//定义指针 	ptr=(pA)malloc(sizeof(A));//把这句和free(ptr)注释掉再看看 	ptr->val=123; 	printf("%d\n",ptr->val); 	free(ptr); }  嗯,果然分配真的不行,我就不明白了,我那个程序怎么没分配空间也不会出错= =[/quote] 哦哦,我知道哪错了= =[/quote] 加油吧，跨年还能静下心来编程，可赞[/quote] 谢谢大神的帮忙和鼓励

引用 9 楼 u013160932 的回复:[quote=引用 8 楼 u013160932 的回复:] [quote=引用 7 楼 a345485527 的回复:] 举个简单的例子  typedef struct { 	int val; }A,*pA;  int main() { 	//下3行正常运行， 	A a; 	a.val=123; 	printf("%d\n",a.val);  	pA ptr;//定义指针 	ptr=(pA)malloc(sizeof(A));//把这句和free(ptr)注释掉再看看 	ptr->val=123; 	printf("%d\n",ptr->val); 	free(ptr); }  嗯,果然分配真的不行,我就不明白了,我那个程序怎么没分配空间也不会出错= =[/quote] 哦哦,我知道哪错了= =[/quote] 加油吧，跨年还能静下心来编程，可赞

引用 8 楼 u013160932 的回复:[quote=引用 7 楼 a345485527 的回复:] 举个简单的例子  typedef struct { 	int val; }A,*pA;  int main() { 	//下3行正常运行， 	A a; 	a.val=123; 	printf("%d\n",a.val);  	pA ptr;//定义指针 	ptr=(pA)malloc(sizeof(A));//把这句和free(ptr)注释掉再看看 	ptr->val=123; 	printf("%d\n",ptr->val); 	free(ptr); }  嗯,果然分配真的不行,我就不明白了,我那个程序怎么没分配空间也不会出错= =[/quote] 哦哦,我知道哪错了= =

引用 7 楼 a345485527 的回复:举个简单的例子  typedef struct { 	int val; }A,*pA;  int main() { 	//下3行正常运行， 	A a; 	a.val=123; 	printf("%d\n",a.val);  	pA ptr;//定义指针 	ptr=(pA)malloc(sizeof(A));//把这句和free(ptr)注释掉再看看 	ptr->val=123; 	printf("%d\n",ptr->val); 	free(ptr); }  嗯,果然分配真的不行,我就不明白了,我那个程序怎么没分配空间也不会出错= =

引用 5 楼 user-2 的回复:void CreatStack(Linkstack s) 这时把s复制一个 stack s; CreatStack(&s);  不报错并不等于正确，你上面代码应该是什么也没做。你也没给CreatStack的源代码 我在回复给了代码了,我改成这样后,遍历,插入,都可以啊= =

引用 3 楼 a345485527 的回复:记住，使用指针之前必须要初始化或者为它分配内存， 在主函数中定义的s是一个指针，而在Init函数中，你只为s->top（也就是QNODE）分配了内存，而没有为s自身分配内存 下面是改正过的：  void Init(stack &s)//初始化 { 	s=(stack)malloc(sizeof(STACK));//给s分配内存 	s->top=(Qnode)malloc(sizeof(NODE));//然后再给s->top分配内存 	s->bot=s->top; 	s->top->next=NULL; }  可是当我换成 void CreatStack(Linkstack s) stack s; CreatStack(&s); 这种形式的时候,函数里面也没分配啊,但是程序运行的到= =  还有,当我用stack定义s的时候不是系统就已经分配好内存了么?

引用 1 楼 a345485527 的回复:1.BTree &T叫做引用，可以理解成把实参直接传递到函数中了，没有拷贝副本 2.没看出什么问题，CreateStack内部的问题吧 那你帮我看看 #include<stdio.h> #include<stdlib.h> typedef struct NODE { 	int data; 	struct NODE *next; }QNODE,*Qnode; typedef struct { 	Qnode top; 	Qnode bot; }STACK,*stack;  void Init(stack &s)//初始化 { 	s->top=(Qnode)malloc(sizeof(NODE)); 	s->bot=s->top; 	s->top->next=NULL; } void push(stack s,int e)//入栈 { 	Qnode p=(Qnode)malloc(sizeof(NODE)); 	p->data=e; 	p->next=s->top; 	s->top=p; } void traverse(stack s)//遍历 {     Qnode p=s->top; 	while(p!=s->bot) 	{ 		printf("%d ",p->data); 		p=p->next; 	} } void pop(stack s)//出栈 { 	Qnode p=(Qnode)malloc(sizeof(NODE)); 	p=s->top; 	s->top=p->next; 	free(p); 	p->next=NULL; } int main() { 	stack s; 	Init(s); }


Question: getchar、putchar和getc、puts的问题。

引用 30 楼 lm_whales 的回复: 每从stdin流中获取一个字符，stdin便少一个字符（stdin内部，维持一个队列） 当无字符可用时，就会等待用户输入

引用 27 楼 u013163178 的回复:getchar你是想说getchar并不是直接从键盘获得字符，而是我们把字符字符放到stdin流中，只有按下回车键，stdin才被刷新，这时getchar就可以从中获取字符，并把它赋值给c让后输出来，每从stdin流中获取一个字符，stdin便少一个字符，自动刷新一次，getchar便再次获得字符，一直到stdin中没有字符，就不会在刷新，是这个意思吗 是这样的 只流缓冲空的时候，getchar这样的流输入，才会等待用户，从键盘输入。 只有接收到回车的时候，putchar这样的流输出，才会自动刷新流缓冲，数据才会输出到屏幕。

引用 24 楼 u013163178 的回复:[quote=引用 16 楼 lm_whales 的回复:] [quote=引用 15 楼 u013163178 的回复:] 我运行了一遍，感觉是一样的啊，空格和回车都是一样的 不是一不一样的问题。 是逻辑问题 第一个程序： 你希望输入一个字符，输出一个字符，才会写成第一个程序那种形式 实际上，是你输入一行，它输出一行，和你的预期完全不符。 这是一种设计错误。 第二个程序 设计的就是输入一整行，接着输出一整行。 结果完全符合要求。   [/quote]不知道为什么putchar能输出字符串，明明用的getchar和putchar却能输出和获得字符串[/quote] 因为是缓冲IO 或者叫 流IO 不论输入输出，都是先放在缓冲里的 只有遇到回车，才开始真的读取，和输出  这里有两个输入输出过程 1）输入 1.1) 1个是用户敲键盘，输入数据到输入流缓冲  1.2) 1个是程序中 getchar() 这个函数，从输入缓冲读取字符 并赋值给c  流输入并不是用户输入一个，getchar()就会执行一次 而是getchar()函数,一直在等待，直到输入流被更新; 即用户输入回车的时候，才开始读取流缓冲中的数据; 而只要流缓冲有数据，getchar()就可以不用等待，一直读取，直到流缓冲被读空。 2)输出  2.1) 1个是 putchar()函数直接把 c 输出到流缓冲;  2.2) 1个是，流缓冲等待输出回车换行，才开始清理流缓冲; 一次性，把一行数据，输出到 stdout 对应的文件或设备中（屏幕）。 此时，输出流缓冲被清空，后面就可以重新输出数据到流缓冲了。  那么，现在看看第一个程序的输入输出过程 程序中 while((c = getchar())!=EOF) {     putchar(c); } 每次调用getchar，把一个字符读到c中，如果缓冲没有数据， 那么就一直等待用户输入，直到用户输入回车('\n')； 此时getchar返回输入流缓冲中，接收的第一个字符；  输入流缓冲，此时，接收一行字符，包括回车换行（‘\n’）。 getchar返回后，只有第一个字符赋值给了c 其他字符还在输入流缓冲。  此时程序调用putchar函数输出c  只要这个字符不是‘\n’ ，那么这个字符只是输出到流缓冲，并不输出到屏幕。 接着又是调用getchar， 然后 putchar  当 getchar读到‘\n’时，接着putchar 输出‘\n’ 此时用户输入的一整行数据，才开始输出到屏幕  结果就是输入一行，输出一行 然后，再重新开始这个过程。  直到读到文件结束标志，此时c == EOF，就是键盘输入ctrl Z ，显示 ^Z，结束程序的运行。 linux ,unix 键盘输入ctrl D ，显示 ^D

引用 23 楼 fjzhtaobao 的回复:假如有一个无符号8位数据255赋给一个byte类型数据 a；溢出后的a是多少？a=-1?a=0?a=-2? a=255

引用 16 楼 lm_whales 的回复:[quote=引用 15 楼 u013163178 的回复:] 我运行了一遍，感觉是一样的啊，空格和回车都是一样的 不是一不一样的问题。 是逻辑问题 第一个程序： 你希望输入一个字符，输出一个字符，才会写成第一个程序那种形式 实际上，是你输入一行，它输出一行，和你的预期完全不符。 这是一种设计错误。 第二个程序 设计的就是输入一整行，接着输出一整行。 结果完全符合要求。   [/quote]不知道为什么putchar能输出字符串，明明用的getchar和putchar却能输出和获得字符串

每天看你们的回复就感觉自己又涨姿势了

谢谢大家的讨论，我已经明白了。十八楼说的很清楚。

18楼的分析非常彻底，你单单从结果来看，确实看不出123来。

引用 26 楼 lm_whales 的回复:[quote=引用 24 楼 u013163178 的回复:] [quote=引用 16 楼 lm_whales 的回复:] [quote=引用 15 楼 u013163178 的回复:] 我运行了一遍，感觉是一样的啊，空格和回车都是一样的 不是一不一样的问题。 是逻辑问题 第一个程序： 你希望输入一个字符，输出一个字符，才会写成第一个程序那种形式 实际上，是你输入一行，它输出一行，和你的预期完全不符。 这是一种设计错误。 第二个程序 设计的就是输入一整行，接着输出一整行。 结果完全符合要求。   [/quote]不知道为什么putchar能输出字符串，明明用的getchar和putchar却能输出和获得字符串[/quote] 因为是缓冲IO 或者叫 流IO 不论输入输出，都是先放在缓冲里的 只有遇到回车，才开始真的读取，和输出  这里有两个输入输出过程 1）输入 1.1) 1个是用户敲键盘，输入数据到输入流缓冲  1.2) 1个是程序中 getchar() 这个函数，从输入缓冲读取字符 并赋值给c  流输入并不是用户输入一个，getchar()就会执行一次 而是getchar()函数,一直在等待，直到输入流被更新; 即用户输入回车的时候，才开始读取流缓冲中的数据; 而只要流缓冲有数据，getchar()就可以不用等待，一直读取，直到流缓冲被读空。 2)输出  2.1) 1个是 putchar()函数直接把 c 输出到流缓冲;  2.2) 1个是，流缓冲等待输出回车换行，才开始清理流缓冲; 一次性，把一行数据，输出到 stdout 对应的文件或设备中（屏幕）。 此时，输出流缓冲被清空，后面就可以重新输出数据到流缓冲了。  那么，现在看看第一个程序的输入输出过程 程序中 while((c = getchar())!=EOF) {     putchar(c); } 每次调用getchar，把一个字符读到c中，如果缓冲没有数据， 那么就一直等待用户输入，直到用户输入回车('\n')； 此时getchar返回输入流缓冲中，接收的第一个字符；  输入流缓冲，此时，接收一行字符，包括回车换行（‘\n’）。 getchar返回后，只有第一个字符赋值给了c 其他字符还在输入流缓冲。  此时程序调用putchar函数输出c  只要这个字符不是‘\n’ ，那么这个字符只是输出到流缓冲，并不输出到屏幕。 接着又是调用getchar， 然后 putchar  当 getchar读到‘\n’时，接着putchar 输出‘\n’ 此时用户输入的一整行数据，才开始输出到屏幕  结果就是输入一行，输出一行 然后，再重新开始这个过程。  直到读到文件结束标志，此时c == EOF，就是键盘输入ctrl Z ，显示 ^Z，结束程序的运行。 linux ,unix 键盘输入ctrl D ，显示 ^D     [/quote]while((c = getchar())!=EOF) {     putchar(c); }getchar你是想说getchar并不是直接从键盘获得字符，而是我们把字符字符放到stdin流中，只有按下回车键，stdin才被刷新，这时getchar就可以从中获取字符，并把它赋值给c让后输出来，每从stdin流中获取一个字符，stdin便少一个字符，自动刷新一次，getchar便再次获得字符，一直到stdin中没有字符，就不会在刷新，是这个意思吗

引用 19 楼 user-8 的回复:另外进阶了以后，就会明白gets其实及其不安全，所以才有fgets及gets_s这样的存在。 引用 18 楼 user-8 的回复:均是死循环？。。。。。。 不是的。。。。。。 运行效果完全相同？。。。。 也不是的，核心概念：流  你这个解释和，比较清晰，不过楼主； 仅仅从，程序运行时的，输入和输出，来看问题的，所以看到的难免片面。

关于功能上来说，是因为加了一个while循环，所以有了一个功能一样的错觉，但是从实现角度来说，这个逻辑是有问题的。第一种是不停的从缓冲区读取字符，然后每getchar一次就putchar一次。而后者是一次性读取出来，然后再由puts一次性输出。完全就是不同的概念。  至于安全问题，可以看一下这里：http://www.360doc.com/content/11/0610/16/6295074_126040631.shtml

均是死循环？  不是的，getchar和gets都有返回NULL的时候，这时while的条件就不满足了，循环就结束了； 那它们什么时候返回NULL呢？当它们读到EOF的时候； 那控制台怎么输入EOF呢？Windows下就是Ctrl+Z  运行效果完全相同？  也不是的，看上去一样，实际运行的原理还是不一样的。 getchar每次读入一个字符，gets每次读一行（但会丢弃回车），这就是它们的区别； 为什么都是回车之后才有反应？因为标准IO都是有缓冲的，而且是行缓冲， 这意味着“标准输入流”只有在按回车之后，输入的东西才会进入流（输入的东西也包括了回车） 比如，刚进入程序，“标准输入流”中没有任何东西，这时getX会等待输入（还没有进循环体） 用户输入abc，“标准输入流”还是没有东西，直到用户输入回车<cr>，这时“标注输入流”中才有东西： abc<cr> 这时标准输入流有东西了，getX可以返回了，  getchar从stdin中读入一个字符a，返回该字符，该字符不为NULL，进入循环体，putchar该字符；然后又回到while，读入下一个字符b，不为NULL，putchar该字符，一直到<cr>，getchar读入<cr>，不为NULL，putchar <cr>产生回车效果，这时stdin空了，等待用户的下一次输入  而gets从stdin中读入abc<cr>，并将abc存入foor（<cr>丢弃），由于成功读入，gets返回foor，它并不是NULL，从而导致进入循环体，puts将输出foor，即abc，同时puts会多输出个回车，然后又回到while，这时stdin已空，程序停下来等待用户的下一次输入  由此可以发现，用户输入 abc<cr> getchar while了四次，而gets只while了一次，这就是它们区别的表现，单纯看输入输出是看不出来的，可以通过debugger跟踪程序的运行，来理解while的过程；也可以通过加一个循环counter，来跟踪while的次数。  核心概念：流

至于，gets 一直都是这么用的； 直到有一天，发现这有安全问题； 于是增加了gets_s 来替换gets 如此而已。

引用 15 楼 u013163178 的回复:我运行了一遍，感觉是一样的啊，空格和回车都是一样的 不是一不一样的问题。 是逻辑问题 第一个程序： 你希望输入一个字符，输出一个字符，才会写成第一个程序那种形式 实际上，是你输入一行，它输出一行，和你的预期完全不符。 这是一种设计错误。 第二个程序 设计的就是输入一整行，接着输出一整行。 结果完全符合要求。

我运行了一遍，感觉是一样的啊，空格和回车都是一样的

引用 11 楼 lm_whales 的回复:1）这些都是缓冲IO函数，用非缓冲，IO函数就不同了  2）getchar只接收一个字符，还要等到输入回车，才会开始读取。    所以，要求输入时，必须一个字符一个回车，并且回车要设法处理掉。     所以，对于第一个程序，输入多个字符，再回车，这种输入是不正确的，属于非法输入；    由于这个程序，并无容错功能，所以输入多个字符，结果不正确，是理所当然的。        至于第二个程序，输入整行，输出整行用 gets,gets_s,puts     这个设计，没有那么明显的失误        运行结果也符合要求。    和上一个完全不同。好像有一点区别，gets_比gets安全些

引用 3 楼 Benjaminzhou93 的回复:本来想测测 getchar 和 gets 空格有什么区别 但是vs2013报错编译失败你吧gets换成gets_s就可以了吧

引用 8 楼 Benjaminzhou93 的回复:[quote=引用 7 楼 Benjaminzhou93 的回复:] [quote=引用 6 楼 Adol1111 的回复:] 这样写怎样： #define gets gets_s[/quote] 试了下没编译通过[/quote] gets_s是微软自己重写的库函数啊，你用#define改名做什么....这不是没区别么


Question: 求大神给注释，谢了

#define _CRT_SECURE_NO_WARNINGS   #include <windows.h>   #include <math.h>   #include <time.h>   #pragma comment(lib, "user32.lib")   #pragma comment(lib, "gdi32.lib")   #pragma comment(linker, "/SUBSYSTEM:Windows")       void GetPos(double degree, int len, int* x, int* y)   {       *x = len * sin(degree);       *y = len * cos(degree);   }       void DrawClock(HWND hw, HDC h, int hour, int minute, int second)   {       HDC bufdc = CreateCompatibleDC(h);       HBITMAP buf = CreateCompatibleBitmap(bufdc, 200, 200);       RECT cr;       	/* 创建一个白色的画刷 */     HBRUSH bBg = CreateSolidBrush(RGB(255, 255, 255));       GetClientRect(hw, &cr);       SelectObject(bufdc, bBg);       SelectObject(bufdc, buf);           FillRect(bufdc, &cr, bBg);           {           int sx, sy, ex, ey;           int i;          /* 这里应该是标记出表上的12个时间点 每个标记是一个小短线*/         for(i = 0; i < 12; ++i) {               GetPos(2*3.14159/12*i, 85, &sx, &sy);               GetPos(2*3.14159/12*i, 95, &ex, &ey);               MoveToEx(bufdc, 100+sx, 100-sy, 0);               LineTo(bufdc, 100+ex, 100-ey);           }       }          /* 画出时针 分针 秒针 */     {           int hx, hy, mx, my, sx, sy;           GetPos(2*3.14159 / 12 * (hour + (double)minute / 60 + (double)second / 3600), 50, &hx, &hy);           GetPos(2*3.14159 / 60 * (minute + (double)second / 60), 65, &mx, &my);           GetPos(2*3.14159 / 60 * second, 80, &sx, &sy);           MoveToEx(bufdc, 100, 100, NULL);           LineTo(bufdc, 100+hx, 100-hy);           MoveToEx(bufdc, 100, 100, NULL);           LineTo(bufdc, 100+mx, 100-my);           MoveToEx(bufdc, 100, 100, NULL);           LineTo(bufdc, 100+sx, 100-sy);       }               BitBlt(h, 0, 0, 200, 200, bufdc, 0, 0, SRCCOPY);       	/* 释放分配的资源 */     DeleteDC(bufdc);       DeleteObject(bBg);       DeleteObject(buf);   }       LRESULT CALLBACK WndProc(HWND h, UINT m, WPARAM w, LPARAM l)   {       switch(m) {           case WM_CREATE:               SetTimer(h, 1, 1000, 0);   /* 设置时间间隔 每一秒作为一个时间间隔 */              return 0;           case WM_ERASEBKGND:               return 1;           case WM_TIMER:               InvalidateRect(h, 0, FALSE);               return 0;           case WM_PAINT: {               PAINTSTRUCT ps;               HDC dc = BeginPaint(h, &ps);               {                   time_t t;                   struct tm* pst;                   time(&t);                   pst = localtime(&t);                  /* 调用上面定义的函数 描绘出当前时钟 */                 DrawClock(h, dc, pst->tm_hour, pst->tm_min, pst->tm_sec);               }               EndPaint(h, &ps);               return 0;           }           case WM_DESTROY:               KillTimer(h, 1);    /* 杀死定时器 */              PostQuitMessage(0);               return 0;           default:               return DefWindowProc(h, m, w, l);       }   }       int APIENTRY WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmd, INT nShow)   {       WNDCLASS wc;       ZeroMemory(&wc, sizeof(wc));       wc.style = CS_HREDRAW | CS_VREDRAW;       wc.lpfnWndProc = WndProc;       wc.hInstance = hInst;       wc.hbrBackground = (HBRUSH) COLOR_WINDOW;       wc.lpszClassName = TEXT("MYCLOCK");               if (RegisterClass(&wc) != 0) {           MSG m;           		/* 创建窗口 */         HWND hw = CreateWindow(TEXT("MYCLOCK"), TEXT("Clock"), WS_OVERLAPPEDWINDOW,               CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInst, 0);                       if (hw != NULL) {               RECT r;               GetWindowRect(hw, &r);               r.right = r.left + 200;               r.bottom = r.top + 200;               AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, FALSE);               MoveWindow(hw, r.left, r.top, r.right - r.left, r.bottom - r.top, FALSE);               ShowWindow(hw, SW_SHOWNORMAL);    /* 将窗口显示出来 */              UpdateWindow(hw);                           while( GetMessage(&m, 0, 0, 0) > 0) {                   TranslateMessage(&m);                   DispatchMessage(&m);               }               return 0;           }           return 1;       } else           return 1; } 不要做伸手党 你自己找本书看看 这就是一个Win32 应用程序 我也很久不做Win32应用程序了 你可以找一下张孝祥的一本关于windows应用程序开发的书  或者是看一下孙鑫的那本VC++深入详解


Question: 如何对编号、单价等排序啊？用冒泡等方法

简单的冒泡还会？

这也行?  冒泡排序是最简单最容易实现的排序方法了吧  你是数据结构不懂还是排序算法不会 看这样应该就是进行简单的数组排序吧 int i = 0; int j = 0;  for (i = 0; i < len - 1; ++i) {     for (j = i + 1; j < len; ++j)     {         /* 如果是对编号的话 用strcmp 判断是正还是负 从而得出谁大谁小 */         if (sequenList.r[i].price > sequenList.r[j].price)         {                交换两者          }     } }   少年不要做伸手党 https://www.google.com.hk/search?q=%E5%86%92%E6%B3%A1%E6%8E%92%E5%BA%8F&oq=%E5%86%92%E6%B3%A1%E6%8E%92%E5%BA%8F&aqs=chrome..69i57j69i60l4j0.2661j0&sourceid=chrome&espv=210&es_sm=122&ie=UTF-8 一搜一大片 要学会自己解决问题


Question: 网络接受jpg，byte数据，如何存入本地路径？

引用 4 楼 lwb910928 的回复:能具体点吗 ？ 不是太懂啊 ！有人好像说还是要有格式的。 关于图像是存在内部的一些字节决定了图像怎么被解析显示的问题 但是因为你在接受和存储的时候和原图像的内容是完全一样的 所以并不会破坏掉原来图像内部的整体格式 所以存储后照样很好的显示 所以你无需考虑图像内容的格式是什么样的

引用 4 楼 lwb910928 的回复:能具体点吗 ？ 不是太懂啊 ！有人好像说还是要有格式的。 格式的话你可以根据接收文件的后缀名来决定你在本地存储的文件的后缀名 这样你在写入本地文件的时候使用二进制方式写入 这样图像之类的文件也都是没有任何问题的

能具体点吗 ？ 不是太懂啊 ！有人好像说还是要有格式的。

文件保存 就和你在本地是的文件操作是一样的 你在本地打开一个文件读入然后存入另一个文件 怎么做这个就怎么做 只是这个接受的文件是从socket读取的数据而已 并且socket也是一个文件描述符 所以当你开始接受网络数据时打开一个文件 然后将接受到的数据写入到你打开的那个文件 在接受完成后 关闭那个文件就OK了

CreateFile WriteFile CloseHandle 不用谢

写文件保存，不谢。


Question: 模块封装。。。。。。

哦，好的，我试下。。。。

用全局变量可以，不过用宏更直接而且有效率。  引用 8 楼 u012889234 的回复:[quote=引用 7 楼 turingo 的回复:] 笔误不好意思，是char*  [quote=引用 2 楼 user-3 的回复:] [quote=引用 1 楼 turingo 的回复:] 例如：  #define A_VERSION  "1.1" ... char a_get_version(void) {     return A_VERSION; }   [quote=引用 楼主 u012889234 的回复:] Version 模块名 		Version 模块定义	程序提供版本管理功能 需求		1. show(Screen) 输出版本 	        2.get()查询版本的数字签名 元数据		1. 版本号 	        2. 作者 		3. 创建时间 		4. 版本更新 接口		1.version_show(Screen) 输出版本信息 		2. version_get()查询版本号   B通过这接口函数可以获得A的版本号。 没想明白怎么写。[/quote]  这示例代码写的... 返回char 就可以？[/quote][/quote]  void vserion_show();  unsigned int version_get(void *version);  void*  version_create(char *author, int version_id, char *sysname); typedef struct _Version {     char *author;     char *sysname;     int version_id;     }Version 若A调用version_create 则创建，   version_show用于A显示自己的信息---就如每次程序启动时会打印的那些东西。。 version_get是B为了获取A的版本号的。   是不是要一个全局变量来保存A的版本号？   [/quote]

引用 7 楼 turingo 的回复:笔误不好意思，是char*  [quote=引用 2 楼 user-3 的回复:] [quote=引用 1 楼 turingo 的回复:] 例如：  #define A_VERSION  "1.1" ... char a_get_version(void) {     return A_VERSION; }   [quote=引用 楼主 u012889234 的回复:] Version 模块名 		Version 模块定义	程序提供版本管理功能 需求		1. show(Screen) 输出版本 	        2.get()查询版本的数字签名 元数据		1. 版本号 	        2. 作者 		3. 创建时间 		4. 版本更新 接口		1.version_show(Screen) 输出版本信息 		2. version_get()查询版本号   B通过这接口函数可以获得A的版本号。 没想明白怎么写。[/quote]  这示例代码写的... 返回char 就可以？[/quote][/quote]  void vserion_show();  unsigned int version_get(void *version);  void*  version_create(char *author, int version_id, char *sysname); typedef struct _Version {     char *author;     char *sysname;     int version_id;     }Version 若A调用version_create 则创建，   version_show用于A显示自己的信息---就如每次程序启动时会打印的那些东西。。 version_get是B为了获取A的版本号的。   是不是要一个全局变量来保存A的版本号？

笔误不好意思，是char*  引用 2 楼 user-3 的回复:[quote=引用 1 楼 turingo 的回复:] 例如：  #define A_VERSION  "1.1" ... char a_get_version(void) {     return A_VERSION; }   [quote=引用 楼主 u012889234 的回复:] Version 模块名 		Version 模块定义	程序提供版本管理功能 需求		1. show(Screen) 输出版本 	        2.get()查询版本的数字签名 元数据		1. 版本号 	        2. 作者 		3. 创建时间 		4. 版本更新 接口		1.version_show(Screen) 输出版本信息 		2. version_get()查询版本号   B通过这接口函数可以获得A的版本号。 没想明白怎么写。[/quote]  这示例代码写的... 返回char 就可以？[/quote]

引用 5 楼 u012997273 的回复:interface

interface

类似windows版本管理器的模块。。。

怎么这么简单？？？

引用 1 楼 turingo 的回复:例如：  #define A_VERSION  "1.1" ... char a_get_version(void) {     return A_VERSION; }   [quote=引用 楼主 u012889234 的回复:] Version 模块名 		Version 模块定义	程序提供版本管理功能 需求		1. show(Screen) 输出版本 	        2.get()查询版本的数字签名 元数据		1. 版本号 	        2. 作者 		3. 创建时间 		4. 版本更新 接口		1.version_show(Screen) 输出版本信息 		2. version_get()查询版本号   B通过这接口函数可以获得A的版本号。 没想明白怎么写。[/quote]  这示例代码写的... 返回char 就可以？

例如：  #define A_VERSION  "1.1" ... char a_get_version(void) {     return A_VERSION; }  引用 楼主 u012889234 的回复:Version 模块名 		Version 模块定义	程序提供版本管理功能 需求		1. show(Screen) 输出版本 	        2.get()查询版本的数字签名 元数据		1. 版本号 	        2. 作者 		3. 创建时间 		4. 版本更新 接口		1.version_show(Screen) 输出版本信息 		2. version_get()查询版本号   B通过这接口函数可以获得A的版本号。 没想明白怎么写。


Question: 为什么输出语句放在选择语句外和内得到结果不一样？

请判断scanf函数的返回值！

这些要学会自己调试，值不一样，你就将不同情况下，用于计算的各变量的值打印出来，问题就显而易见了吧。

格式字符串和实际数据不匹配。%f的话，后面的整型数据要转成float型。


Question: 请各位指点迷津，谢谢--

就这结贴率 就这问题 一看就知道是来蹭作业的  人家一堆英文讽刺你都不知道 着实是可怜人  俗话说:可怜之人必有可恨之处 不知道是真的假的

引用 11 楼 u013340289 的回复:[quote=引用 8 楼 bijiaoben 的回复:] [quote=引用 6 楼 u013340289 的回复:] [quote=引用 5 楼 zhao4zhong1 的回复:] 英语也是一门计算机语言的说。  谢谢你，辛苦写了这么多的解释--可是我的英文不好[/quote] [/quote] 表示是刚自学的--那个开发工具还没安装的呢--让你见笑了 [/quote] 兄弟，赶紧先把环境弄好，咱们这个贵在动手加油

引用 10 楼 u013235485 的回复: char x[] = "56\"a\xab\n"; printf_s("%u",sizeof(x));   单字节字符的情况是7个字节。含 编译器最后添加的一个NULL字符\0。 谢谢。。。

引用 8 楼 bijiaoben 的回复:[quote=引用 6 楼 u013340289 的回复:] [quote=引用 5 楼 zhao4zhong1 的回复:] 英语也是一门计算机语言的说。  谢谢你，辛苦写了这么多的解释--可是我的英文不好[/quote] [/quote] 表示是刚自学的--那个开发工具还没安装的呢--让你见笑了

2和3这种题拿出来问有意思吗？自己敲进去运行一下，结果不就出来了吗？想知道细节就单步跟踪一下，不就OK了吗？有发帖这功夫，2和3的结果早都出来了。

引用 6 楼 u013340289 的回复:[quote=引用 5 楼 zhao4zhong1 的回复:] 英语也是一门计算机语言的说。  谢谢你，辛苦写了这么多的解释--可是我的英文不好[/quote] 指定复制粘贴的说， 你不是有电脑吗，输入进去，运行一下结果就出来啦，呵呵

引用 5 楼 zhao4zhong1 的回复:英语也是一门计算机语言的说。  谢谢你，辛苦写了这么多的解释--可是我的英文不好

英语也是一门计算机语言的说。

引用 1 楼 zhao4zhong1 的回复:C++ Character Constants Character constants are one or more members of the “source character set,” the character set in which a program is written, surrounded by single quotation marks ('). They are used to represent characters in the “execution character set,” the character set on the machine where the program executes.  Microsoft Specific   For Microsoft C++, the source and execution character sets are both ASCII.  END Microsoft Specific  There are three kinds of character constants:   Normal character constants   Multicharacter constants   Wide-character constants  Note   Use wide-character constants in place of multicharacter constants to ensure portability.  Character constants are specified as one or more characters enclosed in single quotation marks. For example:  char ch = 'x';          // Specify normal character constant. int mbch = 'ab';        // Specify system-dependent                         //  multicharacter constant. wchar_t wcch = L'ab';   // Specify wide-character constant.  Note that mbch is of type int. If it were declared as type char, the second byte would not be retained. A multicharacter constant has four meaningful characters; specifying more than four generates an error message.  Syntax  character-constant :  'c-char-sequence' L'c-char-sequence'  c-char-sequence :  c-char c-char-sequence c-char  c-char :  any member of the source character set except the single quotation mark ('), backslash (\), or newline character escape-sequence  escape-sequence :  simple-escape-sequence octal-escape-sequence hexadecimal-escape-sequence  simple-escape-sequence : one of  \' \" \? \\ \a \b \f \n \r \t \v  octal-escape-sequence :  \octal-digit \octal-digit octal-digit \octal-digit octal-digit octal-digit  hexadecimal-escape-sequence :  \xhexadecimal-digit hexadecimal-escape-sequence hexadecimal-digit  Microsoft C++ supports normal, multicharacter, and wide-character constants. Use wide-character constants to specify members of the extended execution character set (for example, to support an international application). Normal character constants have type char, multicharacter constants have type int, and wide-character constants have type wchar_t. (The type wchar_t is defined in the standard include files STDDEF.H, STDLIB.H, and STRING.H. The wide-character functions, however, are prototyped only in STDLIB.H.)  The only difference in specification between normal and wide-character constants is that wide-character constants are preceded by the letter L. For example:  char schar = 'x';               // Normal character constant wchar_t wchar = L'\x81\x19';    // Wide-character constant  Table 1.2 shows reserved or nongraphic characters that are system dependent or not allowed within character constants. These characters should be represented with escape sequences.  Table 1.2   C++ Reserved or Nongraphic Characters  Character ASCII  Representation ASCII  Value Escape Sequence  Newline NL (LF) 10 or 0x0a \n  Horizontal tab HT 9 \t  Vertical tab VT 11 or 0x0b \v  Backspace BS 8 \b  Carriage return CR 13 or 0x0d \r  Formfeed FF 12 or 0x0c \f  Alert BEL 7 \a  Backslash \ 92 or 0x5c \\  Question mark ? 63 or 0x3f \?  Single quotation mark ' 39 or 0x27 \'  Double quotation mark " 34 or 0x22 \"  Octal number ooo — \ooo  Hexadecimal number hhh — \xhhh  Null character NUL 0 \0    If the character following the backslash does not specify a legal escape sequence, the result is implementation defined. In Microsoft C++, the character following the backslash is taken literally, as though the escape were not present, and a level 1 warning (“unrecognized character escape sequence”) is issued.  Octal escape sequences, specified in the form \ooo, consist of a backslash and one, two, or three octal characters. Hexadecimal escape sequences, specified in the form \xhhh, consist of the characters \x followed by a sequence of hexadecimal digits. Unlike octal escape constants, there is no limit on the number of hexadecimal digits in an escape sequence.  Octal escape sequences are terminated by the first character that is not an octal digit, or when three characters are seen. For example:  wchar_t och = L'\076a';  // Sequence terminates at a char    ch = '\233';     // Sequence terminates after 3 characters  Similarly, hexadecimal escape sequences terminate at the first character that is not a hexadecimal digit. Because hexadecimal digits include the letters a through f (and A through F), make sure the escape sequence terminates at the intended digit.  Because the single quotation mark (') encloses character constants, use the escape sequence \' to represent enclosed single quotation marks. The double quotation mark (") can be represented without an escape sequence. The backslash character (\) is a line-continuation character when placed at the end of a line. If you want a backslash character to appear within a character constant, you must type two backslashes in a row (\\). (SeePhases of Translation in the Preprocessor Reference for more information about line continuation.) 谢谢你解答--不过我看不明白，全是英文的

C++ String Literals A string literal consists of zero or more characters from the source character set surrounded by double quotation marks ("). A string literal represents a sequence of characters that, taken together, form a null-terminated string.  Syntax  string-literal :  "s-char-sequenceopt" L"s-char-sequenceopt"  s-char-sequence :  s-char s-char-sequence s-char  s-char :  any member of the source character set except the double quotation mark ("), backslash (\), or newline character escape-sequence  C++ strings have these types:   Array of char[n], where n is the length of the string (in characters) plus 1 for the terminating '\0' that marks the end of the string   Array of wchar_t, for wide-character strings  The result of modifying a string constant is undefined. For example:  char *szStr = "1234"; szStr[2] = 'A';      // Results undefined  Microsoft Specific   In some cases, identical string literals can be “pooled” to save space in the executable file. In string-literal pooling, the compiler causes all references to a particular string literal to point to the same location in memory, instead of having each reference point to a separate instance of the string literal. The/Gf compiler option enables string pooling.  END Microsoft Specific  When specifying string literals, adjacent strings are concatenated. Therefore, this declaration:  char szStr[] = "12" "34";  is identical to this declaration:  char szStr[] = "1234";  This concatenation of adjacent strings makes it easy to specify long strings across multiple lines:  cout << "Four score and seven years "         "ago, our forefathers brought forth "         "upon this continent a new nation.";  In the preceding example, the entire string Four score and seven years ago, our forefathers brought forth upon this continent a new nation. is spliced together. This string can also be specified using line splicing as follows:  cout << "Four score and seven years \ ago, our forefathers brought forth \ upon this continent a new nation.";  After all adjacent strings in the constant have been concatenated, the NULL character, '\0', is appended to provide an end-of-string marker for C string-handling functions.  When the first string contains an escape character, string concatenation can yield surprising results. Consider the following two declarations:  char szStr1[] = "\01" "23"; char szStr2[] = "\0123";  Although it is natural to assume that szStr1 and szStr2 contain the same values, the values they actually contain are shown in Figure 1.1.  Figure 1.1   Escapes and String Concatenation    Microsoft Specific   The maximum length of a string literal is approximately 2,048 bytes. This limit applies to strings of type char[] and wchar_t[]. If a string literal consists of parts enclosed in double quotation marks, the preprocessor concatenates the parts into a single string, and for each line concatenated, it adds an extra byte to the total number of bytes.   For example, suppose a string consists of 40 lines with 50 characters per line (2,000 characters), and one line with 7 characters, and each line is surrounded by double quotation marks. This adds up to 2,007 bytes plus one byte for the terminating null character, for a total of 2,008 bytes. On concatenation, an extra character is added to the total number of bytes for each of the first 40 lines. This makes a total of 2,048 bytes. (The extra characters are not actually written to the string.) Note, however, that if line continuations (\) are used instead of double quotation marks, the preprocessor does not add an extra character for each line.  END Microsoft Specific  Determine the size of string objects by counting the number of characters and adding 1 for the terminating '\0' or 2 for type wchar_t.  Because the double quotation mark (") encloses strings, use the escape sequence (\") to represent enclosed double quotation marks. The single quotation mark (') can be represented without an escape sequence. The backslash character (\) is a line-continuation character when placed at the end of a line. If you want a backslash character to appear within a string, you must type two backslashes (\\). (SeePhases of Translation in the Preprocessor Reference for more information about line continuation.)  To specify a string of type wide-character (wchar_t[]), precede the opening double quotation mark with the character L. For example:  wchar_t wszStr[] = L"1a1g";  All normal escape codes listed in Character Constants are valid in string constants. For example:  cout << "First line\nSecond line"; cout << "Error! Take corrective action\a";  Because the escape code terminates at the first character that is not a hexadecimal digit, specification of string constants with embedded hexadecimal escape codes can cause unexpected results. The following example is intended to create a string literal containing ASCII 5, followed by the characters five:  \x05five"  The actual result is a hexadecimal 5F, which is the ASCII code for an underscore, followed by the characters ive. The following example produces the desired results:   "\005five"     // Use octal constant. "\x05" "five"  // Use string splicing.

大家是不是 因为 我问的问题太简单了--不回复的哇--真心求解。。。。


Question: 为什么这样可以输出 这样不可以输出？

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

int型如果除法，小于1会直接变成0

整形1/2=0，%f格式对应浮点不能用整形参数，改下printf("%.2f", -b/(2.0*a));

先把a、b、c转成float然后再试一下，

真奇怪，程序放在选择语句前，都是0.0 ，无奈。。。

引用 1 楼 user-7 的回复:请养成自己debug的习惯。你应当先自己做一下基本的查错再来问。 你可以把a b c先print出来，看看你实际上读进去的是什么。 读进去是输进去的a,b,c的值，但是就是0.00我自己试了强制转换也没用


Question: access函数在windows下对网络映射驱动器无效?

好像没人回答了，结了

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命令不会。

仔细测试了下发现调用StartServiceCtrlDispatcher注册到windows服务上就有这个问题


Question: 指针操作 如何判断数组结尾

引用 21 楼 baipv008 的回复:[quote=引用 20 楼 cjfdqchwh 的回复:] 其次，这个 &obj 的值为何是 这个值？ 跟 pHead 等“连续”不上  看来你还是弄不明白“指针的值”和“指针的地址”的区别。[/quote] 楼主问这个问题的帖子已经结贴了，应该是有所收获了

引用 20 楼 cjfdqchwh 的回复:其次，这个 &obj 的值为何是 这个值？ 跟 pHead 等“连续”不上  看来你还是弄不明白“指针的值”和“指针的地址”的区别。

其次，这个 &obj 的值为何是 这个值？ 跟 pHead 等“连续”不上

引用 17 楼 zhuobattle 的回复:[quote=引用 12 楼 zhao4zhong1 的回复:] #include <stdio.h> int main() {     int Arry[10];     int *pArry;     int i;      for (i=0;i<10;i++) Arry[i]=i;     pArry=Arry;     while (1) {         printf("%d\n",*pArry);         pArry++;         if (pArry>=Arry+sizeof(Arry)/sizeof(Arry[0])) break;     }     return 0; }  动态分配的情况，sizeof返回4,呵呵[/quote]  我接着问您昨天那个问题： http://bbs.csdn.net/topics/390681909  为什么在 typedf struct里的数组，只是占用 2个字节？而不是4个？我截个图：

引用 12 楼 zhao4zhong1 的回复:#include <stdio.h> int main() {     int Arry[10];     int *pArry;     int i;      for (i=0;i<10;i++) Arry[i]=i;     pArry=Arry;     while (1) {         printf("%d\n",*pArry);         pArry++;         if (pArry>=Arry+sizeof(Arry)/sizeof(Arry[0])) break;     }     return 0; } //0 //1 //2 //3 //4 //5 //6 //7 //8 //9 //  动态分配的情况，sizeof返回4,呵呵

引用 15 楼 zhou19891113 的回复:通过你的描述我理解了两种可能性： 1.你想编写一个shellcode注入别人的代码，在代码中你找到了别人使用数组的地方，想扫描这个数组，但是需要判断这个数组有多大，根据你的描述，这块内存是动态增长的，所以这块空间和数组有一定区别，是不能通过sizeof直接得到大小，并且C语言没有获取一个地址的所指向空间的大小的机制，因此，这种情况，只有通过更进一步分析汇编代码解决。 2.你自己写的代码自己却不知道分配的数组有多大，即使是动态分配的，也不应该出现这样的情况，如果真的 出现这样的情况，建议楼主继续学习C语言和数据结构相关知识，多编代码，多学习，这样可以有效避免这样的情况。 呵呵

引用 23 楼 u010551600 的回复:[quote=引用 21 楼 baipv008 的回复:] [quote=引用 20 楼 cjfdqchwh 的回复:] 其次，这个 &obj 的值为何是 这个值？ 跟 pHead 等“连续”不上  看来你还是弄不明白“指针的值”和“指针的地址”的区别。[/quote] 大神，能不能给我解释一下，这是因为什么？为什么指针的地址加4，但输出的是1呢？ #include<iostream>  using namespace std;  void main() { 	int arry[10]; 	for(int i = 0 ; i< 10 ; ++ i) 	{ 		arry[i] = i ; 	} 	int * pArry  = arry ;   	cout<<" pArry = "<<pArry<<endl; 	int *p1 = pArry ; 	cout<<"++ pArry = "<< ++pArry <<endl; 	cout<<"++pArry - pArry = "<<pArry - p1 <<endl;   	while(1 ) 	{ 		cout<< * pArry<<"  "; 		++ pArry; 		if( pArry >= arry + sizeof(arry) / sizeof(arry[0] )) 			break;  	} 	cout<<endl;  }[/quote] 指针+1，地址加指针类型的大小。

引用 21 楼 baipv008 的回复:[quote=引用 20 楼 cjfdqchwh 的回复:] 其次，这个 &obj 的值为何是 这个值？ 跟 pHead 等“连续”不上  看来你还是弄不明白“指针的值”和“指针的地址”的区别。[/quote] 大神，能不能给我解释一下，这是因为什么？为什么指针的地址加4，但输出的是1呢？ #include<iostream>  using namespace std;  void main() { 	int arry[10]; 	for(int i = 0 ; i< 10 ; ++ i) 	{ 		arry[i] = i ; 	} 	int * pArry  = arry ;   	cout<<" pArry = "<<pArry<<endl; 	int *p1 = pArry ; 	cout<<"++ pArry = "<< ++pArry <<endl; 	cout<<"++pArry - pArry = "<<pArry - p1 <<endl;   	while(1 ) 	{ 		cout<< * pArry<<"  "; 		++ pArry; 		if( pArry >= arry + sizeof(arry) / sizeof(arry[0] )) 			break;  	} 	cout<<endl;  }

引用 3 楼 cjfdqchwh 的回复:[quote=引用 2 楼 ovoovo 的回复:] 通过元素个数判断。不能通过指针等于某个值。  恩，这倒是一个方法。 但是我的实际情况是，这个处理方式，不太适应：   有一个巨大的数据，我编写了一个爬虫程序，不断地爬行着，无法知道哪元素个数是多大 [/quote] 数组定义的时候不需要定义个数吗？

引用 2 楼 ovoovo 的回复:通过元素个数判断。不能通过指针等于某个值。  恩，这倒是一个方法。 但是我的实际情况是，这个处理方式，不太适应：   有一个巨大的数据，我编写了一个爬虫程序，不断地爬行着，无法知道哪元素个数是多大

通过元素个数判断。不能通过指针等于某个值。

问题：     如何判断 数组结尾了？

引用 6 楼 cjfdqchwh 的回复:[quote=引用 4 楼 bijiaoben 的回复:] [quote=引用 3 楼 cjfdqchwh 的回复:] [quote=引用 2 楼 ovoovo 的回复:] 通过元素个数判断。不能通过指针等于某个值。  恩，这倒是一个方法。 但是我的实际情况是，这个处理方式，不太适应：   有一个巨大的数据，我编写了一个爬虫程序，不断地爬行着，无法知道哪元素个数是多大 [/quote] 数组定义的时候不需要定义个数吗？[/quote]  引用 5 楼 starytx 的回复:数组定义的时候没有大小？动态开辟的话也有个变量吧。没有这个大小信息无法判断是否结束  不好意思，是我描述的不恰当。  数据时刻在不断地增加着，这里的这个数组，算是一个缓冲，我本意是想问……。 [/quote]   通过你的描述我理解了两种可能性： 1.你想编写一个shellcode注入别人的代码，在代码中你找到了别人使用数组的地方，想扫描这个数组，但是需要判断这个数组有多大，根据你的描述，这块内存是动态增长的，所以这块空间和数组有一定区别，是不能通过sizeof直接得到大小，并且C语言没有获取一个地址的所指向空间的大小的机制，因此，这种情况，只有通过更进一步分析汇编代码解决。 2.你自己写的代码自己却不知道分配的数组有多大，即使是动态分配的，也不应该出现这样的情况，如果真的 出现这样的情况，建议楼主继续学习C语言和数据结构相关知识，多编代码，多学习，这样可以有效避免这样的情况。

对于C的数组来说，必需自己记着数组的大小。

赵老师好强！！！

引用 10 楼 user-9 的回复: 你自己都不知道啥时候结束，怎么让程序知道什么时候结束呢。  对于你发的这个表情，鄙人表示非常反感，真想痛揍这只泼猴

引用 9 楼 cjfdqchwh 的回复:[quote=引用 8 楼 starytx 的回复:] 那你这个数据的结构是什么？动态扩展的数组？如果是数组，那你顶定义一个计数器变量，在每次增加成员时让这个计数器自增，不久知道有多少个元素了？不明白你在纠结什么  难得糊涂，难得纠结。[/quote] 你自己都不知道啥时候结束，怎么让程序知道什么时候结束呢。

引用 8 楼 starytx 的回复:那你这个数据的结构是什么？动态扩展的数组？如果是数组，那你顶定义一个计数器变量，在每次增加成员时让这个计数器自增，不久知道有多少个元素了？不明白你在纠结什么  难得糊涂，难得纠结。


Question: 伟福仿真器keil c编译器，程序某些行不被编译和执行（急）

实际上语句可能已经执行了，但是执行的光标没有指示到正确的行，而是指到了别的行，所以不要看光标，要看具体的实际变量是不是变了，就是这样，一开始结果不正确，就误以为是某些行看上去没有被编译，单步执行也不执行导致的，其实是程序中用到的外部数据空间定义的太大，超了导致的。

你单步跟踪看到的不被执行？我遇到过这样的情况，某些IDE会有类似的问题（比如AVR studio和IAR），实际上语句可能已经执行了，但是执行的光标没有指示到正确的行，而是指到了别的行，所以不要看光标，要看具体的实际变量是不是变了。还有，发生这样的情况，通常是 1、用了中文的字符，比如中文输入法的情况下打了换行或空格这类不易发现的字符。注意要用ascii字符输入。 2、调试时，优化选项不要选优化。否则优化情况下，单步执行的指针你会觉得跳来跳去，根本看不懂。

编译结果如图

先用软件仿真试试看,如果可以再用硬件仿真


Question: UART丢帧和半帧数据如何处理？

通讯要可靠，协议中要采用双向的通讯协议，比如A向B发数据，那么B要有应答，通过这个应答，A可以知道是否成功，不成功则需要重发。

取决于双方所约定的协议，参考http://en.wikipedia.org/wiki/XMODEM  引用 楼主 jiemo1123 的回复:设备A向设备B通过UART链接，A向B发送数据，如果B收到的不是完整的一帧数据，那要怎么处理？直接抛弃？万一一帧都丢了，而B都不知道，又该如何处理？


Question: <<运算的规则是什么

C/C++标准里都写了，对于循环超过类型本身位数的移位，都是实现定义的。 Intel是这样取模。我记得PowerPC好像不是这样。  引用 6 楼 u013194740 的回复:[quote=引用 3 楼 KenZhang1031 的回复:] 引用1 << 32 是常量，编译时1和32都被当成int,编译时就被计算成为0了。 1 << x无法在编译前确定，是被采用指令shl reg cl来执行的，但是intel的汇编对shl有规定的。 引用 The SAL and SHL instructions perform the same operation (see Figure 7-6). They shift the source operand left by from 1 to 31 bit positions. 所以当移位超过31位后，结果可能会是未知的。  试了试shl和rol没区别啊，一会再看看  很久没写汇编了，不循环左移的指令是还要设置什么啊 直接上图最清楚。    谢谢了，我的意思是，超过32位时，shl其实被当做rol来处理了  现在就是只用汇编，如果超过32位，怎么不循环左移呢，是不是只能shl前自己判断啊[/quote] 并不是循环左移，SHL永远都补0，不会把头部再补过来。 The shift is repeated the number of times indicated by the second operand, which is either an immediate number or the contents of the CL register. To reduce the maximum execution time, the 80386 does not allow shift counts greater than 31. If a shift count greater than 31 is attempted, only the bottom five bits of the shift count are used. (The 8086 uses all eight bits of the shift count.) x86的实现决定不允许超过31位的左移,实际上移动值会和32取模。

引用 3 楼 KenZhang1031 的回复:引用1 << 32 是常量，编译时1和32都被当成int,编译时就被计算成为0了。 1 << x无法在编译前确定，是被采用指令shl reg cl来执行的，但是intel的汇编对shl有规定的。 引用 The SAL and SHL instructions perform the same operation (see Figure 7-6). They shift the source operand left by from 1 to 31 bit positions. 所以当移位超过31位后，结果可能会是未知的。  试了试shl和rol没区别啊，一会再看看  很久没写汇编了，不循环左移的指令是还要设置什么啊 直接上图最清楚。    谢谢了，我的意思是，超过32位时，shl其实被当做rol来处理了  现在就是只用汇编，如果超过32位，怎么不循环左移呢，是不是只能shl前自己判断啊

引用 3 楼 KenZhang1031 的回复:引用1 << 32 是常量，编译时1和32都被当成int,编译时就被计算成为0了。 1 << x无法在编译前确定，是被采用指令shl reg cl来执行的，但是intel的汇编对shl有规定的。 引用 The SAL and SHL instructions perform the same operation (see Figure 7-6). They shift the source operand left by from 1 to 31 bit positions. 所以当移位超过31位后，结果可能会是未知的。  试了试shl和rol没区别啊，一会再看看   很久没写汇编了，不循环左移的指令是还要设置什么啊 直接上图最清楚。   顶

不懂，学习一下

超过32位时，结果是取决于编译器+cpu的，不要结果做任何假设。

引用 楼主 u013194740 的回复:int y = 1 << 32; y是0  int x = 32; int y = 1 << x; y是1 如果考虑常量替换（常量代换）优化，二者极有可能相同，结果是。。。。。0 比如 VC Release 版，二者结果都是。。。。。0 VC Debug 版,结果1 << 32是。。。。。0，1 << x 就是SAL and SHL指令的结果。

引用 1 楼 KenZhang1031 的回复:1 << 32 是常量，编译时1和32都被当成int,编译时就被计算成为0了。 1 << x无法在编译前确定，是被采用指令shl reg cl来执行的，但是intel的汇编对shl有规定的。 引用The SAL and SHL instructions perform the same operation (see Figure 7-6). They shift the source operand left by from 1 to 31 bit positions. 所以当移位超过31位后，结果可能会是未知的。  试了试shl和rol没区别啊，一会再看看  很久没写汇编了，不循环左移的指令是还要设置什么啊


Question: 队列输出元素 求指导~~~~~~~~~~~~~~~~~~~

引用 10 楼 yuzengyuan 的回复:现在的小朋友真是越来越过分了，呵呵，反正不管怎样，不能运行，不能编译，直接扔上来让大家帮忙看。别装逼

引用 8 楼 bijiaoben 的回复:SqQueue *q; chushihua(q);  int chushihua(SqQueue *q) { q->front=q->rear=0; return 0; }  根本没有给指针q分配空间就拿去用了。。。 现在的小朋友真是越来越过分了，呵呵，反正不管怎样，不能运行，不能编译，直接扔上来让大家帮忙看。

#include <stdio.h> #include <stdlib.h>  #define maxsize 100  typedef struct _SqQueue {    int data[maxsize];    int front;    int tail;    int count; }SqQueue;  int init(SqQueue *q) { 	  if(q == NULL) 	  { 	      return -1; 	  }     q->front = 0;     q->tail  = 0;     q->count = 0;          return 0; } int isFull(SqQueue* q) { 	  if(q == NULL) 	  { 	      return -1; 	  } 	   	  if(q->count == maxsize) 	  { 	  	  printf("Queue is full!!\n"); 	      return 1; 	  } 	  else 	  { 	      return 0; 	  } }  int isEmpty(SqQueue* q) { 	  if(q == NULL) 	  { 	      return -1; 	  } 	   	  if(q->count == 0) 	  { 	  	  printf("Queue is empty!!\n"); 	      return 1; 	  } 	  else 	  { 	      return 0; 	  } }  int inQueue(SqQueue *q, int e) {     if(q == NULL) 	  { 	      return -1; 	  }        if(isFull(q) == 1)     {   	    return -1;   	}          q->data[q->tail] = e;     q->tail = (q->tail+1)%(maxsize);     q->count++;     return 0; }  int outQueue(SqQueue *q, int *e) { 	if(q == NULL)   {       return -1;   }      if(isEmpty(q) == 1)   {   		return -1;   }      *e = q->data[q->front];   q->front = (q->front+1)%maxsize;   q->count--;   return 0; } int main() {     int e;     SqQueue *q = (SqQueue*)malloc(sizeof(SqQueue));     if(q == NULL)     {         exit(-1);     }          init(q);          inQueue(q,1);     inQueue(q,3);     inQueue(q,5);     inQueue(q,7);     inQueue(q,8);     int i = 0;     for(; i<10; i++)     {         if(outQueue(q, &e) < 0)         {             break;         }         printf("%d ", e);     }     printf("\n");     free(q);     return 0; } 求40分

引用 4 楼 ovoovo 的回复:你都不结贴，你去结贴，我就给你弄个可以运行的。 结了，。。

不得不引用赵老师的名言： “对学习编程者的忠告：眼过千遍不如手过一遍！书看千行不如手敲一行！手敲千行不如单步一行！单步源代码千行不如单步对应汇编一行！” LZ请自行断点调试下

你都不结贴，你去结贴，我就给你弄个可以运行的。

另外函数名可以不用拼音吗？看着挺费劲的，呵呵。 你指针压根没有初始化，怎么能直接用。

SqQueue *q;//这个指针指向哪里？ chushihua(q);//直接拿来用？

int panduiman(SqQueue *q) { 	return ((q->rear+1)%maxsize==q->front?0:1); }  还有个函数忘写了


Question: 请问, 以下代码为什么要二级消息处理呢?

引用 1 楼 zhuobattle 的回复:重新编译下，代码用code包含起来。  ?

重新编译下，代码用code包含起来。

因为代码抽象通常都是一层一层的，上层只依赖直接相邻的下层，你只有根据代码设计的初衷去了解为什么2层


Question: POJ1001 总是RUNTime Error 在我电脑上运行所有测试用例均通过并且没有出现运行时错误

引用 6 楼 user-1 的回复:[quote=引用 4 楼 gongheguoyingpai11 的回复:] [quote=引用 1 楼 user-1 的回复:] 是OJ平台不能通过吗，看看把system("pause");去掉如何 太感谢了 无语了 竟然真的是因为这个原因 谢谢了 马上结贴 [/quote] OJ平台检测比较严，这条语句，system（“pause”），测试平台是不认识的，它不会为你处理这条语句[/quote] 很感谢 我就很奇怪为什么所有测试用例都没问题就是通不过 唉 竟然是因为这么个原因

引用 4 楼 gongheguoyingpai11 的回复:[quote=引用 1 楼 user-1 的回复:] 是OJ平台不能通过吗，看看把system("pause");去掉如何 太感谢了 无语了 竟然真的是因为这个原因 谢谢了 马上结贴 [/quote] OJ平台检测比较严，这条语句，system（“pause”），测试平台是不认识的，它不会为你处理这条语句

引用 3 楼 user-1 的回复:还有主函数返回值语句要加上，return 0； 不过为什么加上system("pause")就会出现这个问题了呢 优点困惑  return 0应该不会有问题 因为很多优秀的编译器如果你不写return 0都会默认的使用return 0的

引用 1 楼 user-1 的回复:是OJ平台不能通过吗，看看把system("pause");去掉如何 太感谢了 无语了 竟然真的是因为这个原因 谢谢了 马上结贴

还有主函数返回值语句要加上，return 0；

麻烦各位帮忙看一下 我重复的运行和查看了很多遍 并没有出现任何的运行时错误 这个问题确实把我难住了 从网上找的这个题的所有的测试用例都运行了 都没问题 但是一提就提示Runtime Error 我猜测可能是数组越界 但是运行了N多遍确实没出现问题啊 ??

是OJ平台不能通过吗，看看把system("pause");去掉如何


Question: 虚拟内存和物理内存的地址映射关系

你可以看看windows核心编程 看了这个，你会有一个很清晰的概念

虚拟内存是问了方便管理物理内存而虚拟出来的，他们是映射关系 我们所说的地址，其实就是虚拟内存，他怎么映射到物理内存，系统有一套内部的机制 一个进程创建出来时，会保留（也就是分配）虚拟内存，但是，此时很多内存其实没有映射到物理存储器上面 当你需要时，才会映射过去。不需要时，又会释放掉。 还有一个内存共享的问题，就是说，在物理存储器上面的一个存储页，可以映射到虚拟内存上面的多个存储页。这样也就方便了进程通信了

这里有一个缺页中断和虚拟内存的概念

虚拟内存基本概念啊。  当进程所要求的页不在物理内存里，就会发生一个异常，操作系统的内存管理器捕捉这个异常，然后将相应的虚存页从硬盘掉进物理内存。

共产主义，按需分配，呵呵，就是需要的话，才去映射，否则只是无效的地址

实际每个进程不可能都把虚拟内存都加载到物理内存上，照这样以前256M时代时系统直接不用跑了。 当需要使用时，虚拟内存不在物理内存上，会有页中断，系统会帮你管理的。  具体建议看下操作系统相关的书籍。

1. 只有实际使用的才映射 2. 如果实际使用的也不够, 会把不经常使用的页面换到硬盘上

你是不是发现，要是10个进程，不是有40G要映射，更不够了。 肯定不是直接一一映射。

《Windows核心编程》 《深入解析Windows操作系统-Windows Internals》


Question: 一个关于C语言文件的问题，求高手帮忙

我觉得逐行调试比较靠谱

首先 你的意思是说说无法读入 还是说文件打开总是失败 如果失败的话 是路径的问题的可能性大 如果是在Liunx下则可能因为权限的问题引起 无法打开文件 还有 你的数据在文件中是如何存放的? fseek(fp,n+1,SEEK_SET);/*将文件指针移到下一行*/这里的话 你的第三个参数是SEEK_SET则总是移动向第二行而已 如果你想总是向下移动应该使用SEEK_CUR否则永远只是在读入第二行数据(这是假设你的数据存取是正确的情况下)

你的main函数在哪里？

额，求高手帮忙


Question: 杭电oj 第2.1.5怎么做？

题目贴出来呗

要登录呢。。


Question: 在用C语言写程序时，如何长久文件数据

灰常感谢………………

嗯，可以…… 我对文件使用太不熟悉…………

引用 楼主 u013202002 的回复:每次运行程序需重新建立数据，如何可以将数据长久保存在文件里楼上正解！

在使用fopen的是时候第二个参数使用"a" 就是在文件末尾追加数据 就不会抹去原来的数据了

每次写文件就会 抹去原来的数据~~

直接保存文件不行吗？


Question: 写《品悟C》的薛非，怒了! ——【转】踢爆IT劣书出版黑幕——由清华大学出版社之《C语言入门很简单》想到的

引用 407 楼 fefe82 的回复:[quote=引用 47 楼 zhao4zhong1 的回复:] 求问supermegaboy，C/C++标准里面有没有规定函数参数最多多少个？  严格的说并没有。  C++14 Annex B (informative) Implementation quantities [implimits] 2 The limits may constrain quantities that include those described below or others. The bracketed number following each quantity is recommended as the minimum for that quantity. However, these quantities are only guidelines and do not determine compliance. ...... (2.10) — Parameters in one function definition [256]. (2.11) — Arguments in one function call [256][/quote]  才发现，这个帖子这么老了 ... 遁 ...

引用 408 楼 YourKing 的回复:[quote=引用 403 楼 hoodlum1980 的回复:] 这是薛大师炒作自己的帖子，其目的在于炒作他自己。因此此贴内容可谓毫无价值。  亏我无聊，没事调戏薛大师，他正愁炒作失败呢，有人揭露他，他正乐此不疲。  不过，他自己水平不行，能写出什么书来，被市场淘汰实在再正常不过。  薛大师虽有不坠青云之志，可惜天生真不是那块料，自鸣得意写 20 行 C 代码却始终是屎一坨，其不学无术，招摇撞骗，冒充技术界同行，令人发指。死抱着一本 CXX 标准，凭借其极低的智商主观臆测，乃至得出错误结论百出，到处宣讲而贻笑大方。且人品境界低下，脸皮厚如冰冻三尺，动用一众马甲，对揭露他的人污言秽语，混淆视听，为自己鼓吹呐喊，肉麻吹捧。在知乎，豆瓣，博客园，微薄等地纷纷名誉破产，犹如过街老鼠，人人喊打。落得一个无人问津的惨淡收场。  所以此贴内容毫无意义，有碍观瞻，理应被删除。 从头看到尾。也许帖子开头是真的某人炒作，但是中间辩论变了味道，变成lin和鼠侠越战hoodlum1980了，hoodlum1980没有避战。lin主要约战两个题，鼠侠全面约战，包括hoodlum1980提到的汇编等多层次。另，个人观点，先说出脏话的人品上就输了。[/quote] 是hoodlum1980没有应战。 删除没有完全，怕描述不清想改避战一词的，误成了没有避战。到目前为止是避战。

引用 403 楼 hoodlum1980 的回复:这是薛大师炒作自己的帖子，其目的在于炒作他自己。因此此贴内容可谓毫无价值。  亏我无聊，没事调戏薛大师，他正愁炒作失败呢，有人揭露他，他正乐此不疲。  不过，他自己水平不行，能写出什么书来，被市场淘汰实在再正常不过。  薛大师虽有不坠青云之志，可惜天生真不是那块料，自鸣得意写 20 行 C 代码却始终是屎一坨，其不学无术，招摇撞骗，冒充技术界同行，令人发指。死抱着一本 CXX 标准，凭借其极低的智商主观臆测，乃至得出错误结论百出，到处宣讲而贻笑大方。且人品境界低下，脸皮厚如冰冻三尺，动用一众马甲，对揭露他的人污言秽语，混淆视听，为自己鼓吹呐喊，肉麻吹捧。在知乎，豆瓣，博客园，微薄等地纷纷名誉破产，犹如过街老鼠，人人喊打。落得一个无人问津的惨淡收场。  所以此贴内容毫无意义，有碍观瞻，理应被删除。 从头看到尾。也许帖子开头是真的某人炒作，但是中间辩论变了味道，变成lin和鼠侠越战hoodlum1980了，hoodlum1980没有避战。lin主要约战两个题，鼠侠全面约战，包括hoodlum1980提到的汇编等多层次。另，个人观点，先说出脏话的人品上就输了。

引用 47 楼 zhao4zhong1 的回复:求问supermegaboy，C/C++标准里面有没有规定函数参数最多多少个？  严格的说并没有。  C++14 Annex B (informative) Implementation quantities [implimits] 2 The limits may constrain quantities that include those described below or others. The bracketed number following each quantity is recommended as the minimum for that quantity. However, these quantities are only guidelines and do not determine compliance. ...... (2.10) — Parameters in one function definition [256]. (2.11) — Arguments in one function call [256]

引用 28 楼 zhao4zhong1 的回复:高处的葡萄通常都比较酸。   这个薛高处，在原文里面跟其他高处的人骂起来了。 这种高处人的世界，不懂啊。

这样的喷子真是让人无语，我看过钱能的C++程序设计教程，看书学习又不是让你通篇接受，大家都在有选择性的学习。

生命不息，挖坟不止。

技术随岁月流逝得到提升的同时多看几本约束行为的书籍（自愿约束一下嘛），是不知道和谐发展的重要性

引用 398 楼 zhao4zhong1 的回复:建议将此帖内容作为禁词提取样本。

引用 393 楼 hoodlum1980 的回复: 发现转移话题失败  现在选择 彻底的逃避吗  啧啧啧 把头缩起来了 恩 干得好 连用一层循环无法输出菱形这句话都说不出来啊 你的底气是有多么的不足

反正我是看的<C Primer Plus>，相当的经典。谭浩强的那本书我就不想说了，反正国内的计算机教材也就那点水准。对国内的出版物很失望。

引用 387 楼 weimochengxi 的回复:[quote=引用 385 楼 hoodlum1980 的回复:] 实在不想再看到你在这里继续污染论坛了。你要玩去知乎那种垃圾网站玩吧。则毕竟好歹还是个技术社区办的论坛。这么糟蹋不是个事。 话说这个地方有没有管理员，把这个帖子删了吧。看着都让人恶心。如果有违反规则，可以点回复下方的举报按钮，谢谢[/quote] 冷静 他只是不敢回答问题 随意找几个理由  顾左右而言他 企图转移话题焦点  别被他蛊惑了

引用 385 楼 hoodlum1980 的回复:实在不想再看到你在这里继续污染论坛了。你要玩去知乎那种垃圾网站玩吧。则毕竟好歹还是个技术社区办的论坛。这么糟蹋不是个事。 话说这个地方有没有管理员，把这个帖子删了吧。看着都让人恶心。如果有违反规则，可以点回复下方的举报按钮，谢谢

建议将此帖内容作为禁词提取样本。

引用 396 楼 sholber 的回复:[quote=引用 392 楼 hoodlum1980 的回复:] 完全的鸡同鸭讲。你有哪段代码不懂底层是怎么回事，你发出来，我可以给你汇编实现和注释。 或者你自己去学习相关知识。不要在这里拍脑袋臆测。ok。 另外，我提请版主删除此贴，因为此贴没有存在的意义。像大师这种自居为一出生就是先知的恶棍，csdn如果有点追求的话，没有必要为这样的人行炒作藏污纳垢。知乎那样的垃圾网站给大师闹腾还不够吗？ 引用 393 楼 hoodlum1980 的回复:[quote=引用 391 楼 weimochengxi 的回复:] ，只要违反规定就会处理 水贴也要删啊，此贴已经沦为大师自high的乐园，大师在这里肆无忌惮的暴露无知，低素质，难道还要纵容这样的帖子存在吗 此人一不懂技术，二不想讨论和也不想学习技术也没有能力讨论的任何正当主观目的， 我现在实不想被他拉低境界，搅和粪坑是要付出恶心到自己代价的。[/quote]  额滴神哪，候德拉姆同学还要用汇编，啧啧！你弄汇编吧，Ｃ语言你不行，咱们可以接着讨论汇编。你研究的汇编是基于哪种处理器？ＡＲＭ、ＭＣ６８００、Ｚ８０、ＩＮＴＥＬ　x86？来，不管那么多，来，咱们讨论，你先开始！ 你要求版主删帖，内心叵测。心里没有鬼的人，怎么会要求删帖？一个在帖子里风风光光、显得胸怀磊落的人，怎么会要求删帖？一个在帖子里言之凿凿、有理有据，理直气壮的人，怎么会要求删帖？一个在帖子里没有说脏话的人，怎么会要求删帖？一个人在帖子里显得Ｃ语言学得很扎实的人，怎么会要求删帖？一个辩论赢了的人，怎么会要求删帖？唵？ 到底谁是恶棍，请搞清楚啦。只要此帖没删，任何人都可以看到是谁在帖子里满口污言秽语。有此帖为物证，居然还口口声声说别人是恶棍，说ＣＳＤＮ藏污纳垢，到底谁是垢——天啦，这种人，居然罔顾事实，颠倒黑白，真是是可忍孰不可忍，没见这号的。 最后，他还说别人暴露无知，低素质，素质高的人会说脏字吗？如果真是像你说的，你所谓的大师是低素质，就让此帖留着，让世人都知道大师是混蛋好了。相反，说一千道一万，你要管理员删帖，司马昭之心，路人皆知。 我强烈要求管理员不要删帖，让大家知道到底谁是恶棍、低素质，谁口出脏字，谁境界低，谁是在搅和粪坑。 大家的眼睛是雪亮的，留此帖为证，让大家自行评判吧！[/quote]  点赞

引用 392 楼 hoodlum1980 的回复:完全的鸡同鸭讲。你有哪段代码不懂底层是怎么回事，你发出来，我可以给你汇编实现和注释。 或者你自己去学习相关知识。不要在这里拍脑袋臆测。ok。 另外，我提请版主删除此贴，因为此贴没有存在的意义。像大师这种自居为一出生就是先知的恶棍，csdn如果有点追求的话，没有必要为这样的人行炒作藏污纳垢。知乎那样的垃圾网站给大师闹腾还不够吗？ 引用 393 楼 hoodlum1980 的回复:[quote=引用 391 楼 weimochengxi 的回复:] ，只要违反规定就会处理 水贴也要删啊，此贴已经沦为大师自high的乐园，大师在这里肆无忌惮的暴露无知，低素质，难道还要纵容这样的帖子存在吗 此人一不懂技术，二不想讨论和也不想学习技术也没有能力讨论的任何正当主观目的， 我现在实不想被他拉低境界，搅和粪坑是要付出恶心到自己代价的。[/quote]  额滴神哪，候德拉姆同学还要用汇编，啧啧！你弄汇编吧，Ｃ语言你不行，咱们可以接着讨论汇编。你研究的汇编是基于哪种处理器？ＡＲＭ、ＭＣ６８００、Ｚ８０、ＩＮＴＥＬ　x86？来，不管那么多，来，咱们讨论，你先开始！ 你要求版主删帖，内心叵测。心里没有鬼的人，怎么会要求删帖？一个在帖子里风风光光、显得胸怀磊落的人，怎么会要求删帖？一个在帖子里言之凿凿、有理有据，理直气壮的人，怎么会要求删帖？一个在帖子里没有说脏话的人，怎么会要求删帖？一个人在帖子里显得Ｃ语言学得很扎实的人，怎么会要求删帖？一个辩论赢了的人，怎么会要求删帖？唵？ 到底谁是恶棍，请搞清楚啦。只要此帖没删，任何人都可以看到是谁在帖子里满口污言秽语。有此帖为物证，居然还口口声声说别人是恶棍，说ＣＳＤＮ藏污纳垢，到底谁是垢——天啦，这种人，居然罔顾事实，颠倒黑白，真是是可忍孰不可忍，没见这号的。 最后，他还说别人暴露无知，低素质，素质高的人会说脏字吗？如果真是像你说的，你所谓的大师是低素质，就让此帖留着，让世人都知道大师是混蛋好了。相反，说一千道一万，你要管理员删帖，司马昭之心，路人皆知。 我强烈要求管理员不要删帖，让大家知道到底谁是恶棍、低素质，谁口出脏字，谁境界低，谁是在搅和粪坑。 大家的眼睛是雪亮的，留此帖为证，让大家自行评判吧！

引用 393 楼 hoodlum1980 的回复: 借口和废话 真不是一般的多啊  你不是喜欢 搞搞二级题目么  怎么我随随便便贴一个输出星号菱形 你都做不出来啊 就这么跪了? 喂喂喂 不能这么弱啊 太令人失望了 啧啧  在此声明 你做出我给你的星号菱形之前 你的一切和答题无关的话 都将被判定为 逃避答题 企图转移话题

我感觉实践最重要，尽早编程是事实

引用 391 楼 weimochengxi 的回复:，只要违反规定就会处理 水贴也要删啊，此贴已经沦为大师自high的乐园，大师在这里肆无忌惮的暴露无知，低素质，难道还要纵容这样的帖子存在吗 此人一不懂技术，二不想讨论和也不想学习技术也没有能力讨论的任何正当主观目的， 我现在实不想被他拉低境界，搅和粪坑是要付出恶心到自己代价的。


Question: 让正则表达式从指定位置开始查找？

正则表达式速查 正则表达式举例 正则表达式学习 (4页A4纸)http://download.csdn.net/detail/zhao4zhong1/1808549

另外推荐《精通正则表达式》一书，介绍了re的各种概念，不同实现的各种flavor，re的实现原理，等等。  LZ记得结贴。

其实我给的相当于一个伪代码，表达出了基本的意思  不同的re，有不同的flavor，无外乎就是哪些是元字符，元字符如何转义，如何定义首尾，如何定义量词，如何定义捕获组，如何丢弃捕获的结果⋯⋯  \(^.\{80}\)\@<=.*$ 对于这个re，大胆猜测： \(\)定义了捕获组，^表示开始，.表示任一字符，{80}是量词，\(^.\{80}\)就捕获了前80个字符  .*$就是表示到结尾的所有字符了  <=猜是vim特有的东西？表示把捕获的东西(.*$)存入\@中，\@大概是寄存器吧

你可以看一下 正则指引  或者 精通正则表达式  尤其是精通正则表达式 里面对于各种版本的正则都会有一些涉猎 所以一些比较偏僻的东西可能会在里面有介绍

不知道这个神奇的细节会不会有人感兴趣……

引用 6 楼 user-3 的回复:(?<=.{80}).*$ 这样试一下 不知道是不是你想要的意思  这中表示方式vim中无效的，我最开始就这样写的，没反应，查了很多资料，在一个很偏僻的角落里找到了。 等效于"\(.\{80}\)\@<=.*$"，但是如要要求是从行首开始计算的话，还要加个字符吧。 \(^.\{80}\)\@<=.*$

其实，vim和perl对正则的表示略有不同。我上面问题的答案是：\(^.\{80}\)\@<=.*$。先命中一行的前80个字符，不保留，然后命中后面直到行尾的所有字符，验证通过。

(?<=.{80}).*$ 这样试一下 不知道是不是你想要的意思

把你的意思说的更清楚一点 是想找出所有字符数多于80个字符的行? 我没太明白你的意思

然后呢？我要命中后面的东西，不包含前面的80个

[.\n]{80}      匹配任意字符包括'\n'80次

哥，正则呀~我要写到vimrc里面的

char s[1000]; int i; for (i=0;i<100;i++) sprintf(s+i*2,"%2d",i); printf("%s\n",s); printf("%s\n",s+80);


int __cdecl sem_getvalue (sem_t * sem, int * sval); 没用过自己试试...


Question: 请问它们的区别?

|| 是逻辑或

编译选项加/EP /P，重新编译，查看宏展开后对应的.i文件。gcc加-E

个人意见：最大的区别在于|不会逻辑短路，||会逻辑短路  但也许是作者笔误

如果AAA是5这样的宏的话，那么就没问题 见 http://gcc.gnu.org/onlinedocs/cpp/If.html#If if只能处理算术表达式来着  至于|还是||，逻辑上说，是||，只是|恰好也对 因为==产生1或者0 对于1和0来说，|和||的结果刚好一样，即 0 | 0 == 0 || 0 0 | 1 == 0 || 1 1 | 0 == 1 || 0 1 | 1 == 1 || 1 但逻辑不一样，一个是bit与，一个是逻辑与。

引用 18 楼 ForestDB 的回复:如果是AAA这样的话，怎么写都是错，LZ还没发现么？  这里的AAA BBB其实是以下格式定义的宏, #if(CUSTOMERIZATION==AAA|CUSTOMERIZATION==BBB) 这样，编译后，运行时，也没发现什么异常.  #define RITMIX		6 #define TEXET		7 #define AAA		8 #define BBB		9

如果是AAA这样的话，怎么写都是错，LZ还没发现么？

引用 14 楼 ForestDB 的回复:# define foo CCC  # if (foo == AAA || foo == BBB) printf(); # endif  以上是源文件  以下是预编译的结果 # 1 "x.c" # 1 "<built-in>" # 1 "<command-line>" # 1 "x.c"    printf();  LZ是否觉得有些以外？  我是新手，不明白。 请明说，我说的这种情况，应该用 | 还是 || ?

意外。。。。

引用 10 楼 zhao4zhong1 的回复:#if和if相差十万八千里！  你觉得这样写合适吗?

引用 6 楼 huabinsir 的回复:我的意思是: 是不是别人的代码有误? maybe

123|456==507 123||456==true  任何一个整数 >0等同于true <=0等同于false

#if和if相差十万八千里！

|是按位与运算，||是逻辑或运算

引用 6 楼 huabinsir 的回复:我的意思是: 是不是别人的代码有误?  仅对这行代码而言, 从功能上没问题, 但是这么写, 在逻辑上是不合理的.  "||"表达的意图是满足任何一个条件 "|"表达的是将左右操作数做或运算

引用 5 楼 huabinsir 的回复:别人的代码中有以下这样的情况，别人的用意是什么?  #if(CUSTOMERIZATION==AAA|CUSTOMERIZATION==BBB) typedef enum { TimeHour= 0, TimeMin, TimeAP, TimeOK, TimeCancle }TypeTime; TypeTime curTimeItem = TimeHour; #else typedef enum { TimeMin = 0, TimeHour, TimeAP, TimeOK, TimeCancle }TypeTime; TypeTime curTimeItem = TimeMin; #endif  个人觉得宏定义应该这样：  #if(CUSTOMERIZATION==AAA||CUSTOMERIZATION==BBB)  但是按照它这样，编译器也可以成功识别，因为有如下情况:  int i = 1; int k = 0; int j = i || k;//只有都为0时，结果才为0 int s = i | k;//或也刚好是这样，只有两者都是0时结果才为0 //所以在判断上，1和其它非0值结果都是一样。

我的意思是: 是不是别人的代码有误?

搜 位运算 逻辑运算


Question: 数据结构和算法有什么学习捷径

学习算法导论 然后去OJ做题巩固 学习算法不可能有什么捷径的 否则大家不都成了算法大神了

当时就是看谭浩强的书过来的，理解不了链表是怎么回事，就问老师，什么排序，查找，后来慢慢就都学会了

引用 12 楼 aihahaheihei 的回复:http://acm.hdu.edu.cn/listproblem.php?vol=11 花两个星期做完这页，基本没问题了大神，我想问，这么多需要多少条做完呢？？？

加油，我和你一样

基础没有捷径！

其实是有一个捷径的：把书烧成灰，用蜂蜜水送服，一天三本，7天见效。

努力就是最好办法，多看看代码是怎么实现的，理解代码，多实践

做面试和笔试题吧，边做题边学，不至于太枯燥

越是基础的东西越没有捷径可走！  引用 楼主 nezhang 的回复:我扛不住啊，看了就困，越看越晕。各位都是怎么过这关的。有没有什么窍门？网上的严书不要提了，比普通不出名的结构书还不易懂。

做任何事都想着捷径, 那你离成功就越来越远了.

引用 8 楼 taodm 的回复:其实是有一个捷径的：把书烧成灰，用蜂蜜水送服，一天三本，7天见效。 要啥药引子吗？

除了写还能咋样

如果不是为了应付考试，是真的想学懂的话，除了认真去看书，去理解外，没有捷径。如果书看不懂，就换一本，等能看懂了再回过头去看，书关键是要适合自己。建议你可以看看《算法精解：C语言描述》，比较简单一点，重在代码实现，而不是一大堆数学公式，如果看懂了，可以看《算法导论》，看完了应该能算入门了。

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

理解原理，并写代码实现它~~~


Question: 帮忙解答，感谢！！庞果网提示的信息

因为你的测试用例不够复杂，没有覆盖最差的情况。

就是这道题，a =1 b=30

{5 3 1}和{7 5 3}是2组不同的等差三元组，除了等差的性质之外，还有个奇妙的地方在于：5^2 – 3^2 – 1^2 = 7^2 – 5^2 – 3^2 = N = 15。 {19 15 11}同{7 5 3}这对三元组也存在同样的性质：19^2 – 15^2 – 11^2 = 7^2 – 5^2 – 3^2 = N = 15。 这种成对的三元组还有很多。当N = 15时，有3对，分别是{5 3 1}和{7 5 3}，{5 3 1}和{19 15 11}，{7 5 3}和{19 15 11}。 现给出一个区间 [a,b]求a <= N <= b 范围内，共有多少对这样的三元组。（1 <= a <= b <= 5*10^6） 例如：a = 1，b = 30，输出：4。（注：共有4对，{5 3 1}和{7 5 3}，{5 3 1}和{19 15 11}，{7 5 3}和{19 15 11}，{34 27 20}和{12 9 6}）

测试的用例自己指定的啊

跟测试用例的多少和强度有关吧？


LZ想说什么？

你的问题是什么？

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