Question: 求救，帮我看看小程序哪有问题

运行：

修改  #include<stdio.h>  int main() { 	char s[2]; 	char ch;  	printf("请键入一个大写字母：\n"); 	while ((ch = getchar()) != '\n') 	{ 		if (('A' <= ch) && (ch <= 'Z')) 			printf("%c的小写形式是%c\n", ch, ch + 32); 		else 			printf("抱歉，您的输入有误\n"); 	}  	system("pause"); 	return 0; }

引用 5 楼 whappymanlynn 的回复:[quote=引用 2 楼 super_miker 的回复:] while((ch=getchar())!='\n') 亲，能告诉我为神魔吗？是我哪里出错了，给点明示[/quote] 赋值运算的优先级低于比较运算

引用 2 楼 super_miker 的回复:while((ch=getchar())!='\n') 亲，能告诉我为神魔吗？是我哪里出错了，给点明示

while里面不能这么写！

引用 2 楼 super_miker 的回复:while((ch=getchar())!='\n') ++

while((ch=getchar())!='\n')

while里面不能这么写！


Question: 使用串口转I2C实现数据的收发总是出现丢数据的现象

1、 要保证 UART发送前的数据的准确。即gu16ReadAddr + u16I2CSendLen 和 gu16WriteAddr + u16I2CSendLen 不溢出等。  2. HW_UartWriteData 什么方式写，没有code，说不出啥。  3. u8Uart1SendBuf 的内容要对。  4. 你说的太模糊了，不知道你的实际情景，input 指从哪儿input，output从哪儿output，。。。


Question: socket tcp connect服务端的问题

在服务端ping其他电脑出现：来自 192.168.0.115 的回复: 无法访问目标主机。  而在其他电脑上ping其他电脑出现的都是：请求超时。

引用 5 楼 focuslight 的回复:先ping 一下    看连接函数返回值  ping 192.168.0.115 结果都是超时，这是为什么  引用 4 楼 zhao4zhong1 的回复:能ping通的话，抓包； ping不通的话，找网管。 ping 192.168.0.115 结果都是超时，你确定这是网络问题了吗？如果是，我就去找网管了，因为找网管不好找

先ping 一下    看连接函数返回值

能ping通的话，抓包； ping不通的话，找网管。

是IOCP，字母打错了

还有，我还想问问，closesocket， 因为我是用ICOP处理数据接收，所以我应该在什么时候使用closesocket关闭连接客户端的socket？

局域网其他电脑连不上，返回的错误吗是: WSAETIMEDOUT 10060 (0x274C)  A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond.

显然你的 局域网的路由上做了访问规则，找网管 ，妥妥的


Question: 个人设计，打印输入中各个字符出现频度的直方图，出现问题求教谢谢。

printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。

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

非常感谢两位指导，我重新编写了下程序后，依旧 ctrl+f5运行 输入hollow world(小学的时候一直以为是hellow，记习惯了，没改回来。。) 程序停止运行      #include <stdio.h> #define MAXCODE 256 /*最大储存为128，冗余128*/   main() { 	int c,q;  	char a[MAXCODE]; /*字符*/ 	int s[MAXCODE] = { 0 }; /*字符出现的次数*/ 	 	 q = 0;   	while ((c = getchar()) != EOF) 	{ 		a[q] = c;/*有新的字符*/ 		 		for (int i = 0; i < q; i++)/*字符 循环重复检测*/ 		{ 			if (a[q] == a[i])/*新出现的字符与已存字符作对比，若相同则此字符次数++。*/ 			{ 				++s[i]; 				--q; 				break; 			} 			 		} 		++q; 	} 	for (int n = 0; n < q; n++) 	{ 		printf("%s", a[n]);/*输出以p为顺序的字符*/ 		for (int m = 0; m < s[n]; m++) 		{ 			printf("*");/*输出出现字符的次数*/ 		} 		printf("\n");/*输出*结束后，换行*/ 	} 	system("pause"); 	return 0; }

引用 8 楼 super_miker 的回复:        printf("%s", a[n]);/*输出以p为顺序的字符*/  这里用%c，%s是字符串  哦，非常感谢~解决了。 tks~~

for (int i = 0; i < MAXCODE; i++)/*字符 循环重复检测*/ MAXCODE改为q for (int n = 0; n < MAXCODE; n++) 同上              if (a[q] == a[i])/*新出现的字符与已存字符作对比，若相同则此字符次数++。*/             {                 ++s[i];                 --q;             }  加个break;              if (m==s[n])/*最后换行*/             {                 printf("\n");             }  移到循环外部并去掉if语句.  顺便hellow是什么鬼...

for ( i = 0; i < q; i++)/*字符 循环重复检测，只需要和已记录的对比*/  			{ 				if (a[q] == a[i])/*新出现的字符与已存字符作对比，若相同则此字符次数++。*/ 				{ 					++s[i]; 					--q; 					break; 				} 			}  			if(i == q)/*没有找到重复的话，s[i]=1，*/ 			{ 				s[i]++; 			}  			++q;

