Question: printf  函数输出结果为0 为什么？是函数实参中的优先级问题吗？

将a和b颠倒就正常？为什么？ #include <stdio.h> int main() { 	int a = 1, b = 0; 	//printf("b=%d,a=%d\n",b=a+b,a=2*b);  	//b=0,a=0 说明你的编译器是从右到左求值的，就是说先计算a=2*b,这时a=0,在计算b=a+b,这时b=0 	//如果换了编译器，可能就是先算b=a+b,这时b=1,再算a=2*b,这时a=2 	//编译器不同，就可能导致结果不同-->这就是所谓的“未定义行为” 	//所以，这样输出就不一样了：  	printf("b=%d,a=%d\n",a=2*b,b=a+b); // b=2,a=1 	return 0; }

不懂lz在问什么，你的代码你好好看过了吗？ a，b都=0了，printf在怎么折腾a，b，难道还能出现不为0的值？？

引用 17 楼 zhouda829829 的回复:楼上你的答案输出是b=2，a=1 完全是因为你前面的输出是b=%d，a=%d 先输出的值是2*b的后输出的才是a+b 其运算的还是先算b=a+b，即是1。再算a=2*b，即是2。请不要偷换概念好吗？ 恩，谢谢提醒！ 但这不是偷换概念，是我写的顺序错了。  printf("a=%d,b=%d\n",a=2*b,b=a+b); // a=2,b=1

#include <stdio.h> #include <conio.h> int main() {      int a=1,b=0;      a=2*b;      b=a+b;      printf("b=%d,a=%d\n",b,a);      getch(); }  这是用变量存储参数的代码，可结果还是0 为何？

那就是在使用函数时，所有的参数用变量来存储，以防止  编译器决定了不确定的优先级  错误的发生？对吧?

顶置贴就是给初学者看的. 要是你觉得他说的概念跟你学到的完全不一样,那就应该换本正常的书来入门.

编译器决定了不确定的优先级。解决方法：尽量避免表达式作为参数入参。

我想知道如何避免这种错误的发生和解决的方法，置顶贴看了但是太专业了，不是给初学者看的，置顶贴太啰嗦了，我只求解决方法，是否用汇编可以解决？

lz问的莫名其妙啊， PS：zhao老师知识真广博⊙﹏⊙b汗  引用 13 楼 zhao4zhong1 的回复:解决办法参考《仙剑奇侠传》中“书中仙”解决“沉思鬼”的“先迈左脚还是先迈右脚”问题的办法。

#include <stdio.h> #include <conio.h> int main() {      int a=1,b=0;      a=2*b;     // 因为b = 0, 所以 a = 2 * b; 的最终结果也就是a = 0;      b=a+b;     // 因为a = 0, b = 0; 所以b = a + b; 的最终结果也就是b = 0;      // 现在a 和b 的结果都是0，LZ在问什么呢？      printf("b=%d,a=%d\n",b,a);      /* printf("b=%d,a=%d\n",b=a+b,a=2*b); */      getch(); }  LZ 想说这a 和 b 的结果不应该是0吗？  楼上讨论看置顶贴是什么意思啊？   这贴怎么看得那么迷糊啊！！！！~~~~      到底是个什么情况啊？

属于未指定行为（unspecified behavior）因为函数参数的求值顺序未定~~ 参数的求值顺序 和 参数的入栈顺序 是两个概念 求值早于入栈 置顶贴不都说了吗

怎么可能，printf，参数肯定是从左到右进行匹配的  int a=1,b=0;      a=2*b;      b=a+b  b=a+b不是0是什么？既然b=0，那b=2*a不就是0？

#include <stdio.h> #include <conio.h> int main() {      int a=1,b=0;      a=2*b;      b=a+b;      printf("b=%d,a=%d\n",b,a);      /* printf("b=%d,a=%d\n",b=a+b,a=2*b); */      getch(); } 结果 a=0，b=0     lz 认为答案是？

说明编译器对参数从后往前求值。

置顶帖没看了吧  你的做法就是 置顶帖描述的未定义行为

这样试试： int main() {      int a=1,b=0;      printf("a=%d,b=%d\n",a+b,2*b);      return 0; ｝  这种简单的计算，可以自己心算一下； 至少可以笔算出结果； 然后在编译执行。  如果你自己计算了，就不会问为什么了！！！！！


Question: if（0）和if（1）有区别吗？代表布尔吗？

引用 8 楼 AnYidan 的回复:引用 7 楼 ztzi321 的回复:[quote=引用 5 楼 Adol1111 的回复:] C/C++中非0表示真，但0一定表示假已解决！我笨了，写个程序就能解决！仍旧感谢！  教导的是，您学计算机多长时间了，向您学习！

引用 7 楼 ztzi321 的回复:引用 5 楼 Adol1111 的回复:C/C++中非0表示真，但0一定表示假已解决！我笨了，写个程序就能解决！仍旧感谢！  真的不是苯不笨，而是根本没看书

引用 1 楼 tyy_wjt 的回复:0代表假,1代表真   main() { 	if (1) 		printf("这部分会打印"); 	if (0) 		printf("这部分不打印"); }已解决！还是程序说了算！我笨了！

C/C++中非0表示真，但0一定表示假

引用 1 楼 tyy_wjt 的回复:0代表假,1代表真   main() { 	if (1) 		printf("这部分会打印"); 	if (0) 		printf("这部分不打印"); }  int s; if（s）printf(); 如果s可以去0或者1怎么理解？ 是不是0时不打印，1时打印？你确定吗？

if（0）永远不成立 if（1）永远成立


Question: 这种情况该怎么办，请求，输出多行，没行十个元素，要注意格式。

引用 10 楼 caozhy 的回复:还有一个办法，就是你用一个二维数组缓存结果，然后一次性输出。 恩 我试试 要是再不行，放弃这题了，被他折腾得太累了。

还有一个办法，就是你用一个二维数组缓存结果，然后一次性输出。

测试文件:/test.out   结果:答案正确 测试文件:/sample.out   结果:答案错误 	=======原因====== 	当参考答案输出: 	按题目要求 	-------时--------- 	你的程序输出: 	120 150 180 210 240 270 300 330 360 390 	================= 上面的是评测结果。 这个我更加不明白了为什么..只对了一半，会不会是oj平台的问题   引用 5 楼 caozhy 的回复:# include <stdio.h> int main(){     int i,j=0;     bool isstart = true;     for(i=100;i<=1000;i++){                if(i%5==0&&i%6==0){         if (!isstart)  printf(" ");         printf("%d",i);         isstart = false;         j++;         if(j%10==0)printf("\n");         isstart = true;         else;    } if (!isstart) printf("\n");              } return 0; }

引用 7 楼 u013007481 的回复:[quote=引用 5 楼 caozhy 的回复:] # include <stdio.h> int main(){     int i,j=0;     bool isstart = true;     for(i=100;i<=1000;i++){                if(i%5==0&&i%6==0){         if (!isstart)  printf(" ");         printf("%d",i);         isstart = false;         j++;         if(j%10==0)printf("\n");         isstart = true;         else;    } if (!isstart) printf("\n");              } return 0; }刚刚去运行了一下加了个布尔头文件  根据你提供的代码我重新编辑了一下 最后那个if（语句）去掉才行 要不就不符合这个了 #include<stdbool.h> # include <stdio.h>  int main(){      int i,j=0;      bool isstart = true;      for(i=100;i<=1000;i++){                 if(i%5==0&&i%6==0){          if (!isstart)  printf(" ");          printf("%d",i);          isstart = false;          j++;          if(j%10==0){          printf("\n");          isstart = true;          }     }                }  return 0;  } 感谢你的指导[/quote]  呵呵，C++我不会，而且也是手写的。原理你明白就好。

引用 5 楼 caozhy 的回复:# include <stdio.h> int main(){     int i,j=0;     bool isstart = true;     for(i=100;i<=1000;i++){                if(i%5==0&&i%6==0){         if (!isstart)  printf(" ");         printf("%d",i);         isstart = false;         j++;         if(j%10==0)printf("\n");         isstart = true;         else;    } if (!isstart) printf("\n");              } return 0; }刚刚去运行了一下加了个布尔头文件  根据你提供的代码我重新编辑了一下 最后那个if（语句）去掉才行 要不就不符合这个了 #include<stdbool.h> # include <stdio.h>  int main(){      int i,j=0;      bool isstart = true;      for(i=100;i<=1000;i++){                 if(i%5==0&&i%6==0){          if (!isstart)  printf(" ");          printf("%d",i);          isstart = false;          j++;          if(j%10==0){          printf("\n");          isstart = true;          }     }                }  return 0;  } 感谢你的指导

可以有两种方式 1) 分割成几个小函数    1）不带换行，输出一行n个数的函数。    2）带换行，输出一行n个数的函数。    3）总控函数，输出若干行数据，最后一行不换行，如果不是满10 ，最后一行不足10个数。 2）用一个循环，内部使用 if else处理空格和换行   2.1) 空格       每行10个数据，后面不加空格。有两种方式处理：       2.1.1）第一个数据不加空格，其他数据加前置空格。       2.1.2）最后一个不加空格，其它数据后加空格。    2.2）换行      有两种情况：           2.2.1)整十个数，最后一个满行不换行。       2.2.2)非整十个数，最后一个满行换行。             然后输出不足十个数的行，（结尾不加空格）。

引用 1 楼 caozhy 的回复:j%10 == 0 || j=最大元素下标 要是我不知道他的下标怎么办，一共有多少个数我也不知道的想 ，要算出来才知道有多少个，还有最后一个元素不用加换行和空格 ，他题目是要求最后一个每一行最后一个数的后面没有空格

显示从100到1000之间所有能被5和6整除，  # include <stdio.h> 	int main(){ 	    int i,j=0; 	    for(i=100;i<=1000;i++){                if(i%5==0&&i%6==0){ 			        printf("%d",i); 			        j++; 			        if(j%10==0)printf("\n"); 			        else printf(" "); 			   }              } 		return 0; 	}   引用 2 楼 tyy_wjt 的回复:贴代码吧,这样说不清楚 这是一道acm题 运行没问题 但是提交时总是答案错误。

贴代码吧,这样说不清楚

j%10 == 0 || j=最大元素下标


Question: 二维数组怎么异或？

有点迷糊，不知运行结果对不对？

任何数之间都可以异或，不需要恰好都是15

引用 9 楼 worldy 的回复:当然是通过逐个单元异或 比如i=3，j=4 state[3][4]=state[3][4]^ key[3][4]; 就是说我输进去的数是第三行第四列的数，恰好两个都是15，然后再将他们异或吗？

引用 2 楼 u012620515 的回复:就是state[i][j]^=key[i][j]; 这两个数组里的元素怎么异或?  还是取的state[i][j]的值去和key[i][j]的值，进行异或操作的啊！他们本身也只是一个数值而已嘛！ 不要陷进去了

引用 7 楼 u012620515 的回复:我就是不知道怎么把输进去的数，通过state[i][j]^=key[i][j]; 得出结果  printf() 然后在纸上用二进制算算，对照一下

4 8 12 136?这是我运行后的结果

我输出来的结果是: 4, 8, 12, 192. 不知道对不对

我输出来的结果是4, 8 ,12 ,192. 我不知道对不对

引用 2 楼 u012620515 的回复:就是state[i][j]^=key[i][j]; 这两个数组里的元素怎么异或?state[i][j]^=key[i][j];//这样就可以啊

你的问题到底是什么？


Question: Dec-C++编译报错

