Question: 自己用easyx写的2048，没有加界面的时候WASD控制都是正确的，加了界面之后，WASD控制的方向就混乱了

case 'a':                     case 'A':moveup();break;                     case 'w':                     case 'W':moveleft();break;                     case 'd':                     case 'D':movedown();break;                     case 's':                     case 'S':moveright();break;                     default :printf("\a");

不过你逻辑好像有问题 我玩了一下遇到bug了

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

这是代码 #include <graphics.h> #include <easyx.h> #include <conio.h> #include <stdio.h> #include <stdlib.h> #include <time.h> #pragma comment(lib,"Winmm.lib") int num[4][4]={{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}}; int score=0;//  void start1() { 	Sleep(1000); 	setfillcolor(RGB(255,255,255)); 	solidrectangle(0,0,700,700); 	settextstyle(50, 20,"华文新魏"); 	settextcolor(MAGENTA); 	setbkmode(TRANSPARENT); 	outtextxy(80,10,"欢迎试玩由金依编写的游戏"); 	outtextxy(300,60,"2048"); 	Sleep(1000); 	outtextxy(50,110,"尽情挑战更大的合成数字吧~~"); 	Sleep(1000); 	outtextxy(50,500,"点击任意地方继续"); } //开始界面 void hellowin() { 	setfillcolor(LIGHTBLUE); 	solidrectangle(0,0,700,700); 	settextcolor(WHITE); 	setbkmode(TRANSPARENT); 	settextstyle(50, 20,"华文彩云",0,0,200,0,0,0); 	outtextxy(225,100,"2"); 	outtextxy(275,50,"0"); 	outtextxy(375,50,"4"); 	outtextxy(425,100,"8"); 	setfillcolor(RGB(181,230,29)); 	solidroundrect(225,200,425,300,20,20); 	settextcolor(BLACK); 	outtextxy(275,225,"开始"); 	setfillcolor(RGB(0,255,255)); 	solidroundrect(225,350,315,450,20,20);//打开音乐 	solidroundrect(335,350,425,450,20,20);//关闭音乐 	settextcolor(WHITE); 	settextstyle(30, 20,"楷体",0,0,200,0,0,0); 	outtextxy(100,375,"MUSIC"); 	settextstyle(50, 20,"华文彩云",0,0,200,0,0,0); 	outtextxy(240,375,"ON"); 	outtextxy(340,375,"OFF"); 	setfillcolor(RGB(255,255,0)); 	solidroundrect(225,500,425,600,20,20); 	settextcolor(BLACK); 	outtextxy(275,525,"退出"); } //游戏界面 void clear() { 	int x,y; 	setfillcolor(RGB(153,217,234)); 	solidrectangle(0,0,700,700); 	settextstyle(50, 50,"宋体"); 	settextcolor(GREEN); 	setbkmode(TRANSPARENT); 	outtextxy(200,10,"2048"); 	settextstyle(20, 10,"微软雅黑"); 	settextcolor(BLACK); 	outtextxy(0,550,"游戏规则："); 	outtextxy(0,570,"1.W、A、S、D控制移动，W-左，A-上，S-右，D-下"); 	outtextxy(0,590,"2.当数字相同的色块相邻并且向此方向移动时两色块合并"); 	outtextxy(0,610,"3.当合成2048时，挑战成功"); 	outtextxy(0,630,"4.当没有空位并且没有相同的色块相邻时，游戏结束"); 	outtextxy(550,100,"合成分数:"); 	for(x=100;x<500;x+=100) 	{ 		for(y=100;y<500;y+=100) 		{ 			if((x/100)%2==1) 			{ 				if((y/100)%2==1) 				{ 					setfillcolor(RGB(255,188,121)); 					solidrectangle(x,y,x+100,y+100); 				}else{ 					setfillcolor(RGB(255,142,30)); 					solidrectangle(x,y,x+100,y+100); 				} 			}else{ 				if((y/100)%2==1) 				{ 					setfillcolor(RGB(255,142,30)); 					solidrectangle(x,y,x+100,y+100); 				}else{ 					setfillcolor(RGB(255,188,121)); 					solidrectangle(x,y,x+100,y+100); 				} 			} 		} 	} }  //产生随机数 int randnum(int x) { 	int a; 	a=rand()%x; 	return a; }  //判断游戏是否结束,结束返回0，否则返回1 int gamefail() { 	int i,j,l=0;        	for(i=0;i<4;i++) 	{ 		for(j=0;j<4;j++) 		{ 			if(num[i][j]!=0) 				l++;   //l记录非空白格的个数  		} 	} 	//判断 	if(l!=16) 	{ 		return 1; 	}else{ 		l=0;   //l记录是否有相邻的数字相同  		//从上往下 		for(j=0;j<4;j++) 		{ 			for(i=1;i<3;i++) 			{ 				if((num[i][j]==num[i+1][j])||(num[i][j]==num[i-1][j])) 				{ 					l++; 					break; 				} 			} 			if((num[i][j]==num[i+1][j])||(num[i][j]==num[i-1][j])) 				break; 		} 		if(l!=0) 			return 1; 		else 		{	 			l=0; 			for(i=0;i<4;i++) 			{ 				for(j=1;j<3;j++) 				{ 					if((num[i][j]==num[i][j+1])||(num[i][j]==num[i][j-1])) 					{ 						l++; 						break; 					} 				} 				if((num[i][j]==num[i][j+1])||(num[i][j]==num[i][j-1])) 					break; 			} 			if(l!=0) 				return 1; 			else 				return 0; 		} 	} }  //初始化 void start() { 	int x1,y1;//初始随机坐标 	int r;//随机数 	int i,j; 	x1=randnum(4); 	y1=randnum(4); 	r=randnum(10); 	if(r==9) 	{ 		num[x1][y1]=4; 	}else{ 		num[x1][y1]=2; 	} 	i=randnum(4); 	j=randnum(4); 	while(num[i][j]!=0) 	{ 		i=randnum(4); 		j=randnum(4); 	} 	r=randnum(10); 	if(r==9) 	{ 		num[i][j]=4; 	}else{ 		num[i][j]=2; 	} }  void randr() { 	int i,j,r; 	i=randnum(4); 	j=randnum(4); 	while(num[i][j]!=0) 	{ 		i=randnum(4); 		j=randnum(4); 	} 	r=randnum(10); 	if(r==9) 		num[i][j]=4; 	else 		num[i][j]=2; }  void moveup() { 	int i,j,k,l; 	int temp[4]={0,0,0,0};       //间接转换 	//将原来的数组中的非零数相邻放置 	for(j=0;j<4;j++) 	{ 		l=0; 		for(i=0;i<4;i++) 		{ 			for(k=0;k<3;k++) 			{ 				if(num[k][j]==0) 				{ 					num[k][j]=num[k+1][j]; 					num[k+1][j]=0; 				}else	 					l++; 				if(l==4) 					break; 			} 		} 	} 	//将数组的列转入中间变量并移动、相加 	for(j=0;j<4;j++) 	{ 		k=0; 		for(i=0;i<4;i++) 		{ 			if(i==3) 			{ 				temp[k++]=num[i][j]; 				num[i][j]=0; 			}else{ 				if(num[i][j]!=num[i+1][j]&&num[i][j]!=0) 				{ 					temp[k++]=num[i][j]; 					num[i][j]=0; 				}else if(num[i][j]==num[i+1][j]) 				{ 					temp[k++]=num[i][j]+num[i+1][j]; 					score+=temp[k-1];//计算得分 					num[i][j]=num[i+1][j]=0; 				} 			} 		} 		for(i=0;i<4;i++) 			num[i][j]=temp[i]; 	} }  void moveleft() { 	int i,j,k,l; 	int temp[4]={0,0,0,0}; 	for(i=0;i<4;i++) 	{ 		l=0; 		for(j=0;j<4;j++) 		{ 			for(k=0;k<3;k++) 			{ 				if(num[i][k]==0) 				{ 					num[i][k]=num[i][k+1]; 					num[i][k+1]=0; 				}else	 					l++; 				if(l==4) 					break; 			} 		} 	} 	for(i=0;i<4;i++) 	{ 		k=0; 		for(j=0;j<4;j++) 		{ 			if(j==3) 			{ 				if(num[i][j]!=0) 				{ 					temp[k++]=num[i][j]; 					num[i][j]=0; 				} 			}else{ 				if(num[i][j]!=num[i][j+1]&&num[i][j]!=0) 				{ 					temp[k++]=num[i][j]; 					num[i][j]=0; 				}else if(num[i][j]==num[i][j+1]) 				{ 					temp[k++]=num[i][j]+num[i][j+1]; 					score+=temp[k-1]; 					num[i][j]=num[i][j+1]=0; 				} 			} 		} 		for(j=0;j<4;j++) 		{ 			num[i][j]=temp[j]; 		} 	} }  void movedown() { 	int i,j,k,l; 	int temp[4]={0,0,0,0}; 	for(j=0;j<4;j++) 	{ 		l=0; 		for(i=3;i>=0;i--) 		{ 			for(k=3;k>0;k--) 			{ 				if(num[k][j]==0) 				{ 					num[k][j]=num[k-1][j]; 					num[k-1][j]=0; 				}else 					l++; 				if(l==4) 					break; 			} 		} 	} 	for(j=0;j<4;j++) 	{ 		k=3; 		for(i=3;i>=0;i--) 		{ 			if(i==0) 			{ 				if(num[i][j]!=0) 				{ 					temp[k--]=num[i][j]; 					num[i][j]=0; 				} 			}else{ 				if(num[i][j]!=num[i-1][j]&&num[i][j]!=0) 				{ 					temp[k--]=num[i][j]; 					num[i][j]=0; 				}else if(num[i][j]==num[i-1][j]) 				{ 					temp[k--]=num[i][j]+num[i-1][j]; 					score+=temp[k+1]; 					num[i][j]=num[i-1][j]=0; 				} 			} 		} 		for(i=3;i>=0;i--) 			num[i][j]=temp[i]; 	} }  void moveright() { 	int i,j,k,l; 	int temp[4]={0,0,0,0}; 	for(i=0;i<4;i++) 	{ 		l=0; 		for(j=3;j>=0;j--) 		{ 			for(k=3;k>0;k--) 			{ 				if(num[i][k]==0) 				{ 					num[i][k]=num[i][k-1]; 					num[i][k-1]=0; 				}else	 					l++; 				if(l==4) 					break; 			} 		} 	} 	for(i=0;i<4;i++) 	{ 		k=3; 		for(j=3;j>=0;j--) 		{ 			if(j==0) 			{ 				if(num[i][j]!=0) 				{ 					temp[k--]=num[i][j]; 					num[i][j]=0; 				} 			}else{ 				if(num[i][j]!=num[i][j-1]&&num[i][j]!=0) 				{ 					temp[k--]=num[i][j]; 					num[i][j]=0; 				}else if(num[i][j]==num[i][j-1]) 				{ 					temp[k--]=num[i][j]+num[i][j-1]; 					score+=temp[k+1]; 					num[i][j]=num[i][j-1]=0; 				} 			} 		} 		for(j=0;j<4;j++) 			num[i][j]=temp[j]; 	} }  int max1() { 	int i,j,m=num[0][0]; 	for(i=0;i<4;i++) 	{ 		for(j=0;j<4;j++) 		{ 			if(num[i][j]>m) 				m=num[i][j]; 		} 	} 	return m; }  void success() { 	system("cls"); 	setfillcolor(WHITE); 	solidrectangle(0,0,700,700); 	settextcolor(RED); 	settextstyle(50, 20,"华文新魏"); 	outtextxy(300,300,"你赢了！！！"); } void fail() { 	system("cls"); 	setfillcolor(WHITE); 	solidrectangle(0,0,700,700); 	settextcolor(RED); 	settextstyle(50, 20,"华文新魏"); 	outtextxy(300,300,"GAME OVER"); }  void output() { 	int i,j,k=0; 	char a[16][5]; 	char score1[8]; 	for(i=0;i<4;i++) 		for(j=0;j<4;j++) 		{ 			settextstyle(30, 10,"楷体"); 			settextcolor(BLUE); 			sprintf(a[k],"%d",num[i][j]); 			if(num[i][j]!=0) 			outtextxy(100+i*100+50,100+j*100+50,a[k]); 			k++; 		} 	settextstyle(20, 10,"微软雅黑"); 	sprintf(score1,"%d",score); 	settextcolor(RED); 	outtextxy(550,120,score1); }  void main() { 	initgraph(700,700); 	MOUSEMSG m; 	int i,j,k=0,l=0; 	int move; 	int num1[4][4]; 	char c; 	srand((unsigned)time(NULL)); 	mciSendString("open music.mp3 alias mymusic",NULL,0,NULL); 	mciSendString("open 合成音效.wav alias mymusic",NULL,0,NULL); 	mciSendString("open 未移动.wav alias mymusic",NULL,0,NULL); 	mciSendString("play mymusic repeat",NULL,0,NULL); 	start1(); 	FlushMouseMsgBuffer();//清除鼠标信息 	while(1) 	{ 		m=GetMouseMsg(); 		if(m.uMsg==WM_LBUTTONDOWN) 		{	 			break; 		} 	} 	setfillcolor(RGB(255,255,255)); 	solidrectangle(0,0,700,700); 	settextcolor(LIGHTRED); 	settextstyle(50, 20,"华文新魏"); 	outtextxy(25,200,"本游戏是作者做的第一个游戏"); 	Sleep(1000); 	outtextxy(25,300,"有瑕疵，请谅解O(∩_∩)O"); 	Sleep(1000); 	outtextxy(25,400,"本游戏最终解释权归作者所有"); 	Sleep(1500); 	FlushMouseMsgBuffer(); 	hellowin(); 	while(1) 	{ 		m=GetMouseMsg(); 		if(m.uMsg==WM_LBUTTONDOWN) 		{	 			if((m.x>=225&&m.x<=425)&&(m.y>=200&&m.y<=300)) 			{//点击“开始” 				clear(); 				break; 			}if((m.x>=225&&m.x<=425)&&(m.y>=500&&m.y<=600)) 			{//点击“退出” 				return ; 			} 			if(m.y>=350&&m.y<=450) 			{ 				if(m.x>=225&&m.x<=315) 				{ 					mciSendString("play mymusic repeat",NULL,0,NULL);	 				} 				else if(m.x>=335&&m.x<=425) 				{ 					mciSendString("stop mymusic",NULL,0,NULL); 				} 			} 		} 	} 		//初始化 			do 			{ 				for(i=0;i<4;i++) 				{ 					for(j=0;j<4;j++) 					{ 						num[i][j]=0; 					} 				} 				start(); 				for(i=0;i<4;i++) 				{ 					for(j=0;j<4;j++) 					{ 						if(num[i][j]!=0) 							l++; 					} 				} 			}while(l!=2); 			output(); 			while(gamefail()) 			{ 				move=0; 				//判断如何移动 				for(i=0;i<4;i++) 				{ 					for(j=0;j<4;j++) 					{ 						num1[i][j]=num[i][j]; 					} 				} 				c=getch(); 				switch(c) 				{ 					case 'w': 					case 'W':moveup();break; 					case 'a': 					case 'A':moveleft();break; 					case 's': 					case 'S':movedown();break; 					case 'd': 					case 'D':moveright();break; 					default :printf("\a"); 				} 				for(i=0;i<4;i++) 				{ 					for(j=0;j<4;j++) 					{ 						if(num1[i][j]==num[i][j]) 							move++; 						else 							break; 					} 					if(num1[i][j]!=num[i][j]) 						break; 				} 				if(move!=16) 				{ 					//在空白地方产生一个随机数 					randr(); 					clear(); 					mciSendString("stop 合成音效.wav",NULL,0,NULL); 					mciSendString("play 合成音效.wav",NULL,0,NULL); 					output();//输出 				}else{ 					mciSendString("stop 未移动.wav",NULL,0,NULL); 					mciSendString("play 未移动.wav",NULL,0,NULL); 				} 				if(max1()==2048) 				{ 					success(); 					break; 				} 	} 	if(gamefail()&&max1()!=2048) 		fail(); 	getch();	 }