引用 3 楼 w3xse7en 的回复:[quote=引用 2 楼 user-3 的回复:] [quote=引用 1 楼 user-3 的回复:] 没去运行过代码，看了下             if (a[q] == a[i])/*新出现的字符与已存字符作对比，若相同则此字符次数++。*/             {                 ++s[i];                 --q;//这个地方需要跳出循环，直接continue，                continue;             }   说错了，是break;[/quote]  我这里加上去试了下还是停止工作了。[/quote]  写代码逻辑很重要，得清楚你前后的关系，例如你这里的变量q，肯定是记录的字符的个数，那么在打印字符的时候，那么就不该是  for (int n = 0; n < MAXCODE; n++) MAXCODE要换成q  s[i]记录的是对应a[i]字符出现的个数，打印*是没问题的。 但是             if (m==s[n])/*最后换行*/             {                 printf("\n");             } m是无法等于s[n]的，这个需要看下基础知识。         for (int m = 0; m < s[n]; m++)         {             printf("*");/*输出出现字符的次数*/         }            if (m==s[n])/*最后换行*/             {                 printf("\n");             }

引用 2 楼 user-3 的回复:[quote=引用 1 楼 user-3 的回复:] 没去运行过代码，看了下             if (a[q] == a[i])/*新出现的字符与已存字符作对比，若相同则此字符次数++。*/             {                 ++s[i];                 --q;//这个地方需要跳出循环，直接continue，                continue;             }  说错了，是break;[/quote]  我这里加上去试了下还是停止工作了。

引用 1 楼 user-3 的回复:没去运行过代码，看了下             if (a[q] == a[i])/*新出现的字符与已存字符作对比，若相同则此字符次数++。*/             {                 ++s[i];                 --q;//这个地方需要跳出循环，直接continue，                continue;             }  说错了，是break;


Question: 写了个递归的函数， 为什么会报错啊？标题长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长长

你是要这个吧  #include <stdio.h> #include <stdlib.h>  int f(int n, int A, int B) { 	if (n == 1 || n == 2)return 1; 	else return (A*f(n - 1, A, B) + B*f(n - 2, A, B)) % 7; }  int main() { 	int A, B, n; 	while (1) 	{ 		scanf("%d %d %d", &A, &B, &n); 		if (A == 0 && B == 0 && n == 0)break; 		printf("%d\n", f(n, A, B)); 	}  	return 0; }

f不是3个参数吗 你写了1个 f(n-1)


Question: OpenCV中多张图片合成视频中内存不断增加的问题

没释放图像。

cvReleaseImage


Question: 求助 一维数组求重复元素以及个数

要求  输入6个从小到大排列的数字

引用 6 楼 zhangxiangDavaid 的回复: 一楼有bug，  你的输入不符合题目要求

#include<stdio.h> int main() { 	int max_value,cur_value,old_value,max_count=0,cur_count,i;	 	const int SIZE=6; 	for(i=0;i<SIZE;++i) 	{ 		scanf("%d",&cur_value); 		if(!i) 		{ 			old_value=cur_value; 			cur_count=1; 		} 		else if(old_value==cur_value) 			++cur_count; 		else 		{ 			if(cur_count>=max_count) 			{ 				max_value=old_value; 				max_count=cur_count; 			} 			old_value=cur_value; 			cur_count=1; 		} 	} 	if(cur_count>=max_count) 	{ 		max_value=old_value; 		max_count=cur_count; 	} 	printf("value=%d,count=%d\n",max_value,max_count); 	return 0; }

一楼有bug，

引用 4 楼 cfjtaishan 的回复:定义一个数字数组digit[10] = { 0};然后用用一个循环for (i = 0; i <MAX; i++) digit[i]++;最后求一个最大值；是求digit[i]的最大值[

给出的都是Ｎ*Ｎ的算法，可以考虑二叉堆。

#include <memory.h> #include <stdio.h> #define SIZE 6  struct MyNode { 	int value;//值 	int count;//出现次数 	int valid; //是否有效，1有效，0无效 };  int main (void) { 	MyNode nodes[SIZE]; 	memset(nodes,0,sizeof(nodes)); 	int i=0,j=0,temp=0; 	for(i=0;i<SIZE;++i) 	{ 		scanf("%d",&temp); 		for(j=0;j<SIZE;++j) 		{ 			if(nodes[j].value==temp&&nodes[j].valid==1) 			{ 				nodes[j].count++; 			} 			else if (nodes[j].valid==0) 			{ 				nodes[j].value=temp; 				nodes[j].valid=1; 				nodes[j].count=1; 				break; 			} 		} 	} 	MyNode nd=nodes[0]; 	for(i=0;i<SIZE;++i) 	{ 		if(nodes[i].valid==1) 		{ 			if(nd.count<nodes[i].count) 			{ 				nd=nodes[i]; 			} 			else if(nd.count==nodes[i].count&&nd.value<nodes[i].value) 			{ 				nd=nodes[i]; 			} 		} 	} 	printf("value=%d,相同个数为%d\n",nd.value,nd.count); }

Do not let me think! #include <stdio.h> #define SIZE 6 int main () {     int number[SIZE],i,last,j,t,k;     int times[SIZE],n[SIZE];      for (i=0;i<SIZE;i++) {         n[i]=i;         scanf("%d", &number[i]);         if (i==0) {             last=number[i];             times[i]=1;             k=0;         } else {             if (last==number[i]) {                 t=times[i-1];                 for (j=i;j>=k;j--) times[j]=t+1;             } else {                 last=number[i];                 times[i]=1;                 k=i;             }         }     }      for (i=0;i<SIZE-1;i++) {         for (j=i+1;j<SIZE;j++) {             if (times[i]<times[j]) {                 t=times[i];times[i]=times[j];times[j]=t;                 t=n[i];n[i]=n[j];n[j]=t;             }         }     }      if (times[0]>times[1]) {         printf("value=%d, 相同个数为%d\n",number[n[0]],times[0]);     } else {         t=times[0];         for (i=1;i<SIZE;i++) {             if (t!=times[i]) break;         }         t=number[n[0]];         k=0;         for (j=0;j<i;j++) {             if (number[n[j]]>t) {                 t=number[n[j]];                 k=j;             }         }         printf("value=%d, 相同个数为%d\n",t,times[n[k]]);     }      return 0; }


Question: C语言编写小游戏  图像移动很生硬

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


Question: 关于白盒加密源代码，吐血求一个

请问下你找到了白盒加密的实现了吗？ 如果有的话，麻烦发我一下，万分感谢。freeitdog@163.com

啥叫“白盒加密”？ 公开算法的RSA加密是不是“白盒加密”？ 参考OpenSSL源代码。

这些源码一堆，就看怎么使用api了~

但是OpenSSL的环境，最新API获取更新之类的东西就比较麻烦了。

OpenSSL。玩过它的API接口，感觉加解密的接口蛮容易上手的。

I don't know~

大神在哪里呀


Question: 一个简单的问题，新手问的。

引用 11 楼 super_miker 的回复:因为j在第一次循环之后就变成了0，所以之后的循环一开始就不会进去。 如果你要让每次都循环5次，那么每次j初始值都要设为5。 是的，非常对，前面的回答都太高大上了，我听不不懂，但是你的答案我最明白

不知道大家有没有去尝试，我把我的图帖出来，希望大家看看，为什么a的值是5

引用 3 楼 zhao4zhong1 的回复:for (A;B;C) D; //等价于 {  A;  while (1) {   if (!(B)) break;   D;   C;  } }   这个等价描述很形象

是否为局部变量取决于是否定义在函数（包括主函数）内部，如果在定义在函数内部则为局部变量，反之为全局变量。按照楼主的写法，for循环可以访问之前定义的三个变量。顺便说声楼主的 a++' 多了一个单引号。

引用 1 楼 jiht594 的回复:变量的作用域是 大括号{} 这么说太对,  你这里2个for里面都可以访问ija

变量的作用域是 大括号{}

你在循环外定义的，作用域是函数内而不是循环内

没看懂你问的什么

没看懂你问的什么


Question: C fscanf读取错误

fid = fopen("800.hea", "r")  ？是不是800.dat

谢谢 知道了

Format Specification Fields: scanf and wscanf Functions A format specification has the following form:  % [width] [{h | l | I64 | L}]type  The format argument specifies the interpretation of the input and can contain one or more of the following:   White-space characters: blank (' '); tab ('\t'); or newline ('\n'). A white-space character causes scanf to read, but not store, all consecutive white-space characters in the input up to the next non–white-space character. One white-space character in the format matches any number (including 0) and combination of white-space characters in the input.   Non–white-space characters, except for the percent sign (%). A non–white-space character causes scanf to read, but not store, a matching non–white-space character. If the next character in stdin does not match, scanf terminates.   Format specifications, introduced by the percent sign (%). A format specification causes scanf to read and convert characters in the input into values of a specified type. The value is assigned to an argument in the argument list.  The format is read from left to right. Characters outside format specifications are expected to match the sequence of characters in stdin; the matching characters in stdin are scanned but not stored. If a character in stdin conflicts with the format specification, scanf terminates, and the character is left in stdin as if it had not been read.  When the first format specification is encountered, the value of the first input field is converted according to this specification and stored in the location that is specified by the first argument. The second format specification causes the second input field to be converted and stored in the second argument, and so on through the end of the format string.  An input field is defined as all characters up to the first white-space character (space, tab, or newline), or up to the first character that cannot be converted according to the format specification, or until the field width (if specified) is reached. If there are too many arguments for the given specifications, the extra arguments are evaluated but ignored. The results are unpredictable if there are not enough arguments for the format specification.  Each field of the format specification is a single character or a number signifying a particular format option. The type character, which appears after the last optional format field, determines whether the input field is interpreted as a character, a string, or a number.   The simplest format specification contains only the percent sign and a type character (for example, %s). If a percent sign (%) is followed by a character that has no meaning as a format-control character, that character and the following characters (up to the next percent sign) are treated as an ordinary sequence of characters, that is, a sequence of characters that must match the input. For example, to specify that a percent-sign character is to be input, use %%.  An asterisk (*) following the percent sign suppresses assignment of the next input field, which is interpreted as a field of the specified type. The field is scanned but not stored.

//文件800.hea的内容： //800 2 128 230400 //800.dat 212 200 10 0 -101 -25183 0 ECG1 //800.dat 212 200 10 0 123 10510 0 ECG2 #include <stdio.h> #include <stdlib.h> void main() {     int i,j,t;     int nosig, Fs, gain, basevalue;     int *a;     long p,num;     int mh0,mh1,m,n;     float mh00,mh11;       /*mh00组和mh11组心电数据,mh00,mh11获得的数据保存在mh01数组中*/     /*字符变量的数组*/      //------ LOAD HEADER DATA --------------------------------------------------     FILE *fid;     if((fid=fopen("800.hea","r"))==NULL) {         printf("Cannot open file strike any key exit!");         return;     }      fscanf(fid,"%*d%d%d\n",&nosig,&Fs);     printf("%d,%d\n",nosig,Fs);      fscanf(fid,"%*[^\n]\n");  // 跳1 行     //取第二行的200 0     fscanf(fid,"%*s%*d%d%*d%d%*[^\n]\n",&gain,&basevalue);     printf("%d,%d\n",gain,basevalue);     //取第三行的200 0     fscanf(fid,"%*s%*d%d%*d%d%*[^\n]\n",&gain,&basevalue);     printf("%d,%d\n",gain,basevalue);     fclose(fid); } //2,128 //200,0 //200,0 //


Question: 求2的300次方结果怎样才能输出，求具体代码加解释

1.工具bc 2.手动模拟乘法，算大数

仅供参考：#include <iostream> #include <string> using namespace std; inline int compare(string str1,string str2) {//相等返回0，大于返回1，小于返回-1          if (str1.size()>str2.size()) return 1; //长度长的整数大于长度小的整数     else if (str1.size()<str2.size()) return -1;     else                              return str1.compare(str2); //若长度相等，则头到尾按位比较 } string SUB_INT(string str1,string str2); string ADD_INT(string str1,string str2) {//高精度加法     int sign=1; //sign 为符号位     string str;     if (str1[0]=='-') {         if (str2[0]=='-') {             sign=-1;             str=ADD_INT(str1.erase(0,1),str2.erase(0,1));         } else {             str=SUB_INT(str2,str1.erase(0,1));         }     } else {         if (str2[0]=='-') {             str=SUB_INT(str1,str2.erase(0,1));         } else { //把两个整数对齐，短整数前面加0补齐             string::size_type L1,L2;             int i;             L1=str1.size();             L2=str2.size();             if (L1<L2) {                 for (i=1;i<=L2-L1;i++) str1="0"+str1;             } else {                 for (i=1;i<=L1-L2;i++) str2="0"+str2;             }             int int1=0,int2=0; //int2 记录进位             for (i=str1.size()-1;i>=0;i--) {                 int1=(int(str1[i])-'0'+int(str2[i])-'0'+int2)%10;                 int2=(int(str1[i])-'0'+int(str2[i])-'0'+int2)/10;                 str=char(int1+'0')+str;             }             if (int2!=0) str=char(int2+'0')+str;         }     }     //运算后处理符号位     if ((sign==-1)&&(str[0]!='0')) str="-"+str;     return str; } string SUB_INT(string str1,string str2) {//高精度减法     int sign=1; //sign 为符号位     string str;     int i,j;     if (str2[0]=='-') {         str=ADD_INT(str1,str2.erase(0,1));     } else {         int res=compare(str1,str2);         if (res==0) return "0";         if (res<0) {             sign=-1;             string temp =str1;             str1=str2;             str2=temp;         }         string::size_type tempint;         tempint=str1.size()-str2.size();         for (i=str2.size()-1;i>=0;i--) {             if (str1[i+tempint]<str2[i]) {                 j=1;                 while (1) {//zhao4zhong1添加                     if (str1[i+tempint-j]=='0') {                         str1[i+tempint-j]='9';                         j++;                     } else {                         str1[i+tempint-j]=char(int(str1[i+tempint-j])-1);                         break;                     }                 }                 str=char(str1[i+tempint]-str2[i]+':')+str;             } else {                 str=char(str1[i+tempint]-str2[i]+'0')+str;             }         }         for (i=tempint-1;i>=0;i--) str=str1[i]+str;     }     //去除结果中多余的前导0     str.erase(0,str.find_first_not_of('0'));     if (str.empty()) str="0";     if ((sign==-1) && (str[0]!='0')) str ="-"+str;     return str; } string MUL_INT(string str1,string str2) {//高精度乘法     int sign=1; //sign 为符号位     string str;     if (str1[0]=='-') {         sign*=-1;         str1 =str1.erase(0,1);     }     if (str2[0]=='-') {         sign*=-1;         str2 =str2.erase(0,1);     }     int i,j;     string::size_type L1,L2;     L1=str1.size();     L2=str2.size();     for (i=L2-1;i>=0;i--) { //模拟手工乘法竖式         string tempstr;         int int1=0,int2=0,int3=int(str2[i])-'0';         if (int3!=0) {             for (j=1;j<=(int)(L2-1-i);j++) tempstr="0"+tempstr;             for (j=L1-1;j>=0;j--) {                 int1=(int3*(int(str1[j])-'0')+int2)%10;                 int2=(int3*(int(str1[j])-'0')+int2)/10;                 tempstr=char(int1+'0')+tempstr;             }             if (int2!=0) tempstr=char(int2+'0')+tempstr;         }         str=ADD_INT(str,tempstr);     }     //去除结果中的前导0     str.erase(0,str.find_first_not_of('0'));     if (str.empty()) str="0";     if ((sign==-1) && (str[0]!='0')) str="-"+str;     return str; } string DIVIDE_INT(string str1,string str2,int flag) {//高精度除法。flag==1时,返回商; flag==0时,返回余数     string quotient,residue; //定义商和余数     int sign1=1,sign2=1;     if (str2 == "0") {  //判断除数是否为0         quotient= "ERROR!";         residue = "ERROR!";         if (flag==1) return quotient;         else         return residue ;     }     if (str1=="0") { //判断被除数是否为0         quotient="0";         residue ="0";     }     if (str1[0]=='-') {         str1   = str1.erase(0,1);         sign1 *= -1;         sign2  = -1;     }     if (str2[0]=='-') {         str2   = str2.erase(0,1);         sign1 *= -1;     }     int res=compare(str1,str2);     if (res<0) {         quotient="0";         residue =str1;     } else if (res == 0) {         quotient="1";         residue ="0";     } else {         string::size_type L1,L2;         L1=str1.size();         L2=str2.size();         string tempstr;         tempstr.append(str1,0,L2-1);         for (int i=L2-1;i<L1;i++) { //模拟手工除法竖式             tempstr=tempstr+str1[i];             tempstr.erase(0,tempstr.find_first_not_of('0'));//zhao4zhong1添加             if (tempstr.empty()) tempstr="0";//zhao4zhong1添加             for (char ch='9';ch>='0';ch--) { //试商                 string str;                 str=str+ch;                 if (compare(MUL_INT(str2,str),tempstr)<=0) {                     quotient=quotient+ch;                     tempstr =SUB_INT(tempstr,MUL_INT(str2,str));                     break;                 }             }         }         residue=tempstr;     }     //去除结果中的前导0     quotient.erase(0,quotient.find_first_not_of('0'));     if (quotient.empty()) quotient="0";     if ((sign1==-1)&&(quotient[0]!='0')) quotient="-"+quotient;     if ((sign2==-1)&&(residue [0]!='0')) residue ="-"+residue ;     if (flag==1) return quotient;     else         return residue ; } string DIV_INT(string str1,string str2) {//高精度除法,返回商     return DIVIDE_INT(str1,str2,1); } string MOD_INT(string str1,string str2) {//高精度除法,返回余数     return DIVIDE_INT(str1,str2,0); } int main() {     char ch;     string s1,s2,res;      while (cin>>s1>>ch>>s2) {         switch (ch) {             case '+':res=ADD_INT(s1,s2);break;             case '-':res=SUB_INT(s1,s2);break;             case '*':res=MUL_INT(s1,s2);break;             case '/':res=DIV_INT(s1,s2);break;             case '%':res=MOD_INT(s1,s2);break;             default :                   break;         }         cout<<res<<endl;     }     return(0); }

代码不复杂，也就没什么解释了 const int maxn=200; #include<iostream> #include <vector> #include <cstring> using namespace std; const int maxn=200;  void mul(int *a,int *b){     int ca =*a,cb=*b,*pa=a+1,*pb=b+1;     int tmp[maxn]={0},*pc =tmp;     int c=0;     for(int i=0,j;i<cb;i++) {         for(j=0;j<ca;j++){             pc[i+j] +=pb[i]*pa[j]+c;             c       =pc[i+j]/10;             pc[i+j]   %=10;         }         pc[i+j]   =c;         c=0;     }     int cc =ca+cb;     while(!pc[cc-1]) --cc;     memcpy(a+1,tmp,cc*sizeof *pc);     *a =cc; }  void pow(int *r,int *a,int n){     int base[maxn];     memcpy(base,a,(*a+1)*sizeof *a);     while(n){         if(n&1)             mul(r,base);         mul(base,base);         n>>=1;     } } void show(int *a){     int *pa =a+*a;     for(;pa!=a;--pa) cout<<*pa;     cout<<endl; }  int main(){     int r[maxn]={1,1},     k_2[]={1,2},     k_2_30[]={10,4,2,8,1,4,7,3,7,0,1}; // 2^30     pow(r,k_2,300);     show(r);     r[0]=r[1]=1;     pow(r,k_2_30,10);     show(r);     return 0; }  }

引用 8 楼 wangliangffaflgh 的回复:我发现赵老师代码就是牛叉 你发现的比较晚了。

#include<stdio.h> const unsigned long long two_25=1<<25; const unsigned int MOD=1000000000U; int main() { 	unsigned int n[16]={1};	  	int i,j,len=1; 	for(i=0;i<12;++i) 	{ 		unsigned int r=0; // 进位 		for(j=0;j<len;++j) 		{ 			unsigned long long l=n[j]*two_25+r; 			n[j]=l%MOD; 			r=l/MOD; 		} 		if(r)n[len++]=r; 	} 	printf("%u",n[len-1]); 	for(i=len-2;i>=0;--i) 		printf("%09u",n[i]); 	putchar('\n'); 	return 0; }

gmp 三. 自己写也不麻烦.  2037035976334486086268445688409378161051468393665936250636140449354381299763336706183397376

我发现赵老师代码就是牛叉

puts("0x1000000000000000000000000000000000000000000000000000000000000000000000000000"); 后面75个0

二进制->十进制转换一下

用Java BigInteger吧


Question: 对APUE 习题7.10不解

意犹未尽，补充一下，如果编译的时候开了优化，对于这段代码，执行的结果应该是随机的，但如果在： val=5; ptr=&val; 中间加一个print("%d\n",val); 执行的结果仍然是6。这是因为gcc对自变量和寄存器变量的优化方式的问题。 APUE是好书，但是有的地方说的不是很清楚，而且有一些错误的地方，总之，实验得真理。

意犹未尽，补充一下，如果编译的时候开了优化，对于这段代码，执行的结果应该是随机的，但如果在：val=5；

楼主没有按照书上的代码来，书上，ptr在申明的时候就初始化了。作者想说明的问题是自变量的作用域。复合语句中的自变量作用域都局限在复合语句中，一旦跳出符合语句，就不能访问。能执行成功是因为，val把地址给了ptr。有人可能要说自变量在不是在跳出复合语句就释放了吗？尽信书不如无书，其实不是这样的，不信试试看。

引用 1 楼 user-6 的回复:代码执行会不会出错得看程序执行时ptr的值，ptr定义没有初始化，如果if语句进入了，执行不会出错；如果if语句没有进入，那么程序会不会奔溃就不知道了。这个函数存在两个问题，1）使用未初始化的指针，是个隐患，不安全 2）指针指向已销毁不存在的变量（从语法角度），不合理+1，未初始化+临时变量

引用 3 楼 q191201771 的回复:[quote=引用 2 楼 q191201771 的回复:] 因为ptr指向的val的声明周期出if那个大括号就结束了 吧 我打错字了 声明改成生命[/quote]  但是程序可以正常工作是为什么呢，比如 int a = f1(5); 结果a确实等于6啊

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

return (*ptr + 1);  这返回的是int，不是指针类型。

引用 2 楼 q191201771 的回复:因为ptr指向的val的声明周期出if那个大括号就结束了 吧 我打错字了 声明改成生命

因为ptr指向的val的声明周期出if那个大括号就结束了 吧


Question: 栈的输入问题

简单的示例  #include <stdio.h> #include <stdlib.h> #define MAX 256 static int stack[MAX] = {0}; int top = -1;  void push(int val) {     if(++top >= MAX)         return;     stack[top] = val; }  int pop(void) {     if(top == -1)         return -1;     return stack[top --]; }  int main() {     int val = 0;     while(1) {         scanf("%d", &val);             push(val);          if(getchar() == '\n')             break;     }      while(top != -1)         printf("%d ", (val = pop()) == -1 ? ' ' : val );      exit(0); }   也可以考虑使用链式栈存储

顺序栈： http://blog.csdn.net/zhangxiangdavaid/article/details/26819603

用顺序栈就可以了，类似于数组


Question: 快速傅里叶变换算法求解！急急急

这个问题在信号与系统里面解决过，算法没有研究过。

引用 1 楼 zhao4zhong1 的回复:http://www.baigoogledu.com/s.php?hl=zh-CN&q=fast+FFT+%D4%B4%B4%FA%C2%EB    好厉害的搜索~

首先谢谢你的回答。可是我的算法要求和其他的不一样。首先我用的是c99中的complex.h，直接使用复数。另外我的计算变换的函数参量有6个，每个功能不一样。我在上面有说明。我觉得问题是出现在递归调用的格式上面。关键是那个*w怎么用。。


Question: 关于字符输出的问题。

没有现成的C函数库，用VC的话，可以直接显示。  “字符 是以两个字节存储的” ，存储的是 字符编码。很久没有touch FAT32了，不确定是不是用GBK。  显示字符 就是 转换 字符编码为显示点阵，这个网上找的到。  患有，字符编码转换为显示点阵，是与系统语言（简体中文 or 繁体中文 or 日文 or ...）相关的， 对应于不同的编码转换算法。

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


Question: tcp通信中投和尾的字符是确定的，中间消息没有跟他们重复的字符，这种消息怎么接收？、

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

每次尽可能多地接收完，接收到的数据缓存起来，缓存的数据解析出完整的一个消息（有头有尾）交给上层处理，每次接收到的数据与上次解析后剩余的数据拼接后解析。 解析的方法：缓冲区消息头出现之前的数据丢弃，找到消息头后找消息尾，找到消息尾即为一个完整消息，找不到消息尾即为剩余数据，保留在缓存

转base64 再转回来 不过数据长度会变长,

用一个足够长的字符数组接收啊，使用的时候去掉前后的字符就可以了。 还有一种比较简单的：如果你是发送固定长度的结构体，那么直接就用结构体接收


Question: 基于51单片机的波形发生器

输入越界了

假设某次输入时flag 为0 num为255 再经过一轮，flag 为0 num在++后变为0(溢出)，再if后又变成了255.  就是说输入时为255，输出时仍为255没变。


Question: C 实现HTML5服务时，遇到握手状态的判断问题...

引用 5 楼 user-1 的回复:题外话: 看看 RecvData 这个函数 每当 socket  可读时就触发一次, 每次都要判断一次  "握手了没有呀"...  "握手了没有呀" ...  用 FSM 的方式就可以 减少一次 if , 还可以务业分离，把 握手 业务抽出来， 而且 H5的握手协议 是很很多版本  － －!!!   // ===================================== 好久没碰过 epoll 了.... 楼主可以试试 libevent 或  libev   早上试试了， 直接在结构体了加 一个状态变量，可以的，多个客户端连接没有问题。通信都正常也...  你的建议非常好，看你的描述，应该是FSM更好，更合理。 但是你第一回复，没懂... 也不好意思老麻烦你

引用 5 楼 user-1 的回复:题外话: 看看 RecvData 这个函数 每当 socket  可读时就触发一次, 每次都要判断一次  "握手了没有呀"...  "握手了没有呀" ...  用 FSM 的方式就可以 减少一次 if , 还可以务业分离，把 握手 业务抽出来， 而且 H5的握手协议 是很很多版本  － －!!!   // ===================================== 好久没碰过 epoll 了.... 楼主可以试试 libevent 或  libev  谢谢你呀  俺有空去了解一下libevent  ，，，  如果按照您4楼的方法在 设置一个状态，，那在发送函数里，会不会改变这个值的状态呢？ 按你方法先试试，有问题再请教    // send data   void SendData(int fd, int events, void *arg)   {       struct myevent_s *ev = (struct myevent_s*)arg;       int len,i;       // send data       len = send(fd, ev->buff + ev->s_offset, ev->len - ev->s_offset, 0);     if(len > 0)     {         //printf("send[fd=%d], [%d<->%d]%s\n", fd, len, ev->len, ev->buff);         printf("send data is :\n");         for(i=0;i<ev->buff[1]+2;i++)                 printf("  %02X", ev->buff[i]);          printf("\n");         ev->s_offset += len;         if(ev->s_offset == ev->len)         {             // change to receive event             EventDel(g_epollFd, ev);             EventSet(ev, fd, RecvData, ev);               EventAdd(g_epollFd, EPOLLIN, ev);           }   //这三个函数都操作到了EV这个结构提，而状态都会经过这三个函数走一圈     }     else       {           close(ev->fd);           EventDel(g_epollFd, ev);           printf("send[fd=%d] error[%d]\n", fd, errno);       }   }

引用 1 楼 wanyeye 的回复:相对全一点的代码，代码都是来自网络，目前这样方式，只能接受一个客户端连接，并交互通信。  如何在客户端建立连接时，为每个客户端，标记一个状态，如果是第一次连接，则标记一个状态，以便完成握手动作， 握手后，修改状态，直到该客户端关闭连接再恢复该状态，，方便该客户端下次连接服务器以完成握手。  ......  每一个客户端都是一个 struct myevent_s ，如果用状态标记这种方式可以向里面添加  struct myevent_s   {       int fd;       void (*call_back)(int fd, int events, void *arg);       int events;       void *arg;       int status; // 1: in epoll wait list, 0 not in       unsigned char buff[1024]; // recv data buffer       int len, s_offset;       long last_active; // last active time     int connected;    //添加这个标记-- 0:未握手.1:完成握手. };    // //  然后修改 // void RecvData(int fd, int events, void *arg)   {     // ..    // ..   // ..   // if((0==connected))/目前只能接受一个客户端的连接握手，当第二个.......    if((0 == ev->connected))  ///     {                              printf(" shakehand is ok %d \n",fd);                 // ...              secWebSocketKey=computeAcceptKey(ev->buff);                shakeHand(fd,secWebSocketKey);                // connected=1;     // ==========> 相应的 connected 都改成 ev->connected;             ev->connected=1;             // ....     } }

引用 2 楼 user-1 的回复:觉得做个类 FSM 的操作 会方便点 添加一个 握手状态处理 void hand_shake(int fd, int evs, void *arg) {    /// 握手处理完成后   // 改变 call_back;   // EventSet( ...) 域直接   ((struct myevent_s *) arg)->call_back = RecvData;   return 0; }  // 修改接受 客户端connect函数 void AcceptConn(int fd, int events, void *arg)   {      // add a read event for receive data        //   EventSet(&g_Events[i], nfd, RecvData, &g_Events[i]);      // 把原来的 RecvData 改成 hand_shake    EventSet(&g_Events[i], nfd, hand_shake, &g_Events[i]);  }   // ====================================== 把 myevent_s 中的 call_back 变成  call_backs 这种方法会更完整点  调用:  ev->call_back[ev->status](ev->fd, events[i].events, ev->arg);   这样改变 status 就改变了 call_back   没看懂。。。

相对全一点的代码，代码都是来自网络，目前这样方式，只能接受一个客户端连接，并交互通信。  如何在客户端建立连接时，为每个客户端，标记一个状态，如果是第一次连接，则标记一个状态，以便完成握手动作， 握手后，修改状态，直到该客户端关闭连接再恢复该状态，，方便该客户端下次连接服务器以完成握手。     #define REQUEST_LEN_MAX 1024 #define DEFEULT_SERVER_PORT 8000 #define WEB_SOCKET_KEY_LEN_MAX 256 #define RESPONSE_HEADER_LEN_MAX 1024 #define LINE_MAX 256 #define HOST_IP_ADDRESS_TCP "192.168.34.52" #define MAX_EVENTS 500   #define HOST_PORT_TCP 4530  int connected=0;//0:not connect.1:connected.  struct myevent_s   {       int fd;       void (*call_back)(int fd, int events, void *arg);       int events;       void *arg;       int status; // 1: in epoll wait list, 0 not in       unsigned char buff[1024]; // recv data buffer       int len, s_offset;       long last_active; // last active time };   // set event   void EventSet(struct myevent_s *ev, int fd, void (*call_back)(int, int, void*), void *arg)   {       ev->fd = fd;       ev->call_back = call_back;       ev->events = 0;       ev->arg = arg;      ev->status = 0;     bzero(ev->buff, sizeof(ev->buff));     ev->s_offset = 0;       ev->len = 0;     ev->last_active = time(NULL);   }   // add/mod an event to epoll   void EventAdd(int epollFd, int events, struct myevent_s *ev)   {       struct epoll_event epv = {0, {0}};       int op;       epv.data.ptr = ev;       epv.events = ev->events = events;       if(ev->status == 1){           op = EPOLL_CTL_MOD;       }       else{         op = EPOLL_CTL_ADD;           ev->status = 1;      }       if(epoll_ctl(epollFd, op, ev->fd, &epv) < 0)           printf("Event Add failed[fd=%d], evnets[%d]\n", ev->fd, events);       else           printf("Event Add OK[fd=%d], op=%d, evnets[%0X], status:[%d]\n", ev->fd, op, events, ev->status);   }   // delete an event from epoll   void EventDel(int epollFd, struct myevent_s *ev)   {       struct epoll_event epv = {0, {0}};       if(ev->status != 1) return;       epv.data.ptr = ev;       ev->status = 0;     epoll_ctl(epollFd, EPOLL_CTL_DEL, ev->fd, &epv);   }   int g_epollFd;   struct myevent_s g_Events[MAX_EVENTS+1]; // g_Events[MAX_EVENTS] is used by listen fd   void RecvData(int fd, int events, void *arg);   void SendData(int fd, int events, void *arg);    // accept new connections from clients   void AcceptConn(int fd, int events, void *arg)   {       struct sockaddr_in sin;       socklen_t len = sizeof(struct sockaddr_in);       int nfd, i;       // accept       if((nfd = accept(fd, (struct sockaddr*)&sin, &len)) == -1)       {           if(errno != EAGAIN && errno != EINTR)           {           }         printf("%s: accept, %d", __func__, errno);           return;       }       do       {           for(i = 0; i < MAX_EVENTS; i++)           {               if(g_Events[i].status == 0)               {                   break;               }           }           if(i == MAX_EVENTS)           {               printf("%s:max connection limit[%d].", __func__, MAX_EVENTS);               break;           }           // set nonblocking         int iret = 0;         if((iret = fcntl(nfd, F_SETFL, O_NONBLOCK)) < 0)         {             printf("%s: fcntl nonblocking failed:%d", __func__, iret);             break;         }         // add a read event for receive data           EventSet(&g_Events[i], nfd, RecvData, &g_Events[i]);           EventAdd(g_epollFd, EPOLLIN, &g_Events[i]);      }while(0);            printf("new conn %s, %d,time:%ld, pos:%d \n", inet_ntoa(sin.sin_addr),              ntohs(sin.sin_port), g_Events[i].last_active, i);  }   // receive data   // 帖子内容大小有限制，放主贴里了  // send data   void SendData(int fd, int events, void *arg)   {       struct myevent_s *ev = (struct myevent_s*)arg;       int len,i;       // send data       len = send(fd, ev->buff + ev->s_offset, ev->len - ev->s_offset, 0);     if(len > 0)     {         //printf("send[fd=%d], [%d<->%d]%s\n", fd, len, ev->len, ev->buff);         printf("send data is :\n");         for(i=0;i<ev->buff[1]+2;i++)                 printf("  %02X", ev->buff[i]);          printf("\n");         ev->s_offset += len;         if(ev->s_offset == ev->len)         {             // change to receive event             EventDel(g_epollFd, ev);             EventSet(ev, fd, RecvData, ev);               EventAdd(g_epollFd, EPOLLIN, ev);           }     }     else       {           close(ev->fd);           EventDel(g_epollFd, ev);           printf("send[fd=%d] error[%d]\n", fd, errno);       }   }    void InitListenSocket(int epollFd, short port,char* ip)   {       int listenFd = socket(AF_INET, SOCK_STREAM, 0);       fcntl(listenFd, F_SETFL, O_NONBLOCK); // set non-blocking       printf("server listen fd=%d\n", listenFd);       EventSet(&g_Events[MAX_EVENTS], listenFd, AcceptConn, &g_Events[MAX_EVENTS]);       // add listen socket       EventAdd(epollFd, EPOLLIN, &g_Events[MAX_EVENTS]);       // bind & listen       struct sockaddr_in sin;       bzero(&sin, sizeof(sin));       sin.sin_family = AF_INET;       //sin.sin_addr.s_addr = INADDR_ANY;       //sin.sin_addr.s_addr = inet_addr(HOST_IP_ADDRESS_TCP);     sin.sin_addr.s_addr = inet_addr(ip);     sin.sin_port = htons(port);       bind(listenFd, (struct sockaddr*)&sin, sizeof(sin));       listen(listenFd, 5);     printf("server ip is : %s \n",ip); }    int main(int argc, char *argv[]) {         struct sockaddr_in servaddr, cliaddr;         socklen_t cliaddr_len;         int listenfd, connfd;         char buf[REQUEST_LEN_MAX];         char *data;         char str[INET_ADDRSTRLEN];         char *secWebSocketKey;         int i,n;         //int connected=0;//0:not connect.1:connected.                  int port= DEFEULT_SERVER_PORT;          if(argc>1)           {             port=atoi(argv[1]);           }         if(port<=0||port>0xFFFF)           {             printf("Port(%d) is out of range(1-%d)\n",port,0xFFFF);             return;           }           // create epoll ///////////////////////      g_epollFd = epoll_create(MAX_EVENTS);       if(g_epollFd <= 0) printf("create epoll failed.%d\n", g_epollFd);       // create & bind listen socket, and add to epoll, set non-blocking       InitListenSocket(g_epollFd, HOST_PORT_TCP,HOST_IP_ADDRESS_TCP);     // event loop       struct epoll_event events[MAX_EVENTS];       printf("server running:port[%d]\n", HOST_PORT_TCP);       int checkPos = 0;            /////////////////////////////////                   while (1)           {                                      // wait for events to happen           int fds = epoll_wait(g_epollFd, events, MAX_EVENTS, 1000);           if(fds < 0){             printf("epoll_wait error, exit\n");               break;           }        for( i = 0; i < fds; i++){                    struct myevent_s *ev = (struct myevent_s*)events[i].data.ptr;               if((events[i].events&EPOLLIN)&&(ev->events&EPOLLIN)) // read event               {                   ev->call_back(ev->fd, events[i].events, ev->arg);               }               if((events[i].events&EPOLLOUT)&&(ev->events&EPOLLOUT)) // write event               {                   ev->call_back(ev->fd, events[i].events, ev->arg);               }           }                         }//while         close(connfd); }


Question: 11）二叉排序树的实现（二叉链表）,用c语言实现

谢谢

typedef struct ADT { 	struct ADT *left; 	struct ADT *right; 	int Height; 	int elements; }TREE_ADT;  TREE_ADT *Delete_Root(TREE_ADT *p,int n) { 	TREE_ADT *Findtheleftmax(TREE_ADT *); 	TREE_ADT *Findtherightmax(TREE_ADT *);  	TREE_ADT *proot = p, *ptmp = NULL, *ptmpn = NULL;  	 ptmp = Findtheleftmax(p->left); 		 if (p->left->right == NULL)//特殊情况，p->left就是最大 		 { 			 ptmp->right = proot->right; free(proot); 			 proot = ptmp; proot->Height = 0; n++;//重新定义proot,让n+1 		 } 		 else 		 { 			 ptmpn = ptmp->right; 			 ptmp->right = ptmp->right->left;//这里把目标节点的上一个节点连接目标节点的左节点 			 ptmpn->left = proot->left; ptmpn->right = proot->right; free(proot); 			 proot = ptmpn; proot->Height = 0; n++;//重新定义proot,让n+1 		 } 		 return proot;//返回新的头 }  TREE_ADT *Findtheleftmax(TREE_ADT *p) { 	TREE_ADT *ptmp = NULL; 	if (p->right != NULL) 	{ 		ptmp = Findtheleftmax(p->right); 		if (p->right->right == NULL) ptmp = p;//这里把前一个节点返回了 	} 	else 	{ 		for (ptmp = p->left; ptmp != NULL; ptmp->Height--, ptmp = ptmp->left); 		return p; 	} 	return ptmp; }  TREE_ADT *Findtherightmax(TREE_ADT *p) { 	TREE_ADT *ptmp = NULL; 	if (p->left != NULL) 	{ 		ptmp = Findtherightmax(p->left); 		if (p->left->left == NULL) ptmp = p;//这里把前一个节点返回了 	} 	else 	{ 		for (ptmp = p->right; ptmp != NULL; ptmp->Height--, ptmp = ptmp->right); 		return p; 	} 	return ptmp; }    这是删除的，以前写的东西，仅供参考。。。。  你应该自己写一遍然后自己调试一次，这样你才会真正知道怎么写

可是菜鸟不会写代码啊，大神写一个让我看看

num没有初始化。。。而且就算你想用回车判断，也不是这么写吧。。你可以用链表的形式去挨个输入，用字符的形式，然后强制转换就好了，T也没返回分配好的指针，一直都是NULL，至少也要分个树根进去吧。。。  *T=NULL，赋值了，不是判断。。。。  删除的那里。。。直接把p的左右链链接到f上面。。。。如果f本身就存在左右链呢？那不就破坏二叉树了？正确的做法应该是递归到左树的最大节点或者右树的最小节点，然后数据交换，再链接。。  至于那个函数的问题，你可以在main里面定义个数组，你每查找一次就录入一次查找次数（查找次数可以传递一个指针给递归数组，每传递一次就+1直到找到为止），然后最后算平均值就好了


Question: 从confstr()中获取的系统PATH信息不全..

为什么不 system("echo %path%>path.txt"); //然后读文件path.txt的内容 呢？

$ getconf -a | grep CS_PATH CS_PATH                            /bin:/usr/bin

引用 1 楼 user-2 的回复:$ man confstr ......        _CS_PATH               A value for the PATH variable which indicates where all the POSIX.2 standard utilities  can               be found. 这个说的是“all the POSIX.2 standard utilities”，和命令行里面输出的$PATH不一样吧？   噢...明白了,,感谢!!


Question: 关于指针 数组

运行：

修改如下：  #include <stdio.h> #include <stdlib.h> #include <string.h> //如果q改为数组，此处：q[j] = p[i];提示错误 //如果q不用malloc分配空间，同样提示错误 //用malloc分配空间时，在哪个位置释放free //如下程序在输出结果时，会在q末尾输出“？”怎么回事 char *fun(char *p, char *q) { 	int length = 0; 	int i = 0, j = 0; 	length = strlen(p); 	for (; i < length; i++) 	{ 		if (p[i] % 2 == 0) 		{ 			q[j] = p[i]; 			j++; 		} 		else 		{ 			printf("-%c-%d-\n", p[i], p[i]); 		} 	} 	return q; } void main() { 	char p[100] = { '0' }; 	//char *q = NULL; 	char q[100] = { 0 }; 	printf("\n请输入字符串:\n"); 	scanf("%s", p); 	fun(p, q); 	printf("%s\n", q); 	system("pause"); }


Question: 自己写的一个字谜游戏，感觉还是效率低，求最佳优化方法

额。。。我还没学到图论，我先看一下  可是这样的话，这样的散列函数。。好像不能解决单词的顺序问题？比如如果是that,变成了taht

知道图中任一点到其余各点的最短距离算法不？做一些修改，借用一下！ 定义：D^n  =   D^n-1   .   D 其中n和n-1都是幂次，D是初始矩阵。 其中的点运算类似矩阵乘法，但不是矩阵乘法，要借用矩阵乘法的进行方式，矩阵乘法是对应元素相乘再求和，这里改为：对应元素拼接，求其散列值。因此你要一个很好的散列函数——能够在旧散列值基础上推演出新值。其实2^n，n取0-31，做基就不错。 d^n(i,j)表示，矩阵进行了n次点运算第i行第j列上单词，长度为n 不过是O(N^3)复杂度 这个借用或许有优化的方式，交给你了LZ


Question: 如何访问DLL中的全局变量

不是一个人的帖子；(,全局数组调用问题

貌似主程序里#include"dll_ex.h"不对，一下子export，一下子import，乱！

谢谢，你的回复。准备抽些时间研读一下  大致写了一段代码，编译能通过，但是好像赋不了值，代码如下： 在 globalarray.h文件中声明全局数组：  extern double randomarray[];  在dll .cpp中定义及初始化全局数组，及定义两个函数。 #include "globalarray.h" extern "C" { 	double randomarray[100] = {0.0}； 	void get_rand(); 	int __declspec(dllexport) APIENTRY AnotherFunction(v1,v2); } // get_rand()用于生成一组数字然后存放于全局数组中,然后在另外一个函数AnotherFunction中调用这个全局数组中的值，一直不成功，返回都是0.好像get_rand 函数没有运行赋值给全局数组。 void get_rand() { 	int i; 	srand(0); //设置随机数种子 	for (i = 0; i <= 99; i++) 	{ 		randomarray[i] = rand()%1000/1001.0; 	}  }  int __declspec(dllexport) APIENTRY AnotherFunction(v1,v2);  {   double t; t=randomarray[1]; }

建议楼主通读MSDN中有关DLL开发和调试相关章节。

接着问一下： 本人C++刚入门，对于 DLL，我要用全局变量（数组好，还是指针好？还是其它方式更好），在DLL中用一个函数生成3组随机数，这3组随机数可以被多个线程及进程调用，有好的方法吗？  这个生成函数也要写成全局的吗？生成函数如下,数组p[]用于保存生成的随机数。大神们能给个示例吗，谢谢  void get_rand(double p[],int n,int seed) { 	int i; 	srand(seed); //设置随机数种子 	for (i = 0; i <= n; i++) 	{ 		p[i] = rand(); 	} }

对于，加载又卸载了的dll 其中的全局变量，具有不确定的特性 DLL卸载以后，全局变量就不存在了 再次加载未必是同一个全局变量，至少上次改变的值，这次未必能用

DLL导出全局变量 有个问题 什么样的全局变量（进程内的，还是多个进程都可以访问的共享变量）？

用del文件不能成功导出吗？

引用 1 楼 user-6 的回复:http://bbs.csdn.net/topics/391013001  我刚好昨天问过这个问题  总算搞定了，多谢了。 顺便总结一下： 从dll导出全局变量不好，对于希望从DLL获取资源以实现资源共享的情景，最好是导出Get函数获得，这样操作起来更方便而且更安全。 对于必须使用Dll导出全局变量的情况，需要注意一下几点： 1，在Dll源文件定义全局变量，前面的修饰符跟函数一样，一般采用宏的方法。写出来一般是DLL_EX_API g_iTest =0的形式，切记要初始化一下，不然会报错！！！ 2，在Dll头文件里还要再写一次，修饰方法同上，不需要初始化。 3，在主函数调用的时候只要include了响应头文件即可。  Dll学习到此已到一段落，基本的知识已经掌握了~~~~


Question: C语言 不使用sizeof()怎样计算整型数据大小

引用 5 楼 jiht594 的回复:[quote=引用 4 楼 u013390088 的回复:] [quote=引用 2 楼 jiht594 的回复:] int a[2]; 		int x = (int)&a[1]; 		int y = (int)&a[0]; 		cout << x - y << endl;  cout << x - y << endl;是什么意思呢？我不会C++[/quote] printf("%d", x - y);也行 就是a[0]和a[1]地址相减[/quote]  我当时看到这个题就懵了呀~~~

引用 3 楼 ren0065 的回复:unsigned int n = (unsigned int)-1; int i=0; while(n) {     n = n >> 1;     i++; } printf("%d\n", i/8); 用按位右移的方法？！  受小弟一拜~

引用 4 楼 u013390088 的回复:[quote=引用 2 楼 jiht594 的回复:] int a[2]; 		int x = (int)&a[1]; 		int y = (int)&a[0]; 		cout << x - y << endl;  cout << x - y << endl;是什么意思呢？我不会C++[/quote] printf("%d", x - y);也行 就是a[0]和a[1]地址相减

引用 2 楼 jiht594 的回复:int a[2]; 		int x = (int)&a[1]; 		int y = (int)&a[0]; 		cout << x - y << endl;  cout << x - y << endl;是什么意思呢？我不会C++

其实这是一道笔试题。。。。没想出来


Question: 关于Qt

已经找到了，canvas是Qt3的 在Qt4里面，canvas被Qgrahicsview替代了。

QtQuick 慢，那就用 QtWidgets

help me!

please help!


Question: 这是我写的链表的创建，结点的查找，插入，删除，没有语法错误，有逻辑错误，运行程序时总是跳出Windows正在检查该问题的解决方案这个窗口。求大神指点，小弟不胜感

没看完，看了第一个函数就看到内存泄露了。create函数里，如果我第一次输入0，已经申请到的内存就不释放了？

单步调试一下

不对啊，同样的会出现这样的问题啊

仅供参考：//带表头结点的单向链表 #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-> //

int len(struct node *head)//测量链表长度 { 	int num = 0; 	struct node *p; 	//p = head->next; 	p = head; 	while (p != NULL) 	{ 		num++; 		p = p->next; 	} 	return num; } //查找节点最好对查找位置做出判断，插入时，类似 struct node *find(struct node *head, int i)//查找结点 { 	if (i < 1 || i > len(head))   //对查找位置作出判断 	{ 		fprintf(stderr, "i is out of range!\n"); 		return head; 	} 	struct node *p; 	int num = 0; 	p = head; 	for (; p != NULL; p = p->next) 	{ 		num++; 		if (num == i) 			break; 	} 	return(p); }

由于你的设计是不带头结点的，所以删除第一个节点需要特殊处理  struct node *del(struct node *head, int i)//删除一个结点，节点编号从1开始 { 	struct node *p, *pt; 	if (i == 1)    //删除第一节点 	{ 		p = head; 		head = p->next; 		free(p); 		return head; 	} 	int num = 0; 	p = head; 	for (; p != NULL; p = p->next) 	{ 		num++; 		if (num == i - 1) 		{ 			pt = p->next; 			p->next = pt->next; 			free(pt); 			break;  //删除后，直接跳出循环 		}  	} 	return(head); }

int n; struct node *head, *p;  //这一句拿到外面来 printf("1-----创建并输出链表\n"); printf("2-----创建并计算链表的长度\n"); printf("3-----查找并输出该节点的值\n"); printf("4-----插入结点并输出插入节点后的链表\n"); printf("5-----删除结点并输出删除节点后的链表\n"); scanf("%d", &n); …… //dispose(creat()); dispose(head);      //释放内存，使用这一句   其它错误正在查找……

给出你的测试用例呢?


Question: char不是有1字节长度么，为什么我的能装这么长

引用 3 楼 lin5161678 的回复:unsigned char  就不会这样了十分感谢，帮了大忙了！！

十分感谢！！！帮了大忙了

unsigned char  就不会这样了

引用 1 楼 zyw067 的回复:截图的结果是没填格式输出“%02x”的，格式输出后第0位和第9位仍然如图，费解 你是想问 mesg[0]==0xffffffef 我们相等吗? 还是这里printf("第%d位为%02x\n",i,mesg[i]);?? http://bbs.chinaunix.net/thread-1070673-1-1.html

截图的结果是没填格式输出“%02x”的，格式输出后第0位和第9位仍然如图，费解


Question: 2048游戏用C语言编写问题

新手看的注释越多，保持新手状态的时间越长。

注释啊 ，照顾一下新手好么？

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

仅供参考：#include <climits> #include <cstdio> #include <cstring> #include <stack> #include <string> #include <map> #include <vector> #include <cmath>  using namespace std;  const int MAXX = 10;  int box[MAXX][MAXX];  void moveLeft(int n, bool &ret){     for (int i = 0; i < n; ++i){         for (int j = 0; j < n; ++j){             int k;             for (k = j - 1; k >= 0; --k){                 if (box[i][k] != -1){                     break;                 }             }             box[i][k + 1] = box[i][j];              if ((k + 1) != j){                 box[i][j] = -1;                 ret = true;             }         }     } }  void mergeLeft(int n, bool &ret){     for (int i = 0; i < n; ++i){         for (int j = 0; j < n - 1; ++j){             if (box[i][j] == -1)continue;              if (box[i][j] == box[i][j + 1]){                 box[i][j] *= 2;                 box[i][j + 1] = -1;                 ret = true;                 ++j;             }         }     } }  bool left(int n){     bool ret = false;     moveLeft(n, ret);     mergeLeft(n, ret);     moveLeft(n, ret);     return ret; }  void moveRight(int n, bool &ret){     for (int i = 0; i < n; ++i){         for (int j = n - 1; j >= 0; --j){ 			if (box[i][j] == -1)continue;  			int k; 			for (k = j + 1; k < n; ++k){ 				if (box[i][k] != -1){ 					break; 				} 			}  			box[i][k - 1] = box[i][j]; 			if ((k - 1) != j){ 				box[i][j] = -1; 				ret = true; 			} 		} 	} }  void mergeRight(int n, bool &ret){ 	for (int i = 0; i < n; ++i){ 		for (int j = n - 1; j >0; --j){ 			if (box[i][j] == -1)continue;  			if (box[i][j] == box[i][j - 1]){ 				box[i][j] *= 2; 				box[i][j - 1] = -1; 				ret = true; 				--j; 			} 		} 	} }  bool right(int n){ 	bool ret = false; 	moveRight(n, ret); 	mergeRight(n, ret); 	moveRight(n, ret); 	return ret; }  void moveUp(int n, bool &ret){ 	for (int j = 0; j < n; ++j){ 		for (int i = 0; i < n; ++i){ 			int k; 			for (k = i - 1; k >= 0; --k){ 				if (box[k][j] != -1){ 					break; 				} 			} 			box[k + 1][j] = box[i][j];  			if ((k + 1) != i){ 				box[i][j] = -1; 				ret = true; 			} 		} 	} }  void mergeUp(int n, bool &ret){ 	for (int j = 0; j < n; ++j){ 		for (int i = 0; i < n - 1; ++i){ 			if (box[i][j] == -1)continue;  			if (box[i][j] == box[i + 1][j]){ 				box[i][j] *= 2; 				box[i + 1][j] = -1; 				ret = true; 				++i; 			} 		} 	} }  bool up(int n){ 	bool ret = false; 	moveUp(n, ret); 	mergeUp(n, ret); 	moveUp(n, ret); 	return ret; }  void moveDown(int n, bool &ret){ 	for (int j = 0; j < n; ++j){ 		for (int i = n - 1; i >= 0; --i){ 			if (box[i][j] == -1)continue;  			int k; 			for (k = i + 1; k < n; ++k){ 				if (box[k][j] != -1)break; 			}  			box[k - 1][j] = box[i][j];  			if ((k - 1) != i){ 				box[i][j] = -1; 				ret = true; 			} 		} 	} }  void mergeDown(int n, bool &ret){ 	for (int j = 0; j < n; ++j){ 		for (int i = n - 1; i > 0; --i){ 			if (box[i][j] == -1)continue;  			if (box[i][j] == box[i - 1][j]){ 				box[i][j] *= 2; 				box[i - 1][j] = -1; 				ret = true; 				--i; 			} 		} 	} }  bool down(int n){ 	bool ret = false; 	moveDown(n, ret); 	mergeDown(n, ret); 	moveDown(n, ret); 	return ret; }  void line(int n){ 	for (int i = 0; i < n; ++i){ 		printf("--------"); 	} 	printf("-"); 	printf("\n"); }  void print(int n){ 	for (int i = 0; i < n; ++i){ 		line(n); 		for (int j = 0; j < n; ++j){ 			printf("|"); 			if (box[i][j] == -1){ 				printf("\t"); 				continue; 			}  			printf("%2d\t", box[i][j]); 		} 		printf("|"); 		printf("\n"); 	} 	line(n); }  bool isFull(int n){ 	bool mark = true; 	for (int i = 0; i < n; ++i){ 		for (int j = 0; j < n; ++j){ 			if (box[i][j] == -1){ 				mark = false; 				return mark; 			} 		} 	} 	return mark; }  bool isOver(int n){ 	if (!isFull(n)){ 		return false; 	} 	for (int i = 0; i < n; ++i){ 		for (int j = 0; j < n; ++j){ 			if (box[i][j] == box[i][j + 1] || box[i][j] == box[i + 1][j]){ 				return false; 			} 		} 	} 	return true; }  void fillBox(int n){ 	int i, j, num;  	if (isFull(n)){ 		return; 	}  	while (true){         i = rand() % n;         j = rand() % n;         num = rand() % 2 == 0 ? 2 : 4;          if (box[i][j] == -1){             box[i][j] = num;             break;         }     } }  int main(){     //freopen("in.txt", "r", stdin);     memset(box, -1, sizeof(box));      int n;     bool mark;     scanf("%d%*c", &n);      fillBox(n);     fillBox(n);     print(n);      while (true){         char ch;         scanf("%c%*c", &ch);         if (ch == 'a'){             mark = left(n);         }         else if (ch == 'd'){             mark = right(n);         }         else if (ch == 'w'){             mark = up(n);         }         else if (ch == 's'){             mark = down(n);         }         else{             continue;         }         system("cls");         printf("Move:\n");         print(n);         if (!mark){             continue;         }         fillBox(n);         printf("Fill:\n");         print(n);          if (isOver(n)){             printf("\n\nGame Over!\n\n");             break;         }     }      return 0; }


Question: 关于结构体和指针的故事

st定义在栈上，定义之后系统会自动为你开辟一个264字节的空间，假如你定义了一些函数，其中有该struct类型的参数，假如你传递它的对象，那么一次函数调用的栈空间使用是非常大的，所以这时候你定义了一个该struct类型的指针，正如你所说，指针只占用4个字节，那么函数调用所消耗的空间就很少的。

可能这个code的指针的定义，更多是由于程序员的习惯。  有人喜欢用指针，所以多定义一个指向这个局部变量的指针，以后的引用都是用指针。  有人喜欢用结构体，就不用定义指向这个局部变量的指针。

有一个学生  第一天学了一个 '一' 字 就是画一横 第二天学了一个 '二' 字 就是画两横 第三天学了一个 '三' 字 就是画三横 他就认为他已经懂怎么写字了 知道有一天 他写了一个 '万' 字  楼主 你就是这个学三天的学生

1 这个st是局部变量，仅存在于main中，跟os没有关系 2 在这个程序中确实没看出指针有什么用

（1）请问到底操作系统定义了st这个变量了么？  应该是你的程序为st分配空间，并初始化为 {123, "Lucy",10}//struct Student st = {123, "Lucy",10};  （2）我们知道pst变量占用4个字节，为什么要用指针? 定义了结构体？ 还要指针？是不是多此一举啊！  pst是指针类型，在32机上占4个字节~ 定义了结构体，再定义指针是为了访问方便，比如函数之间传值，要把结构体变量st数据全部传递过去要用内存12个字节，把指针或这说把结构体变量st的地址传递过去只占4字节，用地址（指针）操作数据更灵活~

用指针操作内容和用变量操作都是应该掌握的

都可以吧，你习惯用哪个就用。貌似用指针的多一点

小弟你很有才，问的很好 1.栈中定义了此变量 2.有比没有好（C语言），“没有”也比有好（JAVA），是不是有点绕其实就是有谁来做的问题，C中由用户负责，java语言中没有指针，但是由编译器负责底层指针的处理，使得用户和指针画了杠！ 3.不是多此一举，你需要懂得什么是指针，什么是地址，以及二者的关系！

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式...的值【比如printf("%p\n",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495

st这个变量了么？  是的 我们知道pst变量占用4个字节 指针变量属于LONG类型占4个字节  为什么要用指针?   指正是变化的，指向某个内存地址 定义了结构体？ 还要指针？是不是多此一举啊！ 怎么说呢打个比方： 结构体指针就是针对结构体类型房间的万能钥匙 结构体变量就是结构体类型的房间对象 一旦产生房间的对象，房间的位置就是固定的， 然而指针想开哪个房间就开哪个房间，只要是同类型的就可以  换句话说，指针是虚的，变量是实的  如有不对，望广大朋友指正！


Question: 求助！！！！ 关于linux Ecplise 运行C程序的问题！

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


Question: 请教个socket连接状态的问题

每一个连接进入时，如果server允许建立并连接后，记录client的地址。  然后对client进行比对判断，是否是以前已经连接过的。  而5楼的code中，connected对所有的client，不区分不同的client。

下面是服务器接受函数的一段代码  如果是某个客户端第一次连接服务器，则建立握手先，以后，该连接除非重新连接服务器再，则不需要握手动作，做普通SOCKET通信   但是，下面代码作判断时，服务器只能与一个客户端建立连接，其他客户端就不能再连接上了，服务建立握手...   当多个客户端存在时，如何判断每一个客户端是否是第一次与服务器连接，以便建立握手？  len = recv(fd, ev->buff, sizeof(ev->buff), 0);      printf("---------------------\n");     printf("recv data len: %d\n",len);     printf("---------------------\n");     printf("recv data content: %s\n",ev->buff);     printf("\n");     if(len<480){     	printf("recv data content:\n");     	for(i=0;i<len;i++)     		printf("%02x ",ev->buff[i]);     	}              if(0==connected)// 第一次连接 		  { 		    printf("read:%d\n%s\n",len,ev->buff); 		    secWebSocketKey=computeAcceptKey(ev->buff);	 		    shakeHand(fd,secWebSocketKey); 		    connected=1; 		    printf("22222    connected is :%d \n",connected); 		    }     dosomething(); }

NONO ， 可能是我描述不清楚  HTML5服务器，，第一次客户端连接时，需要一次握手协议，，当该客户端再发数据来时，与服务器不用再握手 当作普通SOCKET处理

发送心跳包就可以吧

心跳监控连接状态, 即可,

握手动作又不让你去做，tcp底层自己做了


Question: LCS 递归求最长公共子序列

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


Question: C菜鸟求帮助。弄了个代码有好多错误

为什么不动态创建链表

运行：

修改如下：  #include<stdio.h> #include<stdlib.h> struct node { 	//char ch[1]; 	char ch; 	struct node *next; }; struct node a, b, c, d, e, f, j, h, i, g, k, l, m, n, *next, *p, *head; void print_node(); void main() { 	a.ch = 's';	b.ch = 'p'; 	c.ch = 'r';	d.ch = 'i'; 	e.ch = 'n';	f.ch = 'g'; 	j.ch = ' ';	h.ch = 'c'; 	i.ch = 'o';	g.ch = 'm'; 	k.ch = 'i'; l.ch = 'n'; 	m.ch = 'g';	n.ch = 'x'; 	head = &a; 	a.next = &b;	b.next = &c; 	c.next = &d;	d.next = &e; 	e.next = &f;	f.next = &j; 	j.next = &h;	h.next = &i; 	i.next = &g;	g.next = &k; 	k.next = &l;	l.next = &m; 	m.next = NULL; 	p = head;  	do 	{ 		print_node(); 	} while (p != NULL);  	printf("删除第四个元素\n"); 	c.next = &e; 	d.next = NULL; 	p = head; 	do 	{ 		print_node(); 	} while (p != NULL);  	printf("在第二个元素前插入'x'\n"); 	a.next = &n; 	n.next = &b; 	c.next = &d; 	d.next = &e; 	p = head; 	do 	{ 		print_node(); 	} while (p != NULL);  } void print_node() { 	printf("%c ", p->ch); 	p = p->next; }

将所有的ch="x'替换为ch='x'

给char[]直接赋值有问题

在此代码段里找链表的增删改操作 https://github.com/707wk/Senior-middle-school/blob/master/Filling%20in%20the%20gaps.c

先编译下，看看哪些是明显的错误（编译反馈信息），一般都会提示你第几行第几个字有错误，把这些排除了，还有错误，那就是逻辑错误，使用最简单的printf随时打印自己觉得有问题的变量，随时跟踪，或者用/*……*/把一些代码注释掉，来确定出问题的地方。


Question: 求助，链接出错麻烦帮帮忙看看怎么回事

确认将所有.cpp文件添加到项目、源代码中，重建所有。

引用 1 楼 zhao4zhong1 的回复:项目、属性、链接器、常规、附加库目录：填写附加依赖库所在目录 分号间隔多项 项目、属性、链接器、输入、附加依赖项：填写附加依赖库的名字.lib 空格或分号间隔多项 感谢赵老师，附加库内容如下，链接无法通过，还是1楼的错误提示，是不是缺哪个库呢？ kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib


Question: 这段代码有什么问题？

1.两个单词之间往往只有一个空格，故dcs初始为1 2.把初始化放在while循环的第一句，每次循环都得重新开始 3.i<strlen(sz)


Question: 老说我访问了一块不存在的内存。。。。。。还是文件关闭的问题

能不能把代码嵌在code c/c++中   这确实不会

还是不行啊，fread函数好像有点问题

#include<stdio.h> #include<string.h> #include<stdlib.h> struct person { 	char name[20]; 	char department[20]; 	long base_pay; 	long allowance; 	long total; }; void initial(struct person *per); void set(struct person *per); void file_write(struct person*per,FILE *fp); void file_print(FILE *fp);  void main() { 	FILE *fp; 	if((fp=fopen("paydata.txt","ab+"))==NULL) 	{ 		printf("打开文件失败\n"); 		return ; 	} 	struct person *per; 	per=(struct person *)malloc(sizeof(struct person)); 	initial(per); 	set(per); 	file_write(per,fp); 	file_print(fp); 	fclose(fp);  }    void initial(struct person *per) { 	strcpy(per->name,"0"); 	strcpy(per->department,"0"); 	per->base_pay=0; 	per->allowance=0; 	per->total=0; } void set(struct person *per) { 	printf("请输入人员姓名:\n"); 	scanf("%s",per->name); 	printf("请输入人员单位：\n"); 	scanf("%s",per->department); 	printf("请输入人员基本工资：\n"); 	scanf("%ld",&per->base_pay); 	printf("请输入人员奖金：\n"); 	scanf("%ld",&per->allowance); 	per->total=per->base_pay+per->allowance;//总工资计算 } void file_write(struct person*per,FILE *fp) { 	fwrite(&per,sizeof(struct person),1,fp); }  //print void file_print(FILE *fp) { 	struct person *per; 	per=(struct person *)malloc(sizeof(struct person)); 	printf("name\tdepartment\tbase_pay\tallowance\ttotal\n"); 	while(1) 	{ 		if(feof(fp)) 			break;         fread(&per,sizeof(struct person),1,fp); 		printf("%s\t%s\t%ld\t%ld\t%ld\n",per->name,per->department,per->base_pay,per->allowance,per->total); 	}  }这是改后的  如果把‘&’符号去掉

你在main函数之中已经将文件打开了一次，而且没有关闭，就在file_write里面再次打开文件。 而且你在打开文件失败之后，不立即退出，继续执行后面的命令，将内容写入一个并没有正确打开的文件中。 这就造成了错误。

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

能不能把代码嵌在code c/c++中

快捷贴！我还有问题要问！目前没有分！无法提问。

void file_write(struct person*per) { FILE *fp; if((fp=fopen("paydata.txt","w"))==NULL) printf("打开文件失败\n"); fwrite(/*&*/per,sizeof(struct person),1,fp); fclose(fp); } 请看被我注释掉的部分！

我们老师说，是文件打开关闭打开关闭次数太多，出了问题。。。。。。。。折磨我快两周了


Question: 看下这段代码有什么问题

你的函数需求的是一个数组的数组，但是你传入的是一个二维数组。 数组的数组的本质是在一个一维一数组中储存每一列的指针，但是一个二维数组本质是一个一维数组，只不过编译器记住了它的每一列的长度。

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

这格式都不爱看吧……

楼上的解答正确！！！楼主的程序调用参数不匹配，我在vs2010上试的：  编译的错误好多，都是关于函数调用参数不匹配或者=两边类型不一致……


Question: 关于TLS的一点问题。

恩恩，结贴了，多谢各位~~~

这是一个先有鸡还是先有蛋的问题。

TLS用得不多，因为它不是解决多线程问题的核心部分，它只是必须部分，而大部分还对用户不可见。 等你以后学做库了，就知道它的重要了

要是每次调用函数都加一个参数，还是太麻烦，特别是要是想添加某个变量的时候，需要改一大堆代码，不可能的。 要只是自己写的一个小程序也就算了，多个模块协作的程序呢？不可能要求别人修改函数参数的


Question: linux下关闭文件操作的疑问

4楼验证的合理

int fd = open("somefile", mode); FILE* fp = fdopen(fd, "r"); // 文件操作....  // close(fd); fdopen之后，不要close(fd); 应该用fclose(fp); 因为fclose会关闭fd的。 fclose(fp); // 是否有必要, 运行返回值为0,没有错

这种情况应该只需要关FILE吧。。  有几点： 1、用fdopen打开的FILE会使用指定的file descriptor 2、fclose会关闭底层的file descriptor 3、关掉file descriptor是为了释放OS资源，关FILE不光是释放file descriptor，还顺带释放FILE本身，其实都不关程序退出之后现代OS也是会给你关掉/释放掉的，但是作为常驻程序的话有可能造成内存/资源泄露  看这个示例说明fclose会关闭fd 文件"file"的内容 something here  #include <stdio.h> #include <fcntl.h> #include <unistd.h>  int main( void ) { 	int fd; 	FILE *fp; 	char buf[16] = {0};  	fd = open( "file", O_RDONLY ); 	fp = fdopen( fd, "r" );  	printf( "fd=%d\n", fd ); 	printf( "fileno=%d\n", fileno( fp ) );  	printf( "read=%ld, --%s--\n", read( fd, buf, 10 ), buf );  	fclose( fp ); 	return 0; }  这样没问题，输出：(注意fileno和fd是一样的) fd=3 fileno=3 read=10, --something --   #include <stdio.h> #include <fcntl.h> #include <unistd.h>  int main( void ) { 	int fd; 	FILE *fp; 	char buf[16] = {0};  	fd = open( "file", O_RDONLY ); 	fp = fdopen( fd, "r" );  	printf( "fd=%d\n", fd ); 	printf( "fileno=%d\n", fileno( fp ) );  	fclose( fp ); 	printf( "read=%ld, --%s--\n", read( fd, buf, 10 ), buf );  	return 0; }  这样read出错 fd=3 fileno=3 read=-1, ----

感觉操作一个文件时，不应该使用两类I/O函数。

都关好，虽然不知道为什么

1.如果以用户自己负责的说：都需要关闭 2.如果用户不吊的说，都可以不关，而交给OS处理——进程结束时，所有打开的文件描述都会被关闭！


Question: 结构体数组通过fwrite写入文件，但总是读不出来。

引用 3 楼 olazuwon 的回复:[quote=引用 2 楼 olazuwon 的回复:] [quote=引用 1 楼 zhangxiangDavaid 的回复:] 你是如何打开文件的呢？  fp=fopen();  写入的时候： fp = fopen(path,"w")) 读取的时候：fp = fopen(path,"r")) [/quote] 我发现问题了，读二进制文件必须用fp = fopen(path,"rb")) 不过奇怪了，为什么写入的时候不用"wb“呢？[/quote]  不对， 写入的时候也必须用"wb"，否则读取的时候读了几个以后就错了。

引用 2 楼 olazuwon 的回复:[quote=引用 1 楼 zhangxiangDavaid 的回复:] 你是如何打开文件的呢？  fp=fopen();  写入的时候： fp = fopen(path,"w")) 读取的时候：fp = fopen(path,"r")) [/quote] 我发现问题了，读二进制文件必须用fp = fopen(path,"rb")) 不过奇怪了，为什么写入的时候不用"wb“呢？

引用 1 楼 zhangxiangDavaid 的回复:你是如何打开文件的呢？  fp=fopen();  写入的时候： fp = fopen(path,"w")) 读取的时候：fp = fopen(path,"r"))

你是如何打开文件的呢？  fp=fopen();


Question: 请教各位前辈，c语言基础入门后怎么更好的提升自己水平。

非常谢谢大家！

需求决定一切

1.多看两遍<k&R>必要时参考C99，这是基础！C专家，C指针，C陷阱与缺陷都可以博览 2.代码风格参考CodingStyle 一般二元运算符前后加空格，一元运算符前后不加空格。一行代码做一件事，注意缩进和ID命名遵循一种，基本上就可以了！ 3.小问题找百度，核心问题找google！google被墙了，谷粉用着还不错！ 第一步，搜索已有的解答，未搞定 第二步，搜索对应的英文解答，还未搞定 第三步，查阅手册或标准，还是搞不定 第四步，整理好自己的问题，找大神求助！

多练习，经验和提高都从代码中来，理论加实践才是提高的最好方式

Google C++ 风格指南 - 中文版.chm 支持全文搜索http://download.csdn.net/detail/zhao4zhong1/5040814  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！  单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式...的值【比如printf("%p\n",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495

《编程规范》 《c++primer》     写个五子棋，贪吃蛇之类的小游戏， 学生管理系统等。


Question: 麻烦帮忙看下哪里错了

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

第6行printf的最后是一个全角分号

引用 5 楼 anshiny 的回复:int main() {     double tax, money;     printf("请输入工资（5000至8000元)\n");     scanf("%lf", &money);     tax = (money - 3500) * 0.1 - 105;     money -= tax;     printf("%.2lf\n", money);     return 0; } 五楼正解

类型问题，楼上已给出答案，我顺便漏个脸接接分。。。。

真诚的感谢您的解答，不过这个应该不是问题。

tax=(money-3500)*0.1-105;  中等号右边是double类型  所以tax应该定义为double

谢谢回复，不过不知什么地方还是有错


Question: matlab代码，但不知道怎么编写函数把它转换为C语言，求大神指导。

可以读懂matlab程序后，再用c语言实现。 直接转的工具，效果应该都不好。不过matlab程序好像可以编译为动态库，用c语言调用。

lz你用c实现c++的类试试？

涉及到矩阵操作，不好转换！如果再涉及到matlab内嵌函数功能，你还要把此功能用C方式实现！不知道matlab有没有库让C调用，自己查查

不要做A语言代码修改为B语言代码的无用功。 也不要做用A语言代码直接调用B语言代码库这样复杂、这样容易出错的傻事。 只需让A、B语言代码的输入输出重定向到文本文件，或修改A、B语言代码让其通过文本文件输入输出。 即可很方便地让A、B两种语言之间协调工作。 比如： A将请求数据写到文件a.txt，写完后改名为aa.txt B发现aa.txt存在时，读取其内容，调用相应功能，将结果写到文件b.txt，写完后删除aa.txt，改名为bb.txt A发现bb.txt存在时，读取其内容，读完后删除bb.txt 以上A可以替换为任何一种开发语言或开发环境，B可以替换为任何一种与A不同的开发语言或开发环境。 除非A或B不支持判断文件是否存在、文件读写和文件更名。 但是谁又能举出不支持判断文件是否存在、文件读写和文件更名的开发语言或开发环境呢？  共享临时文本文件这种进程之间的通讯方法相比其它方法的优点有很多，下面仅列出我现在能想到的： ·进程之间松耦合 ·进程可在同一台机器上，也可跨机，跨操作系统，跨硬件平台，甚至跨国。 ·方便调试和监视，只需让第三方或人工查看该临时文本文件即可。 ·方便在线开关服务，只需删除或创建该临时文本文件即可。 ·方便实现分布式和负载均衡。 ·方便队列化提供服务，而且几乎不可能发生队列满的情况（除非硬盘空间满） ·……  “跨语言、跨机，跨操作系统，跨硬件平台，跨国，跨*.*的”苦海无边， 回头是“使用共享纯文本文件进行信息交流”的岸！


Question: 字符串文本读写操作，去掉重复3段IP

改了一下 #include <iostream> #include <vector> #include <string> #include <regex> using namespace std;  string getMatchStr(const string strNew)  { 	std::regex reg("(\\d{1,3}).(\\d{1,3}).(\\d{1,3}).");  	regex expression(reg);  	std::smatch m;  	if (regex_search(strNew, m, reg))  	{  		return m.str(); 	} 	else 	{ 		return ""; 	} }  bool IsExsit(const string& strOld,const  string& strMatched) { 	bool bRet = false	; 	std::regex reg("(\\d{1,3}).(\\d{1,3}).(\\d{1,3}).");  	regex expression(reg);    	std::smatch m;  	if (regex_search(strOld, m, reg))  	{  		//cout << m.str() << endl;  		if(strMatched == m.str()) 		{ 			bRet = true; 		} 	}  	return bRet; } int main (void) { 	vector<string> v; 	string tempStr; 	bool bExsit = false; 	string strMatched;  	while(cin >> tempStr) 	{ 		bExsit = false; 		strMatched = getMatchStr(tempStr); 		for each(auto s in v) 		{ 			if (IsExsit(s, strMatched)) 			{ 				bExsit = true; 				break; 			} 		} 		if (!bExsit) 		{ 			v.push_back(tempStr); 		} 	} 	for each(auto s in v) 	{ 		cout << s << endl; 	} 	cin.ignore( std::numeric_limits<std::streamsize>::max( )); 	cin.clear(); 	cin.get(); 	return 0; }

#include <iostream> #include <vector> #include <string> #include <regex> using namespace std;  bool IsExsit(const string& strOld,const  string& strNew) { 	bool bRet = false	; 	std::regex reg("(\\d{1,3}).(\\d{1,3}).(\\d{1,3}).");  	regex expression(reg);   	string strMatched;  	if (strNew.length() != 0) 	{ 		std::smatch m;  		if (regex_search(strNew, m, reg))  		{  			//cout << m.str() << endl;  			strMatched = m.str(); 			if (regex_search(strOld, m, reg))  			{  				//cout << m.str() << endl;  				if(strMatched == m.str()) 				{ 					bRet = true; 				} 			}  		}  	} 	return bRet; } int main (void) { 	vector<string> v; 	string tempStr; 	bool bExsit = false; 	while(cin >> tempStr) 	{ 		bExsit = false; 		for each(auto s in v) 		{ 			if (IsExsit(s, tempStr)) 			{ 				bExsit = true; 				break; 			} 		} 		if (!bExsit) 		{ 			v.push_back(tempStr); 		} 	}  	for each(auto s in v) 	{ 		cout << s << endl; 	} 	cin.ignore( std::numeric_limits<std::streamsize>::max( )); 	cin.clear(); 	cin.get(); 	return 0; }

用IP的前三个数建一个数组，前三个数共三个字节，共有2的24次方个值，建立一个2的24次方大小(占16MB内存)的数组，并与IP前三个数一一对应。将数组初始化为0，读入文件时将IP前三个数对应的数组中的元素的值设为1，表示此IP存在。 然后手动输入IP，判断IP前三个数对应的数组中的元素是否为1,是1表示IP已存在，是0表示IP不存在，并添加至文件末尾。 代码如下：  #include<stdio.h> char dat[1<<24]={0}; int main() { 	FILE *f = fopen("data.txt","a+"); 	if(f) 	{ 		unsigned int ip[4]; 		while(fscanf(f,"%u.%u.%u.%u",ip,ip+1,ip+2,ip+3)>0) 			dat[ip[0]<<16|ip[1]<<8|ip[2]]=1; 		scanf("%u.%u.%u.%u",ip,ip+1,ip+2,ip+3); 		if(dat[ip[0]<<16|ip[1]<<8|ip[2]]) 			puts("该IP重复。"); 		else 		{ 			fprintf(f, "%u.%u.%u.%u\n", ip[0], ip[1], ip[2], ip[3]); 			printf("已将%u.%u.%u.%u添加至data.txt\n", ip[0], ip[1], ip[2], ip[3]); 		} 		fclose(f); 	} 	return 0; }

//src1，src2， 输入两个字符串， len到第几个'.' //返回0， 相等， 1 不相等。 int mystrcmp(const char * src1, const char *  src2, int len) { 	int index = 0; 	if(!src1 || !src2) 		return 1; 	while(*src1++ == *src2++ && index < len) 	{ 		if(*src1 == '.') 		{ 			index++; 		} 	} 	if(index < len) 		return 1; 	else  		return 0; }  int main() { 	if(!mystrcmp("192.1.2.100", "192.168.1.0", 3)) 	{ 		cout << " == " << endl; 	} 	else 	{ 		cout << " != " << endl; 	} 	return 0; }

把输入 ip 的最后一段去掉，然后用 hash table 或 set 判重即可。


Question: VS下C++控制台程序结构体指针问题

谢谢回答。我解决问题了   pcap_send_queue *p_sendqueue;

//类型不匹配，可以强制转换指针 p_sendqueue=(pcap_sendqueue_queue *)&sendqueue;

不用加 struct 前缀


Question: 往下看

#include <stdio.h> #include <string.h> char s[80]; int i; char c; int main() {     while (1) {         printf("Input a integer:");fflush(stdout);         rewind(stdin);         fgets(s,80,stdin);         if (strlen(s)>10) {             printf("Input too long(>9)!\n");             continue;         }         if (2==sscanf(s,"%d%c",&i,&c)) {             if ('\n'==c) {                 printf("%d is a integer.\n",i);                 break;             }         }         if ('\n'==s[strlen(s)-1]) s[strlen(s)-1]=0;         printf("\"%s\" is NOT a integer!\n",s);     }     return 0; }

恢复已经损坏的输入流

#include <stdio.h> using namespace std; int main(void) { loop:     int sum = 0;     printf("输入任意正整数：\n");     if(scanf("%d",&sum) == 0)     {         fflush(stdin);//windows有效         printf("输入有误,重新输入");         goto loop;     }      return 0; } //输入任意正整数： //梵蒂冈 梵蒂冈地方 //输入有误,重新输入输入任意正整数：


Question: 温湿度检测，为什么显示是0？

示波器、逻辑分析仪、 调试器

引用 4 楼 my_live_123 的回复:电工知识一点不懂，爱莫能助+1，电路挂了的说

电工知识一点不懂，爱莫能助

不懂，态专业了。

百度找ds18b20的驱动程序和你的对照，  时序你应该搞清楚了， 主要是延时一定要准确， 你先测试一下你的延时程序准不准。


Question: 帮忙看看这段代码有什么问题

引用 3 楼 qq_26454465 的回复:之所以有:sz[n-1] = ‘\0’是因为怕szs的字符数超出了n或者等于n，这样就没有空字符了。 看不懂为什么是：sz[n - 1 - 48] = '\0',这个关ASCII什么事呢？ 还有为什么：n是char类型？（刚开始有设置的也是chan类型，后来改成了int类型）  getchar得到的是字符'5', 转成int是53, 你明白了吗?

只需做出一处修改即可  //n = getchar(); scanf("%d", &n);  原因 5被当做字符读入，'5'=53，故copy的字符个数并不是你想的那样。

n是char ascii的0-9 实际对应的是48-57  所以sz[n-1-48] = '\0';  你的例子输出应该是wang, 因为\0算1个长度


Question: 为什么2到100就可以输出所有的素数，2到32767就只能输出一部分？

嗯，我试了改成空格就可以啦，谢谢你

引用 10 楼 former1024 的回复:  因为太多了, 开始的一些被顶掉了  你可以把\n换成空格

如果是2到100的之间的素数，会有3，5等这些比较小的数出现的，为什么到32767就不出现了？它们也是素数呀

引用 7 楼 former1024 的回复:可是我的目的是想要店脑输出2到32767所有的素数，它只输了一部分？为什么？ 这就是所有啊 对后一个是32749, 没错啊  哪个没有??

可是我的目的是想要店脑输出2到32767所有的素数，它只输了一部分？为什么？

引用 3 楼 former1024 的回复:后面的没有截图，最后一个数确实是32749  结果是对的  这里是素数表, 你可以看一下 http://baike.baidu.com/link?url=TWmat9_vrdT7DGx0KO3qbqVzGIh9RRKhLBPu69JhjlzpGCOrQJzI93vG32LJTkJRf8DlmehHds16c3OhyiS0vK

例如3，5，7等等

但前面的那些比较小的数为什么不能输出？

后面的没有截图，最后一个数确实是32749

简要看下，判断素数的逻辑，并无大问题，只是效率还可以提升。 只是输出到了30047，这就只能说明，后面的都不是素数。


Question: leetcode ZigZag convertsion问题  提交代码后回复 runtime error 检查代码许久不知何解

abcdefghijklmnopqrst  abcdefghijklmnopqrst  acegikmoqs bdfhjlnprt  a e i m q bdfhjlnprt c g k o s  a  g  m  s b fh ln rt ce ik oq d  j  p  a   i   q b  hj  pr c g k o s df  ln  t e   m  a    k b   jl   t c  i m  s d h  n r eg   oq f    p  a     m b    ln c   k o d  j  p e i   q fh    rt g     s  a      o b     np c    m q d   l  r e  k   s f j    t gi h  a       q b      pr c     o s d    n  t e   m f  l g k hj i  a        s b       rt c      q d     p e    o f   n g  m h l ik j  a b        t c       s d      r e     q f    p g   o h  n i m jl k  a b c d       t e      s f     r g    q h   p i  o j n km l  a b c d e f      t g     s h    r i   q j  p k o ln m  a b c d e f g h     t i    s j   r k  q l p mo n  a b c d e f g h i j    t k   s l  r m q np o  a b c d e f g h i j k l   t m  s n r oq p  a b c d e f g h i j k l m n  t o s pr q  a b c d e f g h i j k l m n o p t qs r  a b c d e f g h i j k l m n o p q rt s  a b c d e f g h i j k l m n o p q r s t

仅供参考：  #include <stdio.h> #include <stdlib.h> void convert(const char *str, int row) { 	if (row == 1) 	{ 		puts(str); 		return; 	} 	int i, j, len, pos; 	len = strlen(str); 	len++; 	char **show = malloc(sizeof(char*)*row); 	for (i = 0; i < row; i++) 	{ 		show[i] = malloc(sizeof(char)*len); 		memset(show[i], ' ', len); 	} 	//关键代码 	pos = i = j = 0; 	while (1) 	{ 		if (show[i][pos] != ' ') i++; 		for ( ; str[j] && i < row; i++) 		{  			show[i][pos] = str[j++]; 		} 		if (str[j] == '\0') break; 		i -= 2; 		for ( ; str[j] && i >= 0; i--) 		{  			show[i][++pos] = str[j++]; 		} 		i++; 	}  	for (i = 0; i < row; i++) 	{ 		for (j = len - 1; j >= 0; j--) 		if (show[i][j] != ' ') 		{ 			show[i][j + 1] = '\0'; 			break; 		} 	}  	//打印 	for (i = 0; i < row; i++) puts(show[i]); 	//释放内存 	for (i = 0; i < row; i++) free(show[i]); free(show); } int main() { 	char *str = "abcdefghijklmnopqrst"; 	puts(str); 	printf("\n"); 	int row, len = strlen(str); 	for (int row = 1; row <= len; row++) 	{ 		convert(str, row); 		printf("\n"); 	} 	return 0; }


Question: leetcode zigzag conversion 代码提交后回复 runtime error   检查代码很久了不知何解 求帮忙

你说的很对 我重新编辑一下问题

简要说下这程序是要干嘛？不会让我自己搜吧


Question: 请问这两种情况为何结果不同

s=0;的位置不一样，结果应该是不一样的。

代码一是正确的 每一次循环都得把s重置为0


Question: 腾讯笔试的这道题的输出怎么算的

程序并不复杂，运行结果很好推断。

代码得适当修改：  int inc(int a) { 	return(++a); } int multi(int*a, int*b, int*c) { 	return(*c = *a**b); } //typedef int(*FUNC1)(int in); typedef int(*FUNC1)(int in); typedef int(FUNC2)(int*, int*, int*);  void show(FUNC2 fun, int arg1, int *arg2) { 	FUNC1 p = &inc; 	int temp = p(arg1); 	fun(&temp, &arg1, arg2); 	printf("%d\n", *arg2); }  int main() { 	int a; 	show(multi, 10, &a);//110 	return 0; }

编译出错. 没有输出


Question: 请问这种格式怎么输出来

请大家注意下输出示例是   123  9  5 并不是输入一行后下一行回车输出最大值

引用 7 楼 Bpf345 的回复:请大家注意下输出示例是  123 9 5 并不是输入一行后下一行回车输出最大值 int main() {     int repeat, n, a, max, i, j; 	int result[10] = {0};     scanf("%d", &repeat);     for(j=1; j<=repeat; j++) {         scanf("%d", &n);         scanf("%d", &a);         max = a;         for(i=2; i<=n; i++) {             scanf("%d", &a);             if(max < a)                 max = a;         } 		result[j-1] = max;     } 	for(j=0; j<repeat; j++) {         printf("%d\n", result[j]);     }        return 0; }

4楼正解，2楼有问题

楼上已给出正确答案，漏脸凭运气接分。。。。

int main() { 	int repeat, n, a, max, i, j; 	scanf("%d", &repeat); 	for(j=1; j<=repeat; j++) { 		scanf("%d", &n); 		scanf("%d", &a); 		max = a; 		for(i=2; i<=n; i++) { 			scanf("%d", &a); 			if(max < a) 				max = a; 		} 		printf("%d\n", max); 	}	 	return 0; }

输入3 (repeat=3)  4 2 123 -100 0  4 9 1 -1 8  3 1 3 5 输出示例   123  9  5  请问怎样输出这种格式

仅供参考：   #include<stdio.h> int main() { 	int repeat, n, a, max, i, j; 	//scanf("%d(repeat=%d)", &repeat, &repeat); 	scanf("%d", &repeat); 	for (j = 1; j <= repeat; j++) 	{ 		scanf("%d", &n); 		scanf("%d", &max); 		for (i = 1; i < n; i++) 		{ 			if (i == 1) 				scanf("%d", &max); 			else 			{ 				scanf("%d", &a); 				if (a > max) max = a; 			} 		} 		printf("%d\n", max); 	} 	return 0; } //3 //2 1 2 //2 //3 1 2 3 //3 //4 1 2 3 4 //4

先把以前的帖子结了


Question: 数据结构例题，有些看不懂的地方。。。。

先理解冒泡排序的思想，代码就很好写出来了

鄙人的文章：冒泡排序，可看下：http://blog.csdn.net/zhangxiangdavaid/article/details/30271613

程序写错了呗，冒泡排序网上课本上都有

自己选5个数,  在纸上写一边for的过程


Question: oc中，在一个类中组合了另一个类，那另一个类的成员变量如何直接调用？

这是C语言区，不光有C++的，怎么OC都来了。。 不是写OC的，不过这样貌似可以 #import <Foundation/Foundation.h>  @interface figure : NSObject @property float height; @property int weight; @property int handLength; @end  @implementation figure @end  @interface person : NSObject @property figure *shencai; @property int age; @end  @implementation person @end   int main(int argc, const char * argv[]) {      @autoreleasepool {         person *p = [person new];                  p.shencai = [figure new];                  p.age = 10;         p.shencai.height = 123;                  NSLog(@"%f\n", p.shencai.height);     }     return 0; }


引用 3 楼 nemo_87 的回复:[quote=引用 1 楼 hnwyllmm 的回复:] 楼主的程序会有大批量的客户端连过来吗？而且都是短连接？ 看到这种情况用pstack看下你的程序卡在哪里，是不是有死锁的情况 SYN_RECV和CLOSE_WAIT应该都是卡死了，后面一个是连接关闭处理的异常，没有调用close及时关闭 如果连接过大，试着调整backlog参数试试  连接的量是比较大的，客户端采用短链接，目前backlog是5，要不要改大一些[/quote] 试一下，但是感觉这个不是根本原因，还是程序处理 不够及时，看看程序都会卡在哪里

引用 1 楼 hnwyllmm 的回复:楼主的程序会有大批量的客户端连过来吗？而且都是短连接？ 看到这种情况用pstack看下你的程序卡在哪里，是不是有死锁的情况 SYN_RECV和CLOSE_WAIT应该都是卡死了，后面一个是连接关闭处理的异常，没有调用close及时关闭 如果连接过大，试着调整backlog参数试试  连接的量是比较大的，客户端采用短链接，目前backlog是5，要不要改大一些

[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters] "TcpTimedWaitDelay"=dword:0000001e


Question: 字符串数组的长度定义问题

引用 1 楼 brookmill 的回复:这个叫“可变长数组”，有些编译器支持，有些编译器不支持。 http://blog.csdn.net/code_crash/article/details/4854921 一楼正解

可变长数组是C99引入的，只能用于支持c99的编译器，比如gcc。VC、VS之类的就不行。

这说明你的编译器支持c99,c99的相关特性请自行百度。还有为了保证代码的可移植性，最好不要这么写。


Question: printf与scanf通用版本的宽字符版的参数应该如何写?

引用 1 楼 focuslight 的回复:加上_t  _tscanf(_T("%s"),  strBuffer);+1，虽然看不懂是什么意思

加上_t  _tscanf(_T("%s"),  strBuffer);


Question: 新人对findstr函数不懂，求教大神

引用 6 楼 bjym1987 的回复:[quote=引用 5 楼 zhangxiangDavaid 的回复:] ms写的这个strstr简洁，但不高效 这个请问怎样写高效[/quote] 字符串的查找可以使用KMP之类的算法

引用 5 楼 zhangxiangDavaid 的回复:ms写的这个strstr简洁，但不高效 这个请问怎样写高效

ms写的这个strstr简洁，但不高效

C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\strstr.c /*** *strstr.c - search for one string inside another * *       Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *       defines strstr() - search for one string inside another * *******************************************************************************/  #include <cruntime.h> #include <string.h>  /*** *char *strstr(string1, string2) - search for string2 in string1 * *Purpose: *       finds the first occurrence of string2 in string1 * *Entry: *       char *string1 - string to search in *       char *string2 - string to search for * *Exit: *       returns a pointer to the first occurrence of string2 in *       string1, or NULL if string2 does not occur in string1 * *Uses: * *Exceptions: * *******************************************************************************/  char * __cdecl strstr (         const char * str1,         const char * str2         ) {         char *cp = (char *) str1;         char *s1, *s2;          if ( !*str2 )             return((char *)str1);          while (*cp)         {                 s1 = cp;                 s2 = (char *) str2;                  while ( *s1 && *s2 && !(*s1-*s2) )                         s1++, s2++;                  if (!*s2)                         return(cp);                  cp++;         }          return(NULL);  }

能把main函数也出来吗？

if(numStr == 0)   这里直接引用 substr  函数 即可


Question: ubuntu C语言程序输出这样子是什么情况

引用 6 楼 my_live_123 的回复:贴代码出来瞅瞅+1,论坛有部分lz这样只说问题不贴代码的

贴代码出来瞅瞅

引用 4 楼 zhao4zhong1 的回复:看显示乱码的数据的原始字节内容。 我测试了下，  '!'<buf[j]&&buf[j]<='~' //'!'也应该算作可显示字符，所以是'!'<=buf[j]

看显示乱码的数据的原始字节内容。

引用 2 楼 zhao4zhong1 的回复:void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%08x -",i+addr);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             printf("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         printf("%s\n",binstr);     } }  对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A 这个函数是干什么用的/

