Question: if语句满足了但是不执行是为什么,急急急急，明天就要交了

谢谢诸位大佬了

#include <stdio.h>  char chess[][6] = { 	' ', 'X', 'X', ' ', 'O', ' ', 	' ', 'X', 'X', 'O', 'O', 'O', 	' ', 'O', 'X', 'X', 'O', ' ', 	' ', 'O', 'O', 'O', ' ', ' ', 	' ', 'O', 'O', 'X', 'O', 'X', 	' ', 'O', 'X', 'X', 'O', ' ', };  int victory(void) { 	int row[6][6] = {0};		//横向连子数 	int col[6][6] = {0};		//竖向连子数 	int rlean[6][6] = {0};		//右斜连子数 	int llean[6][6] = {0};		//左斜连子数  	int i, j; 	for(i = 0; i < 6; i++){ 		for(j = 0; j < 6; j++){ 			row[i][j] = 1, 			col[i][j] = 1, 			rlean[i][j] = 1, 			llean[i][j] = 1; 		} 	}  	for(i = 0; i < 6; i++){ 		for(j = 0; j < 6; j++){ 			if(row[i][j] == 5 || col[i][j] == 5 || rlean[i][j] == 5 || llean[i][j] == 5){ 				if(chess[i][j] == 'X'){ 					printf("红方胜\n");  					return 0; 				}else if(chess[i][j] == 'O'){ 					printf("蓝方胜\n");  					return 0; 				} 			}  			if(j < 5 && chess[i][j] == chess[i][j + 1]){ 				row[i][j + 1] = row[i][j] + 1; 			} 			 			if(i < 5 && chess[i][j] == chess[i + 1][j]){ 				col[i + 1][j] = col[i][j] + 1; 			}  			if(i < 5 && j < 5 && chess[i][j] == chess[i + 1][j + 1]){ 				rlean[i + 1][j + 1] = rlean[i][j] + 1; 			}  			if(i < 5 && j > 1 && chess[i][j] == chess[i + 1][j - 1]){ 				llean[i + 1][j - 1] = llean[i][j] + 1; 			} 		} 	}  	printf("未分胜负,继续\n");  	return -1; }  int main(void) { 	victory();  	return 0; } 四方向，未分胜负全通过了

引用 31 楼 weixin_41581673 的回复:[quote=引用 24 楼 hzy_76 的回复:] 光标停在if语句不代表条件满足了，只是表示当前在执行判断动作而已。要确认是否条件被满足，还是要看当时的变量值，或者你把if语句这么写：  if (cond) { ... }  如果能跟踪到光标进入大括号内部，就说明条件满足了。 什么意思[/quote]#include <stdio.h>  char chess[][6] = { 	' ', 'X', 'X', ' ', 'O', ' ', 	' ', 'X', 'X', 'O', 'O', ' ', 	' ', 'O', 'X', 'X', 'O', ' ', 	' ', 'O', 'O', 'O', 'X', ' ', 	' ', 'O', 'X', 'X', 'O', 'X', 	' ', 'O', 'X', 'X', 'O', ' ', };  int victory(void) { 	int row[6][6] = {0};		//横向连子数 	int col[6][6] = {0};		//竖向连子数 	int rlean[6][6] = {0};		//右斜连子数 	int llean[6][6] = {0};		//左斜连子数  	int i, j; 	for(i = 0; i < 6; i++){ 		for(j = 0; j < 6; j++){ 			row[i][j] = 1, 			col[i][j] = 1, 			rlean[i][j] = 1, 			llean[i][j] = 1; 		} 	}  	for(i = 0; i < 6; i++){ 		for(j = 0; j < 6; j++){ 			if(row[i][j] == 5 || col[i][j] == 5 || rlean[i][j] == 5 || llean[i][j] == 5){ 				if(chess[i][j] == 'X'){ 					printf("红方胜\n");  					return 0; 				}else if(chess[i][j] == 'O'){ 					printf("蓝方胜\n");  					return 0; 				} 			}  			if(j < 5 && chess[i][j] == chess[i][j + 1]){ 				row[i][j + 1] = row[i][j] + 1; 			} 			 			if(i < 5 && chess[i][j] == chess[i + 1][j]){ 				col[i + 1][j] = col[i][j] + 1; 			}  			if(i < 5 && j < 5 && chess[i][j] == chess[i + 1][j + 1]){ 				rlean[i + 1][j + 1] = rlean[i][j] + 1; 			}  			if(i < 5 && j > 1 && chess[i][j] == chess[i + 1][j - 1]){ 				llean[i + 1][j - 1] = rlean[i][j] + 1; 			} 		} 	}  	printf("未分胜负,继续\n");  	return -1; }  int main(void) { 	victory();  	return 0; }

引用 29 楼 weixin_41581673 的回复:引用 28 楼 wodexiaojidan的回复:引用 25 楼 weixin_41581673 的回复:引用 22 楼 wodexiaojidan 的回复:[quote=引用 21 楼 weixin_41581673 的回复:] 二维数组后面的.row什么的是什么row是横排，col竖列，rlean右斜，llean左斜我的意思是二位数组后面加一个小数点是什么意思，没学过结构体还没学是吧 还没学，有其他方法吗。[/quote]#include <stdio.h> #include <unistd.h> #include <time.h>  int victory(void) { 	int row[6][6] = {0};		//横向连子数 	int col[6][6] = {0};		//竖向连子数 	int rlean[6][6] = {0};		//右斜连子数 	int llean[6][6] = {0};		//左斜连子数  	int i, j; 	for(i = 0; i < 6; i++){ 		for(j = 0; j < 6; i++){ 			row[i][j] = 1, 			col[i][j] = 1, 			rlean[i][j] = 1, 			llean[i][j] = 1; 		} 	}  	for(i = 0; i < 6; i++){ 		for(j = 0; j < 6; j++){ 			if(row[i][j] == 5 || col[i][j] == 5 || rlean[i][j] == 5 || llean[i][j] == 5){ 				if(chess[i][j] == 'X'){ 					printf("红方胜\n");  					return 0; 				}else if(chess[i][j] == 'O'){ 					printf("蓝方胜\n");  					return 0; 				} 			}  			if(j < 5 && chess[i][j] == chess[i][j + 1]){ 				row[i][j + 1] = row[i][j] + 1; 			} 			 			if(i < 5 && chess[i][j] == chess[i + 1][j]){ 				col[i + 1][j] = col[i][j] + 1; 			}  			if(i < 5 && j < 5 && chess[i][j] == chess[i + 1][j + 1]){ 				rlean[i + 1][j + 1] = rlean[i][j] + 1; 			}  			if(i < 5 && j > 1chess[i][j] == chess[i + 1][j - 1]){ 				llean[i + 1][j - 1] = rlean[i][j] + 1; 			} 		} 	}  	printf("未分胜负,继续\n");  	return -1; }

引用 24 楼 hzy_76 的回复:光标停在if语句不代表条件满足了，只是表示当前在执行判断动作而已。要确认是否条件被满足，还是要看当时的变量值，或者你把if语句这么写：  if (cond) { ... }  如果能跟踪到光标进入大括号内部，就说明条件满足了。 什么意思

引用 29 楼 weixin_41581673 的回复:引用 28 楼 wodexiaojidan的回复:引用 25 楼 weixin_41581673 的回复:引用 22 楼 wodexiaojidan 的回复:[quote=引用 21 楼 weixin_41581673 的回复:] 二维数组后面的.row什么的是什么row是横排，col竖列，rlean右斜，llean左斜我的意思是二位数组后面加一个小数点是什么意思，没学过结构体还没学是吧 还没学，有其他方法吗。[/quote]有， 你把四个方向的连子数定义成4个二维数组，我帮写一下

引用 28 楼 wodexiaojidan的回复:引用 25 楼 weixin_41581673 的回复:引用 22 楼 wodexiaojidan 的回复:引用 21 楼 weixin_41581673 的回复:二维数组后面的.row什么的是什么row是横排，col竖列，rlean右斜，llean左斜我的意思是二位数组后面加一个小数点是什么意思，没学过结构体还没学是吧 还没学，有其他方法吗。

逻辑问题，单步调试，查看当前变量值的变化。

引用 23 楼 user-4 的回复:多自己思考问题，想不出来再去google,最后才是求助别人 你知道我想了几个算法吗？写了多久，思考了多久，期间问了几个人吗，如果你是老师的话，你感觉你自己会给一个学两个月的人多长时间编一个小程序？ 再者明天就要上交了，我实在搞不定才来提问的好吗，谢谢

多自己思考问题，想不出来再去google,最后才是求助别人

二维数组后面的.row什么的是什么

struct{     int        row;    	/* - */     int        col;    	/* | */     int        rlean; 	/* \ */  	int  	   llean;	/* / */     char       color; }chess[6][6];   int victory(void) {     int i, j;       for(i = 0; i < 6; i++){         for(j = 0; j < 6; j++)             if(chess[i][j].row == 5 || chess[i][j].col == 5 || chess[i][j].rlean == 5 || chess[i][j].llean == 5){                 if(chess[i][j].color == 'r'){                     printf("Read Player is The Winner\n"); 					return;                 }else if(chess[i][j].color == 'b'){                     printf("Black Player is The Winner\n"); 					return;                 }             }               if(chess[i][j].color == chess[i][(j + 1) % 6].color){                 chess[i][(j + 1) % 6].row = chess[i][j].row + 1;             }                           if(chess[i][j].color == chess[(i + 1) % 6][j].color){                 chess[(i + 1) % 6][j].col = chess[i][j].col + 1;             }               if(chess[i][j].color == chess[(i + 1) % 6][(j + 1) % 6].color){                 chess[(i + 1) % 6][(j + 1) % 6].rlean = chess[i][j].rlean + 1;             } 			 			 if(chess[i][j].color == chess[(i + 1) % 6][(j + 1) % 6].color){                 chess[(i + 1) % 6][(j - 1 + 6) % 6].llean = chess[i][j].llean + 1;             }     } 	 	printf("nobody wins the game\n"); }四个方向  水平  垂直   右斜  左斜