Question: 内存对齐问题

网搜“内存对齐”，不要太纠结……

引用 4 楼 u012578046 的回复:[quote=引用 1 楼 sholber 的回复:] 对齐这件事，和编译器有关。实际上，说起来影响到对齐的因素太多了…… 不对，你这是结构的大小，不是对齐啊。结构的大小同样和编译器有关，影响结构大小的因素太多了……哈哈[/quote]  嘎嘎~

引用 6 楼 my_live_123 的回复:gcc可指定对齐方式：__attribute__((aligned(4)))  嘎哈用它。嘎哈不用_Alignas

就是union变量占用内存字节数不同，union变量是以大的为准 恩，差了四字节，我也觉得是union变量的对齐方式的问题，不过楼主还要去查查资料，我也吃不准 还有就是，楼主，现在我们高级语言，其实不太在乎这点字节数，如果不是特别重要，可以不纠结这个的

引用 1 楼 sholber 的回复:对齐这件事，和编译器有关。实际上，说起来影响到对齐的因素太多了…… 不对，你这是结构的大小，不是对齐啊。结构的大小同样和编译器有关，影响结构大小的因素太多了……哈哈

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

VC 项目属性可以设置对齐的是4字节，还是8字节的


Question: 【求助】C语言关于pow函数问题

什么编译器？？

改成这样试试 fenmu=fenmu+9*(int)(pow(10,i) + 0.5);

C  中的 double 与 int 的转换问题 比为安全点的做法就类似 2楼 那样。+0.5 再(int)  这问题比较坑人........  #include <stdio.h> #include <math.h>  int main(int argc, char *argv[]) { 	int i;  	double a; 	int b; 	int c; 	int d;  	printf("\n%-20s%-20s%-20s%s\n", "double:a", "implicit(int):b", "explicit(int):c", "implicit(int):d"); 	printf("-----------------------------------------------------------------------------------------\n");  	for (i=0; i<8; ++i) { 		a = pow(10, i);		 		b = pow(10, i);		// 隐式 double --> int 		c = (int)a;			// 显式 double --> int 		d = a;				// 这个也是隐式  		printf("%-20lf", a); 		printf("%-20d",  b); 		printf("%-20d",  c); 		printf("%d\n",   d); 	}  	return 0; }  结果会令人有些费解 :  double:a            implicit(int):b     explicit(int):c     implicit(int):d ----------------------------------------------------------------------------------------- 1.000000            1                   1                   1 10.000000           10                  10                  10 100.000000          99                  100                 100 1000.000000         1000                1000                1000 10000.000000        9999                10000               10000 100000.000000       100000              100000              100000 1000000.000000      1000000             1000000             1000000 10000000.000000     9999999             10000000            10000000

理论上不应该是99999999？


Question: 无法将HttpWebRequest转换为HttpWebRequest这怎么回事啊？哪位大哥指定下

是啊我也纳闷啊一样的还提示要转换啥原因啊C#的

你题目是啥。。。他们都是一样的还要转啥。。 要转换，那就强制转换 PS：你这个是java吧。


引用 3 楼 hh794362661 的回复:引用需要定义Host字段 http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html  我的http请求中有Host字段，无论写成IP地址还是域名形式都不行。而且返回的是403Forbidden。 不过看了你给的网址，在GET方法后我用绝对路径请求资源（根据文档，此时Host字段会被忽略），似乎可以访问了。但返回响应时我只能接收到一部分数据。 我把read()函数放在while循环里，直到read()返回-1或0退出循环。我想问下，read()返回0，是表示传输层的数据报或报文段读取完毕了，还是整个http响应都读取完了？谢谢。  你需要按照http协议接受数据，具体接受方法也看http数据传输类型。 http://blog.csdn.net/zhangboyj/article/details/6236780

楼上正解，如果你用IP访问，需要在HTTP协议头部加上Host字段行就可以了

需要定义Host字段 http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html  引用14.23 Host  The Host request-header field specifies the Internet host and port number of the resource being requested, as obtained from the original URI given by the user or referring resource (generally an HTTP URL,  as described in section 3.2.2). The Host field value MUST represent the naming authority of the origin server or gateway given by the original URL. This allows the origin server or gateway to differentiate between internally-ambiguous URLs, such as the root "/" URL of a server for multiple host names on a single IP address.         Host = "Host" ":" host [ ":" port ] ; Section 3.2.2  A "host" without any trailing port information implies the default port for the service requested (e.g., "80" for an HTTP URL). For example, a request on the origin server for <http://www.w3.org/pub/WWW/> would properly include:         GET /pub/WWW/ HTTP/1.1        Host: www.w3.org  A client MUST include a Host header field in all HTTP/1.1 request messages . If the requested URI does not include an Internet host name for the service being requested, then the Host header field MUST be given with an empty value. An HTTP/1.1 proxy MUST ensure that any request message it forwards does contain an appropriate Host header field that identifies the service being requested by the proxy. All Internet-based HTTP/1.1 servers MUST respond with a 400 (Bad Request) status code to any HTTP/1.1 request message which lacks a Host header field.  See sections 5.2 and 19.6.1.1 for other requirements relating to Host.


Question: 初学c，不是很理解，希望帮忙注释下

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

计算机各种语言都差不多，C, VB ,C++ ,JAVA ,PYTHON , 我都知道一点，精华在算法上，算法很重要，自己曾写过一个HASH算未法，动态查找速度真的太快了！。别人写的代码给翻译出算法描述了，这个很难。单步执行，再自己画图吧。肯定能搞出来 。

约瑟夫环是个老问题，把思路理清楚，做出来并不难。

上次还在CSDN和别人讨论约瑟夫环，但这次又忘记什么叫约瑟夫环了。老了，真的是不行了。

楼主，我认为学c需要自己多看书。先按照别人写在熟悉一下。慢慢地理解就知道自己下次该怎么做了。个人观点

楼主先熟悉爱它的数据结构吧

未出现在出局列表中的即是最后留下来的人

输入总人数：21 输入共有数：7

注释如下：  #include <stdlib.h> #include <stdio.h> struct node{ 	int out; 	struct node *next; }node, *list, *p, *r; void YUESEFU(int a, int b) { 	int i, j; 	list = NULL; 	//这个for循环构建链表 	for (i = 1; i <= a; i++) 	{ 		p = (struct node*)malloc(sizeof(node)); 		p->out = i;  //每个人的编号：1,2,……,a 		if (list == NULL) 			list = p; 		else 			r->next = p; 		r = p; 	} 	p->next = list;   //首尾相连，构成一个环 	p = list; 	for (i = 1; i <= a; i++)   //打印链表 	{ 		printf("%d  ", p->out); 		p = p->next; 	} 	printf("\n"); 	p = list;    //加一句，让p重新指向链表开头 	for (i = 1; i<a; i++) 	{ 		for (j = 1; j<b; j++)  //从1数到b 		{ 			r = p;    //r记录出局人的前驱 			p = p->next; 		} 		printf("出局人:%d\n", p->out); 		r->next = p->next;   //出局，链表中删除节点的操作 		p = p->next;  //从出局人的下一个人开始数 	} } void main() { 	int z1, z2; 	printf("请输入总人数:"); 	scanf("%d", &z1); 	printf("请输入共有数:"); 	scanf("%d", &z2); 	YUESEFU(z1, z2); } //请输入总人数:请输入共有数:1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20  21 //出局人 : 7 //出局人 : 14 //出局人 : 21 //出局人 : 8 //出局人 : 16 //出局人 : 3 //出局人 : 12 //出局人 : 1 //出局人 : 11 //出局人 : 2 //出局人 : 15 //出局人 : 6 //出局人 : 20 //出局人 : 18 //出局人 : 17 //出局人 : 19 //出局人 : 5 //出局人 : 13 //出局人 : 4 //出局人 : 9


Question: 如何将特定列的数值对齐

非常感谢，写出来了！！！！  引用 4 楼 zhangxiangDavaid 的回复:这样可好：  FILE *fi, *fo; double d1, d2, d3; int r; int main(void) { 	if (NULL == (fi = fopen("1.txt", "r"))) 	{ 		fprintf(stderr, "Can not open file : 1.txt\n"); 		return 1; 	} 	if (NULL == (fo = fopen("2.txt", "w"))) 	{ 		fprintf(stderr, "Can not open file : 2.txt\n"); 		fclose(fi); 		return 1; 	} 	while (1) 	{ 		r = fscanf(fi, "%lf%lf%lf", &d1, &d2, &d3); 		if (3 == r) fprintf(fo, "%lg %lg %-lg\n", d1, d2, d3); 		else break; 	} 	fclose(fi); 	fclose(fo); 	return 0; } //12915 8105 - 27.52 //12925 8105 - 27.87 //13005 8105 - 9.46 //13015 8105 - 9.92 //13025 8105 - 31.77 //13035 8105 - 32.66 //13045 8105 - 33.62 //13115 8105 - 39.33 //13125 8105 - 9.05 //13135 8105 - 9.85 //13145 8105 - 9.54 //13155 8105 - 9.12 //13165 8105 - 9.69 //13175 8105 - 9.23 //13185 8105 - 43.48 //13195 8105 - 43.67 //13205 8105 - 43.85 //13215 8105 - 44.05 //13225 8105 - 44.25 //13235 8105 - 44.44 //13245 8105 - 44.64 //13255 8105 - 44.84 //13265 8105 - 45.03 //13275 8105 - 45.23 //13285 8105 - 45.43 //13295 8105 - 45.62

非常感谢，写出来了！！！！   引用 5 楼 zysoul 的回复:不是啊，因为我要把数据弄去一个软件处理，但是软件很傻，必须得格式对齐，不然都是NULL。 我算了的，空格是每个数字为4个空格，主要是第3列的-9.xxx类的，比1其他数字少个十位数，所以负号没对齐。 有什么办法可以整吗？求指点。。谢谢  [quote=引用 3 楼 wenpinglaoyao 的回复:] 针对第三个负号的数列，自己单写一个输出函数不就行了  怎么写呢？  引用 1 楼 zhao4zhong1 的回复:人家本来是按小数点对齐的，楼主自作聪明非要按整个字符串左对齐，这不是历史的倒退吗？ 况且每列数据间空格个数不同，丝毫不影响cin或scanf系列函数读取数据。[/quote]

不是啊，因为我要把数据弄去一个软件处理，但是软件很傻，必须得格式对齐，不然都是NULL。 我算了的，空格是每个数字为4个空格，主要是第3列的-9.xxx类的，比1其他数字少个十位数，所以负号没对齐。 有什么办法可以整吗？求指点。。谢谢  引用 3 楼 wenpinglaoyao 的回复:针对第三个负号的数列，自己单写一个输出函数不就行了  怎么写呢？  引用 1 楼 zhao4zhong1 的回复:人家本来是按小数点对齐的，楼主自作聪明非要按整个字符串左对齐，这不是历史的倒退吗？ 况且每列数据间空格个数不同，丝毫不影响cin或scanf系列函数读取数据。

针对第三个负号的数列，自己单写一个输出函数不就行了


Question: 跪求大神，gcc编译问题

看来只能改代码了，感谢2楼 user-3 给的方法，分每人都给了。

没有这个选项，改代码去吧 http://stackoverflow.com/questions/10526602/is-there-a-gcc-flag-to-initialise-local-variable-storage

引用 3 楼 zhao4zhong1 的回复:-finit-local-zero       Initialize local vars and arrays to zero -fzeros                 Treat initial values of 0 like non-zero values 老师再问一下，-fzeros是哪个工具里的？没搜到相关信息。。

引用 2 楼 user-3 的回复:恭喜你，gcc没有这种选项，你只能改代码了。编译时加上 -Wuninitialized 选项，再加上-O选项（-O1 -O2 -O3），然后编译器发现未初始化变量就会报警告，你可以根据警告改代码。  倒不是我不想这样做，主要是太多了，看着就整个人都不好了。。

引用 3 楼 zhao4zhong1 的回复:-finit-local-zero       Initialize local vars and arrays to zero -fzeros                 Treat initial values of 0 like non-zero values 老师，这2个选项我man gcc后没看到，其他的zero的我都看了下，好像也没有，然后百度了下，好像是有 gfortran -finit-local-zero x的用法，然后我也用了，但是gfortran也报没有这个 -finit-local-zero的选项，版本是4.1.2，请问，这个要用哪个版本才能有该选项，或者要加什么组件？  多谢。

引用 3 楼 zhao4zhong1 的回复:-finit-local-zero       Initialize local vars and arrays to zero -fzeros                 Treat initial values of 0 like non-zero values  Options for Fortran:    -finit-local-zero       Initialize local vars and arrays to zero    -fzeros                 Treat initial values of 0 like non-zero values Linux不是开源的吗？楼主高兴了在Linux加载ELF文件对应源代码中打个将无需初始化段内容清零的补丁，在gcc编译生成call函数调用之前将堆栈中临时变量清零的补丁。

gcc -v --help

来大神。。。绝望ing。。。


Question: 【讨论】关于谭浩强《c语言程序设计》一书的错误

引用 69 楼 sholber 的回复:[quote=引用 68 楼 zhao4zhong1 的回复:] 我断定均陵鼠侠是一个不符合“人”标准的东西。  我很疑惑，你是个无标准主义者，怎么还用起了“人”的标准。请问，界定人的标准是什么？给我一个ISO或者国家标准。 由此可见，你是一个无原则的人。需要标准的时候，你用标准（就像你在CSDN写的那些程序一样，符合标准），不需要的时候，你说标准是狗屁。 [/quote] 我写的略微精彩点的程序，都不符合任何标准： http://bbs.csdn.net/topics/390627329 http://bbs.csdn.net/topics/380157851 http://bbs.csdn.net/topics/390968755 http://bbs.csdn.net/topics/380175526

引用 80 楼 zhao4zhong1 的回复:上帝当初创造DNA的时候如果足够严谨，能进化出人类来吗？  这怎么又扯上DNA了，你老这是什么逻辑？  甲：你怎么穿这么多！多热呀！ 乙：早上吃了饺子。 赵老湿，好好补一下《形式逻辑》这门课哟。

引用 76 楼 zhao4zhong1 的回复:照你这么说，那些利用漏洞攻击、越狱、开后门、装木马、……的程序都谈不上精彩。事实上，是黑客自认为精彩罢了。 让你说对了  精彩的是发掘出漏洞 而不是利用漏洞

上帝当初创造DNA的时候如果足够严谨，能进化出人类来吗？

看了好久，终究还是没有看完...