换行符有问题?输出的后面应该是个换行符吧 修改下终端的编码格式试试


Question: 关于字符串的疑问

建议在凡是要用scanf输入一个字符的地方，都将 char c; scanf("%c",&c); 改为 char s[2]; char c; scanf("%1s",s);c=s[0];

引用 3 楼 vnvlyp 的回复:你都没有输入k吧。。 没有机会输入k,它就自动结束了

你都没有输入k吧。。

引用 1 楼 user-4 的回复:第一个scanf之后, 还有一个"回车"在缓冲区中  第二个scanf得到了这个"回车"  解决办法就是2个scanf之间加一句getchar(), 过滤掉回车 加了getchar（）；后还是显示那个结果，好奇怪

需要在多处，加上getchar(); 1.  scanf("%d", &n); getchar();  2.  for (b = 0; b < n; b++){ 	for (i = 0; i < 56; i++){ 		scanf("%c", &a[b][i]); 		} 	getchar(); }  3.  scanf("%d", &k); getchar();  4.  for (t = 0; t < k; t++){ 	scanf("%d", &c[t]); } getchar();

scanf("%d", &n); char a[n][56];  这种维数可变的数组，并不是所有编译器都支持的。所以这种语法并不推荐使用。


Question: 一本学校ACM是怎么学习的

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