引用 18 楼 wodexiaojidan 的回复:你把每个棋子的row,col,lean初始化为1,然后下棋就给color赋值,下完了调用就行了struct{     int        row;    //	-     int        col;    //	|     int        rlean;  //	\ 	int		   llean   //	/     char       color; }chess[6][6];   int victory(void) {     int i, j;       for(i = 0; i < 6; i++){         for(j = 0; j < 6; j++)             if(chess[i][j].row == 5 || chess[i][j].col == 5 || chess[i][j].lean == 5){                 if(chess[i][j].color == 'r'){                     printf("Read Player is The Winner\n"); 					return;                 }else if(chess[i][j].color == 'b'){                     printf("Black Player is The Winner\n"); 					return;                 }             }               if(chess[i][j].color == chess[i][(j + 1) % 6].color){                 chess[i][(j + 1) % 6].row = chess[i][j].row + 1;             }                           if(chess[i][j].color == chess[(i + 1) % 6][j].color){                 chess[(i + 1) % 6][j].col = chess[i][j].col + 1;             }               if(chess[i][j].color == chess[(i + 1) % 6][(j + 1) % 6].color){                 chess[(i + 1) % 6][(j + 1) % 6].rlean = chess[i][j].rlean + 1;             } 			 			 if(chess[i][j].color == chess[(i + 1) % 6][(j + 1) % 6].color){                 chess[(i + 1) % 6][(j - 1 + 6) % 6].llean = chess[i][j].llean + 1;             }     } 	 	printf("nobody wins the game\n"); }每个点四个方向就行了

引用 14 楼 wodexiaojidan 的回复:struct{ 	int		row; 	int		col; 	int		lean; 	char	color; }chess[6][6];  int victory(void) { 	int i, j;  	for(i = 0; i < 6; i++){ 		for(j = 0; j < 6; j++) 			if(chess[i][j].row == 5 || chess[i][j].col == 5 || chess[i][j].lean == 5){ 				if(chess[i][j].color == 'r'){ 					printf("Read Player Win"); 				}else{ 					printf("Black Player Win"); 				} 			}  			if(chess[i][j].color == chess[i][(j + 1) % 6].color){ 				chess[i][(j + 1) % 6].row = chess[i][j].row + 1; 			} 			 			if(chess[i][j].color == chess[(i + 1) % 6][j].color){ 				chess[(i + 1) % 6][j].col = chess[i][j].col + 1; 			}  			if(chess[i][j].color == chess[(i + 1) % 6][(j + 1) % 6].color){ 				chess[(i + 1) % 6][(j + 1) % 6].lean = chess[i][j].lean + 1; 			} 	} }帮你重写了一下，你看能不能用  [quote=引用 10 楼 weixin_41581673 的回复:] 附一张图片比较容易看一点  引用 10 楼 weixin_41581673 的回复:附一张图片比较容易看一点 [/quote]尴尬，看不懂

struct{ 	int		row; 	int		col; 	int		lean; 	char	color; }chess[6][6];  int victory(void) { 	int i, j;  	for(i = 0; i < 6; i++){ 		for(j = 0; j < 6; j++) 			if(chess[i][j].row == 5 || chess[i][j].col == 5 || chess[i][j].lean == 5){ 				if(chess[i][j].color == 'r'){ 					printf("Read Player Win"); 				}else{ 					printf("Black Player Win"); 				} 			}  			if(chess[i][j].color == chess[i][(j + 1) % 6].color){ 				chess[i][(j + 1) % 6].row = chess[i][j].row + 1; 			} 			 			if(chess[i][j].color == chess[(i + 1) % 6][j].color){ 				chess[(i + 1) % 6][j].col = chess[i][j].col + 1; 			}  			if(chess[i][j].color == chess[(i + 1) % 6][(j + 1) % 6].color){ 				chess[(i + 1) % 6][(j + 1) % 6].lean = chess[i][j].lean + 1; 			} 	} }试下这个


Question: 引发了未经处理的异常:读取访问权限冲突。 **t** 是 0xCE1AC0D6。 出现了

#include<stdio.h> #include<string.h>  typedef char DataType;  void GetNext(DataType* t, int* next, int tlength) {     int i = 1, j = 0;     next[1] = 0;     while (i < tlength)     {         if (j == 0 || t[i] == t[j])         {             ++i;             ++j;             next[i] = j;             printf("i = %d, next[%d] = %d\n", i, i, next[i]);         }         else         {             j = next[j];             printf("++++%d\n", j);         }         printf("i = %d\n", i);     } }  int IndexKmp(DataType *s, DataType *t, int pos, int tlength, int slength, int *next) {     int i = pos, j = 1;      while (i <= slength&&j <= tlength)     {         if (j == 0 || t[j]==s[i])         {             i++;             j++;         }         else {             j = next[i];             printf("****i = %d,  %d\n", i, j);         }      }     if (j > tlength)         return i - tlength;     else         return 0; }  int main() {     int locate, tlength, slength, next[256];     DataType s[256], t[256];     printf("输入主串:\n");     scanf("%s", s);     slength = strlen(s);     printf("输入子串:\n");     scanf("%s", t);     tlength = strlen(t);     GetNext(t, next, tlength);     locate = IndexKmp(s, t, 0, tlength, slength, next);     printf("匹配位置:%d\n", locate);     return 0; }   代码逻辑有问题，GetNext函数会将下标为1， 2， 3.。。设置为1，但是下标为0的为随机数； 当进入IndexKmp函数时，初始化j = 1;那么循环中j == 0就不会运行。所以直接是j = next[i];此时i为0，跳出循环；

关于自己是否适合编程的很简单的测试： 在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案：  A里面有10处以上文字或标点错误 B里面没有文字或标点错误并敢为此跟人打赌 C里面没有文字或标点错误并且字体和排版完全与原稿一致 D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感  A不适合编程（理由：打字准确度偏低、粗心大意） B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念） C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证） D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！）  如果想从A变成B的话，到我的资源http://download.csdn.net/detail/zhao4zhong1/4084259里面下载“适合程序员的键盘练习”

出错时中断下来，通过调用堆栈定位到相关位置，分析原因，你IndexKmp函数中，next[i]没初始，j赋值后是一个未初始的值，之后访问t[j]导致出错

你确定你的程序可以编译吗？ #include<stdio,h> //是点，不是逗号 #include<string,h>


Question: 新手求教 C++算牛顿二乘法的根出现的问题

牛顿迭代法公式“ X(n+1)=X(n)-F'(Xn)/F"(Xn) 你的代码迭代公式不对

[code=c] [#include<iostream.h> void main() { using namespace std; float x,x0,f,f1f2; x=1; do { x0=x; f=x*x*x*x*x-3*x*x+1; f1=5*x*x*x*x-6*x; f2=5*4*x*x*x-6 x=x0-f1/f2; }while(x-x0<0.000001); cout<<"x="<<x<<endl; }/code]

稍微改进一下：     if (f1 == 0) x = x0 - (f + 0.0000001) / (f1 + 0.0000001);     else x = x0 - f / f1; 说到底是你用的这公式造成的，也就这样了。

x = x0 - f / (f1 + 0.0000001); 改成这样后X=1.14286e+006 这是赋值上的问题吗

引用 3 楼 qq_41580767 的回复:请问一下应该怎么改呢？ 我之前用int定义的话 会出现我的cpp运行的时候会停止运行 但是用float double的话又什么结果都没有输出出来……  这应该是你用的公式导致的，可以把 x=x0-f/f1; 改成 x = x0 - f / (f1 + 0.0000001); 试试

自己要把算法逻辑理清楚，必要时单步跟踪程序运行，观察程序流程及变量变化情况

第二次迭代的时候f1就成0了，所以 x=x0-f/f1;这里就出现除以0异常。

如果没有输出任何东西，就是算法有问题，造成了死循环


Question: (紧急求助)free字符串的时候报错

錯不在free，而在strcpy

char * str = (char *)malloc(sizeof(char) * 128); 原因如楼上所述！

看代码应该不是释放free的问题，而是strcpy越界导致的。  malloc申请了1个字节的空间，但是要拷贝远远大于1的字符串到str中，很明显越界了。


Question: 微信数据协议

先学会使用抓包软件wireshark


Question: 二进制转１０进制 为什么调用函数　传数组老是出错　编译不成功

zh函数需要的参数是char*，你的变量a是char类型，不匹配  改成：  char a[100]; printf("please input 1001 number "); scanf_s("%s", a, 100);

#include <stdio.h> #include <string.h> int zh(char str[]) {     int sum = 0;/*定义总值*/     int j = 1;/*交换数值*/     int pot = strlen(str) - 1;/*把str数组值先减一*/     for (; pot >= 0; pot--) /*循环　pot值　每次减一*/     {         sum += (str[pot] - '0')*j;         j*=2;/*每次j都乘２*/     }     return sum; } int main() {     int result;     char a[32];      printf("please input 1001 number ");     scanf_s("%s",a, 32);     result= zh(a);     printf("thit is number %d\n",result);     return 0; } 参考一下吧

数组做参数，应该传递数组首地址

字符串转数字，不需要从末尾开始扫描，从头开始就行了：int zh(const char * restrict str) { 	int sum = 0; 	while (*str != 0) 	{ 		char c = *str++; 		if (c < '0' || c > '1') 		{ 			break; 		} 		sum <<= 1; 		sum |= c - '0'; 	} 	return sum; }实在不明白从末尾扫描的优势，如果中间夹杂着不合法字符怎么办？比如字符串 "13579" 转换数字：13579 => sum = sum * 10 + ('1' - '0');  ^ 13579 => sum = sum * 10 + ('3' - '0');   ^ 13579 => sum = sum * 10 + ('5' - '0');    ^ 13579 => sum = sum * 10 + ('7' - '0');     ^ 13579 => sum = sum * 10 + ('9' - '0');      ^这种情况的话，从做到右扫描，遇到第一个不合法字符即可直接终止计算。

这个c 币怎么赚的


Question: 关于随机函数的问题，求教。

C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\rand.c /*** *rand.c - random number generator * *       Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *       defines rand(), srand() - random number generator * *******************************************************************************/  #include <cruntime.h> #include <mtdll.h> #include <stddef.h> #include <stdlib.h>  /*** *void srand(seed) - seed the random number generator * *Purpose: *       Seeds the random number generator with the int given.  Adapted from the *       BASIC random number generator. * *Entry: *       unsigned seed - seed to seed rand # generator with * *Exit: *       None. * *Exceptions: * *******************************************************************************/  void __cdecl srand (         unsigned int seed         ) {         _getptd()->_holdrand = (unsigned long)seed; }   /*** *int rand() - returns a random number * *Purpose: *       returns a pseudo-random number 0 through 32767. * *Entry: *       None. * *Exit: *       Returns a pseudo-random number 0 through 32767. * *Exceptions: * *******************************************************************************/  int __cdecl rand (         void         ) {         _ptiddata ptd = _getptd();          return( ((ptd->_holdrand = ptd->_holdrand * 214013L             + 2531011L) >> 16) & 0x7fff ); }

http://zh.cppreference.com/w/cpp/numeric/random/rand http://zh.cppreference.com/w/cpp/numeric/random/srand  请将上面两个链接的内容完整地读一下，并注意这句话——每次以同一 seed 播种 rand() 时，它必须产生相同的值数列。

srand只是初始化随机数种子，一般运行一次就可以了，可以在程序开始时运行，或者第一次需要随机数的时候运行  http://en.cppreference.com/w/c/numeric/random/srand


Question: code::blocks编译器中，printf函数总是出现乱码

对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A

CB默认 utf-8 ，控制台默认 gbk 所以要贴图看看具体什么情况

控制台下输入chcp看一下当前代码页是多少，chcp 936改成中文。

查看一下你包含代码的这个文件编码格式是不是和控制台 的编码格式不相符 或者是修改一下解决方案的编码格式

不知道呀，有没有解决办法呀？

中文乱码? 控制台编码问题么


Question: 请教dev中工程编译出现makefile报错解决方法

搜“跟我一起写makefile”


Question: 新手做八皇后问题遇到了问题，请教大佬

#include <stdio.h> #include <stdlib.h> #include <string.h> static int count = 0; static int number = 0; static char buffer[8][8]; static void output() {         printf("********** %d ***********\n", count);         for(int i=0;i<8;i++)         {                 for(int j=0;j<8;j++)                 {                         if(buffer[i][j] == 1)                                 printf("# ");                         else                                 printf(". ");                 }                 printf("\n");         } } int check(int x, int y) {         for(int i=1; i<=x; i++)         {                 //the left slash can't has another value                 if(y-i >= 0)                 {                         if(buffer[x-i][y-i] == 1 )                                 return 1;                 }                 //the right slash can't has another value                 if(y+i < 8)                 {                         if(buffer[x-i][y+i] == 1)                                 return 1;                 }                 //the y line  can't has another value                 if(buffer[x-i][y] == 1)                         return 1;         }         return 0; } int check_line(int x) {         //means to the end         if(x == 8)                 return 0;         int ret = 0;         for(int i=0;i<8;i++)         {                 //check if the current point satisfy the condition                 if(check(x, i) == 0)                 {                         //if satisfy the condition, set value.                         buffer[x][i] = 1;                         //from current row, check the next row to find out if                          //there has a point that satisfy the condition.                         if(check_line(x+1) == 0)                         {                                 //if yes.that means we found an situation                                 count++;                                 output();                         }                         // if not. reset the value. and check next point with the same row                         buffer[x][i] = 0;                 }                 else                         ret = 1;         }         if(ret == 1)                 return 1;         return 0; } int eight_queue(int x, int y) {         //set the first point value,and get other valid value from it.         for(int i=0; i<8; i++)         {                 buffer[x][i] = 1;                 //main function. check each row to find out the right point                 check_line(x+1);                 memset(buffer, 0, sizeof(buffer));         } } int main(int argc, char *argv[]) {         //start from the first row         eight_queue(0,0);         return 0; }

仅供参考：#include <stdio.h> int d[8][8]; int n; void queen8(int L) {     int x,y;      if (8==L) {         n++;         printf("%d\n",n);         for (y=0;y<8;y++) {             for (x=0;x<8;x++) { //              printf("%d",d[y][x]);                 if (d[y][x]) printf("■");                 else         printf("□");             }             printf("\n");         }         return;     }     for (x=0;x<8;x++) {         for (y=0;y<L;y++) {             if  (              d[y][x      ]              || (x-(L-y)>=0 && d[y][x-(L-y)])              || (x+(L-y)< 8 && d[y][x+(L-y)]))                 break;         }         if (y>=L) {             d[L][x]=1;             queen8(L+1);             d[L][x]=0;         }     } } int main() {     int y,x;     for (y=0;y<8;y++) {         for (x=0;x<8;x++) {             d[y][x]=0;         }     }     queen8(0);     return 0; }  “给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出

单步跟踪程序运行，观察变量变化情况与你期望的是否一致，分析原因


Question: 这道题时间超限不知道怎么处理,哪位大佬帮看下,求解!?

有一种恶心的算法，将1000000以内的所有质数列出到一个数组中，然后在这个数组中查询，而不是去针对每一个数字计算它是不是质数。因为isPrime太耗费时间了

是wrong answer

编译没有通过。谢谢了。

试试下列代码：  #include <stdio.h>  // 此算法摘自百度百科词条“质数” bool isPrime(unsigned long n) { 	if (n <= 3) { 		return n > 1; 	} 	else if (n % 2 == 0 || n % 3 == 0) { 		return false; 	} 	else { 		for (unsigned short i = 5; i * i <= n; i += 6) { 			if (n % i == 0 || n % (i + 2) == 0) { 				return false; 			} 		} 		return true; 	} }  int main() { 	int n, p, q; 	if (scanf("%d", &n) != 1 || n <= 2) { 		printf("输入错误。"); 		return 0; 	}  	for (p = 1; p <= n / 2; p++) { 		q = n - p; 		if (isPrime(q) && isPrime(p)) { 			printf("%d, %d\n", p, q); 			return 0; 		} 	}  	printf("不能找到两个质数P和Q满足P<=Q并且P+Q=N\n");  	return 0; }


Question: 关于WaitForMultipleObjects的一个疑问

第一个参数是传递第二个参数所指向的句柄个数，所以你这里应该填写 2 的。为什么要填什么 3 了 5 了的？你让系统读取无效数据？按理说 3、4、5 都会读取到垃圾数据，都不应该会成功，但为什么 3、4 成功了，只能说你运气好。

《Windows核心编程》

不懂，帮顶~

系统可能有些句柄号已经预了，比如通常标准输入STD_INPUT_HANDLE获得的句柄值就为3，如果没有这个句柄值自然就无效了


Question: 请教一个问题，malloc在64 bits linux下，malloc(504)后为什么分配到chunk的size字段是512，而不是520？

引用 3 楼 SXJIAKE 的回复:确认用的不是 32 位编译器而是 64 位？另外，这个没有什么规定说额外的大小就一定是多少，具体还是看看 glibc 里面 malloc 是如何实现的。 是64位的

多谢，因为size字段是0x201，说明前一个chunk非空闲，所以pre_size字段的8字节被征用了，多谢

除了申请到的对空间之外，内存管理还会分配额外的空间，用于管理申请的空间；比如申请504个堆上空间，那么内存其实申请的比504要大，其他的部分内存主要是用于存储管理已经申请的空间信息。

malloc实际分配的内存要比你申请的大，因为需要用它们来保存一些信息，最典型的是保存这块内存的大小，这样在你free的时候，才能释放正确大小的内存。

参考Linux中malloc相关源代码。

malloc分配的内在会比实际申请的大，用于记录必要的数据，具体分配多少取决于编译器对函数的实现方式


Question: 循环体要使用的指针变量在循环体外声明还是循环体内声明？

引用 7 楼 mstlq的回复:因为楼主的input和read函数里都有类似fclose (fp);的语句。。。。 close之后的文件指针就是无效的…………  这不是放循坏体内还是循坏体外的问题，关键是fclose之后，不应继续对文件指针做操作 嗯嗯，谢了大哥厉害厉害

引用 5 楼 paschen的回复:[quote=引用 3 楼 ZhangHangXing的回复:][quote=引用 1 楼 paschen的回复:]如果是读同一个文件通常是放在循环外，没必要多次打开，但如果每次读完了要重新读的话要把文件位置指针移动到文件开头 但是不放在循环内，会出现错误啊 指针变量的声明[/quote] 什么错误，给出相关代码，出错应该也是你别的原因导致的[/quote] 我的代码就在上面 就是声明指针变量放的位置不同造成的 放在结构外会出错

引用 3 楼 ZhangHangXing的回复:[quote=引用 1 楼 paschen的回复:]如果是读同一个文件通常是放在循环外，没必要多次打开，但如果每次读完了要重新读的话要把文件位置指针移动到文件开头 但是不放在循环内，会出现错误啊 指针变量的声明[/quote] 什么错误，给出相关代码，出错应该也是你别的原因导致的

引用 1 楼 paschen的回复:如果是读同一个文件通常是放在循环外，没必要多次打开，但如果每次读完了要重新读的话要把文件位置指针移动到文件开头 但是不放在循环内，会出现错误啊 指针变量的声明

引用 2 楼 user-3的回复:先打开，然后再在循环中调用，循环结束关闭。没有必要在循环中定义这样就会多次打开。 但是不放在循环内，会出现错误啊。指针变量的声明


Question: 未初始化的指针为何会指向一个合法的地址?

引用 5 楼 iloveyou418 的回复:[quote=引用 4 楼 fox_lin 的回复:] [quote=引用 2 楼 iloveyou418 的回复:] &pi并不是pi指向的地址，而是pi这个指针自身的地址！ 答案就是这个~默默给楼上打call 其实我不明白不是这个啦,我不明白的是pi的字面值为什么是0x7fffffffe4a0而不是0x0[/quote] 对呀~你定义了这个指针，这个指针在内存中肯定拥有自己的合法地址呀，只是并没有指向一个合法地址，这时候就需要初始化一下，。。。[/quote] 嗯啊,我明白了,就像下面这样:  int fun_2(int **);   int main() {     int r;       int *pi_1;     int *pi_2;     int *pi_3;     int *pi_4;     r = fun_2(&pi_1);     r = fun_2(&pi_2);     r = fun_2(&pi_3);     r = fun_2(&pi_4);       return 0; }   int fun_2(int **pi) {     return 6; }  调试结果: (gdb) p pi_1 $1 = (int *) 0x7fffffffe4a0 (gdb) p pi_2 $2 = (int *) 0x400400 <_start> (gdb) p pi_3 $3 = (int *) 0x400550 <__libc_csu_init> (gdb) p pi_4 $4 = (int *) 0x0  这4个一对比,我就彻底的明白啦,哈哈 谢谢你哦

引用 4 楼 fox_lin 的回复:[quote=引用 2 楼 iloveyou418 的回复:] &pi并不是pi指向的地址，而是pi这个指针自身的地址！ 答案就是这个~默默给楼上打call 其实我不明白不是这个啦,我不明白的是pi的字面值为什么是0x7fffffffe4a0而不是0x0[/quote] 对呀~你定义了这个指针，这个指针在内存中肯定拥有自己的合法地址呀，只是并没有指向一个合法地址，这时候就需要初始化一下，。。。

引用 2 楼 iloveyou418 的回复:&pi并不是pi指向的地址，而是pi这个指针自身的地址！ 答案就是这个~默默给楼上打call 其实我不明白不是这个啦,我不明白的是pi的字面值为什么是0x7fffffffe4a0而不是0x0

引用 1 楼 user-2 的回复:&pi并不是pi指向的地址，而是pi这个指针自身的地址，这个地址是在栈上，肯定是一个合法的地址，pi指向的地址要用pi，由于未初始化，行为是未定义的，既可以指向合法的地址，也可以指向不合法的地址 谢谢解答. &pi是指向指针的指针,运行时,由于指针变量pi已经存在于运行时的内存中,那么肯定有一个存放他的地方,也就是&pi.这个我明白的. 至于pi的字面值为什么是一块合法的地址,也就是你说的"未初始化,可以指向任意地址". 谢谢了.


Question: 如何看程序运行的过程啊

引用 2 楼 weixin_41445971 的回复:[quote=引用 1 楼 棉猴的回复:]下断点啊，F9下断点，F5调试，F10单步执行 断点按下了，我摁下F10是显示投影那些的啊[/quote] 用的笔记本? 如果是，那么需要使用Fn + Esc进行切换

可以自己加打印信息，看某些变量的执行过程中的变化； 如果能借助环境提供的方法更好，gdb可以查看程序执行的每步某个变量的值。

http://blog.csdn.net/zhao4zhong1/article/details/53078924 老司机找bug的十年心路历程

首先你要知道你用的IDE或者调试工具是什么，然后再学习针对这个IDE或者调试工具的调试方法

百度对于IDE名称（集成开发环境）+怎么调试

引用 1 楼 棉猴的回复:下断点啊，F9下断点，F5调试，F10单步执行 断点按下了，我摁下F10是显示投影那些的啊

下断点啊，F9下断点，F5调试，F10单步执行


Question: 括号匹配

仅供参考：#include<stdio.h> #include<malloc.h> #include<string.h> #define STACK_INIT_SIZE 10 #define STACK_GROW_SIZE 5 #define ELEMTYPE char #define OK 1 #define ERROR 0 typedef struct { /*建立一个栈的首结点*/     ELEMTYPE * base;     ELEMTYPE * top;     int stacksize; } SpStack; int InitStack(SpStack *s) { /*建立空的栈并返回首地址*/     s->base=((ELEMTYPE*)malloc(STACK_INIT_SIZE*sizeof(ELEMTYPE)));     if (!s->base) return ERROR;     s->top=s->base;     s->stacksize=STACK_INIT_SIZE;     return OK; } int StackEmpty(SpStack *s) { /*判断栈是否为空*/     if (s->top==s->base) return OK;     else                 return ERROR; } int Push(SpStack *s,ELEMTYPE e) { /*往栈顶插入元素即进栈*/     if (s->top-s->base>=s->stacksize) { /*判断是否栈满*/         s->base=((ELEMTYPE*)realloc(s->base,(s->stacksize+STACK_GROW_SIZE)*sizeof(ELEMTYPE)));         if (!s->base) return ERROR;         s->stacksize+=STACK_GROW_SIZE;         s->top=s->base+s->stacksize;     }     *s->top++=e;     return OK; } int Pop(SpStack *s,ELEMTYPE *e) { /*让栈顶元素依次输出即出栈*/     if (StackEmpty(s)) return ERROR;     *e=*(--s->top);     return OK; } int Comp(ELEMTYPE a,ELEMTYPE b) {     if ((a=='('&&b!=')')       ||(a=='['&&b!=']')       ||(a=='{'&&b!='}')) {         return ERROR;     } else return OK; } int Count(SpStack *s) {     ELEMTYPE e[STACK_INIT_SIZE*2];     ELEMTYPE e1;     int i;      InitStack(s);     fgets(e,STACK_INIT_SIZE*2,stdin);     if ('\n'==e[strlen(e)-1]) e[strlen(e)-1]=0;     printf("%s\n",e);     for (i=0;e[i]!='\0';i++) {         switch (e[i]) {         case '(':         case '[':         case '{':             Push(s,e[i]);             break;         case ')':         case ']':         case '}':             if (StackEmpty(s)) {                 printf("%*s↖右括号多余\n",i+1,"");                 return(ERROR);             } else Pop(s,&e1);             if (!Comp(e1,e[i])) {                 printf("%*s↖左右匹配出错\n",i+1,"");                 return(ERROR);             }         }     }     if (!StackEmpty(s)) {         printf("%*s↖左括号多余\n",i,"");         return(ERROR);     } else {         printf("匹配正确\n");         return(OK);     } } void main() {     SpStack s;     Count(&s);     free(s.base); }

就是用栈。当读取到一个括号的左半边后，将它入栈。当读取到一个括号的右半边时，将栈顶的元素逐个出栈，直到对应的这种括号的左半边。 全部符号读取完毕后，栈应当是空的。

是，我看数据结构里有说，要用堆栈

#include<stdio.h> #include<string.h>  #define max 200 struct no{ 	int x,y; };  struct stack{ 	char *top; 	char *base; 	int size; }; no jun(char e) { 	no m;     if(e=='(')     {     	m.x=0;     	m.y=1;     	return m;     }     else if(e==')')     {     	m.x=1;     	m.y=1;     	return m;     }     else if(e=='[')     {     	m.x=0;     	m.y=2;     	return m;     }     else if(e==']')     {     	m.x=1;     	m.y=2;     	return m;     }     else if(e=='{')     {     	m.x=0;     	m.y=3;     	return m;     }     else     {     	m.x=1;     	m.y=3;     	return m;     } } void set(stack &s) { 	s.base=new char[max]; 	s.top=s.base; 	s.size=max;  } void push(stack &s,char e) { 	*(s.top)=e; 	s.top++; } char top(stack &s) { 	return *(s.top-1); } void pop(stack &s) { 	s.top--; } bool empty(stack &s) { 	if(s.top==s.base) 	return true; 	return false; } int main() { 	stack S; 	char a[1000]; 	int n,g=0; 	set(S); 	printf("请输入要检验的内容：");  	scanf("%s",a); 	n=strlen(a); 	for(int i=0;i<n;i++) 	{          if(jun(a[i]).x==0)          {          	push(S,a[i]);          }          else          {          	if(empty(S))          	{          		g=1;          		break;          	}          	else          	{          	    if(jun(top(S)).y==jun(a[i]).y)          	    {          		    pop(S);          	    }          	    else          	    {          		    g=1;          		    break;          	    }             }          } 	} 	printf("检验结果为："); 	if(g==0) 	printf("匹配\n"); 	else 	printf("此串括号匹配不合法\n"); 	return 0; }

可以使用栈的思想写，简洁清晰


Question: C语言题目

感觉我好像把问题想得太简单了

引用 3 楼 user-1 的回复:#include<stdio.h> #include<stdlib.h> #define number 17 int main() { 	int i = 0; 	int count = 0; 	int a[number] = { 0 }; 	int ret; 	while (count!=1) { 		count = 0; 		for (int j = 0 ;j < number;j++) { 			if (a[j] == 0) { 				if (count % 3 == 0) { 					a[j] = -1; 					ret = j; 				} 				count++; 			} 		}	 	} 	printf("最后一位是%d", ret); 	return 0; } 代码参考，17个人的话最后一位应该是11号 谢谢你的回答！我思路已经了解了

比如说0,1,2,3,4,5,6这么6个人。题意是第一次0，3，6离开。剩下1，2，4，5，他们四个编号分别变成0,1,2,3.然后再0，3离开


Question: 卡在这个问题过不去了

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

你应该是程序运行到第一个循环   i=9  时     nums[9] = nums[9+1]      数组 超限了

前面说的，你在需要j的时候使用的i，还有当删除了一个元素，你依旧还是遍历到第九个元素 以下是示例代码，很常规的方法，可以参考下：  #include <stdio.h>  int main() { 	int real_count = 9; 	int nums[9] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 	int i, j; 	for (i = 0; i < real_count;) 	{ 		if (nums[i] % 3 == 0) 		{ 			real_count--; 			for (j = i; j < real_count; j++) 			{ 				nums[j] = nums[j + 1]; 			} 		} 		else 		{ 			i++; 		} 	}  	for (i = 0; i < real_count; i++) 	{ 		printf("%d ", nums[i]); 	} 	printf("\n");  	return 0; }

用移动的方法解题的话应该是遍历一次数组，下标是3的倍数的标记-1，然后再遍历一次数组，每碰到一个不为-1的就把新数组下标值+1，放到对应位置上。如此循环 这个问题不一定要让数组中的元素移动，这个问题可以用数组下标i表示刚开始时的的第i位，数组元素的值表示状态用0表示未被移除，用别的数字如-1表示已移除。一次一次的遍历整个数组，每次在数组中删去第0，3，6....个状态显示没有被移除的元素，然后记住它的下标。然后发现某次遍历数组时，遍历完毕也只删去了一个数字，那么跳出循环，最后保存下来的下标就是最后剩下的一位的初始位置，详见你上个帖子里面我给出的代码

直接换个思路~在定义一个数组，从第一个数组中筛选出不为3为倍数的数到第二个数组里就行了啊。。。 最后再讲第一个数组值等于第二个数据不就可以了么

内层循环j的起始值应该是i，此外要看你是需要删除一开始为3的倍数的数，还是每一次移动后倍数为3的数，实在想不清楚可以单步跟踪程序运行，看你代码的执行流程及变量变化，理清你的逻辑


Question: 怎么理解结果

#include <stdio.h> void main() {         int x=10,y=20,z=30;         printf("%d,%d,%d,%d\n",x=y=z,x=y==z,x==(y=z),x==(y==z));   }   逗号运算符优先级是1，结合性是自左向右； 赋值运算符优先级是2 ；结合性是自右向左； 等于运算符优先级是9 ；结合性是自左向右； printf对参数的运算顺序是：自右向左；因此： 逆序来看： ④x==(y==z)的运算过程为：判断y的值与z的值是否相等，因此返回0； ③x==(y=z) 的运算过程为：把z赋值给y，则y=30；又因为x不等于20,所以返回0；因此结果为0； ②由于③中z的值赋给了y，因此，z==y为真，返回1；因此结果为1； ①简单的赋值，自右向左，因此结果为30；

引用 7 楼 pearling的回复:[quote=引用 6 楼 weixin_41445971 的回复:] 计算机运行结果是30，1，0，0 但我不理解为什么第二个为什么是1 逗号运算符是自右向左计算的 printf("%d,%d,%d,%d\n",x=y=z,x=y==z,x==(y=z),x==(y==z)); 在x==(y=z)这一步，将z赋值给了y，因此当执行x=y==z时，x取的就是y==z逻辑运算结果，因此是1 [/quote] 你是怎么理解i++跟++i 的？

printf传参的顺序（压栈顺序）从右向左一次计算，因此顺序为：x == (y == z), x == (y=z), x = y==z, x = y = z;

http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

引用 6 楼 weixin_41445971 的回复:计算机运行结果是30，1，0，0 但我不理解为什么第二个为什么是1 涉及到运算符优先级，==（逻辑等）高于=（赋值），所以先计算==的结果，返回true，赋值给x化为int，1

引用 6 楼 weixin_41445971 的回复:计算机运行结果是30，1，0，0 但我不理解为什么第二个为什么是1 逗号运算符是自右向左计算的 printf("%d,%d,%d,%d\n",x=y=z,x=y==z,x==(y=z),x==(y==z)); 在x==(y=z)这一步，将z赋值给了y，因此当执行x=y==z时，x取的就是y==z逻辑运算结果，因此是1

计算机运行结果是30，1，0，0 但我不理解为什么第二个为什么是1

我的是30，30，0，0

楼主，帖子上好像没有显示出结果啊

你的y==z 是个表达式啊！


Question: 关于scanf("%[^\n]",str);

我好像懂了，%[^\n]读到回车就把缓冲区回车之前的赋给要输入的字符串，要是在scanf格式字符串最后放\n，那么他会一直等你输入一个非空格，tab,回车的东西。读字符串时，为了避免读到上次剩下的回车，可以使用" %s"(%前有个空格，会忽略掉开始的所有的空白字符）或者scanf("%[^]%*c",str);%*c表示读入一个字符，但不向任何地方输入


Question: 怎么判断结构体是否有值啊？

引用 4 楼 幻夢之葉的回复:[quote=引用 3 楼 ZhangHangXing 的回复:] [quote=引用 1 楼 幻夢之葉的回复:]int count = fread(&temp,sizeof(p),500,fp);  for(n=0;n<count ;n++) 大佬大佬，为什么啊。原因是什么呢？[/quote] fread返回成功读取的项数 详细了解可以网上搜索这个函数的讲解[/quote] 谢谢大佬，我去看看，

引用 3 楼 ZhangHangXing 的回复:[quote=引用 1 楼 幻夢之葉的回复:]int count = fread(&temp,sizeof(p),500,fp);  for(n=0;n<count ;n++) 大佬大佬，为什么啊。原因是什么呢？[/quote] fread返回成功读取的项数 详细了解可以网上搜索这个函数的讲解

引用 1 楼 幻夢之葉的回复:int count = fread(&temp,sizeof(p),500,fp);  for(n=0;n<count ;n++) 大佬大佬，为什么啊。原因是什么呢？

大佬大佬，为什么啊？


Question: C的结构体相关的数据,声明时该如何定义

引用 4 楼 paschen 的回复:写法3  因为你的指针没有指向一块有效的内存地址，函数中解引将导致非法内存访问 嗯,下午估计犯迷糊了,哈哈,刚学C没多久

写法3  因为你的指针没有指向一块有效的内存地址，函数中解引将导致非法内存访问

引用 3 楼 paschen 的回复:写法1  对一个临时变量，即右值，你不能再取地址 嗯,是了,发现这个问题了,需要声明一个指针做中间变量,不如方法2来的利落. 谢谢你的解答.

写法1  对一个临时变量，即右值，你不能再取地址

引用 1 楼 jianwen0529 的回复:1： 没见过&&取地址的写法，语法没有这个规则  2：不用说了，正常操作  3： 可以根据参数要求的类型：指向指针的指针可以估计getaddrinfo内部有类似如下的语句 struct addrinfo *temp = //动态分配; *param_addr_detail = temp; //param_addr_detail 代表对应的形参名称  你外部addr_detail的初始值是多少？ NULL ？ 那*param_addr_detail的内存是不可写的。即使不是NULL而是一个垃圾值，程序崩溃也是分分钟的事情  谢谢这位大哥. 方法1是我自己臆想出来连续取地址以得到 xxx **,确实是错了. 方法2里我的疑问是那个未初始化的指针为什么会在下面的函数调用前具有合法的地址值,这个问题实际是跟这个函数getaddrinfo有关  方法3也是我自己臆想居多,现在已经明白.


Question: C语言文本写入问题

引用 7 楼 棉猴的回复:应该可以啊，只要两个文件中n值一样就没问题 可是我试过了，好像文本写入不能直接这个在某个特定位置写进去

应该可以啊，只要两个文件中n值一样就没问题

引用 2 楼 user-3的回复:欢迎采纳答案 谢谢！ 采纳什么答案？？？？？？？？

引用 1 楼 qq_40680007的回复:有没有人 ？？？？？？？？？？？？

引用 3 楼 柚子将军的回复:看代码才知道问题原因 int pro[40]; FILE *fp_pro; fp_pro=fopen("d:\\proficiency.txt","r+"); fscanf(fp_pro,"%d",pro); fprintf(fp_pro,"%d",pro[n]); fclose(fp_pro);    代码是这样的 我的n就是每次产生的随机数 可是好像不能这么用

看代码才知道问题原因

欢迎采纳答案 谢谢！

有没有人


Question: 小白求大神帮忙

//逆 void ReversePrint(const char *str) {     if ( *str != 0 )     {         ReversePrint(str+1);         printf("%c", *str);    } }

void printStr(char* p, int pLen) {         打印 p[pLen-1];         if(pLen == 1)                  return;          printStr(char* p, pLen-1); } void main() {        初始化  char* p;        printStr(p, p的长度); }

void printStr(char* p, int pLen) {         打印 p[pLen-1];         if(pLen == 1)                  return;          printStr(char* p, pLen-1); } void main() { char* p        printStr(char* p, pLen-1); }


Question: C语言如何编译生成库文件？

百度搜相关关键字。

引用 2 楼 paschen 的回复:可以动态链接、静态链接，当然也可以直接以提供头文件和源文件，通常为了保护你的代码，一般以库文件方式提供，书的话推荐《程序员的自我修养--链接、装载与库》 是的，我就是对“动态链接、静态链接，当然也可以直接以提供头文件和源文件”都分不清，不知道库文件咋生成，我研究看看，谢谢

引用 1 楼 hzy_76 的回复:一般我们用gcc吧，-c选项就可以只编译而不链接，生成库文件（习惯上扩展名为o），如：  gcc -c test.c  这个库文件就可以被其他程序引用、链接了。  如果需要静态库文件（习惯上扩展名为a），可以使用ar命令：  ar rcs libtest.a test.o  这样生成的库文件以lib开头，其他程序编译时用-ltest即能使用它。  动态库文件则使用-shared参数：  gcc -fPIC -shared -o test.so test.c  收到，谢谢，我要的就是这些东西，静态库文件是什么，我百度看看，先学习试试，然后我再看看ar编译的含义，再瞅瞅动态库，我就是对这些都蒙蒙的，还不知道学名是啥，不知道应该怎么学


Question: 要被逼疯了！ 求教

在build处clean一下或者重建工程复制粘贴代码编译

现代中国人的能力差别很大程度上体现在会不会合理高效地使用百度上。 百度搜相关关键字。

之前我也这样，后面直接不用项目来编程， 用新建空白文件，然后保存成 .c 的格式。  不过我是在学习C语言时候这样用的。

。。。是不是你没有建工程啊，或者文件放进去了没导入、、

在build处clean一下试试

重新创建工程，重新复制代码，重新编译！！！

来点人啊！！！！！！

重新建立个工程试试

https://stackoverflow.com/questions/41491110/code-blocks-it-seems-that-this-project-has-not-been-built-yet 参考一下  http://blog.csdn.net/anonymalias/article/details/21016721  还有这个博客；  http://bbs.csdn.net/topics/380252837 还有之前的帖子；  http://blog.csdn.net/hxl5955/article/details/52315767  能把你逼疯的不是没有解决办法，而是没有发现解决方法；  网上对这个问题，好多人都遇到了。

http://blog.csdn.net/cancan0907/article/details/78073101 参考一下

是.....................


Question: 指针问题，求教

第一，数组名arr只能看做是常量指针，是不能做自增运算的，你可以再定义一个指针char *ptr=arr; while((*(ptr++))!='\0') 第二，你的循环内的指针自增都是多余的，不仅不需要而且造成不符合逻辑和可能的指针越界，循环内部的ptr都不需要++

#include<stdio.h> #include<string.h> int main() { 	char arr[80]; 	int i = 0 , lwords = 0 , swords = 0 , digit = 0 , space = 0 , other = 0; 	 	gets(arr); 	while(arr[i] != '\0') 	{ 		if(arr[i] >= 'a' && arr[i] <= 'z') 			swords++; 		else if(arr[i] >= 'A' && arr[i] <= 'Z') 			lwords++; 		else if(arr[i] >= '0' && arr[i] <= '9') 			digit++; 		else if(arr[i] == ' ') 			space++; 		else 			other++; 		i++; 	} 	 	printf("小写字母数：%d\n",swords); 	printf("大写字母数：%d\n",lwords); 	printf("数字数：%d\n",digit); 	printf("空格数：%d\n",space); 	printf("其他数：%d\n",other); 	 	return 0; }

引用 4 楼 qq_33302340 的回复:不需要一直加  后++  改为前++  别的没问题 改前加一样有问题。建议测试一下试试。 前加也会导致一些字符没有判断。

不需要一直加  后++  改为前++  别的没问题

#include<stdio.h> #include<string.h> int main() {     char arr[80];     int lwords = 0 , swords = 0 , digit = 0 , space = 0 , other = 0;      gets(arr);     char *p = arr;     while(*p != '\0')     {         if(*p >= 'a' && *p <= 'z')             swords++;         else if(*p >= 'A' && *p <= 'Z')             lwords++;         else if(*p >= '0' && *p <= '9')             digit++;         else if(*p == ' ')             space++;         else             other++;         p++;     }      printf("小写字母数：%d\n",swords);     printf("大写字母数：%d\n",lwords);     printf("数字数：%d\n",digit);     printf("空格数：%d\n",space);     printf("其他数：%d\n",other);      return 0; }  参考一下吧；  首先：arr是数组名，因此它不能做左值，但是arr++等价arr = arr + 1;这样arr就做了左值，所以矛盾； 其次，即使arr赋值给了一个可以做左值的指针，但是while (*(p++) != 0)也是不行，因为++的副作用。这样能判断*(p++)是否位'\0'，但是判断之后，p就指向了下一个字符，那么就会把当前的字符跨过去了。你的结果计算出来的数值总数肯定是比实际字符数少的。

if(*(arr++) >= 'a' && *(arr++) <= 'z') else if(*(arr++) >= 'A' && *(arr++) <= 'Z') else if(*(arr++) >= '0' && *(arr++) <= '9') else if(*(arr++) == ' ')  //为什么都 ++？你是判断当前字符，把这里所有的++都删掉即可 //另外循环 while(*(arr++) != '\0') //改为 while(*(arr) != '\0') { //你的操作 arr++; }


Question: C语言数据结构四则运算

你是c语言还是c++，如果是c是没有&引用的

这个程序运算没有结果输出

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

/*    题目二    表达式求值问题    给定一个算术表达式，对该表达式进行四则运算。    基本要求：    （1）以栈作为存储结构，一个栈存放操作符，一个栈存放操作数；    （2）按字符串形式输入表达式；    （3）最终结果放在操作数栈中并输出。    测试数据要求：    给定的表达式中，必须有包含两位数的数值。例如，给定的表达式为：(10+2)*6-12/3    */ #include <stdio.h> #include <stdlib.h>  #define STACK_INIT_SIZE 100 #define STACKINCREMENT 30  typedef struct{     char *base;     int top;     int stacksize; }SqStack;  typedef struct{     int *base;     int top;     int stacksize; }NumStack;  void Init_SqStack(SqStack &S) {     S.base = (char *)malloc(STACK_INIT_SIZE*sizeof(char));     if (!S.base) {         exit(0);     }     S.top = 0;     S.stacksize = STACK_INIT_SIZE; } int SqStackEmpty(SqStack S) {     if(S.top == 0)         return 1;     else         return 0; }  void Push_Sq(SqStack &S,char e) {     if (S.top >= S.stacksize) {         S.base = (char *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(char));         if(!S.base)             exit(0);         S.stacksize += STACKINCREMENT;     }      S.base[S.top++] = e; } void Pop_Sq(SqStack &S,char &e) {     if(S.top==0){         exit(0);     }     e = S.base[--S.top]; }  char GetTop_Sq(SqStack S,char &e) {     if(S.top == 0)         return -1;     e = S.base[S.top-1];      return e; }  void Init_NumStack(NumStack &S) {     S.base=(int *)malloc(STACK_INIT_SIZE*sizeof(int));     if(!S.base)         exit(0);      S.top = 0;     S.stacksize = STACK_INIT_SIZE; }  int NumStackEmpty(NumStack S) {     if(S.top==0)         return 1;     else         return 0; }  void Push_Num(NumStack &S,int e) {     if(S.top>=S.stacksize){         S.base=(int *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(int));         if(!S.base){             exit(0);         }         S.stacksize+=STACKINCREMENT;     }     S.base[S.top++]=e;     return ; }  void Pop_Num(NumStack &S,int &e){     if(S.top==0)         return;      e = S.base[--S.top]; } void GetTop_Num(NumStack S,int &e) {     if(S.top==0){         return ;     }     e=S.base[S.top-1];     return ; } char Priority(char a,char b) {     if(a=='*'||a=='/'){         if(b=='+'||b=='-'){             return '>';         }else if(b=='*'||b=='/'){             return '=';         }else{             return '<';         }     }     if(a=='+'||a=='-'){         if(b=='+'||b=='-'){             return '=';         }         else{             return '<';         }     } }  int calculate(int num1,char x,int num2) {     if(x=='+'){         return num1+num2;     }     else if(x=='-'){         return num1-num2;     }     else if(x=='*'){         return num1*num2;     }     else if(x=='/'){         return num1/num2;     } }  void Init_Storage(char a[]) {     NumStack Num;     SqStack Oper;     Init_SqStack(Oper);     Init_NumStack(Num);     Push_Sq(Oper,'#');     int i=0;     char x,jud;     int num1,num2,result=0;     while (a[i]) {         if(a[i]>='0'&&a[i]<='9')             Push_Num(Num,a[i] - '0');    /*不能直接强制类型转换*/          if(a[i+1] == 0){             Pop_Sq(Oper,x);             Pop_Num(Num,num1);             Pop_Num(Num,num2);             result=calculate(num1,x,num2);         }         else if(a[i]==')') {             while((jud=GetTop_Sq(Oper,jud))!='('){                 Pop_Sq(Oper,x);                 Pop_Num(Num,num1);                 Pop_Num(Num,num2);                 result=calculate(num1,x,num2);             }             Pop_Sq(Oper,x);             Push_Num(Num,result);         }         else {             if(Priority(a[i],jud=GetTop_Sq(Oper,jud))=='>'){ //当前操作符优先级高                 Push_Sq(Oper,a[i]);             }             else if(Priority(a[i],jud=GetTop_Sq(Oper,jud))=='<'||Priority(a[i],jud = GetTop_Sq(Oper,jud))=='='){                 Pop_Sq(Oper,x);                 Pop_Num(Num,num1);                 Pop_Num(Num,num2);                 result=calculate(num1,x,num2);                 Push_Num(Num,result);                 Push_Sq(Oper,a[i]);             }         }         i++;     }     //Pop_Sq(Oper,x);     /*Pop_Num(Num,num1);       Pop_Num(Num,num2);       result=calculate(num1,x,num2);*/     printf("最终结果为%d",result); } int main() {     char a[80];     scanf("%s", a);     Init_Storage(a);     return 0; } 参考一下吧 注意若a定义成5，很容易越界。 程序很接近答案了，建议你在这个基础上继续调试

for(int i=0;i<5;i++){         scanf("%c", &a[i]);     } 少个&

引用 3 楼 zhao4zhong1 的回复:仅供参考：/*--------------------------------------- 函数型计算器(VC++6.0,Win32 Console) 功能： 目前提供了10多个常用数学函数:     ⑴正弦sin     ⑵余弦cos     ⑶正切tan     ⑷开平方sqrt     ⑸反正弦arcsin     ⑹反余弦arccos     ⑺反正切arctan     ⑻常用对数lg     ⑼自然对数ln     ⑽ｅ指数exp     ⑾乘幂函数^     ⑿向上取整ceil     ⒀向下取整floor     ⒁四舍五入取整round 用法： 如果要求2的32次幂，可以打入2^32<回车> 如果要求30度角的正切可键入tan(Pi/6)<回车> 注意不能打入：tan(30)<Enter> 如果要求1.23弧度的正弦，有几种方法都有效： sin(1.23)<Enter> sin 1.23 <Enter> sin1.23  <Enter> 如果验证正余弦的平方和公式,可打入sin(1.23)^2+cos(1.23)^2 <Enter>或sin1.23^2+cos1.23^2 <Enter> 此外两函数表达式连在一起,自动理解为相乘如：sin1.23cos0.77+cos1.23sin0.77就等价于sin(1.23)*cos(0.77)+cos(1.23)*sin(0.77) 当然你还可以依据三角变换，再用sin(1.23+0.77)也即sin2验证一下。 本计算器充分考虑了运算符的优先级因此诸如：2+3*4^2 实际上相当于：2+(3*(4*4)) 另外函数名前面如果是数字,那么自动认为二者相乘. 同理，如果某数的右侧是左括号，则自动认为该数与括弧项之间隐含一乘号。 如：3sin1.2^2+5cos2.1^2 相当于3*sin2(1.2)+5*cos2(2.1) 又如：4(3-2(sqrt5-1)+ln2)+lg5 相当于4*(3-2*(√5 -1)+loge(2))+log10(5) 此外，本计算器提供了圆周率Pi键入字母时不区分大小写,以方便使用。 16进制整数以0x或0X开头。 ----------------------------------------*/ #include <iostream> #include <iomanip> #include <cstdlib> #include <cstring> #include <cctype> #include <cmath> #include <stdio.h> #include <string.h> #include <windows.h> using namespace std; const char Tab=0x9; const int  DIGIT=1; const int MAXLEN=16384; char s[MAXLEN],*endss; int pcs=15; double round(double dVal, short iPlaces) {//iPlaces>=0     char s[30];     double dRetval;      sprintf(s,"%.*lf",iPlaces,dVal);     sscanf(s,"%lf",&dRetval);     return (dRetval); } double fun(double x,char op[],int *iop) {     while (op[*iop-1]<32) //本行使得函数嵌套调用时不必加括号,如 arc sin(sin(1.234)) 只需键入arc sin sin 1.234<Enter>         switch (op[*iop-1]) {         case  7: x=sin(x);    (*iop)--;break;         case  8: x=cos(x);    (*iop)--;break;         case  9: x=tan(x);    (*iop)--;break;         case 10: x=sqrt(x);   (*iop)--;break;         case 11: x=asin(x);   (*iop)--;break;         case 12: x=acos(x);   (*iop)--;break;         case 13: x=atan(x);   (*iop)--;break;         case 14: x=log10(x);  (*iop)--;break;         case 15: x=log(x);    (*iop)--;break;         case 16: x=exp(x);    (*iop)--;break;         case 17: x=ceil(x);   (*iop)--;break;         case 18: x=floor(x);  (*iop)--;break;         case 19: x=round(x,0);(*iop)--;break;         }     return x; } double calc(char *expr,char **addr) {     static int deep; //递归深度     static char *fname[]={"sin","cos","tan","sqrt","arcsin","arccos","arctan","lg","ln","exp","ceil","floor","round",NULL};     double ST[10]={0.0}; //数字栈     char op[10]={'+'}; //运算符栈     char c,*rexp,*pp,*pf;     int ist=1,iop=1,last,i,n;     __int64 i64;      if (!deep) {         pp=pf=expr;         do {             c = *pp++;             if (c!=' '&& c!=Tab)                 *pf++ = c;         } while (c!='\0');     }     pp=expr;     if ((c=*pp)=='-'||c=='+') {         op[0] = c;         pp++;     }     last = !DIGIT;     while ((c=*pp)!='\0') {         if (c=='(') {//左圆括弧             deep++;             ST[ist++]=calc(++pp,addr);             deep--;             ST[ist-1]=fun(ST[ist-1],op,&iop);             pp = *addr;             last = DIGIT;             if (*pp == '('||isalpha(*pp) && strnicmp(pp,"Pi",2)) {//目的是：当右圆括弧的右恻为左圆括弧或函数名字时，默认其为乘法                 op[iop++]='*';                 last = !DIGIT;                 c = op[--iop];                 goto operate ;             }         }         else if (c==')') {//右圆括弧             pp++;             break;         } else if (isalpha(c)) {             if (!strnicmp(pp,"Pi",2)) {                 if (last==DIGIT) {                     cout<< "π左侧遇）" <<endl;exit(1);                 }                 ST[ist++]=3.14159265358979323846264338328;                 ST[ist-1]=fun(ST[ist-1],op,&iop);                 pp += 2;                 last = DIGIT;                 if (!strnicmp(pp,"Pi",2)) {                     cout<< "两个π相连" <<endl;exit(2);                 }                 if (*pp=='(') {                     cout<< "π右侧遇（" <<endl;exit(3);                 }             } else {                 for (i=0; (pf=fname[i])!=NULL; i++)                     if (!strnicmp(pp,pf,strlen(pf))) break;                 if (pf!=NULL) {                     op[iop++] = 07+i;                     pp += strlen(pf);                 } else {                     cout<< "陌生函数名" <<endl;exit(4);                 }             }         } else if (c=='+'||c=='-'||c=='*'||c=='/'||c=='%'||c=='^') {             char cc;             if (last != DIGIT) {                 cout<< "运算符粘连" <<endl;exit(5);             }             pp++;             if (c=='+'||c=='-') {                 do {                     cc = op[--iop];                     --ist;                     switch (cc) {                     case '+':  ST[ist-1] += ST[ist];break;                     case '-':  ST[ist-1] -= ST[ist];break;                     case '*':  ST[ist-1] *= ST[ist];break;                     case '/':  ST[ist-1] /= ST[ist];break;                     case '%':  ST[ist-1] = fmod(ST[ist-1],ST[ist]);break;                     case '^':  ST[ist-1] = pow(ST[ist-1],ST[ist]);break;                     }                 } while (iop);                 op[iop++] = c;             } else if (c=='*'||c=='/'||c=='%') { operate:        cc = op[iop-1];                 if (cc=='+'||cc=='-') {                     op[iop++] = c;                 } else {                     --ist;                     op[iop-1] = c;                     switch (cc) {                     case '*':  ST[ist-1] *= ST[ist];break;                     case '/':  ST[ist-1] /= ST[ist];break;                     case '%':  ST[ist-1] = fmod(ST[ist-1],ST[ist]);break;                     case '^':  ST[ist-1] = pow(ST[ist-1],ST[ist]);break;                     }                 }             } else {                 cc = op[iop-1];                 if (cc=='^') {                     cout<< "乘幂符连用" <<endl;exit(6);                 }                 op[iop++] = c;             }             last = !DIGIT;         } else {             if (last == DIGIT) {                 cout<< "两数字粘连" <<endl;exit(7);             }             if (pp[0]=='0' && (pp[1]=='x'||pp[1]=='X')) {                 sscanf(pp+2,"%I64x%n",&i64,&n);                 rexp=pp+2+n;                 ST[ist++]=(double)i64;             } else ST[ist++]=strtod(pp,&rexp);             ST[ist-1]=fun(ST[ist-1],op,&iop);             if (pp == rexp) {                 cout<< "非法字符" <<endl;exit(8);             }             pp = rexp;             last = DIGIT;             if (*pp == '('||isalpha(*pp)) {                 op[iop++]='*';                 last = !DIGIT;                 c = op[--iop];                 goto operate ;             }         }     }     *addr=pp;     if (iop>=ist) {         cout<< "表达式有误" <<endl;exit(9);     }     while (iop) {         --ist;         switch (op[--iop]) {         case '+':  ST[ist-1] += ST[ist];break;         case '-':  ST[ist-1] -= ST[ist];break;         case '*':  ST[ist-1] *= ST[ist];break;         case '/':  ST[ist-1] /= ST[ist];break;         case '%':  ST[ist-1] = fmod(ST[ist-1],ST[ist]);break;         case '^':  ST[ist-1] = pow(ST[ist-1],ST[ist]);break;         }     }     return ST[0]; } int main(int argc,char **argv) {     int a;      if (argc<2) {         if (GetConsoleOutputCP()!=936) system("chcp 936>NUL");//中文代码页         cout << "计算函数表达式的值。"<<endl<<"支持(),+,-,*,/,%,^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp,ceil,floor,round"<<endl;         while (1) {             cout << "请输入表达式：";             gets(s);             if (s[0]==0) break;//             cout << s <<"=";             cout << setprecision(15) << calc(s,&endss) << endl;         }     } else if (argc==2 && 0==strcmp(argv[1],"/?")) {         if (GetConsoleOutputCP()!=936) system("chcp 936>NUL");//中文代码页         cout << "计算由≥1个命令行参数给出的函数表达式的值。\n"         "最后一个参数是.0～.15表示将计算结果保留小数0～15位\n"         "最后一个参数是x表示将计算结果以16进制正整数格式输出\n"         "支持(),+,-,*,/,%,^^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp,ceil,floor,round\n"         "16进制整数以0x或0X开头\n";     } else {         strncpy(s,argv[1],MAXLEN-1);s[MAXLEN-1]=0;         if (argc>2) {             for (a=2;a<argc-1;a++) strncat(s,argv[a],MAXLEN-1);//将空格间隔的各参数连接到s             if (1==sscanf(argv[a],".%d",&pcs) && 0<=pcs && pcs<=15) {//最后一个参数是.0～.15表示将计算结果保留小数0～15位                 printf("%.*lf\n",pcs,calc(s,&endss));             } else if (argv[a][0]=='x'||argv[a][0]=='X') {//最后一个参数是x表示将计算结果以16进制正整数格式输出                 printf("0x%016I64x\n",(__int64)calc(s,&endss));             } else {                 strncat(s,argv[a],MAXLEN-1);                 printf("%.15lg\n",calc(s,&endss));             }         } else {             printf("%.15lg\n",calc(s,&endss));         }     }     return 0; } 老师能大概讲讲思路吗


Question: IAR刚打开时为什么不能go to definition 呢?

引用 8 楼 u014783685 的回复:编译一下工程应该就可以了吧 不需要，过一会自动就识别了，可以。

编译一下工程应该就可以了吧

引用 4 楼 wearlee 的回复:[quote=引用 2 楼 zhao4zhong1 的回复:] 状态栏中不是显示了正在扫描吗？   大哥,我咋没看到写了正在扫描啊,能截个图看看吗?[/quote] 我猜的。 因为VS20XX IDE在打开一个项目时，状态栏中会显示“正在……”

引用 5 楼 zhao4zhong1 的回复:[quote=引用 4 楼 wearlee 的回复:] [quote=引用 2 楼 zhao4zhong1 的回复:] 状态栏中不是显示了正在扫描吗？   大哥,我咋没看到写了正在扫描啊,能截个图看看吗?[/quote] 我猜的。 因为VS20XX IDE在打开一个项目时，状态栏中会显示“正在……” [/quote] 我说我怎么找了半天没有找到,不过你的猜测也很有依据,里面的机制大概就是这样的.谢谢你啊.....

状态栏中不是显示了正在扫描吗？

意思就是刚打开的时候不能go to definition of

引用 2 楼 zhao4zhong1 的回复:状态栏中不是显示了正在扫描吗？   大哥,我咋没看到写了正在扫描啊,能截个图看看吗?

大哥,我咋没看到写了正在扫描啊,能截个图看看吗?


Question: 从常量字符数组中获取指定字符的索引，还有什么好办法，谢谢

引用 19 楼 sys0613 的回复:[quote=引用 17 楼 zhao4zhong1 的回复:] [code=c]#pragma comment(lib,"user32") 这是啥。。。。[/quote] 告诉你啥叫“羞羞的铁拳”，哦不，“怪怪的字符”。

引用 18 楼 sys0613 的回复:[quote=引用 15 楼 cfjtaishan 的回复:] [quote=引用 14 楼 sys0613 的回复:] [quote=引用 12 楼 cfjtaishan 的回复:] [quote=引用 8 楼 sys0613 的回复:] [quote=引用 5 楼 cfjtaishan 的回复:] [quote=引用 2 楼 sys0613 的回复:] [quote=引用 1 楼 jianwen0529 的回复:] 可以，不过查找不到返回NULL，此刻要进行判断并处理  自己可以写一份函数，也就两三句代码的事情，重点是可以控制。比如判断两个参数的有效性，直接返回索引等等 嗯，写函数防止找不到的NULL，还需要控制别的么？？我其实主要是担心两个指针地址相减会不会偶发一些不兼容的问题。产生不可控制的错误？谢谢[/quote] 应该不会，因为strchr返回也是指向传入参数的相对地址，不会有不兼容的问题。要么找到，返回传入参数的某个字符位置的地址，要么返回NULL，未找到。  不用strchr可能会更好，因为想要的是某个字符所在的位置，那么直接遍历比较即可。若找到返回对应的位置，否则返回-1；通过自定义函数来得到；  #include <stdio.h>   int get_pos(const char *str, int key);  int main(void) {     const char *str = "helloworld";      printf("Pos = %d\n", get_pos(str, 'w'));      return 0; }  int get_pos(const char *str, int key) {     int i;     for (i = 0; str[i]; i++)         if (key == str[i])             break;      if (!str[i])         return -1;      return i; } 参考一下吧[/quote]  好的，谢谢了，自己写这种遍历和strchr哪个效率更好呢？我本身就有数组的长度。。我直接循环遍历可能比你这个还省事。。。[/quote] 还有比这个效率高的。可以贴出来，一起研究下； [/quote] 我是说我事先知道数组长度。。。我担心你那个  if (!str[i])，最后一位可能不是假。。。[/quote] 如果你事先知道数组长度，求字符串数组的长度你需要调用strlen，那么求长度就已经遍历一次了。 这个主要判断是不是'\0'，因为'\0'等价0;0是假，那么！0就是真。[/quote] 嗯，我那个是常量字符数组，所以结尾可能不是‘\0’。。。谢谢您了。懂了[/quote] 如果不是字符串，建议也别用strchr，这个是针对字符串的函数。因此，若不是字符串，那么只能用字符个数作为循环遍历的结束条件，并且不能使用任何字符串的函数。

引用 17 楼 zhao4zhong1 的回复:[code=c]#pragma comment(lib,"user32") 这是啥。。。。

引用 15 楼 cfjtaishan 的回复:[quote=引用 14 楼 sys0613 的回复:] [quote=引用 12 楼 cfjtaishan 的回复:] [quote=引用 8 楼 sys0613 的回复:] [quote=引用 5 楼 cfjtaishan 的回复:] [quote=引用 2 楼 sys0613 的回复:] [quote=引用 1 楼 jianwen0529 的回复:] 可以，不过查找不到返回NULL，此刻要进行判断并处理  自己可以写一份函数，也就两三句代码的事情，重点是可以控制。比如判断两个参数的有效性，直接返回索引等等 嗯，写函数防止找不到的NULL，还需要控制别的么？？我其实主要是担心两个指针地址相减会不会偶发一些不兼容的问题。产生不可控制的错误？谢谢[/quote] 应该不会，因为strchr返回也是指向传入参数的相对地址，不会有不兼容的问题。要么找到，返回传入参数的某个字符位置的地址，要么返回NULL，未找到。  不用strchr可能会更好，因为想要的是某个字符所在的位置，那么直接遍历比较即可。若找到返回对应的位置，否则返回-1；通过自定义函数来得到；  #include <stdio.h>   int get_pos(const char *str, int key);  int main(void) {     const char *str = "helloworld";      printf("Pos = %d\n", get_pos(str, 'w'));      return 0; }  int get_pos(const char *str, int key) {     int i;     for (i = 0; str[i]; i++)         if (key == str[i])             break;      if (!str[i])         return -1;      return i; } 参考一下吧[/quote]  好的，谢谢了，自己写这种遍历和strchr哪个效率更好呢？我本身就有数组的长度。。我直接循环遍历可能比你这个还省事。。。[/quote] 还有比这个效率高的。可以贴出来，一起研究下； [/quote] 我是说我事先知道数组长度。。。我担心你那个  if (!str[i])，最后一位可能不是假。。。[/quote] 如果你事先知道数组长度，求字符串数组的长度你需要调用strlen，那么求长度就已经遍历一次了。 这个主要判断是不是'\0'，因为'\0'等价0;0是假，那么！0就是真。[/quote] 嗯，我那个是常量字符数组，所以结尾可能不是‘\0’。。。谢谢您了。懂了

老赵嘚吧了半天一分没得，论坛玩的就是情怀...

啥叫字符？啥叫字符串？

引用 2 楼 sys0613 的回复:[quote=引用 1 楼 jianwen0529 的回复:] 可以，不过查找不到返回NULL，此刻要进行判断并处理  自己可以写一份函数，也就两三句代码的事情，重点是可以控制。比如判断两个参数的有效性，直接返回索引等等 嗯，写函数防止找不到的NULL，还需要控制别的么？？我其实主要是担心两个指针地址相减会不会偶发一些不兼容的问题。产生不可控制的错误？谢谢[/quote] 应该不会，因为strchr返回也是指向传入参数的相对地址，不会有不兼容的问题。要么找到，返回传入参数的某个字符位置的地址，要么返回NULL，未找到。  不用strchr可能会更好，因为想要的是某个字符所在的位置，那么直接遍历比较即可。若找到返回对应的位置，否则返回-1；通过自定义函数来得到；  #include <stdio.h>   int get_pos(const char *str, int key);  int main(void) {     const char *str = "helloworld";      printf("Pos = %d\n", get_pos(str, 'w'));      return 0; }  int get_pos(const char *str, int key) {     int i;     for (i = 0; str[i]; i++)         if (key == str[i])             break;      if (!str[i])         return -1;      return i; } 参考一下吧

引用 2 楼 sys0613 的回复:[quote=引用 1 楼 jianwen0529 的回复:] 可以，不过查找不到返回NULL，此刻要进行判断并处理  自己可以写一份函数，也就两三句代码的事情，重点是可以控制。比如判断两个参数的有效性，直接返回索引等等 嗯，写函数防止找不到的NULL，还需要控制别的么？？我其实主要是担心两个指针地址相减会不会偶发一些不兼容的问题。产生不可控制的错误？谢谢[/quote] 不会，同类型指针+-这是C语法自带的规则，兼容性什么的不需要考虑

引用 1 楼 jianwen0529 的回复:可以，不过查找不到返回NULL，此刻要进行判断并处理  自己可以写一份函数，也就两三句代码的事情，重点是可以控制。比如判断两个参数的有效性，直接返回索引等等 嗯，写函数防止找不到的NULL，还需要控制别的么？？我其实主要是担心两个指针地址相减会不会偶发一些不兼容的问题。产生不可控制的错误？谢谢

#pragma comment(lib,"user32") #pragma comment(lib,"gdi32") #include <conio.h> #include <stdio.h> #include <stdlib.h> #include <windows.h> extern "C" HWND WINAPI GetConsoleWindow(); void HideTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = FALSE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } void ShowTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = TRUE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } int main() {     HWND  hwnd;     HDC   hdc;     HFONT hfont;     wchar_t wc[2];      system("color F0");     system("cls");     HideTheCursor();     hwnd  = GetConsoleWindow();     hdc   = GetDC(hwnd);     hfont = CreateFont(48,0,0,0,0,0,0,0,GB2312_CHARSET ,0,0,0,0,"宋体-方正超大字符集");     SelectObject(hdc,hfont);     wc[0]=0xD854u;     wc[1]=0xDC00u;     TextOutW(hdc,10,10,wc,2);     DeleteObject(hfont);     ReleaseDC(hwnd,hdc);     getch();     system("color 07");     system("cls");     ShowTheCursor();     return 0; } #if 0 代理项或代理项对是一对共同表示单个字符的 16 位 Unicode 编码值。需要记住的关键一点是： 代理项对实际上是 32 位单个字符，不能再假定一个 16 位 Unicode 编码值正好映射到一个字符。  使用代理项对 代理项对的第一个值是高代理项，包含介于 U+D800 到 U+DBFF 范围内的 16 位代码值。 该对的第二个值是低代理项，包含介于 U+DC00 到 U+DFFF 范围内的值。通过使用代理项对， 16 位 Unicode 编码系统可以对已由 Unicode 标准定义的一百多万个其他字符 (220) 进行寻址。  在传递给 XmlTextWriter 方法的任何字符串中都可以使用代理项字符。不过，代理项字符在编写的 XML 中应该有效。例如，万维网联合会 (W3C) 建议不允许在元素或属性的名称中使用代理项字符。 如果字符串包含无效的代理项对，则引发异常。  另外，可以使用 WriteSurrogateCharEntity 写出与代理项对相对应的字符实体。字符实体以十六 进制格式写出，并用以下公式生成：  (highChar -0xD800) * 0x400 + (lowChar -0xDC00) + 0x10000  如果字符串包含无效的代理项对，则引发异常。下面的示例显示将代理项对作为输入的 WriteSurrogateCharEntity 方法。  C#复制  // The following line writes 𐀀. WriteSurrogateCharEntity ('\uDC00', '\uD800'); 下面的示例生成一个代理项对文件，将其加载到 XmlReader 中，并用新的文件名保存文件。 然后，原始文件和新文件被加载回应用程序的 XML 文档对象模型 (DOM) 结构中以进行比较。  C#复制  char lowChar, highChar; char [] charArray = new char[10]; FileStream targetFile = new FileStream("SurrogatePair.xml",       FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);  lowChar = Convert.ToChar(0xDC00); highChar = Convert.ToChar(0xD800); XmlTextWriter tw = new XmlTextWriter(targetFile, null); tw.Formatting = Formatting.Indented; tw.WriteStartElement("root"); tw.WriteStartAttribute("test", null); tw.WriteSurrogateCharEntity(lowChar, highChar); lowChar = Convert.ToChar(0xDC01); highChar = Convert.ToChar(0xD801); tw.WriteSurrogateCharEntity(lowChar, highChar); lowChar = Convert.ToChar(0xDFFF); highChar = Convert.ToChar(0xDBFF); tw.WriteSurrogateCharEntity(lowChar, highChar);  // Add 10 random surrogate pairs. // As Unicode, the high bytes are in lower // memory; for example, word 6A21 as 21 6A. // The high or low is in the logical sense. Random random = new Random(); for (int i = 0; i < 10; ++i) {       lowChar = Convert.ToChar(random.Next(0xDC00, 0xE000));       highChar = Convert.ToChar(random.Next(0xD800, 0xDC00));       charArray[i] = highChar;       charArray[++i] = lowChar; } tw.WriteChars(charArray, 0, charArray.Length);  for (int i = 0; i < 10; ++i) {       lowChar = Convert.ToChar(random.Next(0xDC00, 0xE000));       highChar = Convert.ToChar(random.Next(0xD800, 0xDC00));       tw.WriteSurrogateCharEntity(lowChar, highChar); }  tw.WriteEndAttribute(); tw.WriteEndElement(); tw.Flush(); tw.Close();  XmlTextReader r = new XmlTextReader("SurrogatePair.xml");  r.Read(); r.MoveToFirstAttribute(); targetFile = new FileStream("SurrogatePairFromReader.xml",        FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);  tw = new XmlTextWriter(targetFile, null); tw.Formatting = Formatting.Indented; tw.WriteStartElement("root"); tw.WriteStartAttribute("test", null); tw.WriteString(r.Value); tw.WriteEndAttribute(); tw.WriteEndElement(); tw.Flush(); tw.Close();  // Load both result files into the DOM and compare. XmlDocument doc1 = new XmlDocument(); XmlDocument doc2 = new XmlDocument(); doc1.Load("SurrogatePair.xml"); doc2.Load("SurrogatePairFromReader.xml"); if (doc1.InnerXml != doc2.InnerXml) {       Console.WriteLine("Surrogate Pair test case failed"); } 在使用 WriteChars 方法（一次写出一个缓冲区的数据）写出时，输入中的代理项对可能 会在一个缓冲区内被意外拆分。由于代理项值是定义完善的，如果 WriteChars 遇到来自 较低范围或者较高范围的 Unicode 值，它将该值标识为代理项对的一半。当遇到  WriteChars 将导致从拆分代理项对的缓冲区写入的情况时，将引发异常。使用   IsHighSurrogate 方法检查缓冲区是否以高代理项字符结束。如果缓冲区中的最后一个   字符不是高代理项，可以将该缓冲区传递给 WriteChars 方法。  请参见 概念 使用 XmlTextWriter 创建格式正确的 XML XmlTextWriter 的 XML 输出格式设置 XmlTextWriter 的命名空间功能  #endif

没问题，同类型指针相减得到的就是元素个数，当然你也可以自己写个循环实现

引用 14 楼 sys0613 的回复:[quote=引用 12 楼 cfjtaishan 的回复:] [quote=引用 8 楼 sys0613 的回复:] [quote=引用 5 楼 cfjtaishan 的回复:] [quote=引用 2 楼 sys0613 的回复:] [quote=引用 1 楼 jianwen0529 的回复:] 可以，不过查找不到返回NULL，此刻要进行判断并处理  自己可以写一份函数，也就两三句代码的事情，重点是可以控制。比如判断两个参数的有效性，直接返回索引等等 嗯，写函数防止找不到的NULL，还需要控制别的么？？我其实主要是担心两个指针地址相减会不会偶发一些不兼容的问题。产生不可控制的错误？谢谢[/quote] 应该不会，因为strchr返回也是指向传入参数的相对地址，不会有不兼容的问题。要么找到，返回传入参数的某个字符位置的地址，要么返回NULL，未找到。  不用strchr可能会更好，因为想要的是某个字符所在的位置，那么直接遍历比较即可。若找到返回对应的位置，否则返回-1；通过自定义函数来得到；  #include <stdio.h>   int get_pos(const char *str, int key);  int main(void) {     const char *str = "helloworld";      printf("Pos = %d\n", get_pos(str, 'w'));      return 0; }  int get_pos(const char *str, int key) {     int i;     for (i = 0; str[i]; i++)         if (key == str[i])             break;      if (!str[i])         return -1;      return i; } 参考一下吧[/quote]  好的，谢谢了，自己写这种遍历和strchr哪个效率更好呢？我本身就有数组的长度。。我直接循环遍历可能比你这个还省事。。。[/quote] 还有比这个效率高的。可以贴出来，一起研究下； [/quote] 我是说我事先知道数组长度。。。我担心你那个  if (!str[i])，最后一位可能不是假。。。[/quote] 如果你事先知道数组长度，求字符串数组的长度你需要调用strlen，那么求长度就已经遍历一次了。 这个主要判断是不是'\0'，因为'\0'等价0;0是假，那么！0就是真。

引用 12 楼 cfjtaishan 的回复:[quote=引用 8 楼 sys0613 的回复:] [quote=引用 5 楼 cfjtaishan 的回复:] [quote=引用 2 楼 sys0613 的回复:] [quote=引用 1 楼 jianwen0529 的回复:] 可以，不过查找不到返回NULL，此刻要进行判断并处理  自己可以写一份函数，也就两三句代码的事情，重点是可以控制。比如判断两个参数的有效性，直接返回索引等等 嗯，写函数防止找不到的NULL，还需要控制别的么？？我其实主要是担心两个指针地址相减会不会偶发一些不兼容的问题。产生不可控制的错误？谢谢[/quote] 应该不会，因为strchr返回也是指向传入参数的相对地址，不会有不兼容的问题。要么找到，返回传入参数的某个字符位置的地址，要么返回NULL，未找到。  不用strchr可能会更好，因为想要的是某个字符所在的位置，那么直接遍历比较即可。若找到返回对应的位置，否则返回-1；通过自定义函数来得到；  #include <stdio.h>   int get_pos(const char *str, int key);  int main(void) {     const char *str = "helloworld";      printf("Pos = %d\n", get_pos(str, 'w'));      return 0; }  int get_pos(const char *str, int key) {     int i;     for (i = 0; str[i]; i++)         if (key == str[i])             break;      if (!str[i])         return -1;      return i; } 参考一下吧[/quote]  好的，谢谢了，自己写这种遍历和strchr哪个效率更好呢？我本身就有数组的长度。。我直接循环遍历可能比你这个还省事。。。[/quote] 还有比这个效率高的。可以贴出来，一起研究下； [/quote] 我是说我事先知道数组长度。。。我担心你那个  if (!str[i])，最后一位可能不是假。。。

最快的方法，当然是再建立一个反向查找表，只需要初始化一次，之后可以直接映射，时间复杂度是O(1)。

引用 8 楼 sys0613 的回复:[quote=引用 5 楼 cfjtaishan 的回复:] [quote=引用 2 楼 sys0613 的回复:] [quote=引用 1 楼 jianwen0529 的回复:] 可以，不过查找不到返回NULL，此刻要进行判断并处理  自己可以写一份函数，也就两三句代码的事情，重点是可以控制。比如判断两个参数的有效性，直接返回索引等等 嗯，写函数防止找不到的NULL，还需要控制别的么？？我其实主要是担心两个指针地址相减会不会偶发一些不兼容的问题。产生不可控制的错误？谢谢[/quote] 应该不会，因为strchr返回也是指向传入参数的相对地址，不会有不兼容的问题。要么找到，返回传入参数的某个字符位置的地址，要么返回NULL，未找到。  不用strchr可能会更好，因为想要的是某个字符所在的位置，那么直接遍历比较即可。若找到返回对应的位置，否则返回-1；通过自定义函数来得到；  #include <stdio.h>   int get_pos(const char *str, int key);  int main(void) {     const char *str = "helloworld";      printf("Pos = %d\n", get_pos(str, 'w'));      return 0; }  int get_pos(const char *str, int key) {     int i;     for (i = 0; str[i]; i++)         if (key == str[i])             break;      if (!str[i])         return -1;      return i; } 参考一下吧[/quote]  好的，谢谢了，自己写这种遍历和strchr哪个效率更好呢？我本身就有数组的长度。。我直接循环遍历可能比你这个还省事。。。[/quote] 还有比这个效率高的。可以贴出来，一起研究下；

你的有长度可以同时判断 一个 word ( 32位机器上 4字节， 64位机器上 8 字节)  是否包含 ch， 比库函数能快一些， 不过， 这并没啥意义 ...

摘自VS2013目录下.\VC\crt\src\strchr.c文件 /*** *strchr.c - search a string for a given character * *       Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *       defines strchr() - search a string for a character * *******************************************************************************/  #include <cruntime.h> #include <string.h>  /*** *char *strchr(string, c) - search a string for a character * *Purpose: *       Searches a string for a given character, which may be the *       null character '\0'. * *Entry: *       char *string - string to search in *       char c - character to search for * *Exit: *       returns pointer to the first occurence of c in string *       returns NULL if c does not occur in string * *Exceptions: * *******************************************************************************/  char * __cdecl strchr (         const char * string,         int ch         ) {         while (*string && *string != (char)ch)                 string++;          if (*string == (char)ch)                 return((char *)string);         return(NULL); }

引用 7 楼 sys0613 的回复:[quote=引用 4 楼 starytx 的回复:] 不用系统函数，自己可以写一个，很简单啊，从字符串首指针开始，自增遍历，直到遇到结束符，定义一个int作为记录索引，初始为-1.在循环中也自增，然后在循环中判断当前字符是不是要查找的字符，是的话就返回索引就行了 因为我这个需要频繁查找，数组长度基本为200，类型为char，用strchr会不会效率更高？这个函数会被调用很多很多次。用从头自增遍历效率慢不？[/quote] strchr的实现本身就是使用了遍历，你可以去看看编译器对其的实现代码


Question: C语言实现程序变量实时更新

保證新數據被保存，這是不可能做到的。我的方案衹是保證在新數據保存過程出現意外時，舊數據還能生效，程序能夠正常啓動。

没有十分完善的做法，可以做备份文件，实现将断电前前一个参数保存没问题。 根据要保存的数据的  引用 3 楼 NeiGongShenHou 的回复:[quote=引用 2 楼 cfjtaishan 的回复:] [quote=引用 1 楼 hzy_76 的回复:] 分成两个文件，一个后缀new，另一个为old，每次从new读，若没找到new文件则从old文件读。 保存变量时，先删除old文件，然后把new文件改名为old，最后保存新的new文件。 这个不能保证掉电前若未保存或正要保存的数据保存不到new文件里。但是可以保证掉电前的前一个保存不会有问题，即old文件里的数据保证没问题。  这样操作是可行的，起码能保证系统启动时能够拿到数据。  [/quote] 如果需要频繁的更新数据，这样每次都需要新建一个new文件，是不是会影响效率[/quote] 不是每次都new文件，而是总共就2个文件，一个是实时更新的，一个是比最新的之前的。即最新和次最新的。 如果要保证数据完整就要牺牲一些程序的性能，因为保存数据和将新的拷贝至次最新文件都会要占用时间片的。

引用 2 楼 cfjtaishan 的回复:[quote=引用 1 楼 hzy_76 的回复:] 分成两个文件，一个后缀new，另一个为old，每次从new读，若没找到new文件则从old文件读。 保存变量时，先删除old文件，然后把new文件改名为old，最后保存新的new文件。 这个不能保证掉电前若未保存或正要保存的数据保存不到new文件里。但是可以保证掉电前的前一个保存不会有问题，即old文件里的数据保证没问题。  这样操作是可行的，起码能保证系统启动时能够拿到数据。  [/quote] 如果需要频繁的更新数据，这样每次都需要新建一个new文件，是不是会影响效率

引用 1 楼 hzy_76 的回复:分成两个文件，一个后缀new，另一个为old，每次从new读，若没找到new文件则从old文件读。 保存变量时，先删除old文件，然后把new文件改名为old，最后保存新的new文件。 这个不能保证掉电前若未保存或正要保存的数据保存不到new文件里。但是可以保证掉电前的前一个保存不会有问题，即old文件里的数据保证没问题。  这样操作是可行的，起码能保证系统启动时能够拿到数据。


Question: C语言字符数组题目（抱歉各位我实在没有分了）

这个更像选择排序，虽然冒泡排序和选择排序时间复杂度在无穷大时相近。但是还是不一样的。

实际就是一个冒泡排序，搞清楚了就很容易理解了：http://blog.csdn.net/guoweimelon/article/details/50902597

你不理解的 if(p!=i) 接合上边的代码意思是发现有比cs[i]还小的字符串，然后交换他们！

应该容易理解 把冒泡排序算法理解，这个轻轻松松！ 外层循环，i 其实记录着最小的字符串的位置


Question: 大佬快来

引用 10 楼 cfjtaishan 的回复:printf("xxx+++++%p\n", t->next);             free(*n);             *n = NULL;             printf("+++++%p\n", t->next); 加一下这两个调试语句，可以发现执行完*n = NULL;此时t->next指向了NULL; 为什么呢，因为n指向的是t->next的地址，不是像branch2那样，m指向和t->next一样，指向堆上（malloc申请的）的空间；n指向的是t->next的地址。即t->next的首地址，那么指向*n = NULL之后，那么t->next就为NULL；（此时t指向的a为2）666，确实呆瓜了，忘了*n对n = &t->next是取解引用，所以free(*n)和free(m)效果并不一样，谢了大哥。

建议单步跟踪程序运行，观察变量变化情况，查看指针指向内存是否有效，是否越界访问

抱歉，没看到break

数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633

引用 2 楼 wodexiaojidan 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] t->next不为NULL，但是不能保证t->next->next不为NULL，所以，当t->next->next为NULL时，(*n)->next->a就会段错误，即相当于NULL->a  所以，我认为branch 1和2都会出现段错误； 因为两个分之处理是一样的。虽然定义的结构体指针不一样。你说的段错误会出现在printf里，我把printf去掉就不会出现。现在问题是我删除的点不在末尾，所以问题不出在printf，想找出问题在哪[/quote] 你的key点在中间，但是if里的操作调过了一个节点。t->next = m->next;并且出了if之后还要执行t = t->next

*n = NULL和m = NULL，可以去掉，去掉后，branch = 1的新的下一个节点的值会被改为0

#include <stdio.h> #include <stdlib.h> #include <string.h>  typedef struct node{ 	int a; 	struct node *next; }node;  #define Branch 2  void delete(node *l, int v) { 	node **n, *t, *m;  	for(t = l; t->next != NULL; t = t->next){ 		if(t->next->a == v){ #if Branch == 1 			n = &t->next; 			 			printf("n: addr = %p, a = %d\n", *n, (*n)->a); 			//printf("n->next: addr = %p, a = %d\n", (*n)->next, (*n)->next->a); 			 			t->next = (*n)->next; 			free(*n); 			*n = NULL; #elif Branch == 2 			m = t->next; 			printf("m: addr = %p, a = %d\n", m, m->a); 			//printf("m->next: addr = %p, a = %d\n", m->next, m->next->a); 			 			t->next = m->next; 			free(m); 			m = NULL; #endif 			//printf("t->next: addr = %p, a = %d\n", t->next, t->next->a);  			break; 		} 	} }  void show(node *l) { 	node *t;  	for(t = l->next; t != NULL; t = t->next){ 		printf("addr = %p, a = %d\n", t, t->a); 	} }  node *create(void) { 	node *head = malloc(sizeof(node)); 	node *p = head;  	int i; 	for(i = 0; i < 10; ++i){ 		node *node = malloc(sizeof(node) * 1); 		node->a = i + 1; 		node->next = NULL; 		p->next = node; 		p = p->next; 	} 	p->next = NULL;  	return head; }  int main(void) { 	node *a = create(); 	 	show(a); 	delete(a, 3); 	show(a);  	return 0; }

引用 1 楼 cfjtaishan 的回复:t->next不为NULL，但是不能保证t->next->next不为NULL，所以，当t->next->next为NULL时，(*n)->next->a就会段错误，即相当于NULL->a  所以，我认为branch 1和2都会出现段错误； 因为两个分之处理是一样的。虽然定义的结构体指针不一样。两个分支表现是，t->next新的节点会随*n变化，不会随m变化，*m被释放新节点值被清零了

n = &t->next; 这句不对吧

引用 1 楼 cfjtaishan 的回复:t->next不为NULL，但是不能保证t->next->next不为NULL，所以，当t->next->next为NULL时，(*n)->next->a就会段错误，即相当于NULL->a  所以，我认为branch 1和2都会出现段错误； 因为两个分之处理是一样的。虽然定义的结构体指针不一样。你说的段错误会出现在printf里，我把printf去掉就不会出现。现在问题是我删除的点不在末尾，所以问题不出在printf，想找出问题在哪


Question: C代码转为C#—— byte[] 数组转byte*指针 如何转？

类型不匹配？

c#的指针不同于C的指针，c#的指针不能指向数组


Question: 关于指针操作的一个小问题

引用 5 楼 qq_41231926 的回复:[quote=引用 2 楼 cfjtaishan 的回复:] #include <stdio.h>  int main(void) {     char * s1;     char * s2 = "Hello world!";          *s1 = *s2;     printf("%c", *s1);          return 0; } s1是野指针，即s1指针里的地址值是随机的，指向的内存区域是随机的。若s1指向了不可写的内存区域，那么*s1 = *s2就会导致段错误；若s1指向了可写的区域，那么是没问题的。可以正常运行。但是这个不确定，所以代码只能有时可以有时不可以。  第二个和第一个，都是因为野指针导致的。对于这样的代码有时好有时不好的情况，是不符合程序要求的。程序需要保证没问题。 先举个例子，如果我初始化一个指向int类型的指针:int * p; 那么我给这个指针的初始化语句可以这么写:*p = 7. 类似的，我给的程序里s1和s2都是指向char类型的指针，那么*s1得到的应该是s1指向的值，也就是字符串首字符的值，那我令*s2 = *s1,使得s2指针指向这个字符，这不就是把指针给初始化了吗？请问这有什么不同吗？？？ [/quote] 指针初始化一般是int *p = NULL; *p = 7;是指向p指向的内存里（4个字节）存放数值7，但是p是野指针，它指向的区域是随机，若指向的区域是不可写的，那么把7赋值给*p，不就是往不可写的内存单元里写数据吗？所以，会导致段错误。

引用 6 楼 qq_41231926的回复:[quote=引用 1 楼 guest25 的回复:] *s2 = *s1;     printf("%c", *s2); 你是想指针复制还是指针指向的内存里的内容复制啊？如果是指针复制请把上面语句里的＊号删除，如果是复制内存里的内容请把s2初始化才行。 我想复制内存里的内容的，那应该怎么样给s2初始化呢？ *s2 = *s1;不就是给s2初始化了么？ [/quote] s2 = s1; 或者 s2 = malloc(); s2 s1是指针变量，如果带*就是访问指针指向的内存空间了。

引用 1 楼 guest25 的回复:*s2 = *s1;     printf("%c", *s2); 你是想指针复制还是指针指向的内存里的内容复制啊？如果是指针复制请把上面语句里的＊号删除，如果是复制内存里的内容请把s2初始化才行。 我想复制内存里的内容的，那应该怎么样给s2初始化呢？ *s2 = *s1;不就是给s2初始化了么？

引用 2 楼 cfjtaishan 的回复:#include <stdio.h>  int main(void) {     char * s1;     char * s2 = "Hello world!";          *s1 = *s2;     printf("%c", *s1);          return 0; } s1是野指针，即s1指针里的地址值是随机的，指向的内存区域是随机的。若s1指向了不可写的内存区域，那么*s1 = *s2就会导致段错误；若s1指向了可写的区域，那么是没问题的。可以正常运行。但是这个不确定，所以代码只能有时可以有时不可以。  第二个和第一个，都是因为野指针导致的。对于这样的代码有时好有时不好的情况，是不符合程序要求的。程序需要保证没问题。 先举个例子，如果我初始化一个指向int类型的指针:int * p; 那么我给这个指针的初始化语句可以这么写:*p = 7. 类似的，我给的程序里s1和s2都是指向char类型的指针，那么*s1得到的应该是s1指向的值，也就是字符串首字符的值，那我令*s2 = *s1,使得s2指针指向这个字符，这不就是把指针给初始化了吗？请问这有什么不同吗？？？

两段都是错的，你的s1指针还没分配内存就使用了，是野指针，程序行为未定义，即使程序没崩，也只能说明运气好

两个代码都不对，内存溢出


Question: 内存莫名的变化

引用 12 楼 wodexiaojidan 的回复:引用 11 楼 ipqtjmqj 的回复:[quote=引用 9 楼 wodexiaojidan 的回复:] [quote=引用 8 楼 ipqtjmqj 的回复:] [quote=引用 6 楼 wodexiaojidan 的回复:] [quote=引用 5 楼 ipqtjmqj 的回复:] https://www.ideone.com/Rm4XSg编译器的毒？ 我的代码可能与你的不一样[/quote]但我用你的那个编译器试了一下  也是正常的[/quote] 你用的是微软的吗[/quote]gcc[/quote] ideone后台用的应该也是gcc,不过gcc有很多版本，编译时可以加不同选项，比如优化开得高，都有可能造成结果不一致。

引用 11 楼 ipqtjmqj 的回复:引用 9 楼 wodexiaojidan 的回复:[quote=引用 8 楼 ipqtjmqj 的回复:] [quote=引用 6 楼 wodexiaojidan 的回复:] [quote=引用 5 楼 ipqtjmqj 的回复:] https://www.ideone.com/Rm4XSg编译器的毒？ 我的代码可能与你的不一样[/quote]但我用你的那个编译器试了一下  也是正常的[/quote] 你用的是微软的吗[/quote]gcc

引用 9 楼 wodexiaojidan 的回复:引用 8 楼 ipqtjmqj 的回复:[quote=引用 6 楼 wodexiaojidan 的回复:] [quote=引用 5 楼 ipqtjmqj 的回复:] https://www.ideone.com/Rm4XSg编译器的毒？ 我的代码可能与你的不一样[/quote]但我用你的那个编译器试了一下  也是正常的[/quote] 你用的是微软的吗

你的代码在vs2010上编译不通过，不知你用的什么编译器？  for(i = 0; i < 10; ++i){         node *node = malloc(sizeof(node) * 1); 这段代码 node* node = ....//这句有问题 改成 node* node1 =....

引用 6 楼 wodexiaojidan 的回复:引用 5 楼 ipqtjmqj 的回复:https://www.ideone.com/Rm4XSg编译器的毒？ 我的代码可能与你的不一样

引用 8 楼 ipqtjmqj 的回复:引用 6 楼 wodexiaojidan 的回复:[quote=引用 5 楼 ipqtjmqj 的回复:] https://www.ideone.com/Rm4XSg编译器的毒？ 我的代码可能与你的不一样[/quote]但我用你的那个编译器试了一下  也是正常的

引用 3 楼 hdt 的回复:引用 2 楼 wodexiaojidan 的回复:[quote=引用 1 楼 hdt 的回复:] 贴出你的代码？代码就是图上的这些，还有一个结构体定义，一个main函数调用，没了 最好能够贴文字的，否则难道要我重敲一边？[/quote]你试试

#include <stdio.h> #include <stdlib.h> #include <string.h>  typedef struct node{ 	int a; 	struct node *next; }node;node *create(void) { 	node *head = malloc(sizeof(node)); 	node *p = head;  	int i; 	for(i = 0; i < 10; ++i){ 		node *node = malloc(sizeof(node) * 1); 		node->a = i + 1; 		node->next = NULL; 		printf("\n1. node: addr = %p, &a = %p, a = 0x%x\n", node, &node->a, node->a); 		p->next = node; 		printf("2. node: addr = %p, &a = %p, a = 0x%x\n", node, &node->a, node->a); 		p = p->next; 		printf("3. node: addr = %p, &a = %p, a = 0x%x\n", node, &node->a, node->a); 	} 	p->next = NULL;  	return head; }int main(void) { 	node *a = create();  	return 0; }

引用 2 楼 wodexiaojidan 的回复:引用 1 楼 hdt 的回复:贴出你的代码？代码就是图上的这些，还有一个结构体定义，一个main函数调用，没了 最好能够贴文字的，否则难道要我重敲一边？

贴出你的代码？


Question: 动画结束 对话框弹出

就是找不到才问的

多百度，   找找资源，先入门啊。


Question: 如何用freopen重复读文件

输入流错误后需要重置输入流   int main(void) { 	FILE *p = freopen("s:\\out..txt", "r", stdin);//我的out.txt里是三行，每一行一个字符串和一个数字 	cout << ftell(p) << endl; 	string a; 	int b; 	/*第一次读取开始*/ 	while (cin >> a >> b) 		cout << a << " " << b << endl; 	/*第一次读取结束*/ 	cout << ftell(p) << "\n" << endl;//输出此时文件内部指针的偏移量   	rewind(p);//重置文件指针 	cout << ftell(p) << endl;//确认文件内部指针的偏移量被重置过 							 //    fclose(stdin); 							 //    freopen("out.txt", "r", stdin);  	std::cin.clear(); 	std::cin.ignore(0x7fffffffffffffff, '\n');  	rewind(p);//重置文件指针 	cout << ftell(p) << endl;//确认文件内部指针的偏移量被重置过  	while (cin >> a >> b) 		cout << a << " " << b << endl; 	cout << ftell(p) << endl;//再次输出此时文件内部指针的偏移量 	return 0; }


Question: Can't Run

引用 1 楼 user-1 的回复:scanf("%c", choose); 改成 scanf("%c", &choose); 我改了 还是不行


Question: 求解，C语言二维数组的行列转换问题

一样的 行遍历或者列遍历 i, j分别代表行列/列行 复制到另一个数组就是j i进行索引 for(i)     for(j)         dst[j][i] = src[i][j]; //dst代表目标数组，src代表源数组

引用这样调换一下行列行不行？  可以啊，你循环变量的取值范围也要根着改

#include <stdio.h>  int main(void) {     int a[3][2] = {{1, 2}, {3, 4}, {5, 6}}, b[2][3];     int i, j;      for (i = 0; i < 3; i++) {         for (j = 0; j < 2; j++) {             b[j][i] = a[i][j];             printf("%d ", a[i][j]);         }         putchar(10);     }      for (j = 0; j < 2; j++) {         for (i = 0; i < 3; i++)             printf("%d ", b[j][i]);         putchar(10);     }     putchar(10);      return 0; } 这样没问题呢 1 2  3 4  5 6  1 3 5  2 4 6 上面是a的输出，下面是b的输出。

结果怎么不对？

我试了一下，结果还是不对。。。实在不知道哪里出问题了

[quote=引用 2 楼 jianwen0529 的回复:] 一样的 谢谢

[quote=引用 1 楼 paschen 的回复:] 引用这样调换一下行列行不行？  好，谢谢，我待会试试


Question: 新人求问  程序写到一半  调试模块时遇到了始终无法解决的问题

引用 1 楼 自信男孩的回复:#include<stdio.h> #include<stdlib.h> #include<string.h> #include<conio.h>  int n;  typedef struct student {     int xuehao;     char xingming[20];     char xingbie[5];     int nianling;     int chengji[3];     int pingjuncj;     int mingci;     struct student *next; }stu;  struct student* head=NULL,*p1,*p2,*p;  struct student* find(stu *f,int num) {     stu *l;     l=f;     while(l) {         if(l->xuehao==num)             break;         l=l->next;     }     return l; }  void cjlr() {     int i = 1;     printf("------------------------学生成绩录入------------------------\n\n");     p1 = (struct student *) malloc(sizeof (struct student));     printf("请输入第%d位学生信息:(输入0结束输入)\n",i++);     printf("\t学号:");scanf("%d",&p1->xuehao);     if(p1->xuehao==0)     {         printf("成绩录入结束,按任意键返回上一层");         free(p1);         return;     }     printf("\t姓名:");scanf("%s",&p1->xingming);     printf("\t性别:");scanf("%s",&p1->xingbie);     printf("\t年龄:");scanf("%d",&p1->nianling);     printf("\t高数成绩:");scanf("%d",&p1->chengji[0]);     printf("\t英语成绩:");scanf("%d",&p1->chengji[1]);     printf("\t程序成绩:");scanf("%d",&p1->chengji[2]);      while (1)     {         n++;         if(n==1)             head = p1;         else             p2->next = p1;          p2 = p1;         p1 = (struct student *) malloc(sizeof (struct student));         printf("请输入第%d位学生信息:\n",i++);         printf("\t学号:");scanf("%d",&p1->xuehao);         if(p1->xuehao==0)         {             printf("成绩录入结束,按任意键返回上一层");             break;         }         printf("\t姓名:");scanf("%s",&p1->xingming);         printf("\t性别:");scanf("%s",&p1->xingbie);         printf("\t年龄:");scanf("%d",&p1->nianling);         printf("\t高数成绩:");scanf("%d",&p1->chengji[0]);         printf("\t英语成绩:");scanf("%d",&p1->chengji[1]);         printf("\t程序成绩:");scanf("%d",&p1->chengji[2]);     }     free(p1);     p2->next = NULL;     printf("\n\n成绩录入成功！");      system("cls"); }  void cjcx() {     if(head==NULL)     {         printf("学生信息尚未录入，请在录入后查询");         return;     }     int num;     printf("------------------------学生成绩查询------------------------\n\n");     printf("\n请输入您要查询的学生学号:   ");     scanf("%d",&num);     p = find(head,num);     if (p) {         printf("\n学号\t姓名\t性别\t年龄\t高数\t英语\t程序\n\n");         printf("%d\t%s\t%s\t%d\t%d\t%d\t%d\n",p->xuehao,p->xingming,p->xingbie,p->nianling,p->chengji[0],p->chengji[1],p ->chengji[2]);     } else {         printf("学号%d未找到",num);     }     printf("\n\n按任意键返回上一层");    getch();    system("cls"); } void cjtj() {  }  void cjsc() {  }  void cjxg() {  }  void cjbc() {  }  void cjjz() {  }  int main() { ss:int i,choose;    for(i=1;i<=60;i++)    {        printf("=");    }    printf("\n\n");    printf("----------------------学生成绩查询系统----------------------\n\n");    printf("\n\t1.成绩录入\n");    printf("\n\t2.成绩查询\n");    printf("\n\t3.成绩添加\n");    printf("\n\t4.成绩删除\n");    printf("\n\t5.成绩修改\n");    printf("\n\t6.成绩保存\n");    printf("\n\t7.成绩加载\n");    printf("\n\t8.退出系统\n");    printf("\n\n");    for(i=1;i<=60;i++)    {        printf("=");    }    printf("\n请选择您要执行的功能:  "); AA:scanf("%d",&choose);    switch (choose)    {        case 1: { system("cls");  cjlr();goto ss;break;}        case 2: { system("cls");  cjcx();goto ss;break;}        case 3: { system("cls");  cjtj();break;}        case 4: { system("cls");  cjsc();break;}        case 5: { system("cls");  cjxg();break;}        case 6: { system("cls");  cjbc();break;}        case 7: { system("cls");  cjjz();break;}        case 8: {   break;}        default:{printf("输入错误请重试:  ");goto AA;}    }    return 0; } 参考一下吧，能不用goto语句就不要用goto语句，因为goto的代码不易阅读；相当于给自己找麻烦  find的问题主要是在创建链表时没有指定尾部的NULL; 啊。没注意到尾节点的null。好吧，谢谢了，这种程序如果不用goto也能实现模块之间的跳转吗


Question: 【算法】拷贝某个目录时候实现某些目录过滤功能，各位大神指教

搜“robocopy”

逐层遍历各级目录，遍历中判断是否满足你要删除的条件进行删除

遍历，取得子目录，剔除目录A，B，复制其他子目录下的目录和文件（遍历及递归）


Question: 在线等，关于数组做参数的问题！在线等！谢谢！

既然做参数，首先得有函数调用，这里面有函数调用数组吗？

请那些喜欢将数组作为函数参数传来传去或作为函数返回值的码农思考一下为什么不把整个互联网内容当作函数参数传来传去或作为函数返回值呢？

你这个数组没有做参数啊，数组做参不是这样子的

退化为指针，应该是是在形参的时候。比如 int my_strlen(const char src[]);把a传入strlen(a)函数里，那么src接收的是一个数组，但是退化位指针了。 这个确实是数组，不能简单理解位指针,数组的长度是字符串的长度+1；1是指'\0'

char *p="1232fgfdfd00"; printf("%d\n",sizeof(p));

《C++函数的数组形参2-2》 http://blog.csdn.net/hou09tian/article/details/78717675 《C++中函数的数组形参2-1》 http://blog.csdn.net/hou09tian/article/details/78046909 希望能够帮到你

你这里并没有用数组作参数，用数组作参数是指参数为a，而不是sizeof(a)

void fun(char a[]) //真实类型是char* { printf("%d", a); } int main() { char a[] = "dddddddd"; fun(a); }  引用 1 楼 jianwen0529 的回复:你这个不是参数，sizeof是一个操作符 对于sizeof来说，a就是一个数组，类型是char [11] 对于printf来说，sizeof计算结果才是它的参数，即11


Question: 关于一些指针内存操作和枚举结构赋值的问题？

嗯嗯 明白 谢谢各位

枚舉不是結構體，它衹是“列出可能的取值”，也就是説QUEUE_STATE定義之後，取值範圍及每一個成員代表的值就已經固定了。你再定義QUEUE_STATE類型的一個變量，這個變量就衹能在“HoldRequests，AllowRequests，FailRequests”之間取值，并不改變每一個成員所代表的值。

非常感谢第一个问题解决了，第二个还是有点不理解呢  “将QueueState 赋值为FailRequests对应的值，而不是将HoldRequests改为FailRequests”这句话意思是，赋值后，HoldRequests=2，AllowRequests=3，FailRequests=4了么？？？ 如果像2楼所说的QueueState 只是一个整数，QueueState 赋值为FailRequests，QueueState的值是2，那么我要是单独取QueueState.HoldRequests; QueueState.AllowRequests; QueueState.FailRequests那它们分别是多少？

1.是的，它们指向同一块内在地址  2.枚举中的HoldRequests等不是变量，只是一个值，你可自己指定为多少，如果没指定，HoldRequests为0， AllowRequests为1，FailRequests 为2，QueueState = FailRequests;相当于只是在赋值，将QueueState 赋值为FailRequests对应的值，而不是将HoldRequests改为FailRequests

問題1，沒錯，就是一樣的。 問題2，QueueState并沒有“第一個成員”這樣的説法，它衹取枚舉結構的其中一個值，也就是説QueueState其實是個整數。賦值后，QueueState的值是2。如果後面又有一句QueueState = HoldRequest，則它的值變爲0。

tmp 和interfaceList 指向同一个内存位置，因此tmp和interfaceList指针变量里存放的数值是一样的。  枚举变量QueueState可以理解成一个int类型的变量。而枚举列表可以理解为一个个的宏定义（整型的）。  QueueState = FailRequests;可以理解为宏定义给int类型赋值。

明白了。先确定范围和具体的值，在定义的该枚举类型变量，取值只能是其中之一。  非常感谢！！！


Question: 关于C++数据结构，结构体数组插入失败顺序表的问题，

引用 5 楼 hdt 的回复:newbase=(ElemType * )realloc(L.elem ,(L.listsize +LISTINCREMENT)*sizeof(ElemType));   [quote=引用 4 楼 yosenc 的回复:] [quote=引用 2 楼 hdt 的回复:] 我在另外的帖子里已经回复你了 既然用到了c++，比如string 应该用new 和delete代替malloc 和freemalloc 和free也通得过呀-[/quote] 编译没问题不代表运行没问题 你用了malloc,而你的结构里面有个string,用malloc，不能自动调用那个string的构造函数，因此那个string成员并没有构造好 ，所以后面的赋值将会出错。 而且你dele的时候，因为同理，不会调用string的析构函数，所以正常销毁string[/quote]了解，谢谢

newbase=(ElemType * )realloc(L.elem ,(L.listsize +LISTINCREMENT)*sizeof(ElemType));   引用 4 楼 yosenc 的回复:[quote=引用 2 楼 hdt 的回复:] 我在另外的帖子里已经回复你了 既然用到了c++，比如string 应该用new 和delete代替malloc 和freemalloc 和free也通得过呀-[/quote] 编译没问题不代表运行没问题 你用了malloc,而你的结构里面有个string,用malloc，不能自动调用那个string的构造函数，因此那个string成员并没有构造好 ，所以后面的赋值将会出错。 而且你dele的时候，因为同理，不会调用string的析构函数，所以正常销毁string

引用 2 楼 hdt 的回复:我在另外的帖子里已经回复你了 既然用到了c++，比如string 应该用new 和delete代替malloc 和freemalloc 和free也通得过呀-

引用 1 楼 cfjtaishan 的回复:#include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <string.h> #include <iostream>  using namespace std;  #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2  #define list_init_size 100   //线性表存储空间的初始分配量 #define LISTINCREMENT 10     //线性表存储空间的分配增量  typedef int Status;   typedef struct elem_type {     //string a;     //string nam;     char a[16];     char nam[16];     float pric;     int cot;     double alcot; }ElemType;  typedef struct sqlist{     ElemType *elem;          //存储空间基址     int length;              //当前长度     int listsize;            //当前分配的存储容量（以sizeof(ElemType)为单位） }SqList;  //构造一个空的线性表L Status InitList_Sq(SqList &L) {     L.elem = (ElemType * )malloc(list_init_size * sizeof(ElemType));     if(!L.elem )         exit(OVERFLOW);//存储分配失败     L.length = 0;               //空表长度为0     L.listsize = list_init_size;//初始存储容量     return OK; }//Initlist_Sq  //在顺序线性表L中第i个位置之前插入新的元素e， //i的合法值为1<=i<=ListLength_Sq(L)+1 Status ListInsert_Sq(SqList &L,int i,ElemType e) {     ElemType *p,*q,*newbase;        //定义指针      if(i < 1||i > L.length + 1)         return ERROR;               //i值不合法     if(L.length >= L.listsize ){     //当前存储空间已满，增加分配         newbase = (ElemType * )realloc(L.elem ,(L.listsize + LISTINCREMENT)*sizeof(ElemType));         if(!newbase)             exit(OVERFLOW); //存储分配失败         L.elem = newbase;            //新基址         L.listsize += LISTINCREMENT; //增加存储容量     }     if (i >= L.length) {         L.elem[L.length] = e;     } else {         q = &(L.elem[i-1]);              //q为插入位置         for(p = &(L.elem [L.length -1]);p > q; --p)             *(p+1) = *p;         *q = e;                           //插入e     }     ++L.length;                    //表长增1     return OK; }//ListInsert_Sq   void input_Elem(SqList k) {     for(int i=0;i<k.length;i++)         cout<<k.elem[i].a<<" "<<k.elem[i].nam<<" "<<k.elem[i].pric<<" "<<k.elem[i].cot<<" "<<endl; } int main() {     SqList l1;     InitList_Sq(l1);     ElemType ele[2];       //ele[0].a="a123";     //ele[0].nam="a1";     strcpy(ele[0].a, "a123");     strcpy(ele[0].nam, "a1");     ele[0].pric=3.6;     ele[0].cot=4;     ListInsert_Sq(l1,1,ele[0]);      //ele[1].a="a223";     //ele[1].nam="a2";     strcpy(ele[1].a, "a223");     strcpy(ele[1].nam, "a2");     ele[1].pric=3.3;     ele[1].cot=5;     ListInsert_Sq(l1, 2, ele[1]);      cout<<"first:"<<endl;     input_Elem(l1);     cout<<endl;     return 0; }  参考一下吧  验证了一下，若用string定义a和nam，在赋值操作时，即 *q = e; 会出现段错误； 换成char []数组后没问题。可以直接赋值。  另外，插入位置作为微调，问题是当length为0时，p = &(L.elem [L.length -1]) p指向的就是&(L.elem[-1]);所以做了修改。非常感谢！


Question: 初入茅庐的新手  来大神解答一下  急需！！！！

#include<stdio.h> #include<stdlib.h> #include<malloc.h>  #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define SIZE 10 #define STACK_INC_SIZE      5 typedef int Status;  typedef struct Car1{     int number;     int ar_time; }CarNode;  typedef struct{     CarNode *base;     CarNode *top;     int size;     int stacksize; }Park;  typedef struct Car2{     int number;     int ar_time;     struct Car2 *next; }*CarPtr;  typedef struct{     CarPtr front;     CarPtr rear;     int length; }Shortcut;  Status InitStack(Park &P) {     P.base = (CarNode*)malloc(SIZE*sizeof(Car1));     if(!P.base)         exit(OVERFLOW);     P.top = P.base;     P.size = SIZE;     P.stacksize = 0;     return OK; } Status Push(Park &P,CarNode e) {     if (P.top - P.base >= SIZE) {         P.base = (CarNode *)realloc(P.base,                 (P.size + STACK_INC_SIZE) * sizeof(Car1));         P.size += STACK_INC_SIZE;     }     *(P.top++) = e;     ++P.stacksize;      return OK; } Status Pop(Park &P,CarNode &e) {     if(P.top==P.base) {         printf("停车场为空.");         return OK;     }     e=*--P.top;     --P.stacksize;     return OK; } Status InitQueue(Shortcut &S) {     S.front=S.rear=(CarPtr)malloc(sizeof(Car2));     if(!S.front)         exit(OVERFLOW);     S.front->next=NULL;     S.length=0;     return OK; }  Status EnQueue(Shortcut &S,int number,int ar_time) {     CarPtr p;     p = (CarPtr)malloc(sizeof(Car2));     if(!p)         exit(OVERFLOW);     p->number=number;     p->ar_time=ar_time;     p->next = NULL;     S.rear->next = p;     S.rear=p;     ++S.length;     return OK; }  Status DeQueue(Shortcut &S,CarPtr &w) {     if(S.length == 0) {         printf("通道为空.");         return OK;     }     w = S.front->next;     S.front->next = S.front->next->next;     --S.length;     return OK; }  Status Arrival(Park &P,Shortcut &S) {     int number,ar_time;     printf("请输入车牌号：");     scanf("%d",&number);     printf("进场的时刻:");     scanf("%d",&ar_time);     if(P.stacksize<SIZE)     {         CarNode c;         c.number=number;         c.ar_time=ar_time;         Push(P,c);         printf("该车应停在第%d号车道.\n",P.stacksize);     }     else     {         EnQueue(S,number,ar_time);         printf("停车场已满,请暂时停在便道的第%d个位置.\n",S.length);     }     return OK; }  Status Leave(Park &P,Park &P1,Shortcut &S) {     int number,le_time,flag=1,money,ar_time;     printf("请输入车牌号：");     scanf("%d",&number);     printf("出场的时刻:");     scanf("%d",&le_time);     CarNode e,m;     CarPtr w;     while(P.stacksize)     {         Pop(P,e);         if(e.number==number)         {             flag=0;             money=(le_time-e.ar_time)*2;             ar_time=e.ar_time;             break;         }         Push(P1,e);     }     while(P1.stacksize)     {         Pop(P1,e);         Push(P,e);     }     if (flag == 0)     {         if(S.length!=0)         {             DeQueue(S,w);             m.ar_time=le_time;             m.number=w->number;             Push(P,m);             free(w);             printf("车牌号为%d的车已由便道进入停车场\n",m.number);         }         printf("停车费为%d, 占用车位数为%d\n",money,P.stacksize);     }     else     {         printf("停车场不存在牌号为%d的车\n", number);     }     return OK; } int main() {     int m=1;     char flag = 0;     Park P,Q;     Shortcut S;     InitStack(P);     InitStack(Q);     InitQueue(S);     while(m)     {         printf("\n 停车场管理程序 \n");         printf("\n");         printf("请选择(A,D,E): ");         scanf("%c",&flag);         switch(flag)         {             case 'A':             case 'a':                 Arrival(P,S);break;             case 'D':             case 'd':                 Leave(P,Q,S);break;             case 'E':             case 'e':                 m=0;                 break;             default:                 printf("Input error!\n");                 break;         }         getchar();         /*         printf("请选择(A,D,E): ");         while (flag != '\n')             scanf("%c",&flag);             */     } } 参考一下吧


Question: 提问

引用 4 楼 rng_nb 的回复:一楼什么鬼，发错了吧。代码应该没问题吧，按你发我的那几张要求图做的。

一楼什么鬼，发错了吧。

如果编写批处理文件（Windows）或者sh文件（Linux），可以利用程序的返回值（退出值）来判断程序的执行结果，以便批处理的流程处理。

是有区别的，exit(0), exit(1);都是退出当前进程；参数0, 1表示退出的状态，0一般是正常退出，其他都是非正常退出；可以通过退出的状态判别进程是因为什么退出的。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h>  #define NAMELEN 10 #define COURSES 4  typedef struct stu_info{ 	char stu_name[NAMELEN]; 	int id, score[COURSES]; 	float avgScoure; 	struct stu_info *next; }STU_INFO;  static STU_INFO DefaultList[5] = { 	{ 		"Alice", 		1, 		{90, 80, 88, 70}, 		82.0f, 		NULL 	}, 	{ 		"Bob", 		2, 		{88, 30, 78, 77}, 		68.3f, 		NULL 	}, 	{ 		"Carol", 		3, 		{90, 95, 90, 100}, 		93.8f, 		NULL 	}, 	{ 		"Geek", 		4, 		{100, 98, 100, 100}, 		99.5f, 		NULL 	}, 	{ 		"Dave", 		5, 		{59, 59, 59, 59}, 		59.0f, 		NULL 	} };  #define MainMenu() do{\ 					printf("*******************Main Menu********************\n");\ 					printf("			1.Show Current List\n");\ 					printf("			2.Insert Student\n");\ 					printf("			3.Delete Student\n");\ 					printf("			4.Search Student\n");\ 					printf("			5.Alanyze Course\n");\ 					printf("			6.Exit The Program\n");\ 					printf("*************************************************\n");\ 				}while(0);  #define Flush() do{\ 					int ch;\ 					while((ch = getchar()) != '\n' && ch != EOF);\ 				}while(0);   #define Push(Next, Node) do{\ 							Next = Node;\ 						}while(0);	  #define CreateDefaultList(L) do{\ 								Push(DefaultList[3].next, &DefaultList[4]);\ 								Push(DefaultList[2].next, &DefaultList[3]);\ 								Push(DefaultList[1].next, &DefaultList[2]);\ 								Push(DefaultList[0].next, &DefaultList[1]);\ 								Push(L->next, &DefaultList[0]);\ 							}while(0);  void SortByAvg(STU_INFO *L) { 	int i, j, sorted, size = 0; 	STU_INFO *t, *curNode, *nextNode, *nextnextNode;  	for(t = L->next; t != NULL; t = t->next, size++); 	 	for(i = 0; i < size - 1; ++i){ 		sorted = 0;  		for(j = 0, curNode = L; j < size - 1 - i; ++j, curNode = curNode->next){ 			nextNode = curNode->next; 			nextnextNode = nextNode->next;  			if(nextNode->avgScoure < nextnextNode->avgScoure){ 				nextNode->next = nextnextNode->next; 				nextnextNode->next = nextNode; 				curNode->next = nextnextNode; 				 				sorted = 1; 			} 		}  		if(!sorted){ 			break; 		} 	} }  void ShowCurrentList(STU_INFO *L) { 	STU_INFO *t; 	int opt;  	do{ 		printf("Please Select The Show Mode :\n1>. Default				2>. Sorted\n"); 		scanf("%d", &opt); 	}while(system("clear"), opt != 1 && opt != 2);  	Flush(); 	if(opt == 2){ 		SortByAvg(L); 	}  	printf("************************************************LIST INFO**********************************************\n"); 	printf("ID		Name		CO1		CO2		CO3		CO4		Avg\n"); 	for(t = L->next; t != NULL; t = t->next){ 		printf("%d		%s		%d		%d		%d		%d		%.1f\n",	 				t->id, t->stu_name, t->score[0], t->score[1], t->score[2], t->score[3], t->avgScoure); 	} 	printf("*******************************************************************************************************\n"); }  void InsertStudent(STU_INFO *L) { 	STU_INFO *t, *node;  	for(t = L; t->next != NULL; t = t->next); 	node = malloc(sizeof(STU_INFO)); 	if(node == NULL){ 		return; 	}  	printf("Please Enter The Information Of The Student To Add :\n"); 	scanf("%d%d%d%d%d", &node->id, &node->score[0], &node->score[1], &node->score[2], &node->score[3]); 	node->avgScoure = ((float)(node->score[0] + node->score[1] + node->score[2] + node->score[3])) / 4; 	Flush(); 	fgets(node->stu_name, sizeof(node->stu_name), stdin); 	node->stu_name[strlen(node->stu_name) - 1] = '\0'; 	node->next = NULL; 	 	Push(t->next, node); 	system("clear"); 	ShowCurrentList(L); }  void DeleteStudent(STU_INFO *L) { 	STU_INFO *t, *node = NULL; 	int id;  	printf("Please Enter The ID Of The Student To Delete :\nID = "); 	scanf("%d", &id); 	Flush();  	for(t = L; t->next != NULL; t = t->next){ 		if(t->next->id == id){ 			node = t->next; 			t->next = node->next; 			break; 		} 	}  	if(node == NULL){ 		printf("Student ID <%d> Not Found.\n", id); 		return; 	} 	printf("Delete operation complete.\n");  	if(node->id >= 6){ 		free(node); 	}  	getchar(); 	system("clear"); 	ShowCurrentList(L); }  void SearchStuent(STU_INFO *L) { 	STU_INFO *t; 	char name[NAMELEN] = "";  	printf("Please Enter The Name Of The Student To Search :\nName = "); 	fgets(name, sizeof(name), stdin); 	name[strlen(name) - 1] = '\0';  	for(t = L->next; t != NULL; t =	t->next){ 		if(strncmp(name, t->stu_name, strlen(t->stu_name)) == 0){ 			printf("Student Info:\n"); 			printf("ID		Name		CO1		CO2		CO3		CO4		Avg\n"); 			printf("%d		%s		%d		%d		%d		%d		%.1f\n",	 					t->id, t->stu_name, t->score[0], t->score[1], t->score[2], t->score[3], t->avgScoure); 			return; 		} 	}  	printf("Student <%s> Not Found.\n"); }  void AnalyzeCourse(STU_INFO *L) { 	STU_INFO *t; 	int i, min, max, sumno = 0, passno = 0; 	float avg = 0.0f, passrate = 0.0f;  	printf("Please Enter The ID Of The Course To Analyze :\n"); 	scanf("%d", &i); 	Flush();  	for(t = L->next, min = max = t->score[i - 1]; t != NULL; t = t->next){ 		if(t->score[i - 1] > max){ 			max = t->score[i - 1]; 		} 		if(t->score[i - 1] < min){ 			min = t->score[i - 1]; 		}  		avg += t->score[i - 1]; 		sumno++;  		if(t->score[i - 1] >= 60){ 			passno++; 		} 	} 	avg /= sumno; 	passrate = (float)passno / sumno;  	printf("Course Info of CO%d :\n", i); 	printf("Max = %d\n", max); 	printf("Min = %d\n", min); 	printf("Avg = %.1f\n", avg); 	printf("PassingRate = %.1f\n", passrate); }  void ExitTheProgram(STU_INFO **L) { 	STU_INFO *t, *preNode; 	 	do{ 		for(t = (*L); t->next != NULL; t = t->next); 		 		if(t != *L){		 			for(preNode = (*L); preNode->next != t; preNode = preNode->next); 			preNode->next = t->next; 			if(t->id >= 6){ 				free(t); 			} 		} 	}while(t != *L);  	free(*L);  	printf("Thanks To Use The Program.\n"); }  int main(void) { 	STU_INFO *stuinfo = malloc(sizeof(STU_INFO)); 	assert(stuinfo != NULL);  	memset(stuinfo, 0, sizeof(STU_INFO));  	CreateDefaultList(stuinfo);  	int mainopt;  	void (*SubMenu[])(STU_INFO *) = { 		ShowCurrentList, 		InsertStudent, 		DeleteStudent, 		SearchStuent, 		AnalyzeCourse 	};  	while(1){ 		do{ 			system("clear"); 			MainMenu();  			printf("\nPlease Enter A Number Between 1 and 6 :\nYou Choose Menu no = "); 			scanf("%d", &mainopt); 			Flush(); 		}while((mainopt < 1 || mainopt > 6) && (system("clear"), printf("Sorry, Please Try Again\n"), getchar())); 		 		if(mainopt != 6){ 			system("clear"); 			SubMenu[mainopt - 1](stuinfo); 		}else{ 			ExitTheProgram(&stuinfo); 			break; 		}  		getchar(); 	}  	return 0; }


Question: C语言不输入任何指令按回车就会正常输出一个人的信息然后录入，输入任何指令就会直接跳出两个人的信息

rewind(stdin);

在scanf("%c“， &stu1[i].record);前加一条语句getchar();用于接收上次输入之后残留在输入缓存里的换行符'\n'； 所有的scanf("%c", &xxx);前面建议根据需要都加getchar();若前面有其他输入，建议加上getchar();否则可以考虑不加；  另外，你的问题恰恰说明fflush(stdin);没有起作用。所以用getchar();替换fflush(stdin);

运行截图


Question: 如何获取微信数据包，，如何确定是手机登录微信，还是PC端

网络传输的数据可以使用抓包工具获取（tcpdump，wireshark，...）


Question: 大佬，我想用easyx实现“一个气球，点鼠标左键气球消失，用文字显示气球爆了，同时气球消失”怎么改。

自己解决了。

哇，赵四老师还在这个论坛，我几乎是看着你的帖子学习的~~

百度搜相关关键字。

这是我修改后的代码    // 气球.cpp : Defines the entry point for the console application. //  #include "stdafx.h"  #include "graphics.h" #include <stdlib.h> #include <time.h> #include <stdlib.h> int main(int argc, char* argv[]) { 		     	initgraph(640, 480);         //显示宽为640,高为480的屏幕 	    int x = 320; 	    int y = 240; 		while(true) 		{ 	    MOUSEMSG m;                 //鼠标信息结构体           m = GetMouseMsg();  		switch (m.uMsg)            //鼠标信息 		{ 			 		case WM_LBUTTONDOWN:                 //左键按下 			{ 			  				BeginBatchDraw(); 				IMAGE img1; 				loadimage(&img1, "气球爆了.jpg", 400, 400);  //显示图片 				putimage(100, 100, &img1);   				FlushBatchDraw(); 				EndBatchDraw(); 			  			 			} 		break; 		 		case WM_RBUTTONDOWN:                    //右键按下 			{ 			 					for(y=480;y>0-190;y--) 					{ 						BeginBatchDraw(); 						ellipse(x,y,x+80,y+110);     //画气球头部 						 						line(x+40, y+110, x+40,y+220);    //画气球尾部 						FlushBatchDraw(); 						cleardevice(); 						Sleep(2); 						EndBatchDraw(); 				} 				  			} 			break;  		}		 		} 	 	 		 		system("pause"); 	    closegraph();     	return 0; }


Question: 有没有研究过unimrcp的朋友，碰到一个比较急的问题，求解决

不知道有多少前人掉在TCP Socket send(人多)send(病少)send(财富) recv(人多病)recv(少财富) 陷阱里面啊！ http://bbs.csdn.net/topics/380167545

mrcp服务器开发，demo,能推荐一点资料吗？谢谢

不是网络导致的丢包，应该是程序本身的问题，我们在这边抓包是没有丢包的。

丢包是不是网络动荡导致的，即网络不好时，来的包都能收到，当网络不好时来的包忽然增多（之前网络不好时在路上的包也一并来了），然后处理模块没有来得及处理导致的丢包；这儿提到的网络是互联网，大网的情况。 如果是网络动荡导致的丢包，可以考虑用缓存环解决。


Question: 泛型宏的代码判断大小

这里已经说的比较详细了，看不懂再回复  http://blog.csdn.net/xiaofeng_yan/article/details/5248693

引用 1 楼 hefashion0190 的回复:a = min(10, 5) ==>  a = _min1 < _min2 ? _min1 : _min; 你说的我当然知道，能解释下(void) (&_min1 == &_min2);吗？