引用 76 楼 zhao4zhong1 的回复:[quote=引用 75 楼 sholber 的回复:] [quote=引用 72 楼 zhao4zhong1 的回复:] [quote=引用 69 楼 sholber 的回复:] [quote=引用 68 楼 zhao4zhong1 的回复:] 我断定均陵鼠侠是一个不符合“人”标准的东西。  我很疑惑，你是个无标准主义者，怎么还用起了“人”的标准。请问，界定人的标准是什么？给我一个ISO或者国家标准。 由此可见，你是一个无原则的人。需要标准的时候，你用标准（就像你在CSDN写的那些程序一样，符合标准），不需要的时候，你说标准是狗屁。 [/quote] 我写的略微精彩点的程序，都不符合任何标准： http://bbs.csdn.net/topics/390627329 http://bbs.csdn.net/topics/380157851 http://bbs.csdn.net/topics/390968755 http://bbs.csdn.net/topics/380175526[/quote]  我没点开这些链接，因为在我看来，既然不符合标准，那就根本谈不上精彩。事实上，是你自认为精彩罢了。 另外，这几个程序是C程序吗？如果不是的话，它们不符合标准我没话说。如果是C程序，既然不符合标准，你怎么就能告诉我你写的是C程序呢？[/quote] 照你这么说，那些利用漏洞攻击、越狱、开后门、装木马、……的程序都谈不上精彩。事实上，是黑客自认为精彩罢了。[/quote]  赵老湿，恕我直言，你老学C这么多年，到了还没搞清楚标准和实现之间的关系。我相信，C标准已经规定了严格的语法，但它并不规定你用这些语法如何写程序。你写的程序不严谨，或者C的实现有缺陷，又或者底层的操作系统有漏洞，这有标准有个毛的关系。 你老的思维呀……我不知道说什么好了。

照你这么说，那些利用法律法规漏洞发横财和为所欲为的大佬都谈不上精彩。事实上，是他们自认为精彩罢了。

引用 75 楼 sholber 的回复:[quote=引用 72 楼 zhao4zhong1 的回复:] [quote=引用 69 楼 sholber 的回复:] [quote=引用 68 楼 zhao4zhong1 的回复:] 我断定均陵鼠侠是一个不符合“人”标准的东西。  我很疑惑，你是个无标准主义者，怎么还用起了“人”的标准。请问，界定人的标准是什么？给我一个ISO或者国家标准。 由此可见，你是一个无原则的人。需要标准的时候，你用标准（就像你在CSDN写的那些程序一样，符合标准），不需要的时候，你说标准是狗屁。 [/quote] 我写的略微精彩点的程序，都不符合任何标准： http://bbs.csdn.net/topics/390627329 http://bbs.csdn.net/topics/380157851 http://bbs.csdn.net/topics/390968755 http://bbs.csdn.net/topics/380175526[/quote]  我没点开这些链接，因为在我看来，既然不符合标准，那就根本谈不上精彩。事实上，是你自认为精彩罢了。 另外，这几个程序是C程序吗？如果不是的话，它们不符合标准我没话说。如果是C程序，既然不符合标准，你怎么就能告诉我你写的是C程序呢？[/quote] 照你这么说，那些利用漏洞攻击、越狱、开后门、装木马、……的程序都谈不上精彩。事实上，是黑客自认为精彩罢了。

引用 72 楼 zhao4zhong1 的回复:[quote=引用 69 楼 sholber 的回复:] [quote=引用 68 楼 zhao4zhong1 的回复:] 我断定均陵鼠侠是一个不符合“人”标准的东西。  我很疑惑，你是个无标准主义者，怎么还用起了“人”的标准。请问，界定人的标准是什么？给我一个ISO或者国家标准。 由此可见，你是一个无原则的人。需要标准的时候，你用标准（就像你在CSDN写的那些程序一样，符合标准），不需要的时候，你说标准是狗屁。 [/quote] 我写的略微精彩点的程序，都不符合任何标准： http://bbs.csdn.net/topics/390627329 http://bbs.csdn.net/topics/380157851 http://bbs.csdn.net/topics/390968755 http://bbs.csdn.net/topics/380175526[/quote]  我没点开这些链接，因为在我看来，既然不符合标准，那就根本谈不上精彩。事实上，是你自认为精彩罢了。 另外，这几个程序是C程序吗？如果不是的话，它们不符合标准我没话说。如果是C程序，既然不符合标准，你怎么就能告诉我你写的是C程序呢？

引用 73 楼 lin5161678 的回复:[quote=引用 72 楼 zhao4zhong1 的回复:] 我写的略微精彩点的程序，都不符合任何标准： http://bbs.csdn.net/topics/390627329 http://bbs.csdn.net/topics/380157851 http://bbs.csdn.net/topics/390968755 http://bbs.csdn.net/topics/380175526 这几段代码  要么就是符合标准 要么就是根本是错的 毫无价值的代码  顺便 谈不上有多精彩[/quote] 那请具体说说都符合了哪项标准，代码中那句话够精彩的反义词？

引用 72 楼 zhao4zhong1 的回复:我写的略微精彩点的程序，都不符合任何标准： http://bbs.csdn.net/topics/390627329 http://bbs.csdn.net/topics/380157851 http://bbs.csdn.net/topics/390968755 http://bbs.csdn.net/topics/380175526 这几段代码  要么就是符合标准 要么就是根本是错的 毫无价值的代码  顺便 谈不上有多精彩

引用 66 楼 zhao4zhong1 的回复:等楼上创造被标准和规定憋死的世界纪录中……  没有个标准，你还学C语言搞毛。 都没有标准了，啥都是C语言。 “哈啾……呸！”，吐口唾沫，这也是C语言。

等楼上创造被标准和规定憋死的世界纪录中……

我个人认为，谭老师的书依然是最佳学习C语言的书，只不过你阅读的方式不对。比如这样阅读——搜索罗列出谭老师书中的错误。。。

引用 4 楼 zhao4zhong1 的回复:楼主闲来无事写写 关于《易经》一书的错误， 我辈也好拜读一下。   每天回帖即可获得10分可用分！  辩证地来看的话，有错误可以训练和提升调试代码的技巧，嘿嘿～ 谭老师写的QBASIC倒是我们以前开课的入门课程，不过没看过谭老师的那本C语言教程，也看到网上褒贬不一； 其实大可不必，能引领读者入门了，就好好练就手上功夫吧

引用 68 楼 zhao4zhong1 的回复:我断定均陵鼠侠是一个不符合“人”标准的东西。  我很疑惑，你是个无标准主义者，怎么还用起了“人”的标准。请问，界定人的标准是什么？给我一个ISO或者国家标准。 由此可见，你是一个无原则的人。需要标准的时候，你用标准（就像你在CSDN写的那些程序一样，符合标准），不需要的时候，你说标准是狗屁。

我断定均陵鼠侠是一个不符合“人”标准的东西。

引用 64 楼 zhao4zhong1 的回复:因为标准和规矩是人定的，所以人不可能被标准和规矩限制死！ 标准和规矩规定不许随地大小便，没见过谁被这条标准和规矩憋死！  改革开放诞生了一批人，他们割断和无视任何事物的历史，觉得自己是开放、包容的。实际上，这是一种变相的历史虚无主义者。比如说，公交车是公共设施，最开始实行的时候，是提供公共服务。不提供也没什么不对，你可以骑自行车嘛。最开始的一代人知道这是公共服务，知道它的定位，也知道感恩。但是下一代人不同，他们不了解历史，单纯地认为它是一种买卖关系。我交了一块钱，你车来得晚了，我会骂司机，打司机，认为老子花钱坐公交，你特么嘎哈来得这么晚？ 如果全世界只有你一个人，你在大街上尿尿谁管你呀。但这个社会人很多，早期的人类为了互利，搭成共识，不得在公共场所尿尿。现在有些后出生的人，不了解历史，说你管老子在哪里尿尿呢！这是老子的自由哇。 语言的标准也是如此。如果赵老湿你自己一个人用C，谁管你标准不标准呢。问题是早期的人类为了交流方便，决定用一个标准互相约束。现在可好，后生的人不知道这个标准的出台历史，觉得标准限制不对，把标准的规定当成一种对立关系，一种攻防关系。如果是攻防关系，攻方是谁？防的一方又是谁？这是历史盲的幼稚和可笑之处。

引用 12 楼 taodm 的回复:学会C语言的标准就是会自己参照C语言标准判断那个挑谭的破书的错的文章的对错。       没有几个学会了C语言的人会有空再去干挑谭的破书的错的事了，这完全是浪费生命，即使是毁人不倦的赵4都不肯干的。 学编程有天分的标准是自己知道什么东西根本不值得去争对错，什么东西必须搬标准来搞个明白。  有这功夫，不如用几本优秀的C语言教材重新过一遍c语言基础。冷暖自知。 比如 C语言大全、C语言解析教程、C how to programming、现代C语言（?这个记不清）毁人不倦的赵4


Question: C语言字符串的输入，排序和输出，程序错误，花了我很长时间，谁能帮我调试下，找出错误原因。

最终还是自己解决问题，也不会在发帖请人帮忙解决具体问题了，但希望人们能教给我方法和知识。

//第11章第10题                                      //输入10个字符串，按不同要求排序输出  #include <stdio.h> #include <string.h> #define LIM 10 #define SIZE 81 void str_oriout (char *fstr[],int num); void str_ascout (char *fstr[],int num);  void str_lenout (char *fstr[],int num); void str_wordout (char *fstr[],int num);   int main (void) { 	char str[LIM][SIZE];                       //char *str[LIM] ,输入存在问题，一次只能输入一行      char * ptstr[LIM];                         //注意声明！！      char ch = 'N'; 	int i,j; 	i = 0; 	j = 0; 	int is_EOF; 	 	printf("Please enter 10 strings\n"); 	while (ch != 'Y') 	{ 		    ch = getchar(); 	        while (i < LIM && ch != EOF)   			      //while (ch = getchar() && i < LIM && ch != EOF)出错，为何？？  			{ 		         if (ch == '\n') 				    { 					 str[i][j] = '\0'; 					 ptstr[i] = str[i]; 					 i++;    				     j = 0; 					} 			     else 				    { 					 str[i][j] = ch; 					 j++; 					}  					 				 ch = getchar();	 			}     			         str_oriout(ptstr,i); 		str_ascout(ptstr,i); 		str_lenout(ptstr,i); 		str_wordout(ptstr,i); 		         i = 0;         j = 0; 		printf("Enter 'Y' to get out!\n"); 		ch = getchar(); 		getchar(); 	}      	return 0;   }    void str_oriout (char *fstr[],int num)        //输出初始字符串  { 	printf("******************1\n");  	int ct = 0; 	for (ct = 0;ct < num;ct++) 		puts(fstr[ct]); }  void str_ascout (char *fstr[],int num)        //按首字母ASCII值的顺序输出字符串  { 	printf("******************2\n");  	char *temp; 	int top,seek; 	for (top = 0;top < num - 1;top++) 	    for (seek = top + 1;seek < num;seek++) 	        if (strcmp(fstr[top],fstr[seek]) > 0) 	        { 	        	temp = fstr[seek]; 	        	fstr[seek] = fstr[top]; 	        	fstr[top] = temp; 			} 	for (top = 0;top < num;top++) 		puts(fstr[top]); }  void str_lenout (char *fstr[],int num)         //按数组长度排序  { 	printf("*******************3\n");  	char *temp; 	int top,seek; 	 	for (top = 0; top < num-1; top++)         for (seek = top + 1; seek < num; seek++)              if (strlen(fstr[top]) < strlen(fstr[seek]))                  {                  	temp = fstr[top];                  	fstr[top] = fstr[seek];                  	fstr[seek] = temp;  				 }   	 	for (top = 0;top < num;top++) 		puts(fstr[top]);			 	 }  void str_wordout (char *fstr[],int num)          //按第一个单词的长度排序  { 	printf("**********************4\n");  	char *temp; 	int top,seek; 	 	for (top = 0; top < num-1; top++)         for (seek = top + 1; seek < num; seek++)             {             	int i,j;             	int count1,count2;             	i = j = 0; 				count1 = count2 = 1;             	             	while (fstr[top][i] != '\0')                        {count1++;                         i++;}                 while (fstr[seek][j] != '\0') 				       {count2++; 				        j++;} 			    if (count1 < count2) 				   { 				   	temp = fstr[top]; 				   	fstr[top] = fstr[seek]; 				   	fstr[seek] = temp;				    	 				   }	         			} 			     for (top = 0;top < num;top++) 		 puts(fstr[top]);			 	 }

何不改成getchar（）输入呢？

修改如下：  //第11章第10题             //C Primer Plus                                  //输入10个字符串，按不同要求排序输出  #include <stdio.h> #include <string.h> #define LIM 10 #define SIZE 81 void str_oriout(char *fstr[], int num); void str_ascout(char *fstr[], int num); void str_lenout(char *fstr[], int num); void str_wordout(char *fstr[], int num); int main(void) { 	char str[LIM][SIZE];                //char *str[LIM] ,输入存在问题，一次只能输入一行  	char * ptstr[LIM];                  //注意声明！！  	char ch = 'N'; 	int i, j; 	i = 0; 	j = 0; 	int is_EOF; 	printf("Please enter 10 strings\n"); 	while (ch != 'Y') 	{ 		while (i < LIM)             //输入10个字符串或遇到EOF结束  		{ 			gets(str[i]);  			ptstr[i] = str[i];  			for (j = 0; j < strlen(str[i]); j++)  //遇到EOF停止   			{ 				if (ptstr[i][j] == EOF) 				{ 					is_EOF = 1; 					break;			   	   //break    				} 			} 			if (is_EOF == 1) 				break;  			puts(str[i]); 			printf("******1\n");          //检查作用  			puts(ptstr[i]); 			printf("******2\n"); 			i++; 		} 		str_oriout(ptstr, i); 		str_ascout(ptstr, i); 		str_lenout(ptstr, i); 		str_wordout(ptstr, i);  		printf("Enter 'Y' to get out!\n"); 		ch = getchar(); 		getchar(); 	}  	return 0; } void str_oriout(char *fstr[], int num)        //输出初始字符串  { 	printf("******1\n"); 	int ct = 0; 	for (ct = 0; ct < num; ct++) 		puts(fstr[ct]); } void str_ascout(char *fstr[], int num)        //按首字母ASCII值的顺序输出字符串  { 	printf("******2\n"); 	char *temp; 	int top, seek; 	for (top = 0; top < num - 1; top++) 		for (seek = top + 1; seek < num; seek++) 			if (strcmp(fstr[top], fstr[seek]) > 0) 			{ 				temp = fstr[seek]; 				fstr[seek] = fstr[top]; 				fstr[top] = temp; 			} 	for (top = 0; top < num; top++) 		puts(fstr[top]); } void str_lenout(char *fstr[], int num)         //按数组长度排序  { 	printf("******3\n"); 	char *temp; 	int top, seek; 	for (top = 0; top < num - 1; top++) 		for (seek = top + 1; seek < num; seek++) 			if (strlen(fstr[top]) < strlen(fstr[seek])) 			{ 				temp = fstr[top]; 				fstr[top] = fstr[seek]; 				fstr[seek] = temp; 			} 	for (top = 0; top < num; top++) 		puts(fstr[top]); } void str_wordout(char *fstr[], int num)          //按第一个单词的长度排序  { 	printf("******4\n"); 	char *temp; 	int top, seek;  	for (top = 0; top < num - 1; top++) 		for (seek = top + 1; seek < num; seek++) 		{ 			int i, j; 			int count1, count2; 			i = j = 0; 			count1 = count2 = 1; 			while (fstr[top][i] != '\0') 			{ 				count1++; 				i++; 			} 			while (fstr[seek][j] != '\0') 			{ 				count2++; 				j++; 			} 			if (count1 < count2) 			{ 				temp = fstr[top]; 				fstr[top] = fstr[seek]; 				fstr[seek] = temp; 			} 		} 	for (top = 0; top < num; top++) 		puts(fstr[top]); }