引用 8 楼 u011322908 的回复:[quote=引用 2 楼 sundq12 的回复:] void createDateList(int (*date)[3],int &num){//此函数应该这样定义  是这样子的，改成这样那个问题就消失了，，，，不过想问一下为什么这样子定义。。。。[/quote]既然函数接收的是引用，那么当然需要在函数定义里面说明了，不然编译器怎么知道是值传递，还是引用传递呢，你可以研究一下引用的用法。

引用 8 楼 u011322908 的回复:[quote=引用 2 楼 sundq12 的回复:] void createDateList(int (*date)[3],int &num){//此函数应该这样定义  是这样子的，改成这样那个问题就消失了，，，，不过想问一下为什么这样子定义。。。。[/quote]  那是因为后面的问题没有提出来而已！编译器卡在这个问题上了而已！  数组指针，指针数组，双指针！google下这些区别联系

引用 2 楼 sundq12 的回复:void createDateList(int (*date)[3],int &num){//此函数应该这样定义  是这样子的，改成这样那个问题就消失了，，，，不过想问一下为什么这样子定义。。。。

引用 4 楼 max_min_ 的回复:确实挺多基本错误的！楼主根据编译的时候编译器提示的基本语法错误把代码改过来吧！ 如果这些都不会的话，应该是基础不过关了，得找一本基础的c语言书籍补补了！ 编译器就提示了一个错误，，，，，，

引用 3 楼 user-4 的回复:你的程序问题好多啊，至于报错的话是因为这里： void createDateList(int (*date)[3],int &num); void createDateList(int (*date)[3],int num){……}  其他方面有好多问题，先说几条，其他的自己改改吧！  数组在做参数的时候会退化成普通的指针，所以不如直接用二维指针，你这样做有个[3]在这，还会引起歧义。  还有指针存储的内容虽然是地址传递，但本身指针只是普通的变量，仍然是值传递，所以针对指针本身的操作，比如new是无效的，你可以这样void createDateList(int (*&date)[3],int &num)用引用传递。否则main里的date和num都没有被修改。  还有：scanf("%d-%d-%d",&date[i][0],&date[i][1],&date[i][2]); 你少了。  还有这里：int main(){ 	int (*date)[3]; 	date=NULL;//初始化 	int num=0;//C++不允许直接使用未初始化变量，养成好习惯 	createDateList(date,num); 	getNearestDate(date,num); } 暂时先指出这点问题，其他的问题自己再改改吧。 恩恩，问题已经解决

void createDateList(int *date[3],int &num);

代码如有不懂，请说一下，在线等


Question: 求教c语言的小问题

引用 2 楼 u010484985 的回复:谢谢哈，解决了，麻烦你了。 问题解决了！及时结贴！左上角或者左下角！谢谢。

谢谢哈，解决了，麻烦你了。

char * str_ncopy(char * str1, const char * str2, int n) {     char * tmp = str1;     int i = 0,     j = 0;     while ( * str2++);//此时循环结束之后，指针已经指向零之后的位置了，所以有误  //这样试试 /* while(*str2) {    str2++; } */     while (n > 0 && ( * str1++=*str2++)) {         n--;     }     /*while(n>0){ str1[i]=str2[j]; i++; j++; n--; }*/     if (n == 0) str2 = '\0';     //str[i]='\0';     return tmp;  }


Question: 求问此C语言程序问题

2楼正解

引用 5 楼 u010484985 的回复:我都断点查看过，也查出了是这一段的问题。	               	while(i>=0){ 		p[j]=str[i]; 		i--; 		j++; 	} 不过这段程序  不是把 str[4]赋值到str[0],str[3]赋值到str[1],就这样循环下去的意思么 而且比如输入123456789  他输出结果987656789，为什么就是到了后几位就赋值不了呢。 请大神帮帮忙，小弟刚学，各位可能觉得很简单，但小弟有点理解不了，希望帮忙解答一下。 你把str[0]用str[4]代替了，那么原本的str[0]不就没了么？那你一点点递减，超过一半以后，不就是在复制刚刚替换掉的内容了么？ 我在2楼写了方法了，就是新建一个数组，把内容拷贝到另外一个数组，不影响原来的数组。

6楼正解 楼主哪里还不明白

while(i>=0)这个循环条件不对，应该到中间位置而不是0

卤煮输出的是4334吧，你一直在操作同一个数组，所以没有达到你的目的，你要好好弄清楚为什么不对呀。

自己设断点调试，这个是程序员必须要学会的。

因为这一段： while(i>=0){ str[j]=str[i];//你后面的内容覆盖了前面的内容，当然重复了。 i--; j++; } 用两个数组就可以了： #include<stdio.h> void str_reverse(char *str,char *tmp){ 	int i=0,j=0; 	while(str[i]!='\0'){ 		i++; 	} 	i--; 	while(i>=0){ 		tmp[j]=str[i]; 		i--; 		j++; 	} 	tmp[j]='\0'; }  int main(){ 	char str[100]; 	char tmp[100]; 	printf("文字列："); 	scanf("%s",str); 	str_reverse(str,tmp); 	printf("结果：%s\n",tmp); 	return 0; }

自己断住调试。


Question: 关于自己用c构造汇编语句[一本书<老码识途>中的一个问题]

c7 05 （mov指令）30 81 14 01（gi地址） 12 00 00 00（18的16进制）  ff 25 （jmp指令）34 81 14 01（原来的地址）  就是把整数18赋值给gi，然后再跳出去


Question: 帮帮忙！！

我 理解了，谢谢你！

引用 4 楼 u012620515 的回复:if(st[i-1]&0x80) st[i]^=0x1b; 请问这个语句呢？主要是不懂&的用法 &就是与的意思，也就是按位与 0x80二进制是1000,0000 假如st[i-1]二进制是1111,1111 每一个相对应的位都进行&操作 所以结果就是1000,0000 再假如st[i-1]二进制是0111,1111 &0x80之后就是（0111,1111）&（1000,0000）=0000,0000

st[i]=st[i-1]<<1;  // st[i]=st[i-1] * 2; 的装B写法 if((t1>>i)&0x01)   // 判断t1的第i比特是否为1

<<是左移操作符 比如st[i-1]=4，二进制就是0100，st[i-1]<<1=0100<<1=1000,就是8 同理，>>是右移  &是逻辑与运算，0x01代表十六进制的1，也就是除了最低位1，其余全部是0 所以就是检查t1右移i位后，最低位是否为1

st[i]=st[i-1]<<1;//将st[i-1]乘以2的值赋给st[i]，左移一位等于乘以2 if((t1>>i)&0x01)//将t1右移i位，然后检查最后一位是否是1


Question: 调用system后，它下面的第一个语句就不执行了怎么回事

单步

引用 5 楼 yangyangsnr 的回复:[quote=引用 1 楼 user-4 的回复:] 我的机器上正常。 嗯，把这几条语句单独拿出来是正常的，但是一放到整体里就会出现上述问题，真奇怪[/quote] 应该不是缓冲区的问题，因为后面有换行符，有刷新缓冲区的！ 是不是system函数执行阻塞了？

引用 7 楼 yangyangsnr 的回复:[quote=引用 6 楼 user-4 的回复:] 1.你怎么知道这条语句被跳过了，你单步调试的时候跳过了还是只是没有打印出来。 2.如果只是没有打印出来，那么可以使用一下fflush试试。 一开始是没有这个printf的，直接是Sleep，结果根本就没有停顿，然后在它下面加了个system("PAUSE")，也不行，最后加了这个printf，printf不显示，但是Sleep就起作用了... 刚才用VC6编译了一下，问题就不出现了。难道真的是编译器的问题？还是整段代码本身就有隐患...[/quote] 是缓冲区不一样吧，DEVC++可能留在缓冲区里了，要用fflush强制冲刷吧。VC6直接就出来了。没用过DEVC++，不清楚，你试试？

引用 6 楼 user-4 的回复:1.你怎么知道这条语句被跳过了，你单步调试的时候跳过了还是只是没有打印出来。 2.如果只是没有打印出来，那么可以使用一下fflush试试。 一开始是没有这个printf的，直接是Sleep，结果根本就没有停顿，然后在它下面加了个system("PAUSE")，也不行，最后加了这个printf，printf不显示，但是Sleep就起作用了... 刚才用VC6编译了一下，问题就不出现了。难道真的是编译器的问题？还是整段代码本身就有隐患...

引用 1 楼 user-4 的回复:我的机器上正常。 嗯，把这几条语句单独拿出来是正常的，但是一放到整体里就会出现上述问题，真奇怪

引用 3 楼 yangyangsnr 的回复:[quote=引用 2 楼 yangyangsnr 的回复:] [quote=引用 1 楼 user-4 的回复:] 我的机器上正常。 晕，不会吧，我在这边试了好多回了，紧接着system语句下面写什么语句都会被跳过，然后从它下面的第二条语句开始执行[/quote] 用的DEVC++[/quote]我也用的是DEVC++好着呢，你但不调试一下看看。

引用 2 楼 yangyangsnr 的回复:[quote=引用 1 楼 user-4 的回复:] 我的机器上正常。 晕，不会吧，我在这边试了好多回了，紧接着system语句下面写什么语句都会被跳过，然后从它下面的第二条语句开始执行[/quote] 用的DEVC++

引用 1 楼 user-4 的回复:我的机器上正常。 晕，不会吧，我在这边试了好多回了，紧接着system语句下面写什么语句都会被跳过，然后从它下面的第二条语句开始执行

我的机器上正常。


Question: 你知道这些为啥这么输出么？

l是long的意思，x是十六进制的意思，d是十进制的意思，例如： %llx相当于long long十六进制输出格式  引用 楼主 qiyoufei 的回复:以下代码编译输出表示什么意思？为什么输出是这样的？诸位路过的帮忙看下，多谢。  int main() {         int i;         for (i= 14; i < 17; ++i)         { 	                long long x = 1024*1024*1024*i; 	                printf("0x%llX,%lld\n", x, x);         }          printf("\n0x%llX,0x%llX,0x%llX\n",\ 1024*1024*1024*1024*14, 1024*1024*1024*1024*15, 1024*1024*1024*1024*16);         printf("%lld,	%lld,	%lld\n",\ 1024*1024*1024*1024*14, 1024*1024*1024*1024*15, 1024*1024*1024*1024*16);          printf("\n0x%llX,0x%llX,0x%llX\n",\  0xFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);//14,15,16         printf("%lld,	%lld,	%lld\n",\  0xFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);		//14,15,16         printf("%d\n", sizeof(long long));         return 0; } 下图为linux下的编译输出、运行输出：   下图为windows32位下的vs2010编译输出、运行输出：

数字太大了，类型装不下，每个类型都有最大值限制的。需要使用大数运算。


Question: 看起来像函数定义，但没有参数列表；跳过明显的函数体

不需要传人参数的main函数

引用 14 楼 truelance 的回复:难道LZ用的是20年前的c教材, 居然用的还是K&R Version 1的函数定义风格. K&R的风格是 main()好不好，连返回类型void都没有。 你那个void main(void)其实和楼主的没本质区别。 标准的写法是：int main(void){     return 0; }  int main(int argc , char*[] argv){     return 0; }

第一行改成 void main(void)

我看到有一堆中文的“，”，不知道是否是这个错误

如果用VC6.0的话，用英文版，把原文贴上来 看不懂英文就别用VC6.0了，用更高版本的  从楼主贴上来的代码中能够看出来的问题，就只有一堆中文符号 写代码要用全英文标点符号，中文标点符号只能作为字符串使用

刚学c就用上   #include <stdafx.h>  了？  还是找本靠谱点的c教程好。 个人推荐 <<C Primer Plus>>

为什么不是stdio。h啊

引用 楼主 u012938896 的回复:#include <stdafx.h> void main（） { float n1，n2，n3，n4,sum,aver; scanf（"%f，%f，%f，%f"，&n1,&n2,&n3,&n4): sum=n1+n2+n3+n4; aver=sum/4; printf("%f=sum\n%f=aver",sum,aver); } 刚开始学C语言不知道这要怎么解决   求大神解说  说的啥？ 没看懂...

引用 楼主 u012938896 的回复:#include <stdafx.h> void main（） { float n1，n2，n3，n4,sum,aver; scanf（"%f，%f，%f，%f"，&n1,&n2,&n3,&n4): sum=n1+n2+n3+n4; aver=sum/4; printf("%f=sum\n%f=aver",sum,aver); } 刚开始学C语言不知道这要怎么解决   求大神解说  解决神马？

引用 7 楼 u012938896 的回复:#include <stdafx.h> void main（） { float n1，n2，n3，n4,sum,aver; scanf（"%f，%f，%f，%f"，&n1,&n2,&n3,&n4): sum=n1+n2+n3+n4; aver=sum/4; printf("%f=sum\n%f=aver",sum,aver); }  调试错误说： 看起来像函数定义，但没有参数列表；跳过明显的函数体 ，不懂怎么弄  我去，你这是英文编译器然后用谷歌翻的？中文编译器应该不会有这种提示吧 你这个代码是直接复制上来的吗，怎么一堆的全角符号啊，另外scanf末尾还有个冒号，头文件改成stdio.h，别的应该没有问题

LZ想表达啥

看起来像函数定义，但没有参数列表；跳过明显的函数体  这句话没有主语

scanf是库函数。


Question: 有一个问题想问大家

如果是c++ 就用g++了！

引用 2 楼 turingo 的回复:c++用g++编译，这里http://development-software.findthebest.com/compare/15-16/Code-Blocks-vs-CodeLite有一个完整的比较表。嗯，谢谢你！

引用 1 楼 max_min_ 的回复:如果是c++ 就用g++了！那g++能不能编译C呢？

gcc好像也能编译cpp文件，要加选项指定


Question: 杭电acm1002，为什么总是Wrong Answer.到底哪里错了？

无回复=_=


Question: C语言字符串验证。速速帮忙谢谢

1. 首先你需要考虑编码的问题，各个编码方式下汉子的编码不一样。 2. 你需要搞明白各个编码方式下（如UTF8）汉子的识别方式。  google一下很多的。


Question: 问一个简单的socket的问题

创建socket的步骤？ bind listen connect 这些不是要ip 和 port ？

write（socketfd, &msg, len）；  socketfd 不是制定写给谁了吗？


Question: 求c高手进来啊！！！为什么会爆呢

简单的修改下： void comeout(plist pl){ 	…… 	while (c>0){//这里多算了一次 		…… 	} }

爆炸是气体膨胀的速度过快！


Question: 最终想学好c语言.

我觉得慢慢看比较好，有的知识即使已经会了，但是再一次看得时候，还是会收获许多，就会想明白一些以前没有懂的知识。

居然没人了

引用 6 楼 caozhy 的回复:觉得天分不够的人（比如我）建议使用田忌赛马的办法，学一种简单的语言，并且学好。  见版主几处说这样的话,, 我自己觉得自己有天赋,但是不是真有得如何辩解,,求讨论

引用 楼主 BlackKOL 的回复:唉, 总是发贴发这样的东西;  曾经被某大蓝鸟带去学了十几个月web开发,后来有些失败+这边工作一些问题;  一只想学c/c++这方面的,纯属自己的爱好,不求多大前途;  这两天看所谓 四书五经里的第一本 C程序设计语言(第2版_新版);  感觉1-4基本都会,看着是会.习题有一种理解上的问题,可能语文没学好 - -;;;;   现在请教各大神: 我是该如何才对, 这本书我想就那么扫一眼看完呢还是得一个字一个字的看才好;  还有请大神给点对学习有帮助的 函数();    return  thank;  慢慢看吧！每次都有新的发现！

引用 18 楼 caozhy 的回复:比如说我以前一个邻居的小孩，我给他辅导数学。  他上了一个破奥数培训班，学了很多“线段图”解题方法。当我和他讲解的时候，我发现他一开始根本听不进去，他总是我行我素地画着匪夷所思的“线段图”。然后我跟他说，你可以用方程来解答。他说你先看看我这个线段图，似乎就差一步就出来了。为了矫正他在奥数班被洗脑和毒害的思维方式，我花了半个小时研究透了他的“线段图”求解法，并且告诉他，你的线段图其实是方程的一个特例，先顺着他的思路用线段图“求解”，然后就坡下驴，告诉他，用方程实际上是一种快速和更好用的线段图。然后他终于学会了方程（二元一次），最后我告诉他，其实你可以忘记线段图了，此时他才明白过来。幸亏他是一个孩子，还比较“听话”，而且中毒不深。  某鸟中毒的人，尤其是那些越是学得起劲，觉得自己颇有心得的人，基本上都是没救药的了。  本屌是被灌毒快2年那样,先是大鸟,后来是我华it(据说本屌城市我it倒闭了);  培训完出来继续被洗脑,去做实施,呵呵  前面记得住的基本语法外别什么框架之类早已忘,虽然猛复习两三天java ssh等框架能懂,做小工外.别的又只是呵呵,, 现在想远离Java .net, 追逐当年的梦(虽然年龄不小了)

引用 18 楼 caozhy 的回复:比如说我以前一个邻居的小孩，我给他辅导数学。  他上了一个破奥数培训班，学了很多“线段图”解题方法。当我和他讲解的时候，我发现他一开始根本听不进去，他总是我行我素地画着匪夷所思的“线段图”。然后我跟他说，你可以用方程来解答。他说你先看看我这个线段图，似乎就差一步就出来了。为了矫正他在奥数班被洗脑和毒害的思维方式，我花了半个小时研究透了他的“线段图”求解法，并且告诉他，你的线段图其实是方程的一个特例，先顺着他的思路用线段图“求解”，然后就坡下驴，告诉他，用方程实际上是一种快速和更好用的线段图。然后他终于学会了方程（二元一次），最后我告诉他，其实你可以忘记线段图了，此时他才明白过来。幸亏他是一个孩子，还比较“听话”，而且中毒不深。  某鸟中毒的人，尤其是那些越是学得起劲，觉得自己颇有心得的人，基本上都是没救药的了。 +1

一字一字看·

引用 16 楼 BlackKOL 的回复:[quote=引用 15 楼 Adol1111 的回复:] [quote=引用 14 楼 BlackKOL 的回复:] [quote=引用 13 楼 u012969197 的回复:] 慢慢看嘛  我是软件专业新生，就跟着老师走咯，在加点自学  看着都会的东西在看多次,我时间没你们多啊,学生娃~[/quote] 看过很多遍的时候有时候还是要看啊。  就比如置顶贴里的顺序点问题，刚开始学的时候就遇到过这问题，纠结了很久，后来才意识到不应该写这样的代码。 前几天又翻了下K&R的TCPL，然后就看到了以前被匆匆跳过的部分就有讲这个问题（因为我也觉得都会了）。 顺便说一下，我是在看过那里之后（粗略的看了下），才遇到那个问题的时候。现在想想，当初应该看细一点的。  看书不在于会还是不会，而是看看能不能给你带来新的认识。如果你觉得能学到新的东西，那就值得看，仔细看。如果你觉得学不到东西，那还有什么看的必要？[/quote]  呵呵, 很多时候在想,大概7,8年前玩电脑,别人说去学cpp,如今还是想学,但还是那么懒惰, 而且被某大蓝鸟培训出来了...唉[/quote] 某鸟的要想学好，比新手稍微麻烦一点，首先得忘记某鸟教你的全部垃圾。 因为某鸟给你灌输了很多有害的，面向低端码农的，根本错误的价值观和方法论。如果你带着这些东西提高，永远也就提高不了了。

引用 15 楼 Adol1111 的回复:[quote=引用 14 楼 BlackKOL 的回复:] [quote=引用 13 楼 u012969197 的回复:] 慢慢看嘛  我是软件专业新生，就跟着老师走咯，在加点自学  看着都会的东西在看多次,我时间没你们多啊,学生娃~[/quote] 看过很多遍的时候有时候还是要看啊。  就比如置顶贴里的顺序点问题，刚开始学的时候就遇到过这问题，纠结了很久，后来才意识到不应该写这样的代码。 前几天又翻了下K&R的TCPL，然后就看到了以前被匆匆跳过的部分就有讲这个问题（因为我也觉得都会了）。 顺便说一下，我是在看过那里之后（粗略的看了下），才遇到那个问题的时候。现在想想，当初应该看细一点的。  看书不在于会还是不会，而是看看能不能给你带来新的认识。如果你觉得能学到新的东西，那就值得看，仔细看。如果你觉得学不到东西，那还有什么看的必要？[/quote]  呵呵, 很多时候在想,大概7,8年前玩电脑,别人说去学cpp,如今还是想学,但还是那么懒惰, 而且被某大蓝鸟培训出来了...唉

我觉得楼主既然已经有基础，一个字一个字的看会很快的，如果看得很慢那还是说明基础不够。 不建议跳着看，说不定就能得到一些意外的收获。

引用 14 楼 BlackKOL 的回复:[quote=引用 13 楼 u012969197 的回复:] 慢慢看嘛  我是软件专业新生，就跟着老师走咯，在加点自学  看着都会的东西在看多次,我时间没你们多啊,学生娃~[/quote] 看过很多遍的时候有时候还是要看啊。  就比如置顶贴里的顺序点问题，刚开始学的时候就遇到过这问题，纠结了很久，后来才意识到不应该写这样的代码。 前几天又翻了下K&R的TCPL，然后就看到了以前被匆匆跳过的部分就有讲这个问题（因为我也觉得都会了）。 顺便说一下，我是在看过那里之后（粗略的看了下），才遇到那个问题的时候。现在想想，当初应该看细一点的。  看书不在于会还是不会，而是看看能不能给你带来新的认识。如果你觉得能学到新的东西，那就值得看，仔细看。如果你觉得学不到东西，那还有什么看的必要？

引用 13 楼 u012969197 的回复:慢慢看嘛  我是软件专业新生，就跟着老师走咯，在加点自学  看着都会的东西在看多次,我时间没你们多啊,学生娃~

慢慢看嘛  我是软件专业新生，就跟着老师走咯，在加点自学

觉得天分不够的人（比如我）建议使用田忌赛马的办法，学一种简单的语言，并且学好。

引用 11 楼 u013004162 的回复:自己也是在自学，本来是为了考计算机二级，但是前面还好，后来越来越不会，自己都没有信心了  主要学习方法得当,我觉得应该不难这个东西.

引用 9 楼 user-10 的回复:[quote=引用 3 楼 BlackKOL 的回复:] [quote=引用 2 楼 AnYidan 的回复:] 带着问题看书  我真没有研究会学习的方法, 呵呵[/quote] 经历了 初中， 高中后，应该都形成了一套自己的学习方式的！所以主要的是认真自己想要做的事情！[/quote]  其实上学的年代.我们是所谓的差生,学校最好的是踢球,可惜国足给我们争脸了,哈哈哈  很多东西看着都会,但没有一个方向去做什么,很迷茫.  对软件方面的思想是有的,也许.但一只没有找到一个学习的方法.

这本书我想就那么扫一眼看完呢还是得一个字一个字的看才好   都不是

引用 3 楼 BlackKOL 的回复:[quote=引用 2 楼 AnYidan 的回复:] 带着问题看书  我真没有研究会学习的方法, 呵呵[/quote] 经历了 初中， 高中后，应该都形成了一套自己的学习方式的！所以主要的是认真自己想要做的事情！


Question: 求大神来解答此问题

fgetc 成功时返回读到一个字节，本来应该是unsigned char型的，但由于函数原型中返回值是int型，所以这个字节要转换成int型再返回，那为什么要规定返回值是int型呢？因为出错或读到文件末尾时 fgetc将返回EOF，即-1，保存在int型的返回值中是0xffffffff，如果读到字节0xff，由unsigned char型转换为int型是0x000000ff，只有规定返回值是int型才能把这两种情况区分开，如果规定返回值是unsigned char型，那么当返回值是0xff时无法区分到底是EOF还是字节0xff。如果需要保存fgetc的返回值，一定要保存在int型变量中，如果写成 unsigned char c = fgetc(fp);，那么根据c的值又无法区分EOF和0xff字节了。注意，fgetc读到文件末尾时返回EOF，只是用这个返回值表示已读到文件末尾，并不是说每个文件末尾都有一个字节是EOF（根据上面的分析，EOF并不是一个字节）。


Question: pthread_mutex_t 和 alarm 一起用为什么就无效了？

引用 1 楼 user-3 的回复:http://www.cppblog.com/mysileng/archive/2013/01/05/196971.html看看这个文章就知道怎么回事了，要学会google嘛。 学习了

void *pthread_func(void * arg) 锁了 然后 print 0 1秒过了 触发SIGALRM void sig_handler(int signo) 再请求锁 好了，竞争了就堵死了


Question: 提问！

引用 5 楼 chenlianghx 的回复:你们的意思是s1[i++]=s2[j++];是先将j放入i,然后再将j++放入i++，是吗，感觉看起来很不习惯啊 警告：一句话内最好不要出现两个以上++，禁止是同名的变量++出现2次以上。不然都是未定义行为，以上的解释都会产生问题。仅当当前情况下，上面的情况是正确的。 建议：分开写，s1[i]=s2[j];i++;j++; 关于未定义行为，看置顶贴：http://bbs.csdn.net/topics/370153775

引用 2 楼 turingo 的回复:i++是执行完之后在加，所以： while(s1[i]!='\0') i++; 时i指向的是'\0'  而后的s1[i++]恰好是把'\0'覆盖了。+++++++++++

i++的意思是，当前操作是用i的值，然后i再自加1.如果是++i，才是i自加1之后再进行别的计算。 参见前++和后++

S2的内容(不包括S2的'\0') ，从S1的'\0'开始覆盖.. 最后再给S1结尾处加'\0'..

引用 6 楼 Adol1111 的回复:[quote=引用 5 楼 chenlianghx 的回复:] 你们的意思是s1[i++]=s2[j++];是先将j放入i,然后再将j++放入i++，是吗，感觉看起来很不习惯啊 警告：一句话内最好不要出现两个以上++，禁止是同名的变量++出现2次以上。不然都是未定义行为，以上的解释都会产生问题。仅当当前情况下，上面的情况是正确的。 建议：分开写，s1[i]=s2[j];i++;j++; 关于未定义行为，看置顶贴：http://bbs.csdn.net/topics/370153775[/quote] 谢谢！

引用 2 楼 turingo 的回复:i++是执行完之后在加，所以： while(s1[i]!='\0') i++; 时i指向的是'\0'  而后的s1[i++]恰好是把'\0'覆盖了。re


Question: 传址报错

引用 1 楼 user-2 的回复:int Add(int & a)// & 是c++的引用操作，  要写成： int Add(int *a) {     *a = 3;     return 0; }  调用处改成： Add(&b); 我刚刚实验了一下 使用C++ 两种方式都可以，使用C语言就只能写成您提供的方式 异常信息中报的是语法错误，C语言中不能使用int Add(int & a)这种方式传参数吗

#include <stdio.h>  /** 这里用&是C++的引用，C语言是不支持的，可以改用指针来实现 */ int Add(int* a) { 	*a = 3; 	return 0; }  int main(int argc, char* argv[]) { 	int b = 5; 	Add(&b);	/* 这里调用的时候由于是指针，所以要传入b的地址 */ 	printf("%d\n", b); 	return 0; }


Question: 如何产生多个不同的1到N的随机排列

引用 楼主 liubin119712 的回复:我说的1到N的随机排列是指：有N个数，每个数都在1到N之间。比方说N=9时，那么873259146就是一个这样的排列。              我已经通过下面的代码产生了一组这样的排列（这个算法是我在大学的算法导论书上看到的，呵呵。。。。）  void GetRandomArray(int arry[],int number) { 	int i,k; 	//srand((int)time(0));// 	for(i=0;i<number-1;i++) 	{ 		k=rand()%(number-i)+i;//使用 %的随机性不是很好，                                       //这个随机性，不是三言两语就说清楚的,建议看书。                                                    		Swap(&arry[i],&arry[k]);  	} }  int main(){  int a[10][9];     srand((int)time(0));//改到这里         for(int i=0;i<10;i++){        for(int j=0;j<9;j++)              a[i] [j] = i+1;              //初始化为 1～9 ，这个初始化代码，可以写到GetRandomArray内部；              //这可以保证不重复，是一个随机序列（随机置换）               //如果用作索引 初始化为 0～n-1 ，这样可以对任意数据做随即置换。                  }            for(int i=0;i<10;i++)        GetRandomArray(a[i],9);     //......     return 0;  }  现在的问题是我想产生很多组这样的排列，每个排列都不同。   怎么办呢？望大神指导一下。。。。 srand 函数在整个程序运行期间，只需要调用一次。 如果希望保持若干互不相关的随机数序列。  那么用一个数据结构保存随机数的种子，每次调用 rand()之前，调用srand 重新 初始化随机数发生器。  举例  struct myrand{ unsigned seed; } ;  void mysrand(struct myRand *sr,unsigned seed) {        srand(seed);        sr->seed =rand();   }  unsigend myrand(struct myRand *sr){        unsigend r = sr->seed;        srand(r);        sr->seed = rand();              return r;   }  这样可以使用同一库函数，生成若干互不相干的随机序列。 C++可以封装成随机数类。  这是不想自己费脑筋的方法。 自己研究随机数的话，可以自己做伪随机序列发生器。  引用 9 楼 angel_su 的回复:你贴出的代码可能1ms就跑完，而time(0)的精度是整秒，所以每次seed都一样反而变成问题。把srand移到程序开始处做一次即可。++

引用 10 楼 lm_whales 的回复:[quote=引用 楼主 liubin119712 的回复:] 我说的1到N的随机排列是指：有N个数，每个数都在1到N之间。比方说N=9时，那么873259146就是一个这样的排列。              我已经通过下面的代码产生了一组这样的排列（这个算法是我在大学的算法导论书上看到的，呵呵。。。。）  void GetRandomArray(int arry[],int number) { 	int i,k; 	//srand((int)time(0));// 	for(i=0;i<number-1;i++) 	{ 		k=rand()%(number-i)+i;//使用 %的随机性不是很好，                                       //这个随机性，不是三言两语就说清楚的,建议看书。                                                    		Swap(&arry[i],&arry[k]);  	} }  int main(){  int a[10][9];     srand((int)time(0));//改到这里         for(int i=0;i<10;i++){        for(int j=0;j<9;j++)              a[i] [j] = i+1;              //初始化为 1～9 ，这个初始化代码，可以写到GetRandomArray内部；              //这可以保证不重复，是一个随机序列（随机置换）               //如果用作索引 初始化为 0～n-1 ，这样可以对任意数据做随即置换。                  }            for(int i=0;i<10;i++)        GetRandomArray(a[i],9);     //......     return 0;  }  现在的问题是我想产生很多组这样的排列，每个排列都不同。   怎么办呢？望大神指导一下。。。。 srand 函数在整个程序运行期间，只需要调用一次。 如果希望保持若干互不相关的随机数序列。  那么用一个数据结构保存随机数的种子，每次调用 rand()之前，调用srand 重新 初始化随机数发生器。  举例  struct myrand{ unsigned seed; } ;  void mysrand(struct myRand *sr,unsigned seed) {        srand(seed);        sr->seed =rand();   }  unsigend myrand(struct myRand *sr){        unsigend r = sr->seed;        srand(r);        sr->seed = rand();              return r;   }  这样可以使用同一库函数，生成若干互不相干的随机序列。 C++可以封装成随机数类。  这是不想自己费脑筋的方法。 自己研究随机数的话，可以自己做伪随机序列发生器。  引用 9 楼 angel_su 的回复:你贴出的代码可能1ms就跑完，而time(0)的精度是整秒，所以每次seed都一样反而变成问题。把srand移到程序开始处做一次即可。++ [/quote]  嗯，确实是这样。  只需在程序开始处调用一次srand，感谢了！

引用 9 楼 angel_su 的回复:你贴出的代码可能1ms就跑完，而time(0)的精度是整秒，所以每次seed都一样反而变成问题。把srand移到程序开始处做一次即可。  嗯，照你说了试了下，果然是这样！ 谢了

#include <stdlib.h> void srand(unsigned int seed);

void GetRandomArray(int arry[],int number)  {      	int i,k;      	srand(GetTickCount()); 	for(i=0;i<number-1;i++)     	{ 		//k=rand()%(number-i)+i;          		//Swap(&arry[i],&arry[k]);//这个做傻用？       		arry[i]=rand()%number+1;//这样不行？ 	}  }  //函数调用之间sleep一会儿

引用 3 楼 user-4 的回复:需要m组，则GetRandomArray调用m次不就是了  我就是那么想的额，可是不行，产生的排列全部是一样的。   具体代码请看我回复  lm_whales  的

引用 2 楼 lm_whales 的回复:srand((int)time(0));放错地方了  population是一个结构体数组，结构体里有一个整型数组cityArray,CITY_SIZE和POPU_SIZE都是常量

引用 2 楼 lm_whales 的回复:srand((int)time(0));放错地方了  while(i<POPU_SIZE) 	{ 		for(j=0;j<CITY_SIZE;j++) 			population[i].cityArray[j]=j+1; 		 		srand((int)time(0)); 		GetRandomArray(population[i].cityArray,CITY_SIZE); }   我的产生多个排列是在这里，把srand函数放这里了，还是不行额

需要m组，则GetRandomArray调用m次不就是了

来个人帮我看下吧。。。。


Question: 问一个关于c primer plus一书中的浮点数显示问题

引用 8 楼 hiteety 的回复:引用 1 楼 Adol1111 的回复:有误差是正常的，计算机在存储的时候是以二进制存储的，但十进制是不能完全转换成二进制的。具体看看float、double二进制的编码就知道了。多谢，是你说的问题，我改为double就没误差了，谢谢！ 换double也难说，总之不要信任浮点数就可以了。double能精确的是15位，但谁能保证第16位是没问题的呢？你这里也只是没看到后面几位而已。看看这篇文章吧，希望对你有用：http://www.cnblogs.com/fromchaos/archive/2010/12/07/1898698.html

引用 5 楼 user-3 的回复:引用 4 楼 hiteety 的回复:[quote=引用 2 楼 user-3 的回复:] %f ----> %.2f你这么只是欺骗嘛  搜搜：浮点数规格化 或者直接试试： http://www.binaryconvert.com/convert_double.html?decimal=048046048049[/quote]嗯，多谢了。

引用 7 楼 czarten 的回复:引用 3 楼 hiteety 的回复:[quote=引用 1 楼 Adol1111 的回复:] 有误差是正常的，计算机在存储的时候是以二进制存储的，但十进制是不能完全转换成二进制的。具体看看float、double二进制的编码就知道了。float的精度都能到六位有效数字，这个数21.29也会有误差？  21.29跟21.290001这不就是6位的精度么 2楼是正确做法，这不是什么欺骗，而是浮点数保存的本来就不是准确值，所以你任何方式都输不出准确值来[/quote]多谢回复，已经理解了，二楼的做法是让显示没有误差，我的意思是想了解误差的来源，所以才这么说。总的来讲，感谢你们。

引用 3 楼 hiteety 的回复:引用 1 楼 Adol1111 的回复:有误差是正常的，计算机在存储的时候是以二进制存储的，但十进制是不能完全转换成二进制的。具体看看float、double二进制的编码就知道了。float的精度都能到六位有效数字，这个数21.29也会有误差？  21.29跟21.290001这不就是6位的精度么 2楼是正确做法，这不是什么欺骗，而是浮点数保存的本来就不是准确值，所以你任何方式都输不出准确值来

引用 3 楼 hiteety 的回复:引用 1 楼 Adol1111 的回复:有误差是正常的，计算机在存储的时候是以二进制存储的，但十进制是不能完全转换成二进制的。具体看看float、double二进制的编码就知道了。float的精度都能到六位有效数字，这个数21.29也会有误差？ float虽然是精确到第六位，但是还有个不精确的第7位，你能保证在第7位上没问题么？编译器对浮点数的优化不同结果也会不同，谁知道会怎么样。还是不要太信任浮点数比较好。

引用 4 楼 hiteety 的回复:引用 2 楼 user-3 的回复:%f ----> %.2f你这么只是欺骗嘛  搜搜：浮点数规格化 或者直接试试： http://www.binaryconvert.com/convert_double.html?decimal=048046048049

引用 2 楼 user-3 的回复:%f ----> %.2f你这么只是欺骗嘛

%f ----> %.2f


Question: 这到底哪错了？？？？？

引用 1 楼 user-2 的回复:malloc的参数是内存大小，单位为字节 malloc(10);申请10字节内存，一个指针大小为4字节，这块内存只能存放两个半指针 使用malloc的时候输入“数量*sizeof(类型）” +1  malloc的时候必须用sizeof来求啊..手动估计遇到内存对齐就完了。


Question: 帮忙看看，指针赋值问题。

引用 2 楼 N_sev7 的回复:好好看看指针到底是怎么回事吧 指针式怎么使用的 最起码的， int *p;///声明  *p表示p是一个整形指针 p = &a； int b = *p;   ///////这个时候*p就是使用p指向的变量 好好翻翻书吧re

建议楼主多打打基础。基础不行啦。

最基础的变量定义，语法规则不了解先别看指针了吧

int a,a=*p; 这显然错误了，用逗号隔开，会导致a重定义，当然，你的p也没申明


Question: socke()错误 :File descriptor in bad state

引用 4 楼 shangyu0801 的回复:[quote=引用 1 楼 ws_yqr 的回复:] 当connect连接失败时，套接字不可用了，必须关闭后重新socket分配才行。 不能通过啥清除错误的方法，去清掉此类错误继续使用么？[/quote]没见过哪里提过有清除错误的方法

引用 1 楼 ws_yqr 的回复:当connect连接失败时，套接字不可用了，必须关闭后重新socket分配才行。 不能通过啥清除错误的方法，去清掉此类错误继续使用么？

这个报错是说文件描述符不可用，socket未释放不能重复用

close掉再开一个socket，因为前一个socket已经bind过端口不能复用了。


Question: 貌似用了野指针，找不到啊  调试不太擅长

老师帮我检查了程序，解决了问题。

正确的代码#include"stdio.h" #include"stdlib.h" #define INITSTACKSIZE 50 #define  QUEUEMAXSIZE 50 #define  INCREMENTSIZE 10 typedef struct  { 	char *top; 	char *base; 	int stacksize; }Stack; typedef struct  { 	char *qbase; 	int front; 	int rear; }Queue; void InitStack(Stack &J) { 	J.base=(char*)malloc(INITSTACKSIZE*sizeof(char)); 	if(!J.base) 		exit(-1); 	J.top=J.base; 	J.stacksize=INITSTACKSIZE; } void DestoryStack(Stack &J) { 	free(J.base); 	J.base=NULL; 	J.top=NULL; 	J.stacksize=0; } int StackEmpty(Stack J) { 	if(J.base==J.top) 		return 1; 	else  		return 0; } void Push(Stack &J,char e) { 	if((J.top-J.base)>=J.stacksize){ 		J.base=(char*)realloc(J.base,(INITSTACKSIZE+INCREMENTSIZE)*sizeof(char)); 	if(!J.base) 		exit(-1); 	J.top=J.base+J.stacksize; 	J.stacksize+=INCREMENTSIZE; 	} 	*(J.top)++=e; } void Pop(Stack &J, char &e) { 	if(StackEmpty(J)) 		exit(-1); 	e=*--J.top; } void InitQueue(Queue &K) { 	K.qbase=(char*)malloc(QUEUEMAXSIZE*sizeof(char)); 	K.front=K.rear=0; } void DestoryQueue(Queue &K) { 	if(K.front==K.rear) 		exit(-1); 	free(K.qbase); 	K.qbase=NULL; 	K.front=K.rear=0; } int QueueEmpty(Queue K) { 	if(K.front==K.rear) 		return 1; 	else  		return 0; } void EnQueue(Queue &K,char f) { 	if((K.rear+1)%QUEUEMAXSIZE==0) 		exit(-1); 	K.qbase[K.rear]=f; 	K.rear=(K.rear+1)%QUEUEMAXSIZE; } void DeQueue(Queue &K,char &f) { 	if(K.front==K.rear) 		exit(-1); 	f=K.qbase[K.front]; 	K.front=(K.front+1)%QUEUEMAXSIZE; }  void Puen(Stack &J,Queue &K,char *r) { 	while((*r)!='@') 	{ 		Push(J,*r); 		EnQueue(K,*r); 		r++; 	} } void Pal(Stack &J,Queue &K) {char a,b; //	while(*(J.top-1)==(K.qbase[K.front])) 	/*printf("\nStack: "); 	char *p=J.top-1; 	while (p!=J.base) 	{	printf("%d ",*p); 		p--; 	} 	printf("%d ",*p); 	*/  	while(!StackEmpty(J)) 	{ 		Pop(J,a); 		DeQueue(K,b); 		printf("a=%d,b=%d\n",a,b); 		if (a!=b) 			break; 		  	} 	if(StackEmpty(J)==1) 		printf("您输入的字符数列是回文数列!\n"); 	else 		printf("您输入的字符数列不是回文数列!\n"); }  int main() { 	char a[50]; 	Stack s; 	Queue q; 	printf("请输入字符序列以‘@’加上回车结束：\n"); 	gets(a); 	printf("您输入的字符数列为：\n"); 	puts(a); 	InitStack(s); 	InitQueue(q); 	Puen(s,q,a); 	Pal(s,q); 	DestoryStack(s); 	DestoryQueue(q); 	return 0; }

呐，编程呢，最重要的就是调试，如果你不会调试 那就学习如何调试。 呐，调试呢，最重要的就是跟踪，如果你不会跟踪 那就学习如何按F9 F10 F11

void Push(Stack &J,char &e) //这里出现错误，自己调试跟踪吧

调试啊，看调用堆栈

#include"stdio.h" #include"stdlib.h" #define INITSTACKSIZE 50 #define  QUEUEMAXSIZE 50 #define  INCREMENTSIZE 10 typedef struct  { 	char *top; 	char *base; 	int stacksize; }Stack; typedef struct  { 	char *qbase; 	int front; 	int rear; }Queue; void InitStack(Stack &J) { 	J.base=(char*)malloc(INITSTACKSIZE*sizeof(char)); 	if(!J.base) 		exit(-1); 	J.top=J.base; 	J.stacksize=INITSTACKSIZE; } void DestoryStack(Stack &J) { 	free(J.base); 	J.base=NULL; 	J.top=NULL; 	J.stacksize=0; } int StackEmpty(Stack J) { 	if(J.base==J.top) 		return 1; 	else  		return 0; } void Push(Stack &J,char e) { 	if((J.top-J.base)>=J.stacksize){ 		J.base=(char*)realloc(J.base,(INITSTACKSIZE+INCREMENTSIZE)*sizeof(char)); 		if(!J.base) 			exit(-1); 		J.top=J.base+J.stacksize; 		J.stacksize+=INCREMENTSIZE; 	} 	*(J.top)++=e; } void Pop(Stack &J) { 	if(StackEmpty(J)) 		exit(-1); 	--J.top; } void InitQueue(Queue &K) { 	K.qbase=(char*)malloc(QUEUEMAXSIZE*sizeof(char)); 	K.front=K.rear=0; } void DestoryQueue(Queue &K) { 	if(K.front==K.rear) 		exit(-1); 	free(K.qbase); 	K.qbase=NULL; 	K.front=K.rear=0; } int QueueEmpty(Queue K) { 	if(K.front==K.rear) 		return 1; 	else  		return 0; } void EnQueue(Queue &K,char f) { 	if((K.rear+1)%QUEUEMAXSIZE==0) 		exit(-1); 	K.qbase[K.rear]=f; 	K.rear=(K.rear+1)%QUEUEMAXSIZE; } void DeQueue(Queue &K) { 	if(K.front==K.rear) 		exit(-1); 	K.front=(K.front+1)%QUEUEMAXSIZE; }  void Puen(Stack &J,Queue &K,char *r) { 	while((*r)!='@') 	{ 		Push(J,*r); 		EnQueue(K,*r); 		r++; 	} } void Pal(Stack &J,Queue &K) { 	//char a,b; 	/*while(*(J.top-1)==(K.qbase[K.front])) 	printf("\nStack: "); 	char *p=J.top-1; 	while (p!=J.base) 	{	printf("%d ",*p); 	p--; 	} 	printf("%d ",*p); 	*/ 	 	//while(!StackEmpty(J)) 	while(*(J.top-1)==(K.qbase[K.front])) 	{ 		Pop(J);//Pop(J,a) 		DeQueue(K);//DeQueue(K), 		//printf("a=%d,b=%d\n",a,b); 		//if (a!=b) 		//break; 		 		 	} 	if(StackEmpty(J)) 		printf("您输入的字符数列是回文数列!\n"); 	else 		printf("您输入的字符数列不是回文数列!\n"); }  int main() { 	char a[50]; 	Stack s; 	Queue q; 	printf("请输入字符序列以‘@’加上回车结束：\n"); 	gets(a); 	printf("您输入的字符数列为：\n"); 	puts(a); 	InitStack(s); 	InitQueue(q); 	Puen(s,q,a); 	Pal(s,q); 	DestoryStack(s); 	DestoryQueue(q); 	return 0; }

引用 1 楼 rogone 的回复: for(int i = 0; i < n / 2; ++i) {     if(s[i] != s[n - 1 - i])     {         return false;     } } return true直接比较就行了，用栈是个什么情况 没看最后一个条件，我错了，请无视


Question: 求一道面试题算法

使用后缀数组嘛。

引用 4 楼 diamont1001 的回复:1）先找重复次数最多的 2）找最大串  比如，例子中1231231245， 1）重复次数最多的是：1，2，都是重复了3次 2）试下1和2的组合，“12”和“21”，发现12重复最多，次数是3，得出结果

1）先找重复次数最多的 2）找最大串

唉，上面的二重循环就要执行N*(N-1)/2次了，看来还是有问题呢，等大神的回答吧

根据字符串构建一个有向图，图的边附上权，并且记录下权最大的边，最后如果只有唯一一个边的权最大，则这个子串就是重复次数最多的最长字串，如果权有多个最大值，则检查出这几个顶点的最长路径，该路径表示的子串就是最长重复次数最多的子串。

先记下来，待会写写

下面提的一种方法，仅供参考：  #include <cstring> #include <cstdio> #include <string> #include <map> #include <set> using namespace std;  struct Substring{     const char* p;     int len;     //the longest and alphabetically smallest is prior     friend bool operator < (const Substring& a, const Substring& b){         if(a.len != b.len) return a.len < b.len;         else return memcmp(a.p, b.p, a.len) > 0;     } }; struct Substring2{     const char* p;     int len;     int times;     //most frequent and longest and alphabetically smallest is prior     friend bool operator < (const Substring2& a, const Substring2& b){         if(a.times != b.times) return a.times > b.times;         else if(a.len != b.len) return a.len > b.len;         else return memcmp(a.p, b.p, a.len) < 0;     } };  int findRepeatMostLargestSubstr(string& dest, const string& src) {     int totalLen = src.size(), len;     const char *s = src.c_str(), *e = s + totalLen, *p;          map<Substring,int> substrMap;     set<Substring2> substrSet;     Substring tmp;     Substring2 tmp2;          for(len = 1; len <= totalLen; ++len){//count the times of every kind of Substring         tmp2.len = tmp.len = len;         for(p = s; p + len <= e; ++p){             tmp2.p = tmp.p = p;             tmp2.times = ++substrMap[tmp];             if(tmp2.times > 1){//not the first time, so it must have been in the set                 --tmp2.times;                 //we cannot change the compare key, so we erase the item then insert a new one                 substrSet.erase(tmp2);                 ++tmp2.times;             }             substrSet.insert(tmp2);         }     }          tmp2 = *substrSet.begin();     dest = src.substr(tmp2.p-s, tmp2.len);     return tmp2.times; }  //测试main函数 int main() {     int times;     string sub;     times = findRepeatMostLargestSubstr(sub, "1231231245");          printf("sub = %s, times = %d\n", sub.c_str(), times);          getchar();     return 0; }  下面是复杂度分析 （1）空间复杂度： 上述算法中枚举了长度为1~N（字符串总长度）的子字符串，一共有 N*1 + (N-1)*2 + ... + (N-i)*i + ... + 1*N  = sum((N+1-i)*i, i = 1~N) = sum((N+1)*i, i = 1~N) - sum(i*i, i = 1~N) = (N+1)*N(N+1)/2 - N(N+1)(2N+1)/6 = N(N+1)(N+2)/6 如果每种子字符串都不同，即无任何子字符串重复出现，则需要的空间最多，此最差空间复杂度为 N(N+1)(N+2)/6 * sizeof(Substring) * 2 = O(N^3)，最后的乘2是因为同时有map和set （2）时间复杂度 观察如下代码 [code=c] friend bool operator < (const Substring& a, const Substring& b){     if(a.len != b.len) return a.len < b.len;     else return memcmp(a.p, b.p, a.len) < 0; } friend bool operator < (const Substring2& a, const Substring2& b){     if(a.times != b.times) return a.times > b.times;     else if(a.len != b.len) return a.len > b.len;     else return memcmp(a.p, b.p, a.len) < 0; } /code] 可以看出： 长度不等时，Substring的比较的复杂度为O(1)，长度相等时一次比较的最差复杂度为O(a.len)； 次数不同或者长度不等时，Substring2的比较的复杂度为O(1)，次数不同且长度相等时一次比较的最差复杂度为O(a.len)。 即使认为每次比较的复杂度为最差的O(N)，由于一共有O( N(N+1)(N+2)/6 )次查询或插入，此时间复杂度就是 O(N)*log( O(N(N+1)(N+2)/6) ) = O(NlogN)，这里取了对数是因为map和set的二分查找性质

说个思路吧  第1，确定最大重复子串的最大长度，int max = strlen（src_str)+1/2 第2, 根据这个最大字串长度来选则字串进行比对， 第一组字串前max个，第二组从第2个字符开始，到max个，以此类推


Question: 一个用带参宏定义字符串的语法

也推荐使用sprintf函数来做！

用ssprintf函数，或者是直接用字符串数组，例如： char str[32]; ssprintf(str, "little_pig_location_%d", version);  引用 楼主 zhuhellozhu 的回复:我有一个系列的字符串，大概是 little_pig_location_1,little_pig_location_2 这样一个系列  之前用了一堆土办法的宏定义了5个location，现在要加到50个，就不能再每个都挨个定义了。  找了一些办法，但是没有通过编译，求解  #define HEADER "little_pig_location_" #define GetVersion(x) HEADER##x printf("%s\n", GetVersion("version1"));

没有看懂你的问题

引用 4 楼 user-5 的回复:[ codes]$ ./main  loc1=little_pig_location_0 loc2=little_pig_location_1 [ codes]$ cat main.cc  #include <stdio.h>  #define make_str(token) #token #define make_word(index) make_str(little_pig_location_##index)  int main(int argc, char *argv[]) {     const char *loc1 = make_word(0);     const char *loc2 = make_word(1);     printf("loc1=%s loc2=%s\n", loc1, loc2);     return 0; }  相邻的字符串自动连接


Question: 霍夫曼树的问题

引用 5 楼 bijiaoben 的回复:*HT = (HuffmanTree)malloc( (m+1) * sizeof(HTNode) );     //因为0号单元不用，所以m需要加一     p = *HT;     p++; // (*HT)[0]不用     for(i = 0; i <= m; p++, i++)     {         p->weight = 0;         p->parent = 0;         p->lchild = 0;         p->rchild = 0;     }  创建树的时候的这段代码指针越界了，p已经指向了HT[1]的元素，然后你又循环了m+1次。  多谢提醒  我明白了

引用 3 楼 u011669700 的回复:[quote=引用 2 楼 user-2123 的回复:] [quote=引用 楼主 u011669700 的回复:] #include<stdio.h> #include<stdlib.h> #include<string.h>  typedef char* *HuffmanCode; typedef struct { 	unsigned int weight; 	unsigned int parent,lchild,rchild; }HTNode, * HuffmanTree;  void CreateHuffmanTree(HuffmanTree *HT, unsigned int *w, int n); void Select(HuffmanTree HT, int i, int *s1, int *s2); void HuffmanTreeCoding(HuffmanTree HT, HuffmanCode *HC, int n); void PreOrderTraverse(HuffmanTree HT, int length); //先序遍历  int main(void) { 	int n; 	int i; 	unsigned int *w; 	HuffmanTree HT = NULL; //构造霍夫曼数的头结点  	 	printf("Please enter the leaf's total of HuffmanTree:"); 	scanf("%d", &n); 	w = (unsigned int *)malloc( (n+1) * sizeof(unsigned int) );  //0号单元不用，所以构造n+1个结点  	printf("Please enter the leaf's weight value of huffmantree\n"); 	for(i = 1; i <= n; i++) 	{ 		printf("please enter the value of %d: ",i); 		scanf("%d", &w[i]); 	} 	CreateHuffmanTree(&HT, w, n); 	HuffmanCode HC = NULL;   //用于存储多个字符串的二级指针  	HuffmanTreeCoding(HT, &HC, n);  //因为要改变指针变量HC的指向，所以要讲HC的地址传入  	for(int i = 1; i <= n; i++) 	{ 		printf("%d : %s\n", w[i], HC[i]); 	} 	printf("\n"); 	 	//PreOrderTraverse(HT, 2 * n); 	 	return 0;  }  void CreateHuffmanTree(HuffmanTree *HT, unsigned int *w, int n) { 	int m; 	int i,s1,s2; 	HuffmanTree p; 	if(n <= 1) 	{ 		printf("parameter is illegal!"); //若结点个数小于等于1，则无法进行树的构造  		return ; 	} 	m = 2 * n - 1; //构造霍夫曼树需要的结点总数 	*HT = (HuffmanTree)malloc( (m+1) * sizeof(HTNode) ); 	//因为0号单元不用，所以m需要加一 	p = *HT; 	p++; // (*HT)[0]不用 	for(i = 0; i <= m; p++, i++) 	{ 		p->weight = 0; 		p->parent = 0; 		p->lchild = 0; 		p->rchild = 0; 	}  	p = *HT; 	p++; 	for(i=1; i<=n; p++, i++) 	{ 		p->weight = w[i]; 	}//存入权值，便于筛选  	for(i = n+1; i <= m; i++)//0号单元未用，以用单元0~n,故 i=n+1  	{ 		Select(*HT, i-1, &s1, &s2); 		//从前i-1个分量中选择parent为０，且权值最小的两个结点，并取其下标给s1,s2  		(*HT)[s1].parent = i; 		(*HT)[s2].parent = i; 		(*HT)[i].lchild = s1; 		(*HT)[i].rchild = s2; 		(*HT)[i].weight = (*HT)[s1].weight + (*HT)[s2].weight;  	} }  void Select(HuffmanTree HT, int i, int *s1, int *s2) { 	int k, j; 	HuffmanTree p; 	p = HT; 	k = 1; 	while(HT[k].parent != 0) k++; 	*s1 = k; 	for(j = 1; j <= i; j++) 	{ 		if( (HT[j].parent == 0) && (HT[j].weight < HT[*s1].weight) )            *s1 = j; 	}//寻找权值最小的结点  	k = 1; 	while( (HT[k].parent != 0) || (k == *s1) )  k++; 	*s2 = k; 	for(j=1;j<=i;j++)     {     	if( (HT[j].parent == 0) && (HT[j].weight < HT[*s2].weight) && (j != *s1) )            *s2 = j;     } //寻找次小的结点  }  void HuffmanTreeCoding(HuffmanTree HT, HuffmanCode *HC, int n) {   	int i,start; 	unsigned int c,f; 	char *cd = NULL; 	*HC = (HuffmanCode)malloc(n * sizeof(char *)); //构造字符指针类型的数组  	cd = (char *)malloc(n * sizeof(char)); //用于存储霍夫曼编码  	cd[n-1] = '\0'; //末尾赋值字符串结尾标志  	for(i = 1; i <= n; i++) 	{ 		start = n - 1; 		for(c=i, f=HT [i].parent; f != 0; c = f, f=HT[f].parent) 		{ 			if(HT[f].lchild == c) 			   cd[--start] = '0';             else                 cd[--start] = '1'; 		}  		(*HC)[i] = (char *)malloc( (n-start) * sizeof(char) ); 		strcpy( (*HC)[i],&cd[start]); 	} 	free(cd); }  void PreOrderTraverse(HuffmanTree HT, int length) { 	HTNode stack[1000]; 	int top = -1; 	HTNode p = HT[length - 1]; 	while( p.weight != 0 || top != -1 ) 	{ 		while(p.weight != 0) 		{ 			printf("%d ",p.weight); 			if(top < 1000) 			{ 				top++; 				stack[top] = p; 			} 			else 			{ 				printf("max"); 				return; 			} 			p = HT[p.lchild]; 		} 		if(top != -1) 		{ 			p = stack[top]; 			top--; 			p = HT[p.rchild]; 		} 	}  }   说是有内存侵犯 0xC0000005: 读取位置 0xFFFFFFFF 时发生访问冲突。 但是在单步调试的时候也没有发现问题 一运行就会崩溃  求指教 找你的指针[/quote]有找过。。。不是指针的问题啊[/quote] 绝对是和指针相关，要么就是数组越界，不过0xffffffff咋看都是指针飞了的问题

直接运行的时候出现错误    单步调试的时候显示正常

引用 2 楼 user-2123 的回复:[quote=引用 楼主 u011669700 的回复:] #include<stdio.h> #include<stdlib.h> #include<string.h>  typedef char* *HuffmanCode; typedef struct { 	unsigned int weight; 	unsigned int parent,lchild,rchild; }HTNode, * HuffmanTree;  void CreateHuffmanTree(HuffmanTree *HT, unsigned int *w, int n); void Select(HuffmanTree HT, int i, int *s1, int *s2); void HuffmanTreeCoding(HuffmanTree HT, HuffmanCode *HC, int n); void PreOrderTraverse(HuffmanTree HT, int length); //先序遍历  int main(void) { 	int n; 	int i; 	unsigned int *w; 	HuffmanTree HT = NULL; //构造霍夫曼数的头结点  	 	printf("Please enter the leaf's total of HuffmanTree:"); 	scanf("%d", &n); 	w = (unsigned int *)malloc( (n+1) * sizeof(unsigned int) );  //0号单元不用，所以构造n+1个结点  	printf("Please enter the leaf's weight value of huffmantree\n"); 	for(i = 1; i <= n; i++) 	{ 		printf("please enter the value of %d: ",i); 		scanf("%d", &w[i]); 	} 	CreateHuffmanTree(&HT, w, n); 	HuffmanCode HC = NULL;   //用于存储多个字符串的二级指针  	HuffmanTreeCoding(HT, &HC, n);  //因为要改变指针变量HC的指向，所以要讲HC的地址传入  	for(int i = 1; i <= n; i++) 	{ 		printf("%d : %s\n", w[i], HC[i]); 	} 	printf("\n"); 	 	//PreOrderTraverse(HT, 2 * n); 	 	return 0;  }  void CreateHuffmanTree(HuffmanTree *HT, unsigned int *w, int n) { 	int m; 	int i,s1,s2; 	HuffmanTree p; 	if(n <= 1) 	{ 		printf("parameter is illegal!"); //若结点个数小于等于1，则无法进行树的构造  		return ; 	} 	m = 2 * n - 1; //构造霍夫曼树需要的结点总数 	*HT = (HuffmanTree)malloc( (m+1) * sizeof(HTNode) ); 	//因为0号单元不用，所以m需要加一 	p = *HT; 	p++; // (*HT)[0]不用 	for(i = 0; i <= m; p++, i++) 	{ 		p->weight = 0; 		p->parent = 0; 		p->lchild = 0; 		p->rchild = 0; 	}  	p = *HT; 	p++; 	for(i=1; i<=n; p++, i++) 	{ 		p->weight = w[i]; 	}//存入权值，便于筛选  	for(i = n+1; i <= m; i++)//0号单元未用，以用单元0~n,故 i=n+1  	{ 		Select(*HT, i-1, &s1, &s2); 		//从前i-1个分量中选择parent为０，且权值最小的两个结点，并取其下标给s1,s2  		(*HT)[s1].parent = i; 		(*HT)[s2].parent = i; 		(*HT)[i].lchild = s1; 		(*HT)[i].rchild = s2; 		(*HT)[i].weight = (*HT)[s1].weight + (*HT)[s2].weight;  	} }  void Select(HuffmanTree HT, int i, int *s1, int *s2) { 	int k, j; 	HuffmanTree p; 	p = HT; 	k = 1; 	while(HT[k].parent != 0) k++; 	*s1 = k; 	for(j = 1; j <= i; j++) 	{ 		if( (HT[j].parent == 0) && (HT[j].weight < HT[*s1].weight) )            *s1 = j; 	}//寻找权值最小的结点  	k = 1; 	while( (HT[k].parent != 0) || (k == *s1) )  k++; 	*s2 = k; 	for(j=1;j<=i;j++)     {     	if( (HT[j].parent == 0) && (HT[j].weight < HT[*s2].weight) && (j != *s1) )            *s2 = j;     } //寻找次小的结点  }  void HuffmanTreeCoding(HuffmanTree HT, HuffmanCode *HC, int n) {   	int i,start; 	unsigned int c,f; 	char *cd = NULL; 	*HC = (HuffmanCode)malloc(n * sizeof(char *)); //构造字符指针类型的数组  	cd = (char *)malloc(n * sizeof(char)); //用于存储霍夫曼编码  	cd[n-1] = '\0'; //末尾赋值字符串结尾标志  	for(i = 1; i <= n; i++) 	{ 		start = n - 1; 		for(c=i, f=HT [i].parent; f != 0; c = f, f=HT[f].parent) 		{ 			if(HT[f].lchild == c) 			   cd[--start] = '0';             else                 cd[--start] = '1'; 		}  		(*HC)[i] = (char *)malloc( (n-start) * sizeof(char) ); 		strcpy( (*HC)[i],&cd[start]); 	} 	free(cd); }  void PreOrderTraverse(HuffmanTree HT, int length) { 	HTNode stack[1000]; 	int top = -1; 	HTNode p = HT[length - 1]; 	while( p.weight != 0 || top != -1 ) 	{ 		while(p.weight != 0) 		{ 			printf("%d ",p.weight); 			if(top < 1000) 			{ 				top++; 				stack[top] = p; 			} 			else 			{ 				printf("max"); 				return; 			} 			p = HT[p.lchild]; 		} 		if(top != -1) 		{ 			p = stack[top]; 			top--; 			p = HT[p.rchild]; 		} 	}  }   说是有内存侵犯 0xC0000005: 读取位置 0xFFFFFFFF 时发生访问冲突。 但是在单步调试的时候也没有发现问题 一运行就会崩溃  求指教 找你的指针[/quote]有找过。。。不是指针的问题啊

引用 楼主 u011669700 的回复:#include<stdio.h> #include<stdlib.h> #include<string.h>  typedef char* *HuffmanCode; typedef struct { 	unsigned int weight; 	unsigned int parent,lchild,rchild; }HTNode, * HuffmanTree;  void CreateHuffmanTree(HuffmanTree *HT, unsigned int *w, int n); void Select(HuffmanTree HT, int i, int *s1, int *s2); void HuffmanTreeCoding(HuffmanTree HT, HuffmanCode *HC, int n); void PreOrderTraverse(HuffmanTree HT, int length); //先序遍历  int main(void) { 	int n; 	int i; 	unsigned int *w; 	HuffmanTree HT = NULL; //构造霍夫曼数的头结点  	 	printf("Please enter the leaf's total of HuffmanTree:"); 	scanf("%d", &n); 	w = (unsigned int *)malloc( (n+1) * sizeof(unsigned int) );  //0号单元不用，所以构造n+1个结点  	printf("Please enter the leaf's weight value of huffmantree\n"); 	for(i = 1; i <= n; i++) 	{ 		printf("please enter the value of %d: ",i); 		scanf("%d", &w[i]); 	} 	CreateHuffmanTree(&HT, w, n); 	HuffmanCode HC = NULL;   //用于存储多个字符串的二级指针  	HuffmanTreeCoding(HT, &HC, n);  //因为要改变指针变量HC的指向，所以要讲HC的地址传入  	for(int i = 1; i <= n; i++) 	{ 		printf("%d : %s\n", w[i], HC[i]); 	} 	printf("\n"); 	 	//PreOrderTraverse(HT, 2 * n); 	 	return 0;  }  void CreateHuffmanTree(HuffmanTree *HT, unsigned int *w, int n) { 	int m; 	int i,s1,s2; 	HuffmanTree p; 	if(n <= 1) 	{ 		printf("parameter is illegal!"); //若结点个数小于等于1，则无法进行树的构造  		return ; 	} 	m = 2 * n - 1; //构造霍夫曼树需要的结点总数 	*HT = (HuffmanTree)malloc( (m+1) * sizeof(HTNode) ); 	//因为0号单元不用，所以m需要加一 	p = *HT; 	p++; // (*HT)[0]不用 	for(i = 0; i <= m; p++, i++) 	{ 		p->weight = 0; 		p->parent = 0; 		p->lchild = 0; 		p->rchild = 0; 	}  	p = *HT; 	p++; 	for(i=1; i<=n; p++, i++) 	{ 		p->weight = w[i]; 	}//存入权值，便于筛选  	for(i = n+1; i <= m; i++)//0号单元未用，以用单元0~n,故 i=n+1  	{ 		Select(*HT, i-1, &s1, &s2); 		//从前i-1个分量中选择parent为０，且权值最小的两个结点，并取其下标给s1,s2  		(*HT)[s1].parent = i; 		(*HT)[s2].parent = i; 		(*HT)[i].lchild = s1; 		(*HT)[i].rchild = s2; 		(*HT)[i].weight = (*HT)[s1].weight + (*HT)[s2].weight;  	} }  void Select(HuffmanTree HT, int i, int *s1, int *s2) { 	int k, j; 	HuffmanTree p; 	p = HT; 	k = 1; 	while(HT[k].parent != 0) k++; 	*s1 = k; 	for(j = 1; j <= i; j++) 	{ 		if( (HT[j].parent == 0) && (HT[j].weight < HT[*s1].weight) )            *s1 = j; 	}//寻找权值最小的结点  	k = 1; 	while( (HT[k].parent != 0) || (k == *s1) )  k++; 	*s2 = k; 	for(j=1;j<=i;j++)     {     	if( (HT[j].parent == 0) && (HT[j].weight < HT[*s2].weight) && (j != *s1) )            *s2 = j;     } //寻找次小的结点  }  void HuffmanTreeCoding(HuffmanTree HT, HuffmanCode *HC, int n) {   	int i,start; 	unsigned int c,f; 	char *cd = NULL; 	*HC = (HuffmanCode)malloc(n * sizeof(char *)); //构造字符指针类型的数组  	cd = (char *)malloc(n * sizeof(char)); //用于存储霍夫曼编码  	cd[n-1] = '\0'; //末尾赋值字符串结尾标志  	for(i = 1; i <= n; i++) 	{ 		start = n - 1; 		for(c=i, f=HT [i].parent; f != 0; c = f, f=HT[f].parent) 		{ 			if(HT[f].lchild == c) 			   cd[--start] = '0';             else                 cd[--start] = '1'; 		}  		(*HC)[i] = (char *)malloc( (n-start) * sizeof(char) ); 		strcpy( (*HC)[i],&cd[start]); 	} 	free(cd); }  void PreOrderTraverse(HuffmanTree HT, int length) { 	HTNode stack[1000]; 	int top = -1; 	HTNode p = HT[length - 1]; 	while( p.weight != 0 || top != -1 ) 	{ 		while(p.weight != 0) 		{ 			printf("%d ",p.weight); 			if(top < 1000) 			{ 				top++; 				stack[top] = p; 			} 			else 			{ 				printf("max"); 				return; 			} 			p = HT[p.lchild]; 		} 		if(top != -1) 		{ 			p = stack[top]; 			top--; 			p = HT[p.rchild]; 		} 	}  }   说是有内存侵犯 0xC0000005: 读取位置 0xFFFFFFFF 时发生访问冲突。 但是在单步调试的时候也没有发现问题 一运行就会崩溃  求指教 找你的指针


Question: 请教个问题！

us 是 unsigned short类型的参数啊

引用 11 楼 renyuzhuo0 的回复:[quote=引用 7 楼 zhao4zhong1 的回复:] 代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试是程序员必须掌握的技能之一。如何写入日志文件？[/quote]#include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef WIN32     #include <windows.h>     #include <io.h> #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  _vsnprintf         vsnprintf #endif //Log{ #define MAXLOGSIZE 20000000 #define MAXLINSIZE 16000 #include <time.h> #include <sys/timeb.h> #include <stdarg.h> char logfilename1[]="MyLog1.log"; char logfilename2[]="MyLog2.log"; static char logstr[MAXLINSIZE+1]; char datestr[16]; char timestr[16]; char mss[4]; CRITICAL_SECTION cs_log; FILE *flog; #ifdef WIN32 void Lock(CRITICAL_SECTION *l) {     EnterCriticalSection(l); } void Unlock(CRITICAL_SECTION *l) {     LeaveCriticalSection(l); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } #endif void LogV(const char *pszFmt,va_list argp) {     struct tm *now;     struct timeb tb;      if (NULL==pszFmt||0==pszFmt[0]) return;     _vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,"%03d",tb.millitm);     printf("%s %s.%s %s",datestr,timestr,mss,logstr);     flog=fopen(logfilename1,"a");     if (NULL!=flog) {         fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);         if (ftell(flog)>MAXLOGSIZE) {             fclose(flog);             if (rename(logfilename1,logfilename2)) {                 remove(logfilename2);                 rename(logfilename1,logfilename2);             }         } else {             fclose(flog);         }     } } void Log(const char *pszFmt,...) {     va_list argp;      Lock(&cs_log);     va_start(argp,pszFmt);     LogV(pszFmt,argp);     va_end(argp);     Unlock(&cs_log); } //Log} int main(int argc,char * argv[]) {     int i; #ifdef WIN32     InitializeCriticalSection(&cs_log); #else     pthread_mutex_init(&cs_log,NULL); #endif     for (i=0;i<10000;i++) {         Log("This is a Log %04d from FILE:%s LINE:%d\n",i, __FILE__, __LINE__);     } #ifdef WIN32     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_log); #endif     return 0; } //1-78行添加到你带main的.c或.cpp的那个文件的最前面 //81-85行添加到你的main函数开头 //89-93行添加到你的main函数结束前 //在要写LOG的地方仿照第87行的写法写LOG到文件MyLog1.log中

us 是个数字：十六进制2507。

代表函数的形参，一个没有符号的短整数。对于VC6来说，可以表示0~65535。

代表函数的形参，一个没有符号的短整数。对于VC6来说，可以表示0~32767。

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

引用 7 楼 zhao4zhong1 的回复:代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试是程序员必须掌握的技能之一。 单步调试和设断点调试我现在还不会，“写到日志文件中一步一步分析出来的”是不是说有些比较难懂的代码，在分析它的意思后，最好写成日志？方便下次看！我有遇到这种情况，有些比较难懂的代码之前我好不容易看懂了，过了段时间再去看，又要费一段脑经去理解，头都是大的！

opaque [Eu5peik] n. 不透明物 adj. 不透明的, 不传热的, 迟钝的  transparent [trAns5pZErEnt] adj. 透明的, 显然的, 明晰的  E文不好，伤不起呀（本人E文非常不好，看代码很吃力的）！ 勉强学学吧！ 这两个单词懂了，就明白程序的大概意思了。

引用 6 楼 u012207185 的回复:还有：printf("box is %s.\n",us & OPAQUE==OPAQUE? "opaque":"transparent") us很多，代表了什么？ 说明这个us每一位有每一位的含义。具体什么含义，得问写程序的人了。

引用 4 楼 caozhy 的回复:代表函数的形参，一个没有符号的短整数。对于VC6来说，可以表示0~65535。 形参我知道，colors[(us>>1)&07],colors[(us>>9) & 07]怎么解释啊？(us>>1)&07是数字3.

us不是函数的参数么

黑体字的程序看不懂啊，us是什么啊？


Question: 尾插法建立链表的一些操作程序运行就会显示错误，就大神指教

你建立的链表有问题，改成这样： linklist tail_createlist(linklist list,int * n){ 	list = (linklist)malloc(sizeof(listnode));//头结点分配空间 	//变量声明 	linklist p,r;	//r为尾指针 	r = list; 	//list = NULL; 	 	datatype  ch; 	while ((ch = getchar()) != '\n'){ 		p = (linklist)malloc(sizeof(listnode)); 		++ *n; 		p->data = ch; 		r->next = p; 		r = p; 	} 	r->next = NULL; 	return (list); }

见你的新帖： 附上答复 关于尾链 /* *	尾插法建立链表并进行排序（大到小），倒置； */  linklist tail_createlist(linklist list,int * n){ list = (linklist)malloc(sizeof(listnode));//头结点分配空间 //变量声明 linklist p,r;	//r为尾指针 r =list = NULL;	 datatype  ch; while ((ch = getchar()) != '\n'){ p = (linklist)malloc(sizeof(listnode)); ++ *n; p->data = ch; r->next = p; r = p; } r->next = NULL; return (list); } 这个函数的这句话 r =list = NULL;	 改成： r = list; list = NULL;

list = (linklist)malloc(sizeof(listnode));//头结点分配空间 	//变量声明 	linklist p,r;	//r为尾指针 	r = p = NULL; 之前给list分配了空间后面又为什么要赋值NULL呢？


Question: 请教一个结构体长度问题

引用 6 楼 baijiaheizhiganmao 的回复:推荐一下这篇博客，相当不错：http://blog.csdn.net/21aspnet/article/details/6729724 看完之后我可以保证你不会疑惑字节对齐了。 谢谢

引用 8 楼 adlay 的回复:[quote=引用 4 楼 yiyamzen 的回复:] [quote=引用 3 楼 adlay 的回复:] char 是 0 个, 不计算空间了，这种结构通常都是变长的, sizeof 的大小不一定是使用时候的大小。 你是说它没有元素？那是不是这个char[0]的存在是不是没有意义了？这个是不是不能指向malloc申请的空间了？[/quote]  有意义，它表示了这个结构体是变长的，而且实际使用的时候也是可以取这个成员的。 搜索： C 变长结构体[/quote] 3Q~

引用 9 楼 Automation_dmu 的回复:[quote=引用 7 楼 yiyamzen 的回复:] [quote=引用 5 楼 Chen8013 的回复:] [quote=引用 2 楼 Automation_dmu 的回复:] char buf[0] 不就是0吗 , 4+4 不等于8吗 Ding.....[/quote] 如果char buf[0]是0，那么它怎么指向申请的内存空间呢？求解。。[/quote] 你把数组和指针的概念搞混淆了，这里数组的长度是0， 你sizeof(asdshdr.buf)时返回的也是0，表示的是数组的长度，当用buf指向申请的内存空间是，是把数组名退化成指针来使用，他指向的是紧随asdsdr之后的那块内存，这个指针不存在于asdsdr中，可以把它当陈一个临时变量。[/quote] 明白了，谢谢。

buf成员对程序没有什么意义,它只是起到填补空间以达到字节对齐的目的,当然即使不加这个成员通常编译器也会给我们自动填补对齐,我们自己加上它只是起到显式的提醒作用.因为long long各占4字节，不存在字节对齐的问题，所以char buf[0]不占用空间

引用 7 楼 yiyamzen 的回复:[quote=引用 5 楼 Chen8013 的回复:] [quote=引用 2 楼 Automation_dmu 的回复:] char buf[0] 不就是0吗 , 4+4 不等于8吗 Ding.....[/quote] 如果char buf[0]是0，那么它怎么指向申请的内存空间呢？求解。。[/quote] 你把数组和指针的概念搞混淆了，这里数组的长度是0， 你sizeof(asdshdr.buf)时返回的也是0，表示的是数组的长度，当用buf指向申请的内存空间是，是把数组名退化成指针来使用，他指向的是紧随asdsdr之后的那块内存，这个指针不存在于asdsdr中，可以把它当陈一个临时变量。

引用 4 楼 yiyamzen 的回复:[quote=引用 3 楼 adlay 的回复:] char 是 0 个, 不计算空间了，这种结构通常都是变长的, sizeof 的大小不一定是使用时候的大小。 你是说它没有元素？那是不是这个char[0]的存在是不是没有意义了？这个是不是不能指向malloc申请的空间了？[/quote]  有意义，它表示了这个结构体是变长的，而且实际使用的时候也是可以取这个成员的。 搜索： C 变长结构体

引用 5 楼 Chen8013 的回复:[quote=引用 2 楼 Automation_dmu 的回复:] char buf[0] 不就是0吗 , 4+4 不等于8吗 Ding.....[/quote] 如果char buf[0]是0，那么它怎么指向申请的内存空间呢？求解。。

引用 2 楼 Automation_dmu 的回复:char buf[0] 不就是0吗 , 4+4 不等于8吗 Ding.....

引用 3 楼 adlay 的回复:char 是 0 个, 不计算空间了，这种结构通常都是变长的, sizeof 的大小不一定是使用时候的大小。 你是说它没有元素？那是不是这个char[0]的存在是不是没有意义了？这个是不是不能指向malloc申请的空间了？

char buf[0] 不就是0吗 , 4+4 不等于8吗

结构体有对齐的问题，参考http://blog.csdn.net/shenbin1430/article/details/4292463  引用 楼主 yiyamzen 的回复:有个结构体 struct sdshdr {     long len;     long free;     char buf[0]; }; 我输出sizeof(long)为4，输出sizeof(struct sdshdr)为什么是8呢？ 不是long+long+char等于4+4+4=12吗？

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


Question: 这个程序为什么输出的是5和s啊？脑子混乱了？

s是因为要截取，5不知道啊

引用 2 楼 czarten 的回复:问题太多了 首先注意单引号和双引号 其次a应该是char不是int 而且字符串赋值不能这么写  #include<stdio.h> #include<string.h> int main() {     char a[100]="aasdfgdfsadfa见s";     printf("%d\n",strlen(a));     printf("%c",a[0]);     return 0; } +1

你直接看汇编自己跟踪吧，就知道为什么了。

你这是在创造语法

引用 3 楼 u012495471 的回复:我知道应该定成字符型，我是故意把数组定义成整型，我想知道为什么定义成整型结果是这样的？我想知道这其中的真相？类型的存储大小不一样，int型一般为4字节，而char一般为1字节

包含两个重大问题： 1、a[0]='aasdfgdfsadfa见s'不符合逻辑的写法，要么改为：    int a[100] = "aasdfgdfsadfa见s";    要么改为：a[0] = 'a' 2、字符串以'\0'结尾，你的程序中没有显式的定义它，所以结果难料，    刚好你的环境是第六个元素为0，所以strlen计算为5，    其它机器和环境可能是另外的值   引用 楼主 u012495471 的回复:#include<stdio.h> #include<string.h> int main() {     int a[100],i;     a[0]='aasdfgdfsadfa见s';     printf("%d\n",strlen(a));     printf("%c",a[0]);     return 0;  }

char字符型是8位的，int是32位的，也就是4个字符顶一个int，你这个复制之后就是这样的 a[0]='aasd' a[1]=fgdf a[2]=sadf a[3]=a见s a[4]=/0就是结束字符；所以 数组长度5， 再把int转为char，可能是因为存储方式，a[0]存储方式为aa ds，所以取到的是s

我只想告诉你，'1'的ASCII码为0x31 那么 '11'就代表着 0x3131

那个a[0]定义的问题很大，int和char通过ascii码转化。

计算机组成原理→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对应的汇编并单步执行观察相应内存和寄存器变化。）  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！

其他实现方式，包括编译出错，不能编译通过。 假设对于某个C,C++编译器；  该程序能够编译通过， 那么a[0]， 只能实际接受一个字符.  至于哪个字符被接受， 看编译器如何实现（比如大小端），以及编译器采用的编码，和编辑器采用的编码。

引用 12 楼 u012495471 的回复:虽然我还是没弄懂，还是感谢你们的解答。看来想了解程序运行的本质，非学汇编不可。至于其中一位哥们儿嘲笑我是在创造语法，我想打个比喻：小时候妈妈叫我们不要玩刀子，听话的孩子没有玩刀子（所以他们没被刀子划伤，妈妈也表扬他是个听话的好孩子，但是他始终不知道为什么不能玩刀子，他们只知道这样做会被妈妈叫做好孩子），有些孩子没听，被刀子划伤了，他恍然大悟，原来妈妈不叫我玩刀子是因为玩刀子可能会划伤啊！有一天，有个没碰过刀子的孩子无聊，见妈妈不在家，和邻居家的一个小孩玩了他从来没碰过的刀子，，，，， 你要先知道，正确的做法，并且很熟练的使用， 然后再去研究，错误的，禁忌的做法为什么错误，错在哪里！ a[0]='aasdfgdfsadfa见s';这种跟具体的编译器的实现有关。 其中一种实现方式，是  a[0]='aasdfgdfsadfa见s' <==> a[0] ='s'; 由于这个数组在栈上，数组a 并没有初始化。 其中存储的值，是程序运行到此处，堆栈上，该位置，某次使用后的残值。  这样，只有a[0] =='s'; 是确定的； 数组中其他99个数据，无从确定是什么值。 a[5]恰巧是0，也不是什么奇怪的事情。 于是strlen(a) =5 ,a[]0]='s' 就是一种很平常的偶然，一种很平常的巧合了。

a[0]是什么 'aasdfgdfsadfa见s'又是什么？ 它们的类型一致否？  strlen的参数需要是什么类型？


Question: 关于网络字节序的问题

这个大端说的是网络协议里面那些内容比如ip地址端口号啊; 至于你发的内容想怎么发就怎么发,和对方定义好就行了

htonl,htons ntohl,ntohs

这个比较靠谱  引用 5 楼 AnYidan 的回复:按byte 发送，在接收端解析收到的byte数组

发送是以byte为单位的，字符串没问题。 有问题的是size大于byte的类型，比如int，long，short和自定义类型 传输前调用hlton或者hston转为网络字节序，收到后ntohl或者ntohs还原，使调用者不需要关注底层大小端问题

不需要考虑这么复杂，在发送数据的时候将数据转换为网络序，在接受的时候将数据转换为本机序，是不会出问题的，而且在发送字符串的时候一般不需要考虑大小端的问题。只管接受即可。

按byte 发送，在接收端解析收到的byte数组

网络序是大端序, 0x2747是先发0x27, 再发0x47; "abcdefg"先发a 内存intel的x86上是小端序, risc芯片(arm/mips/powerpc)传统是大端序, 不过现在都做成可设置的了.

字节序嘛可以理解为字节摆放的顺序，所以楼上正解，以整型为例子可以参考： http://blog.csdn.net/user-8/article/details/6206980


Question: C语言，算法高手进

引用 3 楼 z601316152 的回复:步进值等于n+3   数组下面设 i i==0  取数 0 i+=7  取数 7 i+=7  取数 14 引用 3 楼 z601316152 的回复:步进值等于n+3   数组下面设 i i==0  取数 0 i+=7  取数 7 i+=7  取数 143楼正解

让下标i每次递增n就行了

不需要什么算法吧！地址移位就好了吧！

支持数组下标增加的方法

最好通过地址偏移或者数组下标移动比较方便！因为移动的数和取的数据个数都是固定的！

两个for循环可以吗？

直接数组下标增加就oｋ　了，

#include <stdio.h> int a[21] = {1,2,3,4,5,6,7,8,9,4,5,6,2,5,8,3,6,9,1,4,7}; int b[9]; int i,j,k; int main() {     k=0;     for (i=0;i<21;i+=7) for (j=0;j<3;j++) b[k++]=a[i+j];     for (i=0;i<9;i++) printf("%d,",b[i]);     return 0; } //1,2,3,8,9,4,8,3,6,


Question: C语言函数的用法

char是保留字,用于对变量声明类型,如, char a; 就声明了a为字符型,系统就为a开辟一个字节空间.  scanf() main() { 	char a; 	scanf("%c",&a);//%c表示输入为字符型,&a表示的是变量a的内存地址 	printf("%c",a);  }

问题太基础，根本都不是问题 看看基础书吧，没有理论是不行的 http://download.csdn.net/detail/max_min_/6333711

char是保留字 scanf从标准输入按照格式读取数据，比如从键盘读取变量。scan是扫描的意思，f是format，格式的缩写。

char是关键字，不是函数 scanf可以查MSDN或者man scanf，取决于你的平台。


Question: 求教一个makefile

谢谢大师们的指导

引用 6 楼 max_min_ 的回复:[quote=引用 5 楼 user-2 的回复:] 我拼写错误LZ都没发现？改成 LDFLAGS = -lpthread.a  加了选项之后，它已经出现在命令行中，如下 cc -Wall -O2   -lptrhead.a  mutilprocessserver.c sendReceive.o   -o mutilprocessserver /usr/bin/ld: cannot find -lptrhead.a 如果LZ仔细看看上面的出错信息，就知道生效了，只是打错库了。 LDFLAGS = -lpthread   就可以了吧！ 不需要后缀吧，加了后缀，貌似还要加前缀的[/quote] 版主英明。。

引用 5 楼 user-2 的回复:我拼写错误LZ都没发现？改成 LDFLAGS = -lpthread.a  加了选项之后，它已经出现在命令行中，如下 cc -Wall -O2   -lptrhead.a  mutilprocessserver.c sendReceive.o   -o mutilprocessserver /usr/bin/ld: cannot find -lptrhead.a 如果LZ仔细看看上面的出错信息，就知道生效了，只是打错库了。 LDFLAGS = -lpthread   就可以了吧！ 不需要后缀吧，加了后缀，貌似还要加前缀的

引用 2 楼 max_min_ 的回复: //如果是线程库的话 mutilprocessserver: mutilprocessserver.c sendReceive.o -lpthread //如果是自己生成的话 mutilprocessserver: mutilprocessserver.c sendReceive.o -L ./xx/xx libpthread.a  也可以像一楼那样，不过注意-L 来引导路径嗯嗯  第一种方法可行

引用 1 楼 user-2 的回复:CFLAGS := -Wall -O2  LDFLAGS = -lptrhead.a  ...还是不行啊 报错 cc -Wall -O2   -lptrhead.a  mutilprocessserver.c sendReceive.o   -o mutilprocessserver mutilprocessserver.c: In function ‘main’: mutilprocessserver.c:89: warning: pointer targets in passing argument 3 of ‘accept’ differ in signedness /usr/include/sys/socket.h:214: note: expected ‘socklen_t * __restrict__’ but argument is of type ‘int *’ mutilprocessserver.c:35: warning: unused variable ‘pid’ mutilprocessserver.c: In function ‘noBlocInput’: mutilprocessserver.c:212: warning: ignoring return value of ‘gets’, declared with attribute warn_unused_result In file included from /usr/include/stdio.h:910,                  from sendReceive.h:1,                  from mutilprocessserver.c:10: In function ‘gets’,     inlined from ‘noBlocInput’ at mutilprocessserver.c:212: /usr/include/bits/stdio2.h:230: warning: call to ‘__gets_warn’ declared with attribute warning: please use fgets or getline instead, gets can't specify buffer size /usr/bin/ld: cannot find -lptrhead.a collect2: ld returned 1 exit status make: *** [mutilprocessserver] 错误 1


Question: 二维数组矩形怎么出现的是乱码且不换行？？

经过修改，现在的代码是这个，但是还是不行。 #include<stdio.h> void main() { 	int i,j,a,b; 	printf("请输入不大于100的数组的行数:\n"); 	scanf("%d",&i); 	printf("请输入不大于100的数组的列数:\n"); 	scanf("%d",&j); 	int k[101][101]; 	printf("输入你准备的数字:\n"); 	for(a=0;a<i;a++); 	{ 	for(b=0;b<j;b++); 	scanf("%d ",&k[a][b]); 	} 	for(a=0;a<i;a++) 	{ 		for(b=0;b<j;b++) 		{ 		printf("%d,",k[a][b]); 	    printf("\n"); 		} 	}  }

确认下接收到的 i, j 数值？


Question: C语言新手求问。问什么运行不起来？

谢谢各位！！

这种事情直接加断点调试就好了，以后遇到类似的问题也能解决。

#include <stdio.h>  int main () { 	int i, t, n;//i是数字,t表示除数，n表示所有因子的和  	for (i = 2; i <= 1000; i++) 	{ 		n = 0; //每次判断一个数时设置因子之和为0 		for (t = 1; t < i; t++) 		{ 			if (i % t == 0) 				n += t; 		} 		//判断是否为完数，是则输出 		if (n == i) 		{ 			printf("%d its factors are ",i); 			for (t = 1; t < i; t++) 			{ 				if (i % t == 0) 					printf("%d ",t); 			} 			printf("\n"); 		} 	}  	return 0; } 排版后很容易发现各种嵌套错误

# include <stdio.h>  int main() {     int i, t, n; //i是数字,t表示除数，n表示所有因子的和     n = 0;     for (i = 2; i <= 1000; i++)         for (t = 1; t < i; t++)         {             if (i % t == 0)                 n = n + t;         }     if (n == i)     {         printf("%d its factors are ",i);         for (t = 1; t < i; t++)         {             if (i % t == 0)             printf("%d ",t);         }     }      return 0; }  LZ猜猜我为什么要帮你排版？

# include <stdio.h> int main () { 	int i,t,j,n;//i是数字,t表示除数，n表示所有因子的和     for (i = 2; i <= 1000; i++) 	{ 		for (t = 1; t < i; t++) 		{ 			if (i%t == 0) 				n = n + t; 		}         if (n == i) 			printf("%d ",i); 		n = 0; 	} 	return 0; }


Question: 求助：为什么这道题目我总是RUNTIME ERROR呢？

LZ所谓的所有的测试样例不会就是sample吧  那只是个sample而已。

好的，这其实是一道线性规划的问题，题意是这样的： 航空公司有A，B两条客机，总的乘客人数为N。A客机成本为CostA，载客数为PA；B客机成本为CostB,载客数为PB。每一组的测试数据包括N， CostA， PA， CostB， PB；航空公司需要刚刚好把所有的乘客运送完成。为达到最小Cost，要求输出A客机架次和B客机架次。谢谢！

你把英文大意讲一下吧，不然大家都不愿意看


Question: 怎么从缓冲区读一个字节或多个字节的数据

我问的就是从buf中咋读，，

char buf[BUF_LEN] ;读出来，然后解析就好！

新手，不太明白，，没用过。。。可以详解吗？

用字节流 unsigned char[]  引用 楼主 u012889234 的回复:int1,1   int1,0  datetime,2013-11-27 15:00:00   #时间采用UTC格式 datetime,2013-11-27 17:00:00 int1,1  int1,4  #IPv4采用网络序十进制，4字节；IPv6采用十六进制,16字节 ipv4,192.168.23.39  #变长 有上面的一个参数决定 int2,50001 int1,1  str,admin123   #最长为8字节，不足系统自动以0补齐 str,12345678   #长度必须为8字节 int4,60  对应的文本： 01 00 52 95 98 70 52 95 B4 90 01 04 C0 A8 17 27 C5 51 010 61 64 6D 69 6E 31 32 33 31 32 33 34 35 36 37 38 00 00 00 3C  由于有的参数是变长，，不能使用结构体，，用指针一个个的偏移还原数据该怎么写啊（c代码）。。


Question: Linux2.4内核这东西是咋回事 ？菜鸟求教

引用 1 楼 wangliangffaflgh 的回复:属于Linux2.4内核的有哪些操作系统 内核和操作系统的关系 为啥要编译内核  搜噶 ！ 老兄速度加给力！

属于Linux2.4内核的有哪些操作系统 内核和操作系统的关系 为啥要编译内核


Question: 文件读写的一个问题

y = [1222 1486 1752 2024 2301 2581 2865 3152 3439 3730 4025 4324 4629 4941 5261 5589 5925 6269 6621 6981]; 对于上面信息，你只保存了红色标记的部分 自己分析一下是不是文件指针那里处理处问题了

请检查每个函数的返回值！  When the "r+", "w+", or "a+" access type is specified, both reading and writing are allowed (the file is said to be open for “update”). However, when you switch between reading and writing, there must be an intervening fflush, fsetpos, fseek, or rewind operation. The current position can be specified for the fsetpos or fseek operation, if desired.


Question: 请教一个C语言题目谢谢

我晕 谢谢各位了 也不是作业 是一个练习题 周围都没有人问 只好问下各位大神了 才学习没多久!!一些地方卡主了!!谢谢!!!!

引用 6 楼 nice_cxf 的回复:。。。。明知是作业还给代码，真是害人不浅 是，我错了，下次不给了....

20分  写代码  呕；绝望，彻底的绝望

。。。。明知是作业还给代码，真是害人不浅

引用 1 楼 Adol1111 的回复:这种简单练习还是要自己写啊，多练练手。下面是代码，仅供参考：#include <stdio.h>  #define N 10  int found(int a[],int value){ 	int i=0; 	for(;i<N;i++){ 		if(a[i]==value) 			return 1; 	} 	return 0; }  int main(){ 	int i; 	int value; 	int a[N]; 	for(i=0;i<N;i++){ 		scanf("%d",a+i); 	} 	scanf("%d",&value); 	if(found(a,value)==1){ 		printf("found\n"); 	}else{ 		printf("Not found\n"); 	} 	return 0; } 给点意见哈！ 循环输入10个数的时候，应该要处理一下回车符，判断下scanf返回值

我也是初学,1楼写的比我好多了,楼主仅供参考..。。。。(那些诠释是我为我自己加的,忘记删除了)  看了1楼代码,又学到东西了。

#include <stdio.h> main() { 	int num[10],a,x; 	printf("请输入10个数,用空格隔开\n");  	for (a=0;a<10;a++)//c99标准支持在for里声明a,我这里不行 	{ 		scanf("%d",&num[a]);//输入时可以输10个数,用空格隔开,在输回车 		//或者可以每输一个数按一个回车(因为要的是%d,不会把回车读入) 		//[scanf和getchar都是先看内存有没有已读入的,没有就等待输入] 	}  	printf("请输入一个数x :"); 	scanf("%d",&x); 	for (a=0;a<10;a++) 	{ 		if (num[a]==x) 		{ 			printf("found"); 			a=0; 			break;  		}  	} 	if (a!=0) 		printf("no found");     }

楼主可以完美交作业了


Question: SSH2 VC6.0编译问题

可以看SSH2的官网（如果有的话）


Question: 一个奇怪的输出问题

明白了，谢谢。   引用 2 楼 ws_yqr 的回复:因为%x默认参数类型为unsigned int型，%.2x只是说最小精度为2，C5最高位是1，在char向int扩展的时候高位都置成1了，所以打印出的是FFFFFFC5. 格式化参数请参照http://www.cplusplus.com/reference/cstdio/printf/

改成unsigned char


Question: 大一学生求教。关于do..while..的问题。

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

引用 7 楼 b372119132 的回复:[quote=引用 6 楼 maoshuoqiong 的回复:] [quote=引用 5 楼 b372119132 的回复:] [quote=引用 1 楼 maoshuoqiong 的回复:] #include <stdio.h>  int main() {  	int a = 0, b = 0, c = 0, d = 0;//a表示数字的个数，b表示字母的个数，c表示空格的个数，d表示其他的个数 	char ch,ch1;  	do 	{ 		printf("请输入一行字符：\n");  		while ((ch = getchar())!='\n') 		{ 			if (ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z') 				b++; 			else if(ch >= '0' && ch <= '9') 				a++; 			else if(ch == ' ')//一定注意是 == 而不是 = 				c++; 			else 				d++; 		} 		printf("该字符串共有\n%d个数字\n%d个字母\n%d个空格\n%d个其他字符\n是否需要继续输入?(Y/N):\n",a,b,c,d); 		scanf(" %c",&ch1); 		fflush(stdin); //清空输入流  	}while (ch1 == 'Y'||ch1 == 'y');  	return 0; }  增加fflush函数.  请问我增加了这个函数之后 输入Y后第二次运行时 输出的数据是连同上一个数据一起显示的 这怎么回事 不是已经清空了吗 [/quote]  清空的只是系统输入缓冲区。 你的程序变量又没有被清零。 如果想不相同可以把变量改成循环局部变量，或者在每次循环的时候进行一次清零。 #include <stdio.h>  int main() {  	int a = 0, b = 0, c = 0, d = 0;//a表示数字的个数，b表示字母的个数，c表示空格的个数，d表示其他的个数 	char ch,ch1;  	do 	{ 		printf("请输入一行字符：\n");  		while ((ch = getchar())!='\n') 		{ 			if (ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z') 				b++; 			else if(ch >= '0' && ch <= '9') 				a++; 			else if(ch == ' ')//一定注意是 == 而不是 = 				c++; 			else 				d++; 		} 		printf("该字符串共有\n%d个数字\n%d个字母\n%d个空格\n%d个其他字符\n是否需要继续输入?(Y/N):\n",a,b,c,d); 		scanf(" %c",&ch1); 		fflush(stdin); //清空输入流 		a = b = c = d =0; //变量清零  	}while (ch1 == 'Y'||ch1 == 'y');  	return 0; }[/quote] 好的 努力学习[/quote] 加油，共勉

引用 6 楼 maoshuoqiong 的回复:[quote=引用 5 楼 b372119132 的回复:] [quote=引用 1 楼 maoshuoqiong 的回复:] #include <stdio.h>  int main() {  	int a = 0, b = 0, c = 0, d = 0;//a表示数字的个数，b表示字母的个数，c表示空格的个数，d表示其他的个数 	char ch,ch1;  	do 	{ 		printf("请输入一行字符：\n");  		while ((ch = getchar())!='\n') 		{ 			if (ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z') 				b++; 			else if(ch >= '0' && ch <= '9') 				a++; 			else if(ch == ' ')//一定注意是 == 而不是 = 				c++; 			else 				d++; 		} 		printf("该字符串共有\n%d个数字\n%d个字母\n%d个空格\n%d个其他字符\n是否需要继续输入?(Y/N):\n",a,b,c,d); 		scanf(" %c",&ch1); 		fflush(stdin); //清空输入流  	}while (ch1 == 'Y'||ch1 == 'y');  	return 0; }  增加fflush函数.  请问我增加了这个函数之后 输入Y后第二次运行时 输出的数据是连同上一个数据一起显示的 这怎么回事 不是已经清空了吗 [/quote]  清空的只是系统输入缓冲区。 你的程序变量又没有被清零。 如果想不相同可以把变量改成循环局部变量，或者在每次循环的时候进行一次清零。 #include <stdio.h>  int main() {  	int a = 0, b = 0, c = 0, d = 0;//a表示数字的个数，b表示字母的个数，c表示空格的个数，d表示其他的个数 	char ch,ch1;  	do 	{ 		printf("请输入一行字符：\n");  		while ((ch = getchar())!='\n') 		{ 			if (ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z') 				b++; 			else if(ch >= '0' && ch <= '9') 				a++; 			else if(ch == ' ')//一定注意是 == 而不是 = 				c++; 			else 				d++; 		} 		printf("该字符串共有\n%d个数字\n%d个字母\n%d个空格\n%d个其他字符\n是否需要继续输入?(Y/N):\n",a,b,c,d); 		scanf(" %c",&ch1); 		fflush(stdin); //清空输入流 		a = b = c = d =0; //变量清零  	}while (ch1 == 'Y'||ch1 == 'y');  	return 0; }[/quote] 好的 努力学习

引用 5 楼 b372119132 的回复:[quote=引用 1 楼 maoshuoqiong 的回复:] #include <stdio.h>  int main() {  	int a = 0, b = 0, c = 0, d = 0;//a表示数字的个数，b表示字母的个数，c表示空格的个数，d表示其他的个数 	char ch,ch1;  	do 	{ 		printf("请输入一行字符：\n");  		while ((ch = getchar())!='\n') 		{ 			if (ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z') 				b++; 			else if(ch >= '0' && ch <= '9') 				a++; 			else if(ch == ' ')//一定注意是 == 而不是 = 				c++; 			else 				d++; 		} 		printf("该字符串共有\n%d个数字\n%d个字母\n%d个空格\n%d个其他字符\n是否需要继续输入?(Y/N):\n",a,b,c,d); 		scanf(" %c",&ch1); 		fflush(stdin); //清空输入流  	}while (ch1 == 'Y'||ch1 == 'y');  	return 0; }  增加fflush函数.  请问我增加了这个函数之后 输入Y后第二次运行时 输出的数据是连同上一个数据一起显示的 这怎么回事 不是已经清空了吗 [/quote]  清空的只是系统输入缓冲区。 你的程序变量又没有被清零。 如果想不相同可以把变量改成循环局部变量，或者在每次循环的时候进行一次清零。 #include <stdio.h>  int main() {  	int a = 0, b = 0, c = 0, d = 0;//a表示数字的个数，b表示字母的个数，c表示空格的个数，d表示其他的个数 	char ch,ch1;  	do 	{ 		printf("请输入一行字符：\n");  		while ((ch = getchar())!='\n') 		{ 			if (ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z') 				b++; 			else if(ch >= '0' && ch <= '9') 				a++; 			else if(ch == ' ')//一定注意是 == 而不是 = 				c++; 			else 				d++; 		} 		printf("该字符串共有\n%d个数字\n%d个字母\n%d个空格\n%d个其他字符\n是否需要继续输入?(Y/N):\n",a,b,c,d); 		scanf(" %c",&ch1); 		fflush(stdin); //清空输入流 		a = b = c = d =0; //变量清零  	}while (ch1 == 'Y'||ch1 == 'y');  	return 0; }

引用 1 楼 maoshuoqiong 的回复:#include <stdio.h>  int main() {  	int a = 0, b = 0, c = 0, d = 0;//a表示数字的个数，b表示字母的个数，c表示空格的个数，d表示其他的个数 	char ch,ch1;  	do 	{ 		printf("请输入一行字符：\n");  		while ((ch = getchar())!='\n') 		{ 			if (ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z') 				b++; 			else if(ch >= '0' && ch <= '9') 				a++; 			else if(ch == ' ')//一定注意是 == 而不是 = 				c++; 			else 				d++; 		} 		printf("该字符串共有\n%d个数字\n%d个字母\n%d个空格\n%d个其他字符\n是否需要继续输入?(Y/N):\n",a,b,c,d); 		scanf(" %c",&ch1); 		fflush(stdin); //清空输入流  	}while (ch1 == 'Y'||ch1 == 'y');  	return 0; }  增加fflush函数.  请问我增加了这个函数之后 输入Y后第二次运行时 输出的数据是连同上一个数据一起显示的 这怎么回事 不是已经清空了吗

引用 3 楼 user-3 的回复:因为第二次循环的时候getchar()的缓冲区里还有一个“\n” 一上来ch就直接等于“\n”了 所以导致直接就结束了 需要先用fflush(stdin); 清空缓冲区 就正常了 非常清楚 谢谢了！结了之后才看到 抱歉！

引用 1 楼 maoshuoqiong 的回复:#include <stdio.h>  int main() {  	int a = 0, b = 0, c = 0, d = 0;//a表示数字的个数，b表示字母的个数，c表示空格的个数，d表示其他的个数 	char ch,ch1;  	do 	{ 		printf("请输入一行字符：\n");  		while ((ch = getchar())!='\n') 		{ 			if (ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z') 				b++; 			else if(ch >= '0' && ch <= '9') 				a++; 			else if(ch == ' ')//一定注意是 == 而不是 = 				c++; 			else 				d++; 		} 		printf("该字符串共有\n%d个数字\n%d个字母\n%d个空格\n%d个其他字符\n是否需要继续输入?(Y/N):\n",a,b,c,d); 		scanf(" %c",&ch1); 		fflush(stdin); //清空输入流  	}while (ch1 == 'Y'||ch1 == 'y');  	return 0; }  增加fflush函数. 谢谢了！


Question: 大一学生求教 函数引用问题

引用 5 楼 Adol1111 的回复:int g(int p, int q)//求最小公倍数 { int w; w = (p * q)/f(x, y);//这里的x,y是什么意思？是p,q吗？  return w; } 是的是的 现在弄明白了 谢谢！

引用 4 楼 b372119132 的回复:[quote=引用 3 楼 adeng1919 的回复:] int g(int p, int q)//求最小公倍数 { int w; w = (p * q)/f(x, y);  return w; } 这个函数里面并没有定义x和y，把x换成p，y换成q就对了，是同一个数 非常感谢[/quote]及时结贴就行

引用 3 楼 adeng1919 的回复:int g(int p, int q)//求最小公倍数 { int w; w = (p * q)/f(x, y);  return w; } 这个函数里面并没有定义x和y，把x换成p，y换成q就对了，是同一个数 非常感谢

引用 1 楼 zshuaiqin 的回复:不要这样 我是实在找不到人问 又很苦恼 求别喷。。。


Question: 请教个问题！

引用 1 楼 adeng1919 的回复:struct box_props{ unsigned int opaque:1;     unsigned int fill_color:3; unsigned int :4; unsigned int show_border:1; unsigned int border_color:3; unsigned int border_style:2; unsigned int:2; };  你传的结构体对象，fill_color=3，border_color=3，所以都是数字 colors[pb->fill_color]才是字符串，你字符串的定义是colors啊 运行结果border_color=2，不是3.

我只看到了一串unsigned int struct box_props{     unsigned int opaque:1;     unsigned int fill_color:3;     unsigned int :4;     unsigned int show_border:1;     unsigned int border_color:3;     unsigned int border_style:2;     unsigned int:2; };

pb->border_color不是字符串yellow吗？不是，是数字，colors[pb->border_color]才是字符串yellow


Question: swap汇编指令

temp：地址 a，b：地址的地址  []里面的是地址，没有“值”，汇编不要和c放一起读，读完汇编再看c，呵呵呵

a,b都是指针。

(int &a,int &b) 实际上传递的就是指针值。

void Myswap(int &a,int &b) {     int temp;      temp= a;     a= b;     b=temp; }  你的第4行不是给temp赋值，而是给temp初始化。 “变量赋值”和“变量初始化”不是一回事！ “变量赋值”发生在运行期，其写法遵循赋值语法规定。 “变量初始化”发生在编译期或运行期，其写法遵循初始化列表语法规定。


Question: 关于《高质量程序设计CC++语言》的编译时地址分配的问题

引用 2 楼 xwhbwas2008 的回复:[quote=引用 1 楼 nadleeh123 的回复:] [quote=引用 楼主 xwhbwas2008 的回复:] 再看书中的话，作者说了这么一句话(见里面的红线) 有点不理解，望大侠指点。  编译时只确定了运行时需要的内存大小，地址分配是程序运行加载时os来管理的，你的程序无权直接控制[/quote]  那书中的话是说：数组下标k是一个变量，它在编译时候是没有值的。//这个话是嘛意思阿 ？ [/quote] 本来就是这样啊，那里是个循环体，在汇编层就由跳转指令，比较指令，数据构成的一段指令，下标只会对应一段地址初始值。就算这样你不能理解，换个方式，如果k那里循环5万次，是不是就得有5万个值放在内存

就是在编译时是无法确定这个值是多少的，他可能是任何数字。即使你刚刚定义为int i = 4，然后使用这个i，编译器仍然认为是一个未知的值。因为编译器不检查整个代码，是无法确定你在定义到使用之间有没有修改的。  为了避免无意义的检查，所以编译器是一刀切的。也就是说，编译时我不关系他的值到底是多少，我都认为是不知道。直到运行的时候，我取出了这个值，我才确定了它。  量子力学里有一个叫薛定谔的猫的问题，你可以去了解下。

引用 3 楼 zhao4zhong1 的回复:运行时  书中的话是说：数组下标k是一个变量，它在编译时候是没有值的。//这个话是嘛意思阿 ？

计算机组成原理→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对应的汇编并单步执行观察相应内存和寄存器变化。）

运行时

引用 1 楼 nadleeh123 的回复:[quote=引用 楼主 xwhbwas2008 的回复:] 再看书中的话，作者说了这么一句话(见里面的红线) 有点不理解，望大侠指点。  编译时只确定了运行时需要的内存大小，地址分配是程序运行加载时os来管理的，你的程序无权直接控制[/quote]  那书中的话是说：数组下标k是一个变量，它在编译时候是没有值的。//这个话是嘛意思阿 ？

引用 楼主 xwhbwas2008 的回复:首先问一个问题，  int func() { int a[2],b;//问下这个b,a[0]和 a[1]的地址是什么时候分配的啊？编译时候还是运行的时候  return 0; }  再看书中的话，作者说了这么一句话(见里面的红线) 有点不理解，望大侠指点。  编译时只确定了运行时需要的内存大小，地址分配是程序运行加载时os来管理的，你的程序无权直接控制


Question: 请帮忙推荐一本经典汇编语言的书

引用 2 楼 hangang7403 的回复:汇编语言第2版（完全版）王爽 的 不错 就是有点老+1

引用 11 楼 M173475237 的回复:16位的找王爽。。 windows下的找罗云彬~ linux下的看《汇编语言程序设计》红皮的那本。有中文翻译版。  汇编语言程序设计 [平装] ~ 布鲁姆 (作者)http://www.amazon.cn/%E6%B1%87%E7%BC%96%E8%AF%AD%E8%A8%80%E7%A8%8B%E5%BA%8F%E8%AE%BE%E8%AE%A1-%E5%B8%83%E9%B2%81%E5%A7%86/dp/B0011BB30I/ref=wl_it_dp_o_pC_nS_nC?ie=UTF8&colid=3T498RBWYV9QV&coliid=I2UF1U0E2B7G0B

16位的找王爽。。 windows下的找罗云彬~

我也同求啊，希望那种不要太枯燥的

其实能理解机器底层是如何运算的，基本上学汇编的目的就达到了，毕竟真正用汇编工作的少。

《汇编语言》第二版PDF 王爽 http://download.csdn.net/detail/cui13aiwang/2770201#comment  王爽真真正正是个会教的老师

这种书必须看作者的教书的水平，高手很多，但会教的高手很少，王爽写的书和其他人相比简直是鹤立鸡群。

8086的看王爽的神作《汇编语言第2版》，win32下的汇编看《Windows环境下32位汇编语言程序设计（第2版》

其实打本简明汇编看看就行了

不同平台的汇编语言不同，lz 首先要确定大方向

引用 楼主 u010334406 的回复:想学习汇编语言，想找本经典的书看看，类似于K&R的C语言书一样的书，我英语只有三级水平看不懂，英文的要有翻译版本的。 see mips run linux

汇编语言第2版（完全版）王爽 的 不错 就是有点老

Intel微处理器结构、编程与接口（第六版）----------------------------------------------------------------------------Barry B. Brey 80x86、奔腾机汇编语言程序设计--------------------------------------------------------------------------------------Barry B. Brey Windows环境下32位汇编语言程序设计（第2版)------------------------------------------------------------------------------ --罗云彬 IBM-PC汇编语言程序设计（第2版） 本书是国内优秀教材-------------------------------------------------------------- --沈美明 温冬婵 IBM PC汇编语言程序设计（第五版） 这本书籍是国外优秀教材---------------------------------------------PETER ABEL著,沈美明 温冬蝉译


Question: 这个程序怎么将十进制转化为十六进制的，我是菜鸟，麻烦哪位大神帮我稍微详细的讲解一下

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

这个程序可以实现把一个大数据以十六进制输出，我想知道是怎么实现的

for(;t;t--)printf("%X",b[t]); 数在计算机内都是用二进制存的,用printf输出时,%d就输出十进制值,%x就输出十六进制值,并没有转化


Question: 快速排序算法有问题！求发现！

引用 5 楼 lt114896 的回复:没事写的，可以研究下 void QuikSort(int a[], long low, long high) { 	if(low >= high) 	{ 		return; 	} 	long nlow = low; 	long nhigh = high; 	int temp = 0;	 	bool flag = false;  	while(nlow<nhigh) 	{ 		if(a[nlow] > a[nhigh]) 		{ 			temp = a[nlow]; 			a[nlow] = a[nhigh]; 			a[nhigh] = temp; 			flag = !flag; 		} 		if(flag) 		{ 			nlow++; 		} 		else 		{ 			nhigh--; 		} 	}  	QuikSort(a, low, nhigh); 	QuikSort(a, nhigh+1, high); }  呵呵，你这个应该不是快速排序吧？

引用 2 楼 worldy 的回复:void QuickSort(int array[], int n)  快速排序看这个函数参数就知道不对，快排函数直接或间接的参数必须必须有三个，第一个参数数组，第二个参数开始下标，第三参数个结束下标re

引用 3 楼 Adol1111 的回复:你的快排参数有问题，你一直都是从0排到n这个是不对。其实下标和结束下标都是动态变化的，先由分治算法算出一个点n，然后分别排序改点的两侧 low - n-1 和 n+1 - high。你试试看这个：int partition(int array[], int low,int high) { 	int pivot = array[low];  	if (low>=high) return low;  	while (low<high) { 		while (low < high && array[high] >= pivot) --high; 		array[low]=array[high];//算出high之后记得立刻赋值 		while (low < high && array[low] <= pivot) ++low; 		array[high]=array[low]; 	} 	//array[0] = array[lh];这句话你写的，完全没必要，至少我没看懂。 	array[low] = pivot; 	return low; }  void QuickSort(int array[], int low,int high) { 	int boundary; 	if (low>=high)return; 	boundary = partition(array, low , high); 	QuickSort(array , low , boundary-1);//排low  -  boundary-1 	QuickSort(array , boundary + 1, high );//排boundary+1 - high }++

貌似最后移动pivot的位置有误...      //if (array[lh] >= pivot)     //    return 0;     array[0] = array[lh-1];     array[lh-1] = pivot;     return lh-1;

先 http://www.microsoft.com/visualstudio/chs/downloads#d-2010-express 点开Visual C++ 2010 Express下面的语言选‘简体中文’，再点立即安装  再参考C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\qsort.c


Question: 二进制ip显示成点分十进制

#include <stdio.h> #include <string.h>  typedef union ip_addr_t { unsigned int nip; unsigned char cip[4]; }ip_addr;  int main(int argc, char** argv) { ip_addr ip; ip.nip=0x726F6F74;//your_int_ip;  char buf[16]; memset(buf, 0x00, sizeof(buf)); sprintf(buf,"%d.%d.%d.%d",ip.cip[3],ip.cip[2],ip.cip[1],ip.cip[0]); printf("%s", buf); return 0; }

使用sprintf组成字符串

很好办， 先确定自己电脑的字节序， 然后一个字节一个字节取，（用无符号字符指针即可） 然后将取得的字节转化成数字，根据ASCII码 OK，组合一下就行了

不是这样啦，， int 占4个字节，第一个字节是 0x72                第二个字节是 0x6F                第三个字节是 0x6F                第四个字节是 0x74 也就是 int value = 726F6F74; 转换成字符串 "114.111.111.116".

引用 楼主 u012889234 的回复:二进制IP ： 72 6F 6F 74   要显示成 :114.111.111.116  c语言代码要怎么写啊？ 四个数，用%d打印就是了！只是16进制而已！

必须给！！！

引用 7 楼 u012889234 的回复:5楼的方法还可以，，我咋忘了联合呢，，我是新手！  多指教！！！ 这种写法在项目里面真的用过的，就是要注意大小端的问题。 另外，楼主给分不

感谢6楼再次光临！！！！

5楼的方法还可以，，我咋忘了联合呢，，我是新手！  多指教！！！

#include<stdio.h> void main() {     int ip[4];     int i;     for(i=0;i<4;i++)         scanf("%x",&ip[i]);     for(i=0;i<3;i++)         printf("%d.",ip[i]);     printf("%d\n",ip[i]); }

#include <stdio.h> char IP[4] = {0x72,0x6F,0x6F,0x74}; int main() {     printf("%d.%d.%d.%d",(unsigned)IP[0],(unsigned)IP[1],(unsigned)IP[2],(unsigned)IP[3]);     return 0; } 114.111.111.116

这明显是十六进制啊怎么会是二进制 自己写一个十六进制转十进制的的函数，最后再凑成ip字符串形式


Question: OpenGL glut如何固定窗体大小

WM_GETMINMAXINFO The WM_GETMINMAXINFO message is sent to a window when the size or position of the window is about to change. An application can use this message to override the window's default maximized size and position, or its default minimum or maximum tracking size.   WM_GETMINMAXINFO  lpmmi = (LPMINMAXINFO) lParam; // address of structure    Parameters lpmmi  Value of lParam. Pointer to a MINMAXINFO structure that contains the default maximized position and dimensions, and the default minimum and maximum tracking sizes. An application can override the defaults by setting the members of this structure.  Return Values If an application processes this message, it should return zero.   Remarks The maximum tracking size is the largest window size that can be produced by using the borders to size the window. The minimum tracking size is the smallest window size that can be produced by using the borders to size the window.   QuickInfo   Windows NT: Requires version 3.1 or later.   Windows: Requires Windows 95 or later.   Windows CE: Unsupported.   Header: Declared in winuser.h.  See Also Windows Overview, Window Messages, MoveWindow, SetWindowPos, MINMAXINFO

参考http://libsh.org/ref/online/onlinese2.html，稍作修改即可。  引用 楼主 wuyanxue 的回复:RT 在网上搜过 说可以利用resize()函数将height和width固定死    但不知道怎么固定死这两个参数? 请大神给出解决办法 或者用其他办法也行

引用 楼主 wuyanxue 的回复:RT 在网上搜过 说可以利用resize()函数将height和width固定死    但不知道怎么固定死这两个参数? 请大神给出解决办法 或者用其他办法也行 const类型或者宏...


Question: 队伍长度为L米，并匀速前进。传令兵以匀速，先从队尾跑到队头，再从队头跑回队尾，期间队伍行进了S米。请问传令兵一共跑了多少米？

引用 引用 3 楼 user-6 的回复:用double不要用float试试，数据大的时候float精度不够专业。几天前用double通过了！ 谢谢各位！受教了

int 是几位的？ 如果是16位的，l*l就溢出了。

这是数学题，还是递归，循环的题？

纯数学解法： 设士兵速度为x,部队速度为y 部队行走时间t1=S/y 士兵行走时间t2=L/(x-y)+L/(x+y) t1=t2，得到S/y=2xL/(x^2-y^2)，得到x/y-y/x=2L/S 需要求的是距离A = x*t=x*S/y，得到A/S=x/y，带入得 A/S-S/A=2L/S，得到A^2-2LA-S^2=0。 利用一元二次方程组的解得到，A=L+sqrt(L^2+S^2)。  算完了发现和楼主提供的代码一样的....没啥问题啊！！！！

引用 2 楼 u012540439 的回复:引用算完了发现和楼主提供的代码一样的....没啥问题啊！！！！  OJ通不过嘞…… WA还是ot? 不过这题。。我怎么觉得好像是相对运动的那题啊。。就是把队伍当成火车，然后传令兵走的距离是2L。。

运行代码，输入样例输入，看能否得到跟样例输出一样的输出。

用double不要用float试试，数据大的时候float精度不够


Question: 这个程序的输出该怎么改才正确啊？？

楼主很幸运，居然还能输出一个学生的信息而不是程序崩溃。循环里面每次都输入同一个地址就先不说了。关键是这个地址在数组的有效地址之外，数组长度为5的话，有效下标应该是0到4

http://download.csdn.net/detail/max_min_/6333711 好好看基础书籍，上面的例程都敲下  磨刀不误砍材工！

“多一少一”问题占程序员常犯错误的10%以上！

#include<stdio.h> struct student  {     int num;     char name[50];     float score[3]; }; void inputSore(struct student *p); void printScore(struct student *s);//这里做了修改  void main ()     {     struct student stu[3];     int i;     for(i=0;i<3;i++)//这里做了修改     { 		printf("请输入\n学号:  姓名:     三科考试成绩:\n");         inputSore (&stu[i]);     }     printScore(stu);     }  void inputSore(struct student *p) {     scanf("%d %s %f %f %f",&p->num,p->name,&p->score[0],&p->score[1],&p->score[2]);     printf("\n"); }  void printScore(struct student *s) {     int i;     printf("学号:    姓名:     三科考试成绩:\n");     for (i=0;i<3;i++)     {         printf("%d   ",s[i].num);         printf("%s   ",s[i].name); 		printf("%f   %f   %f\n",s[i].score[0],s[i].score[1],s[i].score[2]);//有修改     } }

for(i=1;i<=5;i++)for(i=0;i<5;i++)下标从0开始     {         printf("请输入\n学号:  姓名:     三科考试成绩:\n");         inputSore (&stu[5]);这里不是该用i么？      }


Question: 辗转相除法求最大公约数出现乱码怎么改？

scanf("%d,%d",&n,&m);你的输入要跟scanf格式相同，11,22


Question: 变量前加“！”是什么意思？

引用 10 楼 truelance 的回复:[quote=引用 7 楼 ztzi321 的回复:] [quote=引用 3 楼 truelance 的回复:] 对于0返回1,  对于非0返回0 UV=(T_INIT *)malloc(sizeof(T_INIT)); 	if(!UV) t_error("UV was not allocated"); 这句话是什么意思？[/quote]  c语言里明确定义了空指针就是0, 这里就是判断malloc返回的结果是否是空指针.[/quote]非常感谢 ！

引用 7 楼 ztzi321 的回复:[quote=引用 3 楼 truelance 的回复:] 对于0返回1,  对于非0返回0 UV=(T_INIT *)malloc(sizeof(T_INIT)); 	if(!UV) t_error("UV was not allocated"); 这句话是什么意思？[/quote]  c语言里明确定义了空指针就是0, 这里就是判断malloc返回的结果是否是空指针.

引用 7 楼 ztzi321 的回复:[quote=引用 3 楼 truelance 的回复:] 对于0返回1,  对于非0返回0 UV=(T_INIT *)malloc(sizeof(T_INIT)); 	if(!UV) t_error("UV was not allocated"); 这句话是什么意思？[/quote] C语言允许用数值表示布尔值，0表示假，非0表示真（不是1是非0） 所以if(!UV)可以写成 if(UV==NULL),也就是UV为0时，!UV会为真，条件成立

引用 7 楼 ztzi321 的回复:[quote=引用 3 楼 truelance 的回复:] 对于0返回1,  对于非0返回0 UV=(T_INIT *)malloc(sizeof(T_INIT)); 	if(!UV) t_error("UV was not allocated"); 这句话是什么意思？[/quote] 是空吗？

引用 3 楼 truelance 的回复:对于0返回1,  对于非0返回0 UV=(T_INIT *)malloc(sizeof(T_INIT)); 	if(!UV) t_error("UV was not allocated"); 这句话是什么意思？

逻辑运算符： 与 &&  或 ||   非    ！ 类似的 位运算符： 与 &    或 |    取反 ~

引用 4 楼 zhxianbin 的回复:逻辑非运算符+1

逻辑非运算符

对于0返回1,  对于非0返回0

! 是非的意思   bool(不是BOOL，这个是WINDOWS的，实际上是uint32)型变量用的

! 是非的意思    基本是BOOL型变量用的

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


Question: C和指针 第六章，编程题目，第二题

#include "stdio.h" #include "string.h" char* ptr (char * p1, char * p2); int  del_substr ( char * st1, char * st2); int main() {	char * d; 	int cmp,cnp,cp,clp,p;				  	char  a [100]= "abcdefghij";		  	char  b[100] = "cde";  	cnp = strlen(a);  	cp = strlen(b);  	d = ptr(a,b);  	cmp = del_substr(a,b);  	if(cmp)  	{  		  			for(clp = 0;clp<cp;clp++)  			  				for(p = 0;p<cnp;p++)	  					  					a[d-a+p] = a[d-a+p+1];	   				printf("%s",a);  			  	}  	else  	printf("没有任何子串");  	 } char * ptr (char * p1, char * p2) { 	char *str1,*str2; 	for(str1 = p1;*str1 != '\0';str1++) 		for(str2 = p2; *str2 != '\0';str2++) 			if(*str1 == *str2) 			return str1; 			 	return NULL; 	 } int del_substr( char * st1, char *st2) { 	char * temp; 	int i,count,p; 	count = 0; 	i = strlen(st2); 	if (st1 == NULL && st2 == NULL)	 		return 0; 	temp = ptr(st1 ,st2); 	if(temp == NULL) 		return 0; 	for(p = 0;p<i;p++) 		if(*temp++ == *st2++) 			count ++; 			if(i == count) 			return 1; 			 	return 0;					 }  这个是我写的代码。测试过了

仅供参考#include <stdio.h> #include <string.h> #include <locale.h> char s[256]; char *p; int r,n,i; int main() {     setlocale(LC_ALL,"chs");     while (1) {         printf("请输入一行文字(空行结束),\"%%20\"将替换为\" \",\"你懂得\"将替换为\"XXXXXX\":\n");         fgets(s,256,stdin);         if ('\n'==s[0]) break;         p=s;         while (1) {             p=strstr(p,"%20");             if (p) {                 memmove(p+1,p+3,strlen(p)-3+1);                 p[0]=' ';             } else break;         }         p=s;         while (1) {             p=strstr(p,"你懂得");             if (p) {                 memmove(p+6,p+6,strlen(p)-6+1);                 for (i=0;i<6;i++) p[i]='X';             } else break;         }         printf("%s",s);     }     return 0; } //请输入一行文字(空行结束),"%20"将替换为" ","你懂得"将替换为"XXXXXX": //abcdefg%20helloworld%20something.pdf //abcdefg helloworld something.pdf //请输入一行文字(空行结束),"%20"将替换为" ","你懂得"将替换为"XXXXXX": //这是测试文字你懂得，在这个你懂的地方，就得做你懂得的事 //这是测试文字XXXXX，在这个你懂的地方，就得做XXXXX的事 //请输入一行文字(空行结束),"%20"将替换为" ","你懂得"将替换为"XXXXXX": //

楼主去搜一下KMP算法，做字符串模式匹配，然后再删除就好了。

引用 楼主 u012804737 的回复:题目说起来不难，编写一个函数，删除一个字符串的一部分。函数原型如下，  int del_substr(char *str ,char const * substr) 要求是不使用操纵字符的库函数。 首先判断，子串在不在主串中，在的话，返回1 不在的话返回0； 举例， str = abcdef  substr = cde 那么返回1 如果   str = abcdef   substr bce  那么返回0 我想了半天，想了好多办法，就是没有一种可行的，最接近的方法也差了点，没办法只能求救。只希望大家帮我写到返回值那一块，剩下的删除字符串，我可以自己写，或则可以告诉我一个思路。  想了差不多一天的时间，才想出来，老的帖子没办法回复了，网上也没有符合要求的代码，自己写的，贴一个，算是鼓励自己，我这智商实在不适合学习C语言，看来 不用string.h下的函数就自己写个类似的呗-.-,string.h里面的玩意儿经常被当作面试题


Question: 关于数据结构有点小问题。为什么编译器显示没有错误，而执行是总出现程序终止，这都是那种错误呢？

关于尾链 /* *	尾插法建立链表并进行排序（大到小），倒置； */  linklist tail_createlist(linklist list,int * n){ 	list = (linklist)malloc(sizeof(listnode));//头结点分配空间 	//变量声明 	linklist p,r;	//r为尾指针 	r =list = NULL;	 	datatype  ch; 	while ((ch = getchar()) != '\n'){ 		p = (linklist)malloc(sizeof(listnode)); 		++ *n; 		p->data = ch; 		r->next = p; 		r = p; 	} 	r->next = NULL; 	return (list); } 这个函数的这句话 r =list = NULL;	 改成： 	r = list; 	list = NULL;

main函数这样改。 int main() { 	linklist LIST = NULL; 	LIST = head_createlist(LIST); 	print(LIST); 	return 0; }

/* *	尾插法建立链表并进行排序（大到小），倒置； */ #include <stdio.h> #include <stdlib.h> typedef char datatype ; //节点的描述 typedef struct node { 	datatype data;		//数据域 	struct node *next;	//指针域 }listnode,*linklist; linklist tail_createlist(linklist list,int * n);	//函数声明 linklist print(linklist list,int n); linklist sort(linklist list,int n); linklist invertion(linklist list,int n ); main(void) { 	int count ;	//节点数 	count = 0; 	linklist LIST; 	LIST = NULL; 	LIST = tail_createlist(LIST,&count);//这样要返回值，因为指针作为函数参数无法改变指针的指向，必须用返回值了 	print(LIST,count); 	LIST = sort(LIST,count); 	print(LIST,count); 	LIST = invertion(LIST,count); 	printf("\n"); 	return 0; } linklist tail_createlist(linklist list,int * n){ 	list = (linklist)malloc(sizeof(listnode));//头结点分配空间 	//变量声明 	linklist p,r;	//r为尾指针 	r =list = NULL; 	datatype  ch; 	while ((ch = getchar()) != '\n'){ 		p = (linklist)malloc(sizeof(listnode)); 		++ *n; 		p->data = ch; 		r->next = p; 		r = p; 	} 		r->next = NULL; 		return (list); } linklist print(linklist list,int n){ 	while (list->next != NULL){ 		printf("%c",list->next->data); 		list = list->next; 	} 	printf("\n"); 	printf("%d\n",n); 	return 0 ; } linklist sort(linklist list,int n){ 	//用冒泡法做一个循环 	linklist sign; 	sign = list; 	int i , j  ; 	datatype exchange; 	 	for(i = 1;i<= n;i++){ 		list = sign; 		for(j = 1;j<= n-i;j++){	 			if((list->next->data) < (list->next->next->data)){ 				exchange = list->next->next->data; 				list->next->next->data = list->next->data; 				list->next->data = exchange; 			} 			list = list->next; 		} 	} 	 	return (list); } linklist invertion(linklist list,int n){ 	int i , j; 	linklist sign; 	sign = list; 	for(i = 1;i <= n; i++){ 		list = sign; 		for(j = 1; j <= n - i;j++){ 			list = list->next; 		} 		printf("%c",list->next->data); 			 	} 	return (list); } 麻烦看些这个哪里错了呢？

#include <stdio.h> #include <stdlib.h> typedef char datatype ; //节点的描述 typedef struct node{ 	datatype data;	 //数据域 	struct node *next;	//指针域 }Node; Node* head_createlist();	//函数声明 void print(Node* list); main(void) { 	Node *list; 	list = head_createlist(); 	print(list); 	return 0; } 	Node *head_createlist() 	{ 		Node *p, *list; 		Node *head; 		datatype  ch; 		list = (Node*)malloc(sizeof(Node));//头结点分配空间 	//变量声明 		head = list; 		while ((ch=getchar()) != '\n') 		{ 			p = (Node*)malloc(sizeof(Node)); 			p->data = ch; 			head->next = p; 			head = p; 		} 		head->next = NULL; 		return list; } void print(Node* list) { 	Node *p; 	p = list->next; 	while (p) 	{ 		printf("%c\n",p->data); 		p = p->next; 	} 	 }稍微改了下，你看看

声明要放在函数块的头部


Question: 关于链表写入文件和下次打开程序从文件读取数据的问题

是代码太长了木有人为我解答么！？


Question: 多维数组排序

先横排再纵排

sorry想错了，看成一维数组排序，正解。

引用 楼主 landuodejiafeimao 的回复:给定一个10*10数组,对其进行排序,使其满足，每行从左到右升序排列,同时每列从上到下升序排列 只能分别对行和列进行排序么？那样，我觉得有可能会无解啊？比如如果中间排出现了最大值，那无论如何也不行了，所以，是不是这些输入不是随意的？或者是可以出现无解的情况？ 如果可以全部任意排序，那就如楼上说的。 引用 7 楼 ForestDB 的回复:看成100个元素的一维数组，排序之。 看成一维数组排序

看成100个元素的一维数组，排序之。

如果觉得麻烦，可以先将这个10*10的二维数组赋值给100的一维数组，然后再对这个一位数组进行排序，排好后存进二维数组即可，反正没有空间复杂度的限制。

做两个函数，第一个先对行排序，然后第二个对每一行循环排序

不难阿，我的思路，你把这个二维数组按照一维排序方式排序（二维数组可以看做一维数组，对吧？），就行了。就是你当成是100大小的一维数组就行了，从小到大排。 能写出来吗？

结果不唯一,不过正常从小到大排就行

就是说随机输入一个10*10的矩阵用数组存储，现在对其进行排序，使得最终结果为每一行从左到右为升序，同时满足每一列从上到下也为升序，请给出排序算法

问题描述不够详细