《全国青少年信息学竞赛培训教材——复赛》

敲代码 刷题n~

我想参加叻

有校队，先报名，然后上半年课，之后考试选人

本人木有参加过ACM。但是学习这件事，只能自己好好琢磨。

一本学校都是从中学开始学习的。

本科进实验室说明你还是很勤奋的骚年，进实验室还是学习为主，主要靠自觉，到哪都一样！


Question: 请问如何写入文件

多谢。没想到是这里地方出错了。一开始还往更深的地方想了。多谢您的指点！

memset(buf+i,mask[rand()%2],fileLength); 这溢出了吧！ 应该是buf[i]=mask[rand()%2];吧。 还有你没delete[] buf;

错误信息如下： Windows 已在 文件涂写.exe 中触发一个断点。  其原因可能是堆被损坏，这说明 文件涂写.exe 中或它所加载的任何 DLL 中有 Bug。  原因也可能是用户在 文件涂写.exe 具有焦点时按下了 F12。  输出窗口可能提供了更多诊断信息。  可是涉及到堆栈，我记得就算是16位程序也是有64kb的堆栈空间的，我要读的文件一共才500多字节，应该不会导致溢出的吧？ 32位程序的堆栈空间应该更大才对吧？


Question: 小白求教：有n个整数，使前面各数顺序向后移m个位置，最后m个数变成前面m个数。写一函数move