//第11章第10题             //C Primer Plus                                  //输入10个字符串，按不同要求排序输出  #include <stdio.h> #include <string.h> #define LIM 10 #define SIZE 81 void str_oriout (char *fstr[],int num); void str_ascout (char *fstr[],int num);  void str_lenout (char *fstr[],int num); void str_wordout (char *fstr[],int num);     int main (void) { 	char str[LIM][SIZE];                       //char *str[LIM] ,输入存在问题，一次只能输入一行      char * ptstr[LIM];                         //注意声明！！      char ch = 'N'; 	int i,j; 	i = 0; 	j = 0; 	int is_EOF; 	 	printf("Please enter 10 strings\n"); 	while (ch != 'Y') 	{ 		while(i < LIM)                         //输入10个字符串或遇到EOF结束  	    { 	    	gets(str[i]); 	    	ptstr[i] = str[i]; 	    	 		    for(j = 0;j < strlen(str[i]);j++)  //遇到EOF停止   		    { 			      if (ptstr[i][j] == EOF)         			         { 			   	      is_EOF = 1; 			   	      break;			   	   //break    			         }	 			}  	           		    i++;   		     		    if (is_EOF == 1) 	           break;    	            	        puts(str[i]);   			printf("******1\n");                    //检查作用  			puts(ptstr[i]); 			printf("******2\n");  	    } 	     		str_oriout(ptstr,i); 		str_ascout(ptstr,i); 		str_lenout(ptstr,i); 		str_wordout(ptstr,i); 	 		printf("Enter 'Y' to get out!\n"); 		ch = getchar(); 		getchar(); 		     }      	return 0;   }    void str_oriout (char *fstr[],int num)        //输出初始字符串  { 	printf("******1\n");  	int ct = 0; 	for (ct = 0;ct < num;ct++) 		puts(fstr[ct]); }  void str_ascout (char *fstr[],int num)        //按首字母ASCII值的顺序输出字符串  { 	printf("******2\n");  	char *temp; 	int top,seek; 	for (top = 0;top < num - 1;top++) 	    for (seek = top + 1;seek < num;seek++) 	        if (strcmp(fstr[top],fstr[seek]) > 0) 	        { 	        	temp = fstr[seek]; 	        	fstr[seek] = fstr[top]; 	        	fstr[top] = temp; 			} 	for (top = 0;top < num;top++) 		puts(fstr[top]); }  void str_lenout (char *fstr[],int num)         //按数组长度排序  { 	printf("******3");  	char *temp; 	int top,seek; 	 	for (top = 0; top < num-1; top++)         for (seek = top + 1; seek < num; seek++)              if (strlen(fstr[top]) < strlen(fstr[seek]))                  {                  	temp = fstr[top];                  	fstr[top] = fstr[seek];                  	fstr[seek] = temp;  				 }   	 	for (top = 0;top < num;top++) 		puts(fstr[top]);			 	 }  void str_wordout (char *fstr[],int num)          //按第一个单词的长度排序  { 	printf("******4");  	char *temp; 	int top,seek; 	 	for (top = 0; top < num-1; top++)         for (seek = top + 1; seek < num; seek++)             {             	int i,j;             	int count1,count2;             	i = j = 0; 				count1 = count2 = 1;             	             	while (fstr[top][i] != '\0')                        {count1++;                         i++;}                 while (fstr[seek][j] != '\0') 				       {count2++; 				        j++;} 			    if (count1 < count2) 				   { 				   	temp = fstr[top]; 				   	fstr[top] = fstr[seek]; 				   	fstr[seek] = temp;				    	 				   }	         			} 			     for (top = 0;top < num;top++) 		 puts(fstr[top]);			 	 }