有 n>=m*2 和n<m*2 的区别

int move(int *p, int n, int m);  int main() {	 	int m, n, i, *p; 	scanf("%d", &n); 	if((p = (int *)calloc(n, sizeof(int))) == NULL) 		exit(1); 	for(i=0; i<n; i++) 		scanf("%d", p + i); 	scanf("%d", &m); 	if(1 == move(p, n, m)) { 		for(i=0; i<n; i++) 			printf("%d ", *(p + i)); 		printf("\n"); 	} else { 		printf("参数有误!\n"); 	} 	return 0; }  int move(int *p, int n, int m) { 	int i, j, *t; 	j = 0; 	if(n < m) 		return 0;  	if(n == m) 		return 1;  	if((t = (int *)calloc(m, sizeof(int))) == NULL) 		exit(0); 	 	for(i=n-m; i<n; i++){ 		t[j++] = *(p + i); 	} 	for(i=n-m-1; i>=0; i--) 		*(p + i + m) = *(p + i); 	for(i=m-1; i>=0; i--) 		*(p + i) = t[i]; 	return 1; }

后m个数移到前面后，保持前后顺序吗？ 如，12345    m=2 移动后， 是 45123，还是54123？


Question: 数据类型`运算符与算数方式我太懂

加减乘除运算，输出结果

这个语句的作用是要输出“计算公式和计算结果” 假如你要计算1+2，结果为3； 那么你的number1里面存了1，number2存了2，ch存了‘+’，result存了3；  printf("运算结果:%d%c%d=%d\n",number1,ch,number2,result);　 结果就是： “运算结果： %d----------对应整数number1=1； %c-----------对应字符ch=‘+’ %d----------对应整数number2=2； = %d----------对应整数result=3； \n---------换行”  就是 “运算结果：1+2=3”


Question: 二个有意思的C调试现象

打个比方吧： 每成功出生一个健康的小孩，不管他/她，不管漂亮难看，不管大小，不管黑白，反正一切不管了，就是一个原生态！此时无论你对TA做什么，TA都不会觉得你的行为对TA有什么重要的价值与意义！而且很快你会发现无论你做什么，都是在自娱自乐。对TA无所谓的！如果因为你对TA做什么有什么不好的后果，那这个后果（比如被TA父母暴揍）只能自负！ 好了，下面对号 小孩 = 分配的内存 原生态 = 未初始化 你对小孩的行为 = 读写内存 行为无意义 = 随机值没用 被揍 = 随机值给程序引入了bug 后果自负 = bug自己调 有没有秒懂？

引用 1 楼 Bokutake 的回复:你的一个“现象”的程序有没有多运行几次呢？你可以多运行几次，结果不一定都是你说的那个规律。 局部变量都是在栈里分配的，栈空间是不会自动清空的，如果你没有显式指定初始化语句，所以值会是随机的，不能保证会是多少。 第二个，其实地址不可能是负值，因为x86的Linux程序里栈空间位于用户地址空间的最高处（3G用户空间）。所以程序执行时，j的地址接近3G的位置。最高位是1，所以会打印为负值。打印地址一般用%x。没初始化就是随即的

1 没发现 2. 你自己转的long int 还问为什么是负的?


Question: 用c语言写的递归函数遇到了问题求大神帮看看

谁能给个正确的解答呀

void Search(int Remainder, int Start, int nTerm){ 	int i; 	if (Remainder == 0){ 		Count++; 		if (Count % 4 != 1){ 			printf(";"); 		} 		printf("%d=%d", N, Terms[0]); 		for (i = 1; i<nTerm; i++){ 			printf("+%d", Terms[i]); 		} 		if (Count % 4 == 0){ 			printf("\n"); 		} 	} 	else{ 		for (i = Start; i <= Remainder; i++){ 			Terms[nTerm] = i; 		} 		//循环完i就是Remainder+1，那么你这里调用递归第一个参数是-1，跟没调用一样 		Search(Remainder - i, i, nTerm + 1); 	} }


Question: < 小白求助求>2的30次方，反过来求30√1073741824,c语言实现

搜“竖式开方”

找到 2的30次开方的数学逼近公式，然后实现这个公式的code。

找到 2的30次方的数学逼近公式，然后实现这个公式的code。

引用 1 楼 user-3 的回复:pwo(2,1.0/30)  谢了，我也是用的这个，我还以为是我这个方法不对，原来是我在用SCANF给值的时少了个&,这个编译器没报错···

pow(1073741824, 1.0 / 30)


Question: 很诡异的错误。

没代码说个毛线

代码贴出来看看

同意1L说法， 逻辑处理有问题， 有没有下标越界， 野指针， 使用了未初始化的变量等。

应该还是逻辑上有些问题，看看是不是有变量未初始化或者某些if语句的else没有添加，从“double”转换到“unsigned long”这个warning也算是比较烦人了，最好能处理一下。

调试的时候奔溃，然后看堆栈。

不存在什么诡异的问题  能运行就是能运行，不能运行就是不能运行，就算你运行一万次遇到一次出问题，那也一定是你程序的问题～～  你这种错误很显然是内存溢出了 或者 数组越界了

有没有调用与系统资源有关的函数？请求系统资源以后有没有检查是否成功？

楼上说的野指针有道理，我昨天也碰到和你一样的情况，编译没问题，运行就会这样。后来我发现是结构体变量指针，没有用malloc分配一个内存空间，就直接给结构体里面的成员赋值

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


Question: poj 1045 调试过，与网上ac代码没有区别，怎么老是wA

邮箱多少，发过来。我发给你~

http://download.csdn.net/download/u010174146/7299005 惭愧，我没有做过poj题目，比你外行。这是我在网上搜索到的答案，和你的答案一样。你参考一下，网上这类问题很多，多看看，综合参考一下。

哥们，下载分不够


Question: 全局断电

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

按Alt+8键打开汇编指令窗口，将断点挪到更精确的汇编指令处。