[code=c          //C Primer Plus                                   #include <stdio.h> #include <string.h> #define LIM 10 #define SIZE 81 void str_oriout (char *fstr[],int num); void str_ascout (char *fstr[],int num);  void str_lenout (char *fstr[],int num); void str_wordout (char *fstr[],int num);     int main (void) { 	char str[LIM][SIZE];                       //char         char * ptstr[LIM];                                 char ch = 'N'; 	int i,j; 	i = 0; 	j = 0; 	int is_EOF; 	 	printf("Please enter 10 strings\n"); 	while (ch != 'Y') 	{ 		while(i < LIM)                         //                 {	     	    	gets(str[i]); 	    	 		    for(j = 0;j < strlen(str[i]);j++)  // 		    { 			      if (str[i][j] == EOF)         			         { 			   	      is_EOF = 1; 			   	      break;			   	   //break   			         }	 			}  	        ptstr[i] = str[i];   		    i++;   		     		    if (is_EOF == 1) 	           break;    	            	        puts(str[i]);                       			puts(ptstr[i]); 	    } 	     		str_oriout(ptstr,i); 		str_ascout(ptstr,i); 		str_lenout(ptstr,i); 		str_wordout(ptstr,i); 	 		printf("Enter 'Y' to get out!\n"); 		ch = getchar(); 		getchar(); 		     }      	return 0;   }    void str_oriout (char *fstr[],int num)        // { 	int ct = 0; 	for (ct = 0;ct < num;ct++) 		puts(fstr[ct]); }  void str_ascout (char *fstr[],int num)        // { 	char *temp; 	int top,seek; 	for (top = 0;top < num - 1;top++) 	    for (seek = top + 1;seek < num;seek++) 	        if (strcmp(fstr[top],fstr[seek]) > 0) 	        { 	        	temp = fstr[seek]; 	        	fstr[seek] = fstr[top]; 	        	fstr[top] = temp; 			} 	for (top = 0;top < num;top++) 		puts(fstr[top]); }  void str_lenout (char *fstr[],int num)          { 	char *temp; 	int top,seek; 	 	for (top = 0; top < num-1; top++)         for (seek = top + 1; seek < num; seek++)              if (strlen(fstr[top]) < strlen(fstr[seek]))                  {                  	temp = fstr[top];                  	fstr[top] = fstr[seek];                  	fstr[seek] = temp;  				 }   	 	for (top = 0;top < num;top++) 		puts(fstr[top]);			 	 }  void str_wordout (char *fstr[],int num)          // { 	char *temp; 	int top,seek; 	 	for (top = 0; top < num-1; top++)         for (seek = top + 1; seek < num; seek++)             {             	int i,j;             	int count1,count2;             	i = j = 0; 				count1 = count2 = 1;             	             	while (fstr[top][i] != '\0')                        {count1++;                         i++;}                 while (fstr[seek][j] != '\0') 				       {count2++; 				        j++;} 			    if (count1 < count2) 				   { 				   	temp = fstr[top]; 				   	fstr[top] = fstr[seek]; 				   	fstr[seek] = temp;				    	 				   }	         			} 			     for (top = 0;top < num;top++) 		 puts(fstr[top]);			 	 }  ][/code]

引用 3 楼 user-2 的回复:第二个while后面少了一个"{";导致程序有错，加个“｛”吧。然后再调调看。 while(i < LIM)  后加"{".  那个是编辑的时候打掉的了的，这样的错误，编译器可以检查出。

大一，上学期开的C，没学到什么，于是自学C Primer Plus，到了第11章字符串和字符串函数，卡在这里了。章末的程序题花我很长时间，这道题已使我用了一天或者更久。这样学习，是不是效率太低不可取？

//°´Ê××ÖÄ¸ASCIIÖµµÄË³ÐòÊä³ö×Ö·û´®  汉字注释全成了乱码！！！！谁能解释下？


Question: Shell 的一个小字符串的处理，求解答

引用 8 楼 henuyx 的回复: echo HFGJv10.3.7628 | awk -Fv '{print $2}' | awk -F. '{printf("%02d %02d\n", $1, $2);}'   ---------------- 窃以为 楼主想获得版本号，因此先以v分隔，后以点号分隔  本想将前面的echo加一个粗体强调一些，竟然显示俩strong标签，给CSDN跪了...  echo HFGJv10.3.7628 | awk -Fv '{print $2}' | awk -F. '{printf("%02d %02d\n", $1, $2);}'

引用 15 楼 henuyx 的回复:[quote=引用 13 楼 henuyx 的回复:] [quote=引用 12 楼 Cabbage_c 的回复:]   这样一直提示报错。 awk : cmd. line 1: {printf("%02d%02d"),}                                                                       ^sysntax error  少个逗号！！！[/quote]  手动测试了一下，再makefile中的shell变量是需要两个$$的，和Makefile本身的额变量$()做区别。 看代码：  ver=$(shell echo "HFGJv10.3.7628" | awk -Fv '{print $$2}' | awk -F. '{printf("%02d%02d\n", $$1, $$2);}') [/quote]   谢谢大哥  么么哒！！！！！！！！！！

ok了  解决了   谢谢楼上的大哥！！！！！！！！！！！！   SFT=$(shell echo "HFBv1.2.456 | awk -Fv '{print $$2}' | awk -F. 'printf("%02d%02d", $$1, $$2)')

引用 13 楼 henuyx 的回复:[quote=引用 12 楼 Cabbage_c 的回复:]   这样一直提示报错。 awk : cmd. line 1: {printf("%02d%02d"),}                                                                       ^sysntax error  少个逗号！！！[/quote]  手动测试了一下，再makefile中的shell变量是需要两个$$的，和Makefile本身的额变量$()做区别。 看代码：  ver=$(shell echo "HFGJv10.3.7628" | awk -Fv '{print $$2}' | awk -F. '{printf("%02d%02d\n", $$1, $$2);}')

引用 13 楼 henuyx 的回复:[quote=引用 12 楼 Cabbage_c 的回复:]   这样一直提示报错。 awk : cmd. line 1: {printf("%02d%02d"),}                                                                       ^sysntax error  少个逗号！！！[/quote]  不少逗号的   还是错误啊啊啊啊啊啊

引用 12 楼 Cabbage_c 的回复:  这样一直提示报错。 awk : cmd. line 1: {printf("%02d%02d"),}                                                                       ^sysntax error  少个逗号！！！

引用 9 楼 henuyx 的回复:[quote=引用 8 楼 henuyx 的回复:]  echo HFGJv10.3.7628 | awk -Fv '{print $2}' | awk -F. '{printf("%02d %02d\n", $1, $2);}'   ---------------- 窃以为 楼主想获得版本号，因此先以v分隔，后以点号分隔  本想将前面的echo加一个粗体强调一些，竟然显示俩strong标签，给CSDN跪了...  echo HFGJv10.3.7628 | awk -Fv '{print $2}' | awk -F. '{printf("%02d %02d\n", $1, $2);}' [/quote]  大哥 再问一个问题  我在makefile里想定义一个变量等于这个结果，一直提示解析错误 VER=echo HFGJv10.3.7628 | awk -Fv '{print $2}' | awk -F. '{printf("%02d %02d\n", $1, $2);}' 然后我再调用VER，比如./kk.sh $VER

引用 9 楼 henuyx 的回复:[quote=引用 8 楼 henuyx 的回复:]  echo HFGJv10.3.7628 | awk -Fv '{print $2}' | awk -F. '{printf("%02d %02d\n", $1, $2);}'   ---------------- 窃以为 楼主想获得版本号，因此先以v分隔，后以点号分隔  本想将前面的echo加一个粗体强调一些，竟然显示俩strong标签，给CSDN跪了...  echo HFGJv10.3.7628 | awk -Fv '{print $2}' | awk -F. '{printf("%02d %02d\n", $1, $2);}' [/quote]   太谢谢了  么么哒

rem 批处理中的字符串处理详解 rem 首先说一下，批处理和高级语言不同，没有字符串处理函数，比如strcat之类的，但是却可以利用环境变量来实现这些函数的功能。 rem 本文对照C语言中的字符串处理函数，讲解在批处理中的实现方法。 rem rem 首先说一下字符串的存储，在C语言中，采用字符数组或者字符指针来存储字符串，而BAT中没有这些东东，所以要依靠环境变量来存储。 rem 设置环境变量的语句为set语句，本文不详细介绍了，参考set /?语句。 rem rem 1、C语中的strcpy函数，将一个字符串复制到另一个字符型指针或字符数组，覆盖原来的字符串。 rem rem C语言中的调用方法：strcpy(目标字符串,源字符串) rem rem 在批处理中的实现方法： rem rem set 目标字符串=%源字符串% rem rem 示例： rem 代码: @echo off rem 关闭屏幕回显（可选） set str1=This is old string rem 设置str1中存储的字符串，注意没有双引号，这点与C语言等不同！ set str2=This is new string rem 设置str2中存储的字符串 echo 执行字符串拷贝以前： echo str1=%str1% echo str2=%str2% rem 先输出一次原有的字符串 set str1=%str2% rem 字符串拷贝 echo 执行字符串拷贝以后： echo str1=%str1% echo str2=%str2% rem 输出执行完字符串拷贝后的字符串 echo 输出完毕，按任意键退出&&pause>nul&&exit rem 输出信息，当用户按任意键时，结束该批处理。效果图：  rem 2、C语中的strcat函数，将一个字符串连接到另一个字符型指针或字符数组的末尾。 rem rem C语言中的调用方法：strcat(目标字符串,源字符串) rem rem 在批处理中的实现方法： rem rem set 目标字符串=%目标字符串%%源字符串% rem rem 示例： rem 代码: @echo off set str1=This is string1 set str2=This is string2 rem 设置str1和str2中存储的字符串 echo 连接字符串以前： echo str1=%str1% echo str2=%str2% rem 先输出一次原有的字符串 set str1=%str1%%str2% rem 字符串连接 echo 连接字符串以后： echo str1=%str1% echo str2=%str2% rem 输出执行完字符串连接后的两个字符串 echo 输出完毕，按任意键退出&&pause>nul&&exit效果图：  rem 3、字符串截取，C中没有这种函数，不过可以通过语句实现，不再介绍，直接说批处理的。 rem rem set 目标字符串=%源字符串:~起始值,截取长度% rem rem 注意，起始值从0开始！ rem 截取长度是可选的，如果省略逗号和截取长度，将会从起始值一直截取到字符串的结尾。 rem rem 示例： rem 代码: @echo off set str1=This is string1 rem 设置str1中存储的字符串 set str2=%str1:~8,6% set str3=%str1:~0,4% set str4=%str1:~5% rem 字符串截取 echo 原字符串： echo str1=%str1% echo 截取得到的字符串： echo str2=%str2% echo str3=%str3% echo str4=%str4% rem 输出执行结果 echo 输出完毕，按任意键退出&&pause>nul&&exit效果图：  rem 4、C语中的strlen函数，取得字符串的长度。 rem rem C语言中的调用方法：strlen(字符串) rem rem 在批处理中的实现方法是利用goto和标签，形成循环结构，不断将字符串截短1字符，并用变量记录截短的次数，直到字符串变成空串。 rem rem 示例： rem 代码: @echo off set str1=This is a test string set strlen=0 set str=%str1% rem 将str1复制到str :next1 rem 标签，用于goto跳转 rem 注意与注释语句的区别，注释用两个冒号开头，标签则为一个冒号 if not "%str%"=="" ( rem 判断str是不是空串，如果不是则执行下边的语句 set /a strlen+=1 rem 算术运算，使strlen的值自增1，相当于strlen++或者++strlen语句 set str=%str:~1% rem 截取字符串，赋给自身 goto next1 rem 跳转到next1标签 rem 这里利用goto和标签，构成循环结构 ) rem 当以上循环结构执行完毕时，会执行下边的语句 echo str1=%str1% echo str1的长度为：%strlen%  rem 5、C语中的strchr函数，在一个字符串中查找一个字符的首次出现位置，找到时返回所在位置，找不到时返回0值。 rem rem 批处理中的思路：不断截短字符串，并取截短后字符串中的首字符，和要求的字符比较，如果相同就利用goto语句跳出循环，输出结果，如果没有相同的字符，执行到最后就输出0值。 rem rem 示例： rem 代码: @echo off Setlocal ENABLEDELAYEDEXPANSION rem 启用命令扩展，参加setlocal /?命令 set str1=This is a test string set ch1=t rem 注意，这里是区分大小写的！ set str=%str1% rem 复制字符串，用来截短，而不影响源字符串 :next if not "%str%"=="" ( set /a num+=1 if "!str:~0,1!"=="%ch1%" goto last rem 比较首字符是否为要求的字符，如果是则跳出循环 set str=%str:~1% goto next ) set /a num=0 rem 没有找到字符时，将num置零 :last echo 字符'%ch1%'在字符串"%str1%"中的首次出现位置为%num% echo 输出完毕，按任意键退出&&pause>nul&&exit效果图：  rem 最后出几道题，看看大家学习的怎么样！ rem (1)如何实现C语言中strstr函数的功能？ rem 提示：strstr函数的功能是在字符串1中查找字符串2，找到时返回串2首次出现的位置，否则返回0值。与strchr区别就是，第二个参数是字符串，而不是字符了。

VER=“HFGJv10.3.7628” X=`echo $VER | grep -o '[0-9]\.'`   啊啊啊啊啊   不会啊

引用 4 楼 user-3 的回复:自己上网查下awk的用法   应该不难的  查了下， 写了好多中都不行，所以想让大神帮忙写一下啊，    大神你在哪里

自己上网查下awk的用法   应该不难的

我只知道应该用awk  抱歉，太久都忘光光了，帮顶～～～～

help

求帮忙啊，  不会用sek 和 awk 啊  。


Question: typedef const struct定义的结构体如何具体使用？

楼上的正解，要传地址

MessageCreate的第一个参数接收地址，所以应该这样调用  MessageCreate（&aabb, ccdd）;

M_essage aabb[1];


Question: configure中出现有关CFLAGS的问题

CFLAGS 是c的编译器参数设置 LDFLAGS 是链接库的路径

看起来是./configure成功结束

搜“跟我一起写makefile”

一般来说不是，有的configure脚本会在最后打印出配置的参数以供确认。 当然，在没有完整的log之前并不能判断


Question: Linux c 下recvfrom bootp（dhcp） packet

引用 2 楼 a30037338 的回复:printf("received datagram from %s,port:%d\n",inet_ntoa(their_addr.sin_addr),ntohs(their_addr.sin_port)); 改成 their_addr.sin_addr.s_addr其实这样还是不行的

INET_ADDR Section: POSIX Programmer's Manual (P) Updated: 2003  --------------------------------------------------------------------------------    NAME inet_addr, inet_ntoa - IPv4 address manipulation    SYNOPSIS #include <arpa/inet.h>    in_addr_t inet_addr(const char *cp);  char *inet_ntoa(struct in_addr in);      DESCRIPTION The inet_addr() function shall convert the string pointed to by cp, in the standard IPv4 dotted decimal notation, to an integer value suitable for use as an Internet address.   The inet_ntoa() function shall convert the Internet host address specified by in to a string in the Internet standard dot notation.   The inet_ntoa() function need not be reentrant. A function that is not required to be reentrant is not required to be thread-safe.   All Internet addresses shall be returned in network order (bytes ordered from left to right).   Values specified using IPv4 dotted decimal notation take one of the following forms:   a.b.c.d When four parts are specified, each shall be interpreted as a byte of data and assigned, from left to right, to the four bytes of an Internet address.  a.b.c When a three-part address is specified, the last part shall be interpreted as a 16-bit quantity and placed in the rightmost two bytes of the network address. This makes the three-part address format convenient for specifying Class B network addresses as "128.net.host" .  a.b When a two-part address is supplied, the last part shall be interpreted as a 24-bit quantity and placed in the rightmost three bytes of the network address. This makes the two-part address format convenient for specifying Class A network addresses as "net.host" .  a When only one part is given, the value shall be stored directly in the network address without any byte rearrangement.   All numbers supplied as parts in IPv4 dotted decimal notation may be decimal, octal, or hexadecimal, as specified in the ISO C standard (that is, a leading 0x or 0X implies hexadecimal; otherwise, a leading '0' implies octal; otherwise, the number is interpreted as decimal).     RETURN VALUE Upon successful completion, inet_addr() shall return the Internet address. Otherwise, it shall return ( in_addr_t)(-1).   The inet_ntoa() function shall return a pointer to the network address in Internet standard dot notation.     ERRORS No errors are defined.   The following sections are informative.     EXAMPLES None.     APPLICATION USAGE The return value of inet_ntoa() may point to static data that may be overwritten by subsequent calls to inet_ntoa().     RATIONALE None.     FUTURE DIRECTIONS None.     SEE ALSO endhostent() , endnetent() , the Base Definitions volume of IEEE Std 1003.1-2001, <arpa/inet.h>     COPYRIGHT Portions of this text are reprinted and reproduced in electronic form from IEEE Std 1003.1, 2003 Edition, Standard for Information Technology -- Portable Operating System Interface (POSIX), The Open Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the Institute of Electrical and Electronics Engineers, Inc and The Open Group. In the event of any discrepancy between this version and the original IEEE and The Open Group Standard, the original IEEE and The Open Group Standard is the referee document. The original Standard can be obtained online at http://www.opengroup.org/unix/online.html .  --------------------------------------------------------------------------------


Question: 用C语言实现二叉排序树查找，代码包含查找时间和次数

二叉搜索树 http://blog.csdn.net/zhangxiangdavaid/article/details/36437541


Question: 求数组的长度——函数调用咋不行哈【我太菜了描述不好<相信你们应该能理解】

# include <stdio.h>  void f (int a []) {     printf ("%d\n", * a);     printf ("%d\n", a [1]); }  int main (void) {     /* 俺决定用数组第一个元素来存放数组大小，嘎嘎！*/     int a [3] = {sizeof a,};     f (a); }

引用 7 楼 u013966434 的回复:[quote=引用 6 楼 mingliang37 的回复:] 数组作为参数传递给函数退化为指针，所以无法用函数来求数组的长度。 终于有人懂我的意思了-------------------------你能确定不行[/quote] C里面真不行

引用 13 楼 cao_julians 的回复:[quote=引用 10 楼 sholber 的回复:] # include <stdio.h>  int n;  void f (int a [n]);  int main (void) {     int a [n = 3];     a [0] = 1;     a [1] = 3;     a [2] = 5;     f (a); }  void f (int a [n]) {     /*     **在这里，a依然被转换为指针，但传递进来的n可以使用。     **数组的大小在它在存续期间不会改变，即使改变了n的值。     */     while (n --)         printf ("%d\n", a [n]); }  是Ｃ10的新特性？Ｃ89和Ｃ99里没有吧？[/quote]  C99的，不过跟你的问题关系不大，我写着玩的。

引用 10 楼 sholber 的回复:# include <stdio.h>  int n;  void f (int a [n]);  int main (void) {     int a [n = 3];     a [0] = 1;     a [1] = 3;     a [2] = 5;     f (a); }  void f (int a [n]) {     /*     **在这里，a依然被转换为指针，但传递进来的n可以使用。     **数组的大小在它在存续期间不会改变，即使改变了n的值。     */     while (n --)         printf ("%d\n", a [n]); }  是Ｃ10的新特性？Ｃ89和Ｃ99里没有吧？

引用 6 楼 mingliang37 的回复:数组作为参数传递给函数退化为指针，所以无法用函数来求数组的长度。 终于有人懂我的意思了-------------------------你能确定不行

数组作为参数传递给函数退化为指针，所以无法用函数来求数组的长度。

当然可以的啊。。 len = sizeof(a) / sizeof(&a[0])

引用 2 楼 u013966434 的回复:你讲的 我能理解 但我想知道能否通过函数调用也可以去实现求数组的长度————能不能 谢谢啦 一般这样，void fun(int *arr, int n);     //n是数组的大小

引用 2 楼 u013966434 的回复:你讲的 我能理解 但我想知道能否通过函数调用也可以去实现求数组的长度————能不能 谢谢啦 把数组地址传给函数在函数里面是无法计算出数组大小的，因为函数的形参不管定义成数组或者指针，其本质都是指针，所以在函数里面用sizeof计算出来的是指针的大小，而不是数组的大小。

数组名a在不同的场合中表示的意义不同，比较普遍的是表示数组首元素的指针，即a表示&a[0]; 另外很固定的场合是&a 和sizeof(a),a表示整个数组。  因此，代码第七行len得到了整个数组的字节数。 而下一行向L函数传递的是首元素的指针&a[0], 函数实参t指向了首元素a[0],函数中sizeof(*t)得到是首元素a[0]的字节数。  关于数组名的语义不同是C语言的难点，【C与指针】讲解的很好

只能传数组地址，函数是求不出来长度的。

纠正一下措辞，不是传进来的喔。

C++中的数组不记录数组长度的，通常想把一个数组传入函数，还需要传入这个数组的长度  除非你自己写一个类来管理，类似标准模板库中的string类管理char数组

正规的C语言 对于int L(int *t)是绝对不可能获得t数组的长度的。  在C实现中，只能用替代办法。


Question: 程序不能再别人的电脑上正常使用

引用 12 楼 qq_25235869 的回复:@paschen 什么是静态链接？？  常规中选择在静态链接库中使用MFC，在C/C++代码生成里的运行库选择为MTd/MT

@paschen 什么是静态链接？？

如果你是托管的C++，他电脑上得安装了相应版本的.net才能运行

使用静态链接，否则有些电脑会缺少msvcrXXX.dll等

首先记得要编译成release的，而不是DEBUG的，其次，他的电脑要有VC运行库

引用 9 楼 qq_25235869 的回复:@zhao4zhong1 这样回答好不好  比如locale.h文件包含了那些东西？ setlocale(LC_ALL,"chs");这个文件还可以有哪些参数？ 自己打开include\locale.h看不就行了。

谁不让你的程序在他的电脑上用，拉过来打一顿。  gcc ... -finput-charset =utf-8   -fexec-charset=gbk

#include <locale.h> #include <stdio.h> int main() {  setlocale(LC_ALL,"chs");  printf("汉字不乱码\n");  return 0; }

@zhao4zhong1 你放上来的代码 可以解释一下吗？？

用depends.exe查看exe依赖的dll  在你的代码中添加： #include <locale.h> setlocale(LC_ALL,"chs");

你在别人的电脑上运行以后，看下缺少什么文件，这个东西叫做动态链接库，缺少什么就在你电脑的环境中找什么文件，然后复制到可运行程序的文件夹下，然后就可以运行了，可能会出现多个缺少文件，耐心调试。

别人的机器和你的不一样，需要一些vc的文件

因为用到了 一些 动态库吧 没有安装开发环境的机器就不能正常使用了 把用到的动态库放在程序同一个目录里一起拷贝


Question: 如何创建这样表

请楼主移驾SQL论坛：http://bbs.csdn.net/forums/MSSQL

数据库不是这样用的，你把大量二进制数据保存在数据库，很不好哦


Question: C语言新手入门题目，求大神指导

修改如下：  int main() { 	int i, j, m, k, l; 	//int a[20]; 	int a[1000]; 	for (i = 2; i <= 1000; i++) 	{ 		k = l = 0; 		memset(a, 0, sizeof(int) * 1000); 		for (j = 1; j < i; j++) 		{ 			if (i % j == 0) 			{ 				a[k] = j; 				l += a[k]; 				k++; 			} 		} 		if (l == i) 		{ 			printf("%d its facrors are ", i); 			for (m = 0; a[m + 1]; m++) 				printf("%d,", a[m]); 			printf("%d\n", a[m]); 		} 	} 	return 0; } //6 its facrors are 1, 2, 3 //28 its facrors are 1, 2, 4, 7, 14 //496 its facrors are 1, 2, 4, 8, 16, 31, 62, 124, 248

if (l == i) 		{ 			printf("%d its facrors are", i); 			for (m = 0; m<k; m++) 				printf("%d,", a[m]);

设个断点调试。 l += a[k];这句话中k越界了，你数组a只有20个空间，k远远大于20


Question: 请教一个问题更优的算法

两种方案：  １：先输入所有数据，然后用快排排序，快排平均时间复杂度是O(nlogn),但最坏情况时间复杂度为O(n^2)，不过快排函数Ｃ语言的标准库已经帮你实现了：qsort,直接用就可以了。  ２：用红黑树保存数据，在输入数据的时候就直接进行了排序，红黑树插入操作最坏情况时间复杂度为O(log(n))，所以输入+排序总的时间复杂度为O(nlogn)，但红黑树你要自己实现。

＜1000个元素，冒泡排序 ＜100000个元素，qsort函数 ＜10000000个元素，放数据库中，建索引，（B+树排序） ≥10000000个元素，没用到过。

楼主你用的是冒泡排序吧，这个有什么说的，肯定超时，最慢的算法

关于排序，还是数据结构里面的几种算法比较成熟，这里可以使用哈希排序算法，n lg(n)，的时间复杂度，用两个嵌套就行了

谢谢各位的指点，学到了不少新知识

引用 1 楼 zhangxiangDavaid 的回复:使用qsort()：  #include <search.h> typedef struct point { 	int s; 	int x; 	int y; }Point; Point *ps; int i, n; int cmp(Point *p1, Point *p2) { 	if (p1->x < p2->x) return 0; 	else if (p1->x > p2->x) return 1; 	else return p1->y > p2->y; } int main() { 	scanf("%d", &n); 	ps = malloc(sizeof(Point)*n); 	i = 0; 	//读入坐标 	while (i < n) 	{ 		scanf("%d%d%d", &ps[i].s, &ps[i].x, &ps[i].y); 		i++; 	} 	qsort(ps, n, sizeof(Point), cmp); 	for (i = 0; i < n; i++) printf("%d ", ps[i].s); 	printf("\n"); 	free(ps); 	return 0; }  引用 1 楼 zhangxiangDavaid 的回复:使用qsort()：  #include <search.h> typedef struct point { 	int s; 	int x; 	int y; }Point; Point *ps; int i, n; int cmp(Point *p1, Point *p2) { 	if (p1->x < p2->x) return 0; 	else if (p1->x > p2->x) return 1; 	else return p1->y > p2->y; } int main() { 	scanf("%d", &n); 	ps = malloc(sizeof(Point)*n); 	i = 0; 	//读入坐标 	while (i < n) 	{ 		scanf("%d%d%d", &ps[i].s, &ps[i].x, &ps[i].y); 		i++; 	} 	qsort(ps, n, sizeof(Point), cmp); 	for (i = 0; i < n; i++) printf("%d ", ps[i].s); 	printf("\n"); 	free(ps); 	return 0; }   谢谢指点

引用 2 楼 hnwyllmm 的回复:我的思路是用内存换时间 其实X坐标的个数最多也就20W，那就弄个大小是20W的数组，每个数组的索引是X，每个数组的元素是一个链表，链表按照Y来排序 当然，这种算法如果遇到所有X相同，只有Y不同的时候，那效率就灰常低了  空间时间折中的排序算法是桶排序，原理类似，但是内存用的少一些，楼主可以搜索一下，看看会不会有启发 引用 2 楼 hnwyllmm 的回复:我的思路是用内存换时间 其实X坐标的个数最多也就20W，那就弄个大小是20W的数组，每个数组的索引是X，每个数组的元素是一个链表，链表按照Y来排序 当然，这种算法如果遇到所有X相同，只有Y不同的时候，那效率就灰常低了  空间时间折中的排序算法是桶排序，原理类似，但是内存用的少一些，楼主可以搜索一下，看看会不会有启发  你好，这是我自己写的代码，但提交后是Time Limit Exceeded ，麻烦指点一下其中可以优化的地方，谢谢  #include<stdio.h> #include<stdlib.h> struct zuobiao {     int xuhao;     int x;     int y; };  int main() {     int n,i,t;      struct zuobiao *p;      scanf("%d",&n);      p=(struct zuobiao*)malloc((n+1)*sizeof(struct zuobiao));      for(i=1;i<=n;i++)     {         scanf("%d%d%d",&(p+i)->xuhao,&(p+i)->x,&(p+i)->y);     }      for(i=1;i<n;i++)         for(t=i+1;t<=n;t++)     {         if(((p+i)->x)>((p+t)->x)||((p+i)->x)==((p+t)->x)&&((p+i)->y)>((p+t)->y))         {             p[0]=p[i];             p[i]=p[t];             p[t]=p[0];         }     }      for(i=1;i<=n;i++)         printf("%d ",(p+i)->xuhao);      printf("\n");          return 0; }

引用 2 楼 hnwyllmm 的回复:我的思路是用内存换时间 其实X坐标的个数最多也就20W，那就弄个大小是20W的数组，每个数组的索引是X，每个数组的元素是一个链表，链表按照Y来排序 当然，这种算法如果遇到所有X相同，只有Y不同的时候，那效率就灰常低了  空间时间折中的排序算法是桶排序，原理类似，但是内存用的少一些，楼主可以搜索一下，看看会不会有启发  好的，我试试

感觉这个数据是＜10W的 用快排可能好点把？


Question: 怎么样用VC实现，已知若干离散点，用圆弧拟合，求出圆心坐标和半径

自己用几何不能实现吗,就几个公式, 两根弦,中心线交叉,得到圆心......

圆弧拟合 源码 http://www.baigoogledu.com/s.php?hl=zh-CN&q=%D4%B2%BB%A1%C4%E2%BA%CF+%D4%B4%C2%EB


Question: 菜鸟请教广工一道OJ题

你两层for当然TLE啊，看看n有多大。这题显然要做线性算法

引用 1 楼 user-1 的回复:你两层for当然TLE啊，看看n有多大。这题显然要做线性算法  谢谢你的回复


Question: 结构体中点号

vs下，也可使用  struct Data { 	int a; 	int b; }; int main(void) { 	struct Data d = 	{ 		.a = 12, 		.b = 13, 	}; 	printf("d.a=%d,d.b=%d\n", d.a, d.b); 	return 0; }

如果在使用这个结构体GT2005_plat 时，使用方法还是和普通的初始化方式一样吧

2L 正解，  内核里到处是这种代码。

这是GCC的扩展语法，为了方便初始化 .后面的都是结构体成员名字

是不是对一个结构体变量的初始化。


Question: 关于同一个程序不同编译器下运行结果不同的问题

引用 5 楼 u014444402 的回复:lf的问题吧。换成f就成了。 为什么呢？？？

有没有其它的代码干扰？

lf的问题吧。换成f就成了。

引用 1 楼 zhangxiangDavaid 的回复:意外，匪夷所思，你再试试 确定，每次的结果都是啊

引用 1 楼 zhangxiangDavaid 的回复:意外，匪夷所思，你再试试  试了好几次了

不大可能吧 你确定codeblocks执行的代码是这个？

意外，匪夷所思，你再试试


Question: 结构体在主函数之上定义如何在文件子函数中使用 Dev c++

那个#include后面的"另一个.c"是我用的文件包含啊.

你把main函数放在最底下就可以了啊，还有，你为什么会include一个.c文件

将相关头文件添加到当前项目中。

你前面的是struct stu，而在函数lingyige() 中的是struct student 如图：

3楼说的我知道错了,但是我又修改了错误,还是和原来的错误一样````而且,我在做的另一个包括很多子程序的这种形式主函数,结构也不能用.

编译器问题，可以这样使用：  struct stu { 	int a; 	char b; }; int main(void) { 	//声明struct stu类型的变量 	struct stu s; 	s.a = 12; 	s.b = 13; 	return 0; }

但是我想用的是文件子函数.....


Question: 求助：嗯！代吗现在读写数字并保存进文件可以了，但当名字改成汉字时就会不能输出原始数据了

程序员的常识之一：不要将程序源代码或项目或exe放在桌面这种复杂（多半带空格和汉字且在防火墙或杀毒软件严密控制的C盘上）的目录下。

打开文件前 加上这个试试  std::locale::global(std::locale("")); 另外路径少用中文


Question: opengl 的画曲线函数 gluNurbsCurve（）的控制点二维数组怎么赋值？

引用 2 楼 guoyunfei1 的回复:谢谢啊 百万军中取上将首级如探囊取物，千万行里改关键源码在弹指瞬间。

谢谢啊

GLfloat ** ctrlpoints;       //new 一个动态二维数组     ctrlpoints = new float * [9];     for (i = 0;i < 9;i++)         ctrlpoints[i]= new float [3]; 改成 GLfloat *ctrlpoints;       //new 一个动态二维数组     ctrlpoints = new float [9*3];  for(i=0;i<9;i++)          //给二维数组赋值     {         for(j=0;j<3;j++)         {           ctrlpoints[i*3+j] = buffCtlPts[i][j] ; //把控制点数据传给变量         }     } 试试看


Question: C语言使用free报错

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 仅供参考：//带表头结点的单向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> struct NODE {     int          data;     struct NODE *next; } H,*head,*p,*q,*s1,*s2,*s3,*s4,*s; int i,j,k,n,t,m; int main() {     srand(time(NULL));      //填写头节点数据     H.data=-1;     H.next=NULL;     head=&H;      //创建10个节点的单链表     p=head;     for (i=0;i<10;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) return 1;         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         p->next=q;         p=q;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将值为5的结点插入到单链表的第k个结点前     k=3;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) return 1;             q->data=5;             q->next=p->next;             p->next=q;             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //删除第k个节点     k=5;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=p->next;             if (q) {                 p->next=q->next;                 free(q);             }             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //从小到大排序     for (p=head;p!=NULL && p->next!=NULL;p=p->next) {         for (q=p->next;q!=NULL && q->next!=NULL;q=q->next) {             if (p->next->data > q->next->data) {                  //交换data //              printf("swap %02d %02d\n",p->next->data,q->next->data); //              t=p->next->data;p->next->data=q->next->data;q->next->data=t;                  //或者                  //交换next //              printf("swap %02d %02d\n",p->next->data,q->next->data);                 s1=p->next;                 s2=p->next->next;                 s3=q->next;                 s4=q->next->next;                  if (s2!=s3) {                      p->next=s3;                     s3->next=s2;                      q->next=s1;                     s1->next=s4;                 } else {                      p->next=s3;                     s3->next=s1;                            q=s3;                     s1->next=s4;                 }                  //输出整个单链表 //              s=head->next; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d->",s->data); //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将单链表中前 m 个结点和后 n 个结点进行互换,m+n为链表总长10     m=4;     n=6;     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m+1==k) {             q=p;         }         s=p;         p=p->next;     }     s1=head->next;     head->next=q->next;     s->next=s1;     q->next=NULL;      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //释放所有节点     p=head->next;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //18->94->58->17->27->20->43->57->75->78-> //18->94->05->58->17->27->20->43->57->75->78-> //18->94->05->58->27->20->43->57->75->78-> //05->18->20->27->43->57->58->75->78->94-> //43->57->58->75->78->94->05->18->20->27-> //

free失败一般是 1.free不是malloc的内存 2.双重free，释放已经释放的内存

/*把线程数组加入到队列中*/ void addQueue() { 	ready->head = ready->tail = NULL; 	for (int i = 0; i < count; i++) { 		if (i == 0) { 			ready->head = &pcbs[i]; 			pcbs[0].next = &pcbs[1];   //加一句 		} 		else if (i == count - 1) { 			ready->tail = &pcbs[count - 1]; 		}  		if (i < count - 1) { 			pcbs[i].next = &pcbs[i + 1]; 		} 	} }

部分修改：  /*删除线程操作*/ void delete() { 	PCB *pb, *pre; 	pre = NULL; 	pb = ready->head; 	while (pb && pb->needTime) 	{ 		pre = pb; 		pb = pb->next; 	} 	if (NULL == pre) 	{ 		//free(pb); 		ready->head = ready->tail = NULL; 	} 	else 	{ 		pre->next = pb->next; 	} 	free(pb); 	//ready->head = pb->next; 	//	free(pb); 	count--; 	//if (ready->head == NULL) { 	//	ready->tail = ready->head; 	//} }  //运行 void priorityRun(int n) { 	priorityCreate(n); 	initReady(); 	addQueue(); 	sort(); 	while (count != 0) { 		PCB *pcb = ready->head;//取出队列头部的 		pcb->needTime--; 		pcb->priority = pcb->priority - 3; 		printf("队列%s	  进程剩余需要的时间为%d	优先级剩余为%d \n", pcb->name, pcb->needTime, pcb->priority); 		if (pcb->needTime == 0) { 			delete(); 		} 		//else { 			sort();   //只要有线程的优先级发生变化，就要排序 		//} 	} }

引用 5 楼 zhangxiangDavaid 的回复: /*对队列排序*/ void sort() { 	//何用？ 	//for (int i = 0; i<count; i++) { 	//	if (i == 0) { 	//		pcbs[i] = *ready->head; 	//	} 	//	else { 	//		pcbs[i] = *pcbs[i - 1].next;   // 	//	}  	//}  	for (int i = 0; i < count; i++) { 		for (int j = count - 1; j > i; j--) { 			if (pcbs[j].priority > pcbs[j - 1].priority) { 				PCB temp; 				temp = pcbs[j]; 				pcbs[j] = pcbs[j - 1]; 				pcbs[j - 1] = temp; 			} 		} 	} 	addQueue();//对拍好序的数组加入到队列 }  如果把线程删除以后，数组中的元素就改变了，所以把队列中的线程再给数组赋一遍，保证数组中没有删除的那个线程

/*按照优先权法创建线程*/ void priorityCreate(int n) {     char name[5];     PCB *p;     printf("请输入进程每个进程的名字：\n");     for (int i = 0; i < n; i++) {         gets_s(name,5);         p = (PCB *)malloc(sizeof(PCB));         strcpy(p->name, name);         p->priority = rand() % 10 + 10;         p->needTime = rand() % 5 + 5;         p->next = NULL;           pcbs[i] = *p;         count++;     }   }

点击中止，alt+7打开调用堆栈，双击查看，进行调试


Question: 关于调试

F9设断点，F5运行，F10单步执行，F11进入函数，好了差不多这样，然后看看监视器。

网上搜呗。如：vs调试技巧

调试没有技巧，在你觉得有问题的地方下断点，查看局部变量运行到此处的值，是否异常。其它变量watch


Question: 关于循环链表解决约瑟夫环的问题

代码有内存泄露的问题，值得注意

修改如下：  void JOSEPHU(int n, int m) { 	int i, j; 	list = NULL; 	for (i = 1; i <= n; i++) 	{ 		p = (struct node*)malloc(sizeof(node)); 		p->data = i; 		if (list == NULL) 			list = p; 		else 			r->next = p; 		r = p; 	} 	p->next = list;    /*建立一个循环链表*/ 	p = list; 	for (i = 1; i <= n; i++) 	{ 		printf("%d  ", p->data); 		p = p->next; 	} 	printf("\n"); /*打印链表,并检查循环链表是不输入正确*/ 	for (i = 1; i<n; i++) 	{ 		for (j = 1; j<m; j++) 		{ 			r = p; 			p = p->next; 		} 		printf("出局人:%d\n", p->data); 		r->next = p->next; 		p = p->next;     //加一句 	} }


Question: 求解

…………………… #include <stdio.h>  int main(void) { 	int a, b; 	while (scanf("%d+%d", &a, &b) != EOF) 	{ 		printf("%d\n", a+b); 	} 	return 0; }

修改后， 15行   n = strlen(A) > strlen(B) ? strlen(A) : strlen(B);  多余

有bug，修改如下：  char A[4], B[4]; int main(void)//39 { 	int i, j, n; 	i = j = 0; 	char str[10]; 	scanf("%s", str);  	while ('+' != str[i]) i++; 	i--; 	while (i > -1) A[j++] = str[i--]; 	i = strlen(str) - 1; 	j = 0; 	while ('+' != str[i]) B[j++] = str[i--]; 	n = strlen(A) > strlen(B) ? strlen(A) : strlen(B); 	if (strlen(A) >= strlen(B)) 	{ 		for (i = 0; i < strlen(B); i++) 		{ 			j = A[i] - '0' + B[i] - '0'; 			A[i] = j % 10 + '0'; 			A[i + 1] += j / 10; 		} 		i = strlen(A) - 1; 		while (i > -1) printf("%c", A[i--]); 	} 	else 	{ 		for (i = 0; i < strlen(A); i++) 		{ 			j = A[i] - '0' + B[i] - '0'; 			B[i] = j % 10 + '0'; 			B[i + 1] += j / 10; 		} 		i = strlen(B) - 1; 		while (i > -1) printf("%c", B[i--]); 	} 	printf("\n"); 	return 0; }

这样可好：  char A[4], B[4]; int main(void) { 	int i, j, n; 	i = j = 0; 	char str[10]; 	scanf("%s", str); 	while ('+' != str[i]) i++; 	i--; 	while (i > -1) A[j++] = str[i--]; 	i = strlen(str) - 1; 	j = 0; 	while ('+' != str[i]) B[j++] = str[i--]; 	n = strlen(A) > strlen(B) ? strlen(A) : strlen(B); 	for (i = 0; i < n; i++) 	{ 		j = A[i] - '0' + B[i] - '0';  		A[i] = j % 10 + '0';  		if (j >= 10) A[i + 1] += j / 10; 	} 	i = strlen(A) - 1; 	while (i > -1) printf("%c", A[i--]); 	printf("\n"); 	return 0; }


Question: malloc的使用？

其实电脑开机后物理内存的每个字节都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。  借邻居家一分地种菜，为什么我刚才种了一亩，邻居家也没来人痛扁我呢？

开车要求系安全带，但你想偷懒就是不系，结果开了几次发现没啥事，但反过来不能说明不系安全带就是正确的。对于你系不系安全带的问题，交警部门也不可能在每辆车启动时来检查你有没有系安全带。说的有点罗嗦，自己体会吧。

不要违法操作，虽然不一定出事，但做多了，一定会出事。

引用 楼主 liguanjun09050642 的回复:按照某课本写的栈，用函数malloc将预分配空间设置为1，为什么输入10个数字没有报错？ #include <iostream> using namespace std; #include <stdlib.h>  #define SInitSize 1 #define SizeIncrese 10 #define OVERFLOW 1  typedef  int SElemType ; typedef int Status;  struct Stack {     SElemType *top;     SElemType *base;     int StackSize; };  void InitStack(Stack &s) {     s.base=(SElemType *)malloc(SInitSize*sizeof(SElemType));     if(!s.base)         exit(OVERFLOW);     s.top=s.base; }  void Push(Stack &s, const SElemType e) { /*    if(s.top-s.base>=s.StackSize)         s.base=(SElemType *)realloc(s.base,(s.StackSize+SizeIncrese)*sizeof(SElemType));     if(!s.base)         exit(OVERFLOW); */     *s.top=e;     ++s.top; }  Status Pop(Stack &s, SElemType &e) {     if(s.top==s.base)         return 0;     --s.top;     e=*s.top;     return 1; }  void Print(const Stack &s) {     SElemType *currptr=s.top;     while(currptr!=s.base)     {         --currptr;         cout<<*currptr<<' ';      } }  int main() {     Stack s;     InitStack(s);     SElemType e;     while(cin>>e)         Push(s,e);     Print(s);      return 0; }   引用 1 楼 zhangxiangDavaid 的回复:意外，不可依赖 引用 2 楼 user-4 的回复:别写这种风格的代码..  C 不C  C++不C++的 溢出没报错是因为你颜值高，人品好我是小白

意外，不可依赖


Question: 函数指针， gcc编译报错

pfAppy 最后一个参，搞错了吧  ( ...., pvExtra);   // 没有*  (一般函数指针都习惯直接用)  /// --------------- 乱码..!!!!!  把终端的显示编码调一下。

直接pfApply()


Question: 大神帮看看下面的代码！！从文件中读取数据并建立链表然后输出到屏幕上，结果没有输出原数据

我知道了!应该在从文件中读数据的这段代码 fscanf_s(fp,"%f %f %f %f %f", &p_o->eng, &p_o->math, &p_o->computer, &p_o->ave, &p_o->sum);  的格式控制串最后加一个\n就行了啦！ 还是谢谢大神的耐心解答啦！

引用 11 楼 baidu_27937801 的回复:[quote=引用 10 楼 zhangxiangDavaid 的回复:] 9.00后回车 "%ld %s %.1f %.1f %.1f %.2f %.2f\n"  这是我写入文件时的数据格式，是要用\r字符吗[/quote] 贴出所以源码和stu.txt，我直接给你改好

引用 10 楼 zhangxiangDavaid 的回复:9.00后回车 "%ld %s %.1f %.1f %.1f %.2f %.2f\n"  这是我写入文件时的数据格式，是要用\r字符吗

这个是我保存数据到文件的代码 void save_file(STUDENT *head) { 	FILE *fp_sa; 	STUDENT *p; 	char ch1 = '\n',ch2='\r'; 	system("cls"); 	if (fopen_s(&fp_sa,"stu.txt", "w") != 0)//文件读指针fp_s指向文件信息区,打开方式为写 	{ 		printf("文件打开失败！\n");//文件打开失败提示语 		exit(0); 	} 	p = head->next; 	while (p != NULL)//输出数据到文件 	{ 		fprintf(fp_sa, FORMAT_DATA, p->ID, p->name, p->eng, p->math, p->computer, p->ave, p->sum); 		p = p->next; 	} 	fputc(ch2,fp_sa); 	fputc(ch1, fp_sa); 	fclose(fp_sa); 	printf("\n******************************保存完毕****************************\n"); }

引用 7 楼 zhangxiangDavaid 的回复:采用换行结束 这个具体应该怎么用呢？我刚才试了下没成功

采用换行结束

引用 5 楼 baidu_27937801 的回复:[quote=引用 4 楼 zhangxiangDavaid 的回复:] 一次性读出，试试：  fscanf(fp, "%ld%s%lf%lf%lf%lf%lf\n", &p_s->ID, p_s->name, &p_s->eng, &p_s->math, &p_s->computer, &p_s->ave, &p_s->sum);  不好意思哈点错啦 我又改了下输出前面的数据是没问题了，但最后还是会输出一堆乱码。代码如下 ************************************************************************************** void function_output() { 	STUDENT *head_s, *p_o, *last_s, *p; 	FILE *fp; 	system("cls"); 	if (fopen_s(&fp, "stu.txt", "r") != 0) 	{ 		printf("文件打开失败！\n");//打开失败提示语 		exit(0); 	} 	head_s = (STUDENT*)malloc(L); 	last_s = head_s; 	while (!feof(fp))//读取文件并创建链表 	{ 		p_o = (STUDENT *)malloc(L); 		fscanf_s(fp,"%ld", &p_o->ID); 		fscanf_s(fp, "%*c"); 		fgets(p_o->name,sizeof(p_o->name),fp); 		fscanf_s(fp,"%f %f %f %f %f", &p_o->eng, &p_o->math, &p_o->computer, &p_o->ave, &p_o->sum); 		last_s->next = p_o; 		last_s = last_s->next; 	} 	last_s->next = NULL; 	fclose(fp); 	p = head_s->next;//指向头结点 	printf("\n所有学生信息如下：\n"); 	printf(FORMAT_HEAD, "学号", "姓名", "英语", "数学", "计算机", "平均成绩", "总成绩"); 	while (p != NULL) 	{ 		printf(FORMAT_DATA, p->ID, p->name, p->eng, p->math, p->computer, p->ave, p->sum);//输出当前结点包含的信息 		p = p->next;//指向下一个结点	 	} 	printf("\t\t   ┌─────┐\n"); 	printf("\t\t   │输出完成！│\n"); 	printf("\t\t   └─────┘\n"); 	system("pause"); } ************************************************************************************************************************************ 截图如下 [/quote] 把stu.txt中最后一行数据一换行结束

引用 4 楼 zhangxiangDavaid 的回复:一次性读出，试试：  fscanf(fp, "%ld%s%lf%lf%lf%lf%lf\n", &p_s->ID, p_s->name, &p_s->eng, &p_s->math, &p_s->computer, &p_s->ave, &p_s->sum);  不好意思哈点错啦 我又改了下输出前面的数据是没问题了，但最后还是会输出一堆乱码。代码如下 ************************************************************************************** void function_output() { 	STUDENT *head_s, *p_o, *last_s, *p; 	FILE *fp; 	system("cls"); 	if (fopen_s(&fp, "stu.txt", "r") != 0) 	{ 		printf("文件打开失败！\n");//打开失败提示语 		exit(0); 	} 	head_s = (STUDENT*)malloc(L); 	last_s = head_s; 	while (!feof(fp))//读取文件并创建链表 	{ 		p_o = (STUDENT *)malloc(L); 		fscanf_s(fp,"%ld", &p_o->ID); 		fscanf_s(fp, "%*c"); 		fgets(p_o->name,sizeof(p_o->name),fp); 		fscanf_s(fp,"%f %f %f %f %f", &p_o->eng, &p_o->math, &p_o->computer, &p_o->ave, &p_o->sum); 		last_s->next = p_o; 		last_s = last_s->next; 	} 	last_s->next = NULL; 	fclose(fp); 	p = head_s->next;//指向头结点 	printf("\n所有学生信息如下：\n"); 	printf(FORMAT_HEAD, "学号", "姓名", "英语", "数学", "计算机", "平均成绩", "总成绩"); 	while (p != NULL) 	{ 		printf(FORMAT_DATA, p->ID, p->name, p->eng, p->math, p->computer, p->ave, p->sum);//输出当前结点包含的信息 		p = p->next;//指向下一个结点	 	} 	printf("\t\t   ┌─────┐\n"); 	printf("\t\t   │输出完成！│\n"); 	printf("\t\t   └─────┘\n"); 	system("pause"); } ************************************************************************************************************************************ 截图如下

引用 2 楼 zhangxiangDavaid 的回复:试试：  fscanf_s(fp, "%ld", &p_s->ID); //fscanf_s(fp, "%*c"); //fgets(p_s, sizeof(p_s->name), fp); fscanf(fp, "%s", p_s->name);   //如果姓名用字符串存储 fscanf_s(fp, "%lf%lf%lf%lf%lf", &p_s->eng, &p_s->math, &p_s->computer, &p_s->ave, &p_s->sum);  姓名是用字符串儿储存的，但这样不行 报fscanf出错 ********************************************************************************** 错误	1	error C4996: 'fscanf': This function or variable may be unsafe. Consider using fscanf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.	d:\实验三\1.c	148	1	实验三 ****************************************************************************************** 改成fscanf_s后会在fscanf(fp, "%s", p_s->name);  报访问冲突的错

姓名使用什么类型存储的？


Question: 来大神帮帮忙，如下程序是文件的写入部分形式，怎么按照写入格式读取出来再写入到文本文件？？

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

不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了

引用 3 楼 qq_28058879 的回复:求大神们    不要用数组的   不知道 有几个值 malloc,realloc,free

求大神们    不要用数组的   不知道 有几个值

bool save_to_file(const char *filename) {  	int i; 	FILE *fp; 	size_t written;  	double dx = m_dx * m_spatial_scale; 	double dy = m_dy * m_spatial_scale; 	double dz = m_dz * m_spatial_scale;   	if (m_buf_idx == NULL) return false;  	fp = fopen(filename, "wb"); 	if (!fp) return false;   	//nx,ny,nz 	fwrite(&m_numx, sizeof(int), 1, fp); 	fwrite(&m_numy, sizeof(int), 1, fp); 	fwrite(&m_numz, sizeof(int), 1, fp); 	//dx, dy, dz 	for (i = 0; i < m_numx; i++) { 		fwrite(&dx, sizeof(double), 1, fp); 	} 	for (i = 0; i < m_numy; i++) { 		fwrite(&dy, sizeof(double), 1, fp); 	} 	for (i = 0; i < m_numz; i++) { 		fwrite(&dz, sizeof(double), 1, fp); 	} 	//material index buf 	//m_bufsize = m_numx * m_numy * m_numz; 	written = fwrite(m_buf_idx, sizeof(uint16_t), m_bufsize, fp); 	//material index buf 	fclose(fp);  	if (written != m_bufsize) return false;  	return true; }   这是写入的函数

char *filename = "1.txt"; #define m_bufsize 4 typedef unsigned __int16 uint16_t; int write() { 	FILE *fp; 	size_t written; 	fp = fopen(filename, "wb"); 	if (!fp) return 0; 	unsigned __int16 m_buf_idx[4] = { 12, 14, 16, 18 }; 	//material index buf 	//m_bufsize = m_numx * m_numy * m_numz; 	written = fwrite(m_buf_idx, sizeof(uint16_t), m_bufsize, fp); 	//material index buf 	fclose(fp);  	if (written != m_bufsize) return 0; 	return 1; } int read() { 	FILE *fp; 	size_t readn; 	fp = fopen(filename, "rb"); 	if (!fp) return 0; 	uint16_t m_buf_idx[m_bufsize]; 	readn = fread(m_buf_idx, sizeof(uint16_t), m_bufsize, fp); 	fclose(fp); 	if (readn != m_bufsize) return 0; 	//写入新的文件 	fp = fopen("2.txt", "wb"); 	if (!fp) return 0; 	size_t written; 	written = fwrite(m_buf_idx, sizeof(uint16_t), m_bufsize, fp); 	fclose(fp); 	if (written != m_bufsize) return 0; 	return 1; } int main(void) { 	if (write()) printf("write success\n"); 	else printf("write fail\n"); 	if (read()) printf("read success\n"); 	else printf("read fail\n");  	return 0; }


Question: 菜鸟请教为什么会得到runtime error

引用 6 楼 brookmill 的回复:你们两个的代码，在输入“20 9”的时候结果不一样。 我把你的这一行  sum=sum+k*(shang/xia); 改成            fact = k*(shang/xia);    sum=sum+fact; 这样结果就一样了。 至于为什么，我也不知道，可能是浮点数计算的误差造成的。  你好，按你的改了，但提交后还是Runtime Error，按OJ返回的这个结果可能是除数为0，但个人又觉得不太可能，请问你觉得会不会有可能

引用 3 楼 brookmill 的回复:直接算pow(x,i)/(t!)肯定会爆的。 我觉得应该分步计算，大致像是类似这样：x/(1*2*3)*x/(4*5)……但是又涉及到精度控制，我也没想好具体应该怎么做。  这是我同学的代码，感觉我的跟他的思路差不多，但为什么他提交就对而我却是错的呢，请问我们两个的代码哪里不一样呢？  #include<stdio.h> #include<math.h> int main() {     double sinx,x;     int n;     while(scanf("%lf%d",&x,&n)!=EOF)     {         double fenzi,fenmu,xiang,flag,k;         int i,j;         flag=-1;         sinx=0;         k=pow(10,-n);         i=1;         xiang=1;         while(fabs(xiang)>=k)         {             flag=-1*flag;             fenmu=1;             fenzi=pow(x,2*i-1);              for(j=1;j<=2*i-1;j++)             fenmu=fenmu*j;              xiang=flag*(fenzi/fenmu);              sinx=sinx+xiang;             i++;         }       printf("%.*lf\n",n,sinx);     }     return 0; }

看来是一个数据范围的问题

这样直接算阶乘，fact的结果会爆表吧。 注意题目说x是任意实数，那么当x很大的时候pow(x,i)就会超出double的范围了

看不出有啥子问题


Question: fscanf的用法

Read formatted data from a stream. More secure versions of these functions are available; see fscanf_s, _fscanf_s_l, fwscanf_s, _fwscanf_s_l. Parameters stream Pointer to FILE structure. format Format-control string. argument Optional arguments. locale The locale to use. Return Value Each of these functions returns the number of fields successfully converted and assigned; the return value does not include fields that were read but not assigned. A return value of 0 indicates that no fields were assigned. If an error occurs, or if the end of the file stream is reached before the first conversion, the return value is EOF for fscanf and fwscanf. These functions validate their parameters. If stream or format is a null pointer, the invalid parameter handler is invoked, as described in Parameter Validation. If execution is allowed to continue, these functions return EOF and set errno to EINVAL. Remarks The fscanf function reads data from the current position of stream into the locations given by argument (if any). Each argument must be a pointer to a variable of a type that corresponds to a type specifier in format. format controls the interpretation of the input fields and has the same form and function as the format argument for scanf; see scanf for a description of format. fwscanf is a wide-character version of fscanf; the format argument to fwscanf is a wide-character string. These functions behave identically identically if the stream is opened in ANSI mode. fscanf doesn't currently support input from a UNICODE stream. The versions of these functions with the _l suffix are identical except that they use the locale parameter passed in instead of the current thread locale.

fscanf()是读 fprintf()是写  #include<stdio.h> int main(void) { 	FILE * Testfscanf; 	char name[15] = "Testfscanf";  	if ((Testfscanf = fopen("Testfscanf.txt", "a+")) == NULL) { 		fprintf(stderr, "error"); 	} 	//fscanf(Testfscanf, "%s", name);   //读 	fprintf(Testfscanf, "%s", name);    //写 	fclose(Testfscanf); 	return 0; }


Question: 【求助】 malloc首次执行有错，先执行其他，没错

你的代码中，malloc申请的内存大小只和len有关，和i无关

贴完整的代码，另外是不是申请太大，不够

for（i） for循环到底怎么写的

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。


Question: Linux 这个现象是内存泄漏吗？

引用 4 楼 Kende0120 的回复:[quote=引用 2 楼 hnwyllmm 的回复:] RSS增长不一定是内存泄露 RSS：该进程占用的物理内存的总数量，单位是KB。 进程占用的内存首先体现在虚拟内存上，如果进程访问到某个内存的时候，才会给他分配真实的物理内存。当然物理内存是有限的，如果增长到限制的最大值，那就不会再增长了，这时候不增长也不能说没有内存泄露。 是否真的有内存泄露，可以运行的时间延长，观察进程占用的内存是否确实一直增长 内存泄露检测工具是一种辅助手法，能够帮助程序员检测出肉眼不易观察的内存泄露，但是也不能完全依赖  先纠正一下，不是RSS， 是RES。  程序的处理顺序 ：接收到命令后分配内存，启动子线程，运行后再关掉子线程，最后释放内存。 每次接收到命令后RES都会增大，即使释放内存后也不会减少，而是随着运行的次数增加而持续增大 这个有问题吗？ [/quote] 如果是RES的话，是不是可能用了第三方的内存库，或者内存池，内存并没有释放，因此内核并没有释放对应的物理内存，反而运行时间久了还会增加

引用 3 楼 wangzuxi 的回复:内存泄露调试工具很多，valgrind比较有名  谢谢，我会下载来试用一下。

引用 2 楼 hnwyllmm 的回复:RSS增长不一定是内存泄露 RSS：该进程占用的物理内存的总数量，单位是KB。 进程占用的内存首先体现在虚拟内存上，如果进程访问到某个内存的时候，才会给他分配真实的物理内存。当然物理内存是有限的，如果增长到限制的最大值，那就不会再增长了，这时候不增长也不能说没有内存泄露。 是否真的有内存泄露，可以运行的时间延长，观察进程占用的内存是否确实一直增长 内存泄露检测工具是一种辅助手法，能够帮助程序员检测出肉眼不易观察的内存泄露，但是也不能完全依赖  先纠正一下，不是RSS， 是RES。  程序的处理顺序 ：接收到命令后分配内存，启动子线程，运行后再关掉子线程，最后释放内存。 每次接收到命令后RES都会增大，即使释放内存后也不会减少，而是随着运行的次数增加而持续增大 这个有问题吗？

内存泄露调试工具很多，valgrind比较有名

循环调用疑似泄露的代码， 如果有内存泄露， 效果很明显。


Question: pipe的小问题

引用 2 楼 zhangxiangDavaid 的回复: nbytes = (fd[0],readbuffer,sizeof(readbuffer));  //改为 nbytes = read(fd[0],readbuffer,sizeof(readbuffer)); 果然如此，大牛，我太粗心大意了

好像没有写入数据，后面就直接开始读了，然后无线循环读………………


Question: 求解*与++的优先级问题

引用 12 楼 woaixupan 的回复:不同编译器结果不一样，纠结这个问题有何意义？把这个搞懂了能得到什么？ 得到老师表扬

不同编译器结果不一样，纠结这个问题有何意义？把这个搞懂了能得到什么？

引用 10 楼 bear234 的回复:话说编程多年了，从来没记住过优先级...........都是括号搞定.... 怎么不好好看题目啊！ 同学，这个问题与优先级没有关系嘛， 我就不信这个题目你用括号能搞定！

自己写代码搞不清楚算符优先级请多加括号。 看别人代码搞不清楚算符优先级能调试的话请单步调试对应汇编。 看别人代码搞不清楚算符优先级不能调试的话想办法照写一小段孤立的可调试的代码然后单步调试对应汇编。 看别人代码搞不清楚算符优先级不能调试的话且没有办法照写一小段孤立的可调试的代码然后单步调试对应汇编的话只能参考算符优先级表猜了（提醒：并不能100%猜对）。 //C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+

话说编程多年了，从来没记住过优先级...........都是括号搞定....

出这种题目的人，应该拉出去爆菊

了解一下c++中 “顺序点”的概念吧

没有人会这样写代码，至少我带的团队绝对不能这样干

类似的题快成月经贴了  学校都教了些什么啊？

题目是错的  看置顶帖补补课

引用 1 楼 user-9 的回复:*　>　++ 写反了是*　<　++


Question: CSV 以及其他dat文件通过C语言读取到ORACLE 数据库

inotify 监控文件变动情况，OCCI 插数据库


Question: 关于2048的问题

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 ); }

引用 1 楼 user-3 的回复:Srand这个函数应该只运行一次，他是随机数种子，起初始化作用。你把它放在每一个随机数函数执行之前是多余的， 原来是这样

参考代码段： https://github.com/707wk/Senior-middle-school/tree/master/2048


Question: 谁能帮我设计一个C语言游戏,就是输入a或b,最后输出a或b

2楼概念错误！ a==b等价于!a>b && !b>a

这样可好：  #include <stdio.h> #include <time.h> int a, b; char choice; int main(void) { 	srand(time(NULL)); 	while (1) 	{ 		a = rand() % 100; 		b = rand() % 100; 		do 		{ 			printf("input a or b :"); 			scanf("%c", &choice); fflush(stdin); 		} while ('a' != choice && 'b' != choice); 		printf("a=%d,b=%d\n", a, b); 		switch (choice) 		{ 		case 'a':  			if (a >= b) printf("Win\n"); 			else printf("Fail\n"); 			break; 		case 'b': 			if (b >= a) printf("Win\n"); 			else printf("Fail\n"); 			break; 		} 	} 	return 0; }

#include <stdio.h> #include <stdlib.h> #include <time.h> int a,b; char g; int main() {     srand(time(NULL));     a=rand();     b=rand();     while (1) {         printf("I have two number a and b,please guess which is bigger(a or b):");fflush(stdout);         rewind(stdin);         scanf("%c",&g);         if ('a'==g || 'b'==g) break;     }     if (('a'==g && a>b)       ||('b'==g && b>a)) {         printf("Lucky! You get it! a,b is %d,%d\n",a,b);     } else {         printf("Sorry! You loose. a,b is %d,%d\n",a,b);     }     return 0; } //c:\test>test //I have two number a and b,please guess which is bigger(a or b):c //I have two number a and b,please guess which is bigger(a or b):a //Sorry! You loose. a,b is 12377,17191 // //c:\test>test //I have two number a and b,please guess which is bigger(a or b):a //Lucky! You get it! a,b is 12471,1215 //


Question: 程序通讯协议，服务器给客户端发送一串文本，例如begin/ speed 50 /begin，那么客户端应该怎么去解析这个文本。

protobuf

Socket  对于TCP/UDP协议 直接提取，就可以得到原串....然后对你自己的字符串进行解析就ok了

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

这个一般是怎么写的呢？给个思路，谢谢呀。

服务端和客户端定好发送解析协议。


Question: C语言字符数组

这样可好：  #include <stdio.h> int main() { 	char c[10]; 	c[0] = 'I'; c[1] = ' '; c[2] = 'a'; c[3] = 'm'; c[4] = ' '; c[5] = 'h'; c[6] = 'a'; c[7] = 'p'; c[8] = 'p'; c[9] = 'y'; 	printf("%c%c%c%c%c%c%c%c%c%c\n", c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8], c[9], c[10]); 	printf("%.10s", c); 	return 0; } //I am happy //I am happy

char s[] = "I am happy"; puts(s);

#include <stdio.h> int main(int argc, char *argv[]) {     char c[] = "I am happy";     printf ("%s\n",c);      return 0; }

#include <stdio.h> int main () { char c[]="i am happy",*p=c; while(*p){  printf("%c",*p++);   }  return 0; }  给分吧！

#include <stdio.h>  main() { 	int i=0; 	char c[11]="I am happy"; 	for(i=0;i<10;i++) 	{ 		printf("%c",c[i]); 	} }  ／／不知道这样算简短吗？


Question: 求嵌入式开发板代码解读（要求：对代码整体结构及每行代码进行注释）.一旦选中，可支付宝支付100元人民币。多谢。

请问代码中很多东西我看不懂，虽然我的C代码量有1万行左右，请问我该如何着手。谢谢。

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

这不是已经写的很清楚了吗?


Question: 我用快速幂求矩阵乘积不知道WA在哪里了

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。  “多一少一”问题占程序员常犯错误的10%以上！ 避免“多一少一”问题的方法之一是将比如<10甚至<5的数代入程序片断，搬手指头心算验证一下程序到底应该写为 x、x-1、x+1中的哪个？ <、<=、==、>、>=中的哪个？


Question: 关于数组实现约瑟夫环的问题

几点解释：  各变量的含义： a[N]记录每个人的编号：1、2、3……N b[N]对应每个人是否出局的标记：值0表明人已出局  理解第二个for循环 n从-1开始 for (sum = p; sum > 1; sum--){  //sum>1表明最后只留一人     for (i = 1; i <= 7;) {      //从这里看出数到7的人出局                      n = (n + 1)%p;          //n每次往前走一步，但具体值需对p求余，这是一个环         if (b[n] == 1)          //只有未出局的人才计数，所以只有b[n]为1，才算走了一步             i++;            }            printf(" %d", a[n]);        //打印出局人的编号     b[n] = 0;                   //此人出局 }

约瑟夫问题的数组解法 http://blog.csdn.net/zhangxiangdavaid/article/details/25057811

仅供参考：//假设有n个人团团围做，从第1个人开始数数，数到第m个人时候，第m个人出列， //然后继续从1开始数数，数到第m个人退出 #include <stdio.h> #include <conio.h> int i,k,t; int n,m; static char f[1001];//0该座位未出圈,1该座位已出圈 void main() {     while (1) {         printf("Input n m(1000>=n>=m>=1):");         fflush(stdout);         rewind(stdin);         if (2==scanf("%d%d",&n,&m)) {             if (1000>=n && n>=m && m>=1) break;         }     }     t=0;//已出圈总人数     i=1;//座位编号     k=1;//当前要数的数     while (1) {         if (0==f[i]) {             if (m==k) {                 t++;                 f[i]=1;                 printf("%3d ",i);                 if (0==t%10) printf("\n");                 if (t>=n) break;             }             k++;if (k>m) k=1;         }         i++;if (i>n) i=1;     }     cprintf("Press any key ...");     getch(); }


Question: PIC CAN发送中对错误的处理

我又试了一个上午的中断，无奈的是，貌似IRXIE与IRXIF都不听我的指挥，至少ICD3上的变量表上的值一直不变，但我总觉得实际上是变的。不然不可能在我关闭上位机时，可以进入中断，而第二次发送时却又无法进入了。也不可能发生如下情况，中断将IRXIE关闭，才可以避免连续地反复进入中断，我之所以这么做，是因为我怎么也无法将IRXIF置1。我想过，有无可能中断的进入，其实与IRXIE无关，一直显示0，只是进入之后，判断IRXIF成功了，一直显示1。但并没有找到其他任何低级中断。 最后使用的办法是，  while(TXB0CONbits.TXREQ)     {        // if (!TXB2CONbits.TXREQ) break;         if(TXB0CONbits.TXERR)//break;             TXB0CONbits.TXREQ=0;        // __delay_ms(2);     } 此外，经过测试，delay并不会影响定时器的中断。除非别的地方，有一些错误。 这个中断的问题，暂时搁置，以后希望可以明白。

引用 1 楼 zhao4zhong1 的回复:#include <windows.h> //... TXB0CONbits.TXREQ = 1; //置1，则开始发送 int n; while(1) {  if (!TXB0CONbits.TXREQ) break;//发送完毕，退出  Sleep(100);//延时100ms  n++;  if (n>=600) break;//一分钟超时，退出。 }   我之前用的__delay的函数，但是存在一个问题，因为我计算积分需要精确的定时，但据说__delay中无法进行定时器中断，是这样么？


Question: 自己写的2048，求指导

2048游戏 C源码 http://www.baigoogledu.com/s.php?hl=zh-CN&q=2048%D3%CE%CF%B7+C%D4%B4%C2%EB


Question: 为什么我用keybd_event 没效果

关闭360等流氓软件试试

我也是看伊成的视屏也错在这不知道什么问题，如果解决了请回复下谢谢

问题已经解决 换个系统搞定了

还是不行啊  没效果

keybd_event(0x5b,0,0,0); 	keybd_event('R',0,0,0); 	keybd_event('R',0,2,0); 	keybd_event(0x5b,0,2,0); 可用 我也在看尹成

是不是系统问题 你们用的是不是win8 能实现？？？

keybd_event The keybd_event function synthesizes a keystroke. The system can use such a synthesized keystroke to generate a WM_KEYUP or WM_KEYDOWN message. The keyboard driver's interrupt handler calls the keybd_event function.   Windows NT: This function has been superseded. Use SendInput instead.  VOID keybd_event(   BYTE bVk,           // virtual-key code   BYTE bScan,         // hardware scan code   DWORD dwFlags,      // flags specifying various function options   DWORD dwExtraInfo   // additional data associated with keystroke );   Parameters bVk  Specifies a virtual-key code. The code must be a value in the range 1 to 254.  bScan  Specifies a hardware scan code for the key.  dwFlags  A set of flag bits that specify various aspects of function operation. An application can use any combination of the following predefined constant values to set the flags. Value Meaning  KEYEVENTF_EXTENDEDKEY If specified, the scan code was preceded by a prefix byte having the value 0xE0 (224).  KEYEVENTF_KEYUP If specified, the key is being released. If not specified, the key is being depressed.    dwExtraInfo  Specifies an additional 32-bit value associated with the key stroke.  Return Values This function has no return value.   Remarks Although keybd_event passes an OEM-dependent hardware scan code to the system, applications should not use the scan code. The system converts scan codes to virtual-key codes internally and clears the up/down bit in the scan code before passing it to applications.   An application can simulate a press of the PRINTSCREEN key in order to obtain a screen snapshot and save it to the clipboard. To do this, call keybd_event with the bVk parameter set to VK_SNAPSHOT, and the bScan parameter set to 0 for a snapshot of the full screen or set bScan to 1 for a snapshot of the active window.   Windows CE: Windows CE supports an additional flag for the dwFlags parameter. Use the KEYEVENTF_SILENT flag to simulate a keystroke without making a clicking sound.  Windows CE does not support the KEYEVENTF_EXTENDEDKEY flag.  QuickInfo   Windows NT: Requires version 3.1 or later.   Windows: Requires Windows 95 or later.   Windows CE: Requires version 1.0 or later.   Header: Declared in winuser.h.   Import Library: Use user32.lib.  See Also Keyboard Input Overview, Keyboard Input Functions, GetAsyncKeyState, GetKeyState, MapVirtualKey, SetKeyboardState

按键按下后，需要再设置 KEYEVENTF_KEYUP状态


Question: 向大神求教一个代码运行后与本人期望不符的小问题

引用 3 楼 zhangxiangDavaid 的回复:[quote=引用 2 楼 ma815841356 的回复:] [quote=引用 1 楼 cs_dingz 的回复:] 你把%d\n换成%d空格试试。。  换成空格输出就正常了，这是为何呢？求指点[/quote] 10000以内的素数太多，黑窗口只有这么大，最早输出的，就无法看到了。 素数从2开始，建议从i=2，开始输出[/quote]  谢谢指点

引用 2 楼 ma815841356 的回复:[quote=引用 1 楼 cs_dingz 的回复:] 你把%d\n换成%d空格试试。。  换成空格输出就正常了，这是为何呢？求指点[/quote] 10000以内的素数太多，黑窗口只有这么大，最早输出的，就无法看到了。 素数从2开始，建议从i=2，开始输出

引用 1 楼 cs_dingz 的回复:你把%d\n换成%d空格试试。。  换成空格输出就正常了，这是为何呢？求指点

你把%d\n换成%d空格试试。。