Question: 构建二叉链表（报错！）

还不行，我再想想，先记录下。  #include <stdio.h> #include <string.h> #include <stdlib.h>  typedef struct BiNode { 	char data;  	BiNode* LChild; 	BiNode* RChild;	 }BiNode,*BiTree;  BiTree Trans(char *preorder,char *inoreder,int len) { 	char *p,*q; 	BiTree root; 	int i=0;  	if(len<=0) 		return NULL;   	root->data = preorder[0];   	root->LChild = NULL;  	root->RChild = NULL;   	while(i<len)  	{   		if(inoreder[i]==preorder[0])    			break;   		i++;  	}  	p = preorder+1;                   	q = inoreder;                 	root->LChild = Trans(p,q,i);    	p = preorder+i+1;                 	q = inoreder+i+1;             	root->RChild = Trans(p,q,len-i-1);    	return root; }  void PreOrder(BiNode* R) { 	if(R!=NULL) 		{ 			printf("%d",R->data); 			PreOrder(R->LChild); 			PreOrder(R->RChild); 		} }  void InOrder(BiNode* R) { 	if(R!=NULL) 		{ 			InOrder(R->LChild); 			printf("%d",R->data);			 			InOrder(R->RChild); 		} }  void PostOrder(BiNode* R) { 	if(R!=NULL) 		{			 			PostOrder(R->LChild); 			PostOrder(R->RChild); 			printf("%d",R->data); 		} }   void main() { 	BiTree root; 	char *start,*medium,*end; 	int i,n,num; 	printf("-------------以先序和中序建立二叉树-----------------\n"); 	printf("Please input the number of nodes in the binary tree\n"); 	scanf("%d",&num); 	start=(char*)(malloc (num*sizeof(char))); 	medium=(char*)(malloc (num*sizeof(char))); 	printf("Please input the preorder of the binary tree \n"); 	for(i=0;i<num;i++) 	{ 		scanf("%d",&start[i]); 	} 	printf("Please input the inoreder of the binary tree\n"); 	for(i=0;i<num;i++) 	{ 		scanf("%d",&medium[i]); 	}		 	 	root=Trans(start,medium,num); 	printf("The postorder of the binary tree is:\n"); 	PostOrder(root); 	}

最前面的结构体应该改成这样吧，因为你BiTree是做一种类型：   typedef struct BiNode { 	char data;  	BiNode* LChild; 	BiNode* RChild;    }BiNode,*BiTree;


Question: Glibc提供的TCP相关API

引用 1 楼 user-1 的回复:参看：http://download.csdn.net/download/jinlxz/4669382  多谢


Question: 离散最大似然解码运行不能，似乎是栈的问题

栈大小通常是1M，可以设置默认栈大小 不过对于大数组建议使用动态分配

数组太大了，栈内存已经不够


Question: VC++6.0如何基于对话框在模态编辑框中输入四个数值点击确定按钮按大小依次显示在主对话框四个静态文本中？

引用 3 楼 lxf129 的回复:[quote=引用 1 楼 paschen的回复:]添加一个对话框，在上面摆放需要的控件，为对话框关联一个类，在需要的地方使用DoModal方法创建一个模态对话框，在对话框中的按钮点击消息中实现比较与输出 比较和输出，大神能在详细些吗？[/quote]  GetDlgItemText取得字符串 _ttoi转成数值 比较，然后SetDlgItemText设置回去

引用 1 楼 paschen的回复:添加一个对话框，在上面摆放需要的控件，为对话框关联一个类，在需要的地方使用DoModal方法创建一个模态对话框，在对话框中的按钮点击消息中实现比较与输出 比较和输出，大神能在详细些吗？

利用GetDlgItemText(控件ID，接收控件字符串的Cstring)  然后解析EDIT内容中的字符串拆分来看。  利用 SetDlgItemText(控件ID，设置字符串） 来进行设置静态编辑框


Question: C语言数组初始化问题咨询

不要在看老谭的了，书挺老的了，可能那本书在当时很权威，但是语法更新了几代，换本书看吧

就是说如果是 int* p = new int[10]这种方式申请的就不行

这里的静态是指在栈上分配的，相对于动态在堆上分配的 而不是static的意思

静态存储的静态不是static的意思吧

书是老谭第一版，第82页一维数组初始化，编译器TC2.0，不是gcc，像各位说的应该是有问题，像C primer plus这书没规定说要静态存储，谢谢各位。

说明语法更新了~ 不要纠结这种没有意义的事情

你这说的很抽象啊，是一个函数，还是一个模块呢？

就因为你现在还看老谭的书


Question: C 一例疑惑 请大侠解答程序运行的步骤 不甚感谢！！！

估计是这些case 1: putchar(c + 4);后面没有加break的原因。。。输出的内容让你疑惑了。。。

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

看来看去不知道  你在问什么

1 输入遇回车结束 2 输入   输出    0       2   1        3   2        66    3       77    4       88    5       99    其它 c+2 (不知道是什么)


Question: 菜鸟求问关于题目，删除字符串中的子串

引用 7 楼 paschen 的回复:The strcat function appends strSource to strDestination and terminates the resulting string with a null character. The initial character of strSource overwrites the terminating null character of strDestination. The behavior of strcat is undefined if the source and destination strings overlap.  你执行strcat时，源字符串与目的字符串区域有一部分是重合的，行为是不确定的  你单步调试你的代码后会发现，stract后，字符串没有以\0结尾了，以致后面的操作出错，原因如上所述

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

引用 3楼github_27756899 的回复:while(strstr( a, b)!=NULL){//比如a为thisisatest b为is    front=strstr( a, b);//front指向搜索出a中第一个字符的位置    rear=front+cnt;  //rear等于去掉子字符串的开始 isatest   *front='\0';    //修改的部分   strcat( a, rear);//复制之后a为thisatest    //修改的部分    }编译通过了，然后一运行就停止运行了，不止一次了，是不是编译器有问题？

a=strcat( a, rear);//复制之后a为thisatest  你的a不是指针，不能直接赋值。

木有人吗，求大神解答

引用 4 楼 paschen 的回复:a=strcat( a, rear); 改成 strcat( a, rear); 拼接后的字符串已经在a中了  如果你要一个用其返回值，可以这样写：  char* s; s = strcat( a, rear);  照你说的改了，编译通过了，然后一运行就停止运行了，不止一次了，是不是编译器有问题？


Question: 计算机原理中的位向量表示集合的原理是什么？

引用 5 楼 BlueBloodSpider 的回复:[quote=引用 楼主 Last_stardust的回复:]如题，书上给出的例子是这样的： a=[01101001]表示{0，3，5，6} b=[01010101]表示{0，2，4，6} 最终a&b={01000001}={0，6}  谁能解释一下这8位二进制是如何表示集合的呢？ 深入理解计算机系统[/quote] fud软工硕士考纲指定教材

引用 楼主 Last_stardust的回复:如题，书上给出的例子是这样的： a=[01101001]表示{0，3，5，6} b=[01010101]表示{0，2，4，6} 最终a&b={01000001}={0，6}  谁能解释一下这8位二进制是如何表示集合的呢？ 深入理解计算机系统

向量的位置，和集合的元素在等于1的时候对应  以题目的例子来讲，a=[01101001]，从右边数起，第0、3、5、6位是1，所以就表示了0、3、5、6这4个数，b的话同理，对应的是0、2、4、6这4个数。之后的并集就不用再说了吧。

右边是最低位，1表示存在，0表示不存在

参考：集合的特征函数

第 i 位 为 1 表示 i 在 集合里。


Question: 有没有谁会求Huffman树的非递归算法

忘了说是求WPL，哈哈


Question: malloc函数无法正常调用问题

调试时单步运行，检查是哪出了问题

仅供参考：//将c:\\tmp文件夹下的所有文件的内容全部放到用malloc分配的内存中 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <io.h> struct FB {     char fn[256];     size_t fl;     char *b;     struct FB *next;     struct FB *prev; } *fh,*fb,*ft; char ln[256]; char fpn[256]; FILE *af; FILE *f; int L,n; int main() {     system("dir /b /a-d c:\\tmp\\*.* >c:\\allfn.txt");     af=fopen("c:\\allfn.txt","r");     if (NULL==af) {         printf("Can not open file c:\\allfn.txt!\n");         return 1;     }     fh=NULL;     fb=NULL;     n=0;     while (1) {         if (NULL==fgets(ln,256,af)) break;         L=strlen(ln);         if ('\n'==ln[L-1]) ln[L-1]=0;         printf("read %s\n",ln);         strcpy(fpn,"c:\\tmp\\");         strcat(fpn,ln);         ft=(struct FB *)malloc(sizeof(struct FB));         if (NULL==ft) {             printf("Can not malloc ft!\n");             fclose(af);             return 2;//之前的malloc在main退出后由操作系统自动free         }         printf("ft[%d]==%p\n",n,ft);         strcpy(ft->fn,fpn);         f=fopen(fpn,"rb");         if (NULL==f) {             printf("Can not open file %s!\n",fpn);             fclose(af);             return 3;//之前的malloc在main退出后由操作系统自动free         }         ft->fl=_filelength(fileno(f));         ft->b=malloc(ft->fl);         if (NULL==ft->b) {             printf("Can not malloc ft->b!\n");             fclose(f);             fclose(af);             return 4;//之前的malloc在main退出后由操作系统自动free         }         printf("ft[%d]->b==%p\n",n,ft->b);         if (ft->fl!=fread(ft->b,1,ft->fl,f)) {             printf("fread error!\n");             fclose(f);             fclose(af);             return 5;//之前的malloc在main退出后由操作系统自动free         }         fclose(f);         ft->next=NULL;          if (NULL==fh) {             ft->prev=NULL;             fh=ft;         } else {             fb->next=ft;             ft->prev=fb;         }         fb=ft;         n++;     }     fclose(af);     printf("-----list-----\n");     for (ft=fh;NULL!=ft;ft=ft->next) {         printf("%8d %s\n",ft->fl,ft->fn);         if (NULL!=ft) fb=ft;     }     printf("-----free-----\n");     n--;     if (NULL!=fh) {         for (ft=fb->prev;NULL!=ft;ft=ft->prev) {             if (NULL!=ft->next->b) {                 printf("ft[%d]->b==%p\n",n,ft->next->b);                 free(ft->next->b);             }             if (NULL!=ft->next) {                 printf("ft[%d]==%p\n",n,ft->next);                 free(ft->next);             }             n--;         }         if (NULL!=fh->b) {             printf("ft[0]->b==%p\n",fh->b);             free(fh->b);         }         printf("ft[0]==%p\n",fh);         free(fh);     }     return 0; } //C:\tmp\tmp\Debug>dir /a-d c:\tmp // 驱动器 C 中的卷是 C_HD5_1 // 卷的序列号是 1817-D526 // // c:\tmp 的目录 // //找不到文件 // //C:\tmp\tmp\Debug>tmp //找不到文件 //-----list----- //-----free----- // //C:\tmp\tmp\Debug>dir /a-d c:\tmp // 驱动器 C 中的卷是 C_HD5_1 // 卷的序列号是 1817-D526 // // c:\tmp 的目录 // //2011-06-30  18:04            44,840 my_c.rar //2011-06-30  17:18             1,036 err.frm //2011-06-30  14:32            14,243 出租.txt //2011-06-28  12:08            23,681 MSDN98书签.txt //             4 个文件         83,800 字节 //             0 个目录 17,041,870,848 可用字节 // //C:\tmp\tmp\Debug>tmp //read my_c.rar //ft[0]==00421800 //ft[0]->b==00520068 //read err.frm //ft[1]==00421670 //ft[1]->b==0052AFC0 //read 出租.txt //ft[2]==00421530 //ft[2]->b==00378F28 //read MSDN98书签.txt //ft[3]==004213F0 //ft[3]->b==0052B3F8 //-----list----- // 44840 c:\tmp\my_c.rar //  1036 c:\tmp\err.frm // 14243 c:\tmp\出租.txt // 23681 c:\tmp\MSDN98书签.txt //-----free----- //ft[3]->b==0052B3F8 //ft[3]==004213F0 //ft[2]->b==00378F28 //ft[2]==00421530 //ft[1]->b==0052AFC0 //ft[1]==00421670 //ft[0]->b==00520068 //ft[0]==00421800 // //C:\tmp\tmp\Debug>


Question: 用于求大整数的尾数方法

仅供参考：#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); }

可以通过编译链接

描述清楚一点要做什么


Question: 二叉树的层次建立，错在哪里

引用 2 楼 logiciel 的回复:建议修改如下: #include <stdio.h> #include <stdlib.h>  #define MaxSize 30  typedef struct QueueNode* PtrQType ; typedef struct BinTreeNode* PtrBT ;  //二叉树结点结构体 struct BinTreeNode {   int BTNodeData ;   struct BinTreeNode* Right;   struct BinTreeNode* Left ; } ;  //顺序队列 struct QueueNode {   struct BinTreeNode* AddressData[MaxSize] ;//指针数组，数组中保存的是地址   int rear ;   int front ;  } ;   //队列的初始化 PtrQType CreateQueue(  ) {   PtrQType PtrQ ;   PtrQ=(struct QueueNode*)malloc(sizeof(struct QueueNode));   PtrQ->front=0 ;   PtrQ->rear=0  ;    return PtrQ ; }  //入队 void AddQ( PtrQType PtrQ , struct BinTreeNode* a ) {   int IsFull( PtrQType PtrQ ) ;   //判断队列是否已满   if( !IsFull(PtrQ) )//没满添加数据   {     (PtrQ->AddressData[PtrQ->rear]) = a ;     (PtrQ->rear)++ ;   }   else      printf("队列已满，停止入队\n");  }  //出队,并返回队首(树的地址) int IsEmpty( PtrQType PtrQ ); PtrBT DeleteQ( PtrQType PtrQ ) {   int i ;   if( !IsEmpty(PtrQ) )   {     i=PtrQ->front ;     PtrQ->front++ ;      return PtrQ->AddressData[i] ;   }   else {printf("队列已空\n"); return NULL;} //else printf("队列已空\n") ; }   //队列是否已满 int IsFull( PtrQType PtrQ ) {   if (PtrQ->rear == MaxSize-1)     return 1 ;   else     return 0 ; }  //队列已空 int IsEmpty( PtrQType PtrQ ) {   if( PtrQ->front >= PtrQ->rear ) //改 if( PtrQ->front > PtrQ->rear )     return 1 ;   else     return 0 ;  }    PtrBT CreateBinTree(  ) {   //函数声明   PtrQType CreateQueue(  ) ;		//队列初始化   void AddQ( PtrQType PtrQ , struct BinTreeNode* a ) ;	//入队   PtrBT DeleteQ( PtrQType PtrQ ) ;   //出队     int Data ;   PtrBT BT,T ;   PtrQType PtrQ ;		     BT = NULL ;			//树的初始化   T = NULL ;    PtrQ = CreateQueue() ;    scanf("%d",&Data) ;		//读入数根节点数据，数据为0则输出空树   if( Data )   {     BT = ( PtrBT )malloc(sizeof(struct BinTreeNode) ) ;     BT->BTNodeData = Data ;     BT->Left = BT->Right = NULL; //加     AddQ( PtrQ , BT ) ;   }   else return NULL ;    while( !IsEmpty(PtrQ)  )		//当队列非空时执行...   {     T = DeleteQ( PtrQ ) ;	//弹出队首，地址赋给指针T     scanf("%d",&Data) ;		//读入左儿子结点数据     if( Data )				//左儿子结点读入数据，并将左儿子结点指针入队     {       T->Left = ( PtrBT )malloc(sizeof(struct BinTreeNode) ) ;       T->Left->BTNodeData = Data ;       T->Left->Left = T->Left->Right = NULL; //加       AddQ( PtrQ , T->Left ) ;     }     else T->Left=NULL ;      if (IsEmpty(PtrQ)) break; //加      T = DeleteQ( PtrQ ) ;      scanf("%d",&Data) ;		//读入右儿子结点数据     if( Data )				//右儿子结点读入数据，并将右儿子结点指针入队     {       T->Right = ( PtrBT )malloc(sizeof(struct BinTreeNode) ) ;       T->Right->BTNodeData = Data ;       T->Right->Left = T->Right->Right = NULL; //加       AddQ( PtrQ , T->Right ) ;     }     else T->Right=NULL ;   }   return BT ;		 	 }     void InOrderTraversal( PtrBT BT  ) {   if(BT)   {     InOrderTraversal(BT->Left);     printf("%d",BT->BTNodeData);     InOrderTraversal(BT->Right);    } }    int main(	) {   PtrBT BT ;   printf("请输入树（层次建立）\n") ;   BT = CreateBinTree() ;    //中序遍历   InOrderTraversal(BT);     printf( "层次输出树：\n"  ) ;   //	PrintfBT(  BT ) ;   }  大神，麻烦对我说下为什么加上BT->Left = BT->Right = NULL;，T->Left->Left = T->Left->Right = NULL;，T->Right->Left = T->Right->Right = NULL程序就可以运行了。没赋初值NULL时，我将BT的地址压入栈然后弹出赋给了T，为T->left开辟空间的语句不合法吗

引用 3 楼 u010107248 的回复:[quote=引用 2 楼 logiciel 的回复:] 建议修改如下: #include <stdio.h> #include <stdlib.h>  #define MaxSize 30  typedef struct QueueNode* PtrQType ; typedef struct BinTreeNode* PtrBT ;  //二叉树结点结构体 struct BinTreeNode {   int BTNodeData ;   struct BinTreeNode* Right;   struct BinTreeNode* Left ; } ;  //顺序队列 struct QueueNode {   struct BinTreeNode* AddressData[MaxSize] ;//指针数组，数组中保存的是地址   int rear ;   int front ;  } ;   //队列的初始化 PtrQType CreateQueue(  ) {   PtrQType PtrQ ;   PtrQ=(struct QueueNode*)malloc(sizeof(struct QueueNode));   PtrQ->front=0 ;   PtrQ->rear=0  ;    return PtrQ ; }  //入队 void AddQ( PtrQType PtrQ , struct BinTreeNode* a ) {   int IsFull( PtrQType PtrQ ) ;   //判断队列是否已满   if( !IsFull(PtrQ) )//没满添加数据   {     (PtrQ->AddressData[PtrQ->rear]) = a ;     (PtrQ->rear)++ ;   }   else      printf("队列已满，停止入队\n");  }  //出队,并返回队首(树的地址) int IsEmpty( PtrQType PtrQ ); PtrBT DeleteQ( PtrQType PtrQ ) {   int i ;   if( !IsEmpty(PtrQ) )   {     i=PtrQ->front ;     PtrQ->front++ ;      return PtrQ->AddressData[i] ;   }   else {printf("队列已空\n"); return NULL;} //else printf("队列已空\n") ; }   //队列是否已满 int IsFull( PtrQType PtrQ ) {   if (PtrQ->rear == MaxSize-1)     return 1 ;   else     return 0 ; }  //队列已空 int IsEmpty( PtrQType PtrQ ) {   if( PtrQ->front >= PtrQ->rear ) //改 if( PtrQ->front > PtrQ->rear )     return 1 ;   else     return 0 ;  }    PtrBT CreateBinTree(  ) {   //函数声明   PtrQType CreateQueue(  ) ;		//队列初始化   void AddQ( PtrQType PtrQ , struct BinTreeNode* a ) ;	//入队   PtrBT DeleteQ( PtrQType PtrQ ) ;   //出队     int Data ;   PtrBT BT,T ;   PtrQType PtrQ ;		     BT = NULL ;			//树的初始化   T = NULL ;    PtrQ = CreateQueue() ;    scanf("%d",&Data) ;		//读入数根节点数据，数据为0则输出空树   if( Data )   {     BT = ( PtrBT )malloc(sizeof(struct BinTreeNode) ) ;     BT->BTNodeData = Data ;     BT->Left = BT->Right = NULL; //加     AddQ( PtrQ , BT ) ;   }   else return NULL ;    while( !IsEmpty(PtrQ)  )		//当队列非空时执行...   {     T = DeleteQ( PtrQ ) ;	//弹出队首，地址赋给指针T     scanf("%d",&Data) ;		//读入左儿子结点数据     if( Data )				//左儿子结点读入数据，并将左儿子结点指针入队     {       T->Left = ( PtrBT )malloc(sizeof(struct BinTreeNode) ) ;       T->Left->BTNodeData = Data ;       T->Left->Left = T->Left->Right = NULL; //加       AddQ( PtrQ , T->Left ) ;     }     else T->Left=NULL ;      if (IsEmpty(PtrQ)) break; //加      T = DeleteQ( PtrQ ) ;      scanf("%d",&Data) ;		//读入右儿子结点数据     if( Data )				//右儿子结点读入数据，并将右儿子结点指针入队     {       T->Right = ( PtrBT )malloc(sizeof(struct BinTreeNode) ) ;       T->Right->BTNodeData = Data ;       T->Right->Left = T->Right->Right = NULL; //加       AddQ( PtrQ , T->Right ) ;     }     else T->Right=NULL ;   }   return BT ;		 	 }     void InOrderTraversal( PtrBT BT  ) {   if(BT)   {     InOrderTraversal(BT->Left);     printf("%d",BT->BTNodeData);     InOrderTraversal(BT->Right);    } }    int main(	) {   PtrBT BT ;   printf("请输入树（层次建立）\n") ;   BT = CreateBinTree() ;    //中序遍历   InOrderTraversal(BT);     printf( "层次输出树：\n"  ) ;   //	PrintfBT(  BT ) ;   }  大神，麻烦对我说下为什么加上BT->Left = BT->Right = NULL;，T->Left->Left = T->Left->Right = NULL;，T->Right->Left = T->Right->Right = NULL程序就可以运行了。没赋初值NULL时，我将BT的地址压入栈然后弹出赋给了T，为T->left开辟空间的语句不合法吗[/quote]  我将代码改写了，应该还是队列建立出错了

二叉树, 每个结点可能有两个子结点, T = DeleteQ( PtrQ ) ;之后应该直接scanf("%d%d", &T->Left->BTNodeData,&T->Right->BTNodeData), 你的代码是弹出队首, 读一个, 再弹一个

为T->left开辟空间的语句是合法的，但还要为T->left的T->Left->Left 和 T->Left->Right 赋初值NULL。否则当T->left最终是叶子节点时T->Left->Left 和T->Left->Right 的值是非法的，在中序遍历时将出错。


Question: C语言问题

什么鬼，求解啊

少年不如我帮你写吧٩(๑`^´๑)۶


Question: 建立子窗口问题

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  检查是否资源泄漏的办法之一： 在任务管理器 进程 查看 选择列 里面选择：内存使用、虚拟内存大小、句柄数、线程数、USER对象、GDI对象 让你的程序(进程)不退出,循环执行主流程很多遍，越多越好，比如1000000次甚至无限循环，记录以上各数值，再隔至少一小时，越长越好，比如一个月，再记录以上各数值。如果以上两组数值的差较大或随时间流逝不断增加，则铁定有对应资源的资源泄漏！

设置了一下属性:WS_CHILD|WS_VISIBLE|WS_OVERLAPPEDWINDOW 窗口是出来了，可运行几秒可，程序死机了，崩溃了.

用spy++看一下

哪位帮看看，谢谢

引用 1 楼 user-3 的回复:看 GetLastError 谢谢，用此函数查看得出： (1410)- 类别已存在。  应该是类名问题，char szClass[] = "Class9";   1.  我这函数是写在dll中的，发现第一调用没问题，再次调用就会报1410错误号，调用程序结束后，这个注册类还是在内存中存在，没有释放,我的推断， 2.  首次调用时输出ok,成功调用，但并没有出现子窗口，什么原因?

看 GetLastError


Question: 在一个排好序的数组中添加一个数使它按原来的顺序输出   运行结果有问题  大神帮帮我

引用 3 楼 qq_30931153 的回复:#include<stdio.h>  void add(int num[6]);   int main() { 	int i;     int num[6]={2 , 4 , 6 , 8 , 9};      add (num);     for(i=0;i<6;i++) 	{     printf("%d",num[i]); 	}  	return 0; } void add(int num[6]) {     int i , j , a ,k ;      printf( "输入要插入的数=\n" ) ;     scanf_s( "%d" , &a );      for(i=0;i<5;i++)     {         if(a<num[i])         break;     }     for(j=5;j>=i+1;j--)     {   k=j-1;        num[j]=num[k];      }  	num[i]=a; }           // 但是运行结果最后一个数总是5  没有啊，可以正常运行，插入数后重新排列好

那应该怎么改呢

数组越界。  你的数组只有 5 个位置，再插入一个数就不够用了。


Question: Visual Studio编译win32控制台程序时总是弹出两个cmd窗口

嗯嗯 版主在我们眼里都是大的

嗯嗯，另外我只是小版主

引用 1 楼 user-1 的回复:什么叫先后弹出两个控制台窗口，不会啊，有具体代码？ 多写大版主关心。问题解决了。是杀毒软件avast的问题。我把avast停了后就okey了。 代码很简单。我是用helloworld测试的。 IDE：vs2010 文件：helloworld.c 代码： #include<stdio.h>  int main() { 	printf("hello,world\n"); 	getchar(); }

什么叫先后弹出两个控制台窗口，不会啊，有具体代码？


Question: c语言中**.exe已触发了一个断点

请判断fscanf函数的返回值。

引用 2楼赵4老师 的回复:崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。我一步一步调试，他说我栈溢出，但是我查找了一下，发现栈没有溢出的

引用 1楼user-2 的回复:这样呢？  if ((fp = fopen(f, "rt")) == 0) { printf("\n\n error!"); return; }这样子还是不行，


Question: 【C语言动态内存分配】用malloc动态分配内存后，如何获取数组的大小？

理解和讨论之前请先学会如何观察！  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。

引用 5 楼 zhao4zhong1 的回复:_msize Returns the size of a memory block allocated in the heap.  size_t _msize( void *memblock );  Routine Required Header Compatibility  _msize <malloc.h> Win 95, Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  _msize returns the size (in bytes) as an unsigned integer.  Parameter  memblock  Pointer to memory block  Remarks  The _msize function returns the size, in bytes, of the memory block allocated by a call to calloc, malloc, or realloc.  When the application is linked with a debug version of the C run-time libraries, _msize resolves to _msize_dbg. For more information about how the heap is managed during the debugging process, see Using C Run-Time Library Debugging Support.  Example  /* REALLOC.C: This program allocates a block of memory for  * buffer and then uses _msize to display the size of that  * block. Next, it uses realloc to expand the amount of  * memory used by buffer and then calls _msize again to  * display the new amount of memory allocated to buffer.  */  #include <stdio.h> #include <malloc.h> #include <stdlib.h>  void main( void ) {    long *buffer;    size_t size;     if( (buffer = (long *)malloc( 1000 * sizeof( long ) )) == NULL )       exit( 1 );     size = _msize( buffer );    printf( "Size of block after malloc of 1000 longs: %u\n", size );     /* Reallocate and show new size: */    if( (buffer = realloc( buffer, size + (1000 * sizeof( long )) ))          ==  NULL )       exit( 1 );    size = _msize( buffer );    printf( "Size of block after realloc of 1000 more longs: %u\n",              size );     free( buffer );    exit( 0 ); }   Output  Size of block after malloc of 1000 longs: 4000 Size of block after realloc of 1000 more longs: 8000   Memory Allocation Routines  See Also   calloc, _expand, malloc, realloc 大师，能否再详细讲解下底层是如何完成内存管理的呢？思考如下： 1.下面的代码中，p只是个指针，但是你不用告诉编译器p的长度，他自己就能判断出来，delete[] p;因此推测有地方保存了内存块长度，那么为什么不把这个长度提供出来呢，而实际中又往往需要程序员自己保存长度，岂不是多此一举？ 2.执行这个代码char *p = new char[2]; _mszie(p+1);//assert false会抛出非法堆指针的错误，因此推测有地方保存了内存块的起始地址；而执行delete[] (p+1);//_BLOCK_TYPE_IS_VALID又会抛出块类型非法的错误，与堆指针错误不同，推测两者并非使用相同的判断方式。那么为什么要有两种不同的判断方式呢

我就操啊，mb打了那么多登录一下全没了

引用 3 楼 user-3 的回复:动态申请返回的其他是一个指针，C/C++里函数返回不了基本类型里的数组的，返回的仅是退化后的指针数组首元素的指针，而指针是不会记录数组大小的，所以如果要在敌后得到申请的是多大，在申请时自己用一个变量来保存 那么您可不可以看一下我第二段代码？为何用realloc重新分配后存不进？不用函数的话，代码如下： int n=12345678; 	int i=0; 	int *a; 	a=(int *)malloc(9*sizeof(int)); 	while(n!=0){     a[i]=n%10; 	realloc(a,(i+1)*sizeof(int));     n=n/10;     i++;     } 	a[i]=i; 	for(int j=0;j<=a[i];j++){ 		if(a[j]!=NULL){ 	printf("%d\n",a[j]); 		} 	} 	free(a); 最后屏幕上打出的除了第一个和最后一个其余的都是乱码，也就是说没有把数给存进去

引用 楼主 thuzhangga 的回复:部分代码如下： int *a=(int *)malloc(100*sizeof(int)); printf("%d",sizeof(a)); 但是输出的结果老是4而不是100?  动态申请的数组得到的只是指针，32位下指针长度就是4字节，只要返回的不为空，就肯定已经申请到了100个元素大小的int空间了，可放心使用。数组的大小申请时需要保存后，之后不能通过这种方式获取到了

其实我的主要目的是将十进制数字变成数组（一个一个数字分开），想到了用动态内存分配，代码如下： int *trans(int n){ int *a=(int *)malloc(sizeof(int)); int i=0; if(n==0){ a[0]=0; goto end;} else{ while(n!=0){ a=(int *)realloc(a,(i+1)*sizeof(int)); a[i]=n%10; n=n/10; i++; } } return a; end:return a; }


Question: c语言 从文件中读取数据

直接：  fscanf(fp, "%s%s%d%d%d", a[i].number, a[i].name, &(a[i].score[0]), &(a[i].score[1], &(a[i].score[2])));

for(i=0;i<5;i++)  {             fscanf(fp,"%d%s",&a[i].number,a[i].name);        for(j=0;j<3;j++)         {   fscanf(fp,"%d",&a[i].score[j]);          }  }   printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。


Question: 求大神解释一下，我知道是求1到20的阶乘和，但是不明白n=n*j;什么意思

n=n*j;  每种语言都有这种表达式，就是用n的旧值乘以 j 结果赋值给 n； C,C++一般简化为 n *= j; 具体在程序里的作用，就是实现i 的阶乘。因为循环种 j 分别为i，。。。1； 不过，程序可能是错误的。 因为 n应该对于每个i初始化为1， 开始计算阶乘。

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

添加printf语句，查看~，即可理解

内层循环求阶乘，外层循环求和，n=n*j;  就是让n依次乘每个数啊 比如你 i 为10 的时候，循环完相当于 n = 10*9*8*...*1


Question: 求大神给我解释这些代码。。。

for(int i=1;i<=20;i++) { for(int j=i;j>=1;j--) { n=n*j; } s=s+n; } i=1时，j=i=1初始化内层for, 判断j>=1是否成立，成立就执行花括号{}内的语句n=n*j;(右边运算完后把结果赋给左边的变量n） 如果j>=1不成立，for语句结束，执行下面（for语句下面）的语句s=s+n; 外层的for语句执行流程与内层for一样。


Question: 被编译器和内存对齐搞死了，求救

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

引用 1 楼 elimio 的回复:知道了，是内存对齐的问题，这个编译器好坑！8bit的数据类型都是按16位对齐的  这个参数可以设置的

你这种情况我遇到过，可以尝试原来的工程的编译器吧，不然工程量会很大的。

知道了，是内存对齐的问题，这个编译器好坑！8bit的数据类型都是按16位对齐的


Question: 高斯消去法用c语言 编程，可是不知那错了，求高手指点。。。

for循环有3个，还有k 的，输出也有错

高斯消元吗？ 公式: M[i] - (i * M[i]) = 0 (i == 1)


Question: 如何使用内嵌汇编实现斐波那契数列，求出第N个数

参考下面： 15:       if (n<2) { 0040104E   cmp         dword ptr [ebp-4],2 00401052   jge         main+68h (00401078) 16:           r=n; 00401054   mov         ecx,dword ptr [ebp-4] 00401057   mov         dword ptr [ebp-8],ecx 17:           printf("fib(%d) = %d\n", n, r); 0040105A   mov         edx,dword ptr [ebp-8] 0040105D   push        edx 0040105E   mov         eax,dword ptr [ebp-4] 00401061   push        eax 00401062   push        offset string "fib(%d) = %d\n" (00413020) 00401067   call        dword ptr [__imp__printf (004150b0)] 0040106D   add         esp,0Ch 18:           return r; 00401070   mov         eax,dword ptr [ebp-8] 00401073   jmp         main+101h (00401111) 19:       } else { 20:           char *argv2[2]; 21:           char argv21[3]; 22:           argv2[1]=argv21; 00401078   lea         ecx,[argv21] 0040107B   mov         dword ptr [ebp-0Ch],ecx 23:           sprintf(argv2[1],"%d",n-2); 0040107E   mov         edx,dword ptr [ebp-4] 00401081   sub         edx,2 00401084   push        edx 00401085   push        offset string "%d" (0041301c) 0040108A   mov         eax,dword ptr [ebp-0Ch] 0040108D   push        eax 0040108E   call        dword ptr [__imp__sprintf (004150a8)] 00401094   add         esp,0Ch 24:           r=main(2,argv2); 00401097   lea         ecx,[argv2] 0040109A   push        ecx 0040109B   push        2 0040109D   call        @ILT+0(_main) (00401005) 004010A2   add         esp,8 004010A5   mov         dword ptr [ebp-8],eax 25: 26:           char *argv1[2]; 27:           char argv11[3]; 28:           argv1[1]=argv11; 004010A8   lea         edx,[argv11] 004010AB   mov         dword ptr [ebp-18h],edx 29:           sprintf(argv1[1],"%d",n-1); 004010AE   mov         eax,dword ptr [ebp-4] 004010B1   sub         eax,1 004010B4   push        eax 004010B5   push        offset string "%d" (0041301c) 004010BA   mov         ecx,dword ptr [ebp-18h] 004010BD   push        ecx 004010BE   call        dword ptr [__imp__sprintf (004150a8)] 004010C4   add         esp,0Ch 30:           r+=main(2,argv1); 004010C7   lea         edx,[argv1] 004010CA   push        edx 004010CB   push        2 004010CD   call        @ILT+0(_main) (00401005) 004010D2   add         esp,8 004010D5   mov         ecx,dword ptr [ebp-8] 004010D8   add         ecx,eax 004010DA   mov         dword ptr [ebp-8],ecx 31:           printf("fib(%d) = %d\n", n, r); 004010DD   mov         edx,dword ptr [ebp-8] 004010E0   push        edx 004010E1   mov         eax,dword ptr [ebp-4] 004010E4   push        eax 004010E5   push        offset string "fib(%d) = %d\n" (00413020) 004010EA   call        dword ptr [__imp__printf (004150b0)] 004010F0   add         esp,0Ch 32:           return r; 004010F3   mov         eax,dword ptr [ebp-8] 004010F6   jmp         main+101h (00401111) 33:       } 34: 35:       __asm { 36: 37:       // FILL YOUR CODE HERE 38:       // evaluate r = f(n) 39:           nop 004010F8   nop 40:       }

将以下C代码对应汇编指令手动翻译为嵌入汇编语法代替nop指令： //斐波那契数列：0,1,1,2,3,5,8,13,21.。。。 //f(n)=f(n-2)+f(n-1) //f(0)=0 //f(1)=1 #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) {     int n, r;     if (argc < 2) {         printf("Usage: %s number(<40)\n", argv[0]);         return -1;     }     n = atoi(argv[1]);      if (n<2) {         r=n;         printf("fib(%d) = %d\n", n, r);         return r;     } else {         char *argv2[2];         char argv21[3];         argv2[1]=argv21;         sprintf(argv2[1],"%d",n-2);         r=main(2,argv2);          char *argv1[2];         char argv11[3];         argv1[1]=argv11;         sprintf(argv1[1],"%d",n-1);         r+=main(2,argv1);         printf("fib(%d) = %d\n", n, r);         return r;     }      __asm {      // FILL YOUR CODE HERE     // evaluate r = f(n)         nop     }     printf("fib(%d) = %d\n", n, r);     return 0; }

为什么要使用汇编, 是为了学习汇编还是为了速度


Question: 有关哈夫曼树的编码程序问题求解

试修改以下3行：        else cd[--start]='1';//改 else cd[--start]=='1';  int main() {   HuffmanTree HT;   HuffmanCode HC;   int *w;   int n,i;   //移到下面 HC=(HuffmanCode)malloc(n*sizeof(HuffmanCode));   //移到下面 w=(int *)malloc(n*sizeof(int));   printf("请输入结点个数：");   scanf("%d",&n);   HC=(HuffmanCode)malloc(n*sizeof(HuffmanCode));//移到这里   w=(int *)malloc(n*sizeof(int));//移到这里


Question: C语言小BUG（已找到错误代码，，在线等  急，）

已解决      找到问题所在了

引用 1 楼 user-1 的回复:scanf("%c", &cha1);取地址忘了    不过还是有错，

scanf("%c", &cha1);


Question: 小弟写了一个文件的读写程序 有点小问题 求指导

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

换个编译器吧，可能是getw, putw不兼容的问题？

引用 3 楼 u012033027 的回复:换个编译器吧，可能是getw, putw不兼容的问题？ 发帖的时候用的是DEV-C 然后换成VC++6.0 还是一样的

引用 1 楼 u012033027 的回复:我试了一下，没有问题啊。 可能是你最后没有输出换行符号，结果被覆盖了。 你尝试在      while((number = getw(f3)) != EOF)      printf("%4d",number);  之后再加一个 printf("\n"); 吧。  我试了一下 还是一样的结果呢 不知道为什么 纠结了一晚上了


Question: C语言问题

引用 6 楼 dsq2753919456 的回复:最后要将字符串前后调换才能实现进制转化，可是你的代码中并没有体现。  只是帮你改了你代码中一些问题，没具体看你怎么实现，你可以在此基础上改进

最后要将字符串前后调换才能实现进制转化，可是你的代码中并没有体现。

你程序很多问题，不一 一说了，帮你改好了，你自己看，不明白再问：   # include <stdio.h> # define N 100 char* itob(int n, char s[], int b); int main() { 	char a[N]; 	int x; 	int y; 	printf("请输入一个十进制数"); 	scanf_s("%d", &x); 	printf("请输入一个不小于2不大于35的数"); 	scanf_s("%d", &y); 	printf("%s", itob(x, a, y)); 	return 0; } char* itob(int n, char s[], int b) { 	int i = 0; 	while (n >0) 	{ 		if(n>=b) 			s[i] = (n%b>9)?n%b-10+'A':n%b; 		if (n < b) 			s[i] =(n>9)?n-10+'A':n; 		s[i] = s[i] + '0'; 		i++; 		n = n / b; 	} 	s[i] = '\0'; 	return s; }

引用 3 楼 dsq2753919456 的回复:程序可以运行 ，可是运行出来的是一个奇怪的图形，求大神指教，楼上几位实在是太酱油了。  itob(x, a, y); printf("%c", itob); 这里写的有问题，itob是一个函数名，代表这个函数的地址，用printf("%c",itob);打印肯定就是把一个地址按照%c的方式打印，肯定就错了。我想你应该是printf("%s", a);前面的a[N]初始化为0就好了。

调用函数不应该放在主函数里面定义吗？

编译器肯定会告诉你那里错了啊。 然后调试


Question: 程序哪里不对，总打印出错

着实没有看明白你的程序为什么要这么写~~~~

每次循环merge都会增加2个字节的内存，每次循环只输入一个字符，怎么会内存过小 追问：realloc函数第二个参数比原内存大，element3每次都加一

你将 merge放入循环，每次都要把它重新分配内存，分配的内存过小。


Question: C语言新手问题

引用 2 楼 qq_31741093 的回复:tmp = pArray[i] 不是就指向一个实体 结构体吗 ?  为什么不能定义成指针?  首先 （pArray[i]） 是一个实体，不是指针 其次你可以这样写：struct Teacher* tmp;  tmp = &pArray[i];  这种写法是对的，只是你要实现的是交换两个对象，所以你要产生一个临时的中间对象来作中转，如果你定义一个指针指向原来的对象，你就没法实现交换，这取决于你想要实现的功能

pArray是指针，pArray[i]就不是指针了，是按索引取到的对应元素，(&pArray[i]) 可以作为指针  第二个问题：tmp如果你定义成指针，也要让他指向一个实际结构体才行啊，不然仅仅是一个指针


Question: C语言问题

太棒了，圆满解决了我的问题

htoi 函数返回的是s[i] ， 只是一个字符，而且返回时 i 的值已经是-1了，相当于返回 s[-1]的值了

1、调用了两次htoi(a)函数，所以输出两个1010； 2、在htoi(a)结束时返回了s[i]，但i此时为-1，所以实际返回的是一个越界的值（值不确定)，所以printf函数打印出了-52。


Question: C#winform窗体

使用SetWindowPos  另C#问题建议楼主去.Net区中C#区提问

如果是要在最前，可以将topmost属性设为true


Question: FILE p和FILE *p有什么区别？

前一个是声明类对象，后一个是声明一个可指向类对象的指针

FILE p和FILE *p。 大概可以这么理解: 1 . 前一个p指文件型变量，后一个p指文件地址型变量。 2 . 前一个p的内存地址已定，后一个p内存地址未定。

学习了

引用 5 楼 u010165006 的回复:[quote=引用 4 楼 u010165006 的回复:] FILE是一个结构体，比较复杂，http://www.cnblogs.com/svking/archive/2012/08/08/FILE.html FILE *p 就是定义一个指向FILE结构体变量的指针，一般的 FILE *fopen(const char *filename, const char *mode); 函数都是构造一个FILE结构体并返回这个结构体地址即FILE *指针，可以用p=fopen(...)得到这个指针值。 以后的文件操作都需要这个p指向的FILE信息。[/quote] fclose(p)释放这块结构体内存。

引用 4 楼 u010165006 的回复:FILE是一个结构体，比较复杂，http://www.cnblogs.com/svking/archive/2012/08/08/FILE.html FILE *p 就是定义一个指向FILE结构体变量的指针，一般的 FILE *fopen(const char *filename, const char *mode); 函数都是构造一个FILE结构体并返回这个结构体地址即FILE *指针，可以用p=fopen(...)得到这个指针值。 以后的文件操作都需要这个p指向的FILE信息。

一个是结构体，一个是指针


Question: 大家帮忙看一下count怎么不能用啊

for (i = value; i >= 0; i--) 			accumulate(i);   accumulate拼写错了，你前面声明的是accumutale

什么叫“不能用”？


Question: dhcp option 20 c语言怎么编写处理函数？forwarding non-local source routing datagrame?

可以看下dhcpd 源码，里面是否有支持，如果支持的话或许只需打开某个flag，  没有的话就得深入看了。

大神在哪里？

求个大概思路就可以


Question: 怎么把结构体里面的数据复制到一个数组里面

#include <stdio.h> typedef unsigned char uchar; typedef struct { uchar year  ;//年,芯片以2000年为基数,如2014年,只需要赋值14即可 uchar month ;//月 uchar day   ;//日 uchar hour  ;//时 uchar minute;//分 uchar second;//秒 uchar weekn ;//星期几(星期日0) }TDS1302; TDS1302 a; uchar b[7]; int main() {     a.year  =15;     a.month =11;     a.day   =13;     a.hour  =12;     a.minute=43;     a.second=56;     a.weekn = 5;     b[0]=a.year  ;     b[1]=a.month ;     b[2]=a.day   ;     b[3]=a.hour  ;     b[4]=a.minute;     b[5]=a.second;     b[6]=a.weekn ;     printf("20%d-%02d-%02d %02d:%02d:%02d 星期%.2s\n",         b[0],         b[1],         b[2],         b[3],         b[4],         b[5],         "日一二三四五六"+2*b[6]);     return 0; } //2015-11-13 12:43:56 星期五 //

没看懂啥意思， 数组要同类型数据的啊，结构体里又不是都像这个一样都是相同的， 有没有大师点播我一下

同一类型的，可以不过不靠谱 毕竟依赖预编译器的实现特性 虽然编译器都是这么实现的，但是不知道有没有成为标准。

memcp就行了

不能用memcpy函数，因为有对齐问题。参考下面： #include <stdio.h> #define field_offset(s,f) (int)(&(((struct s *)(0))->f)) struct AD  { int a; char b[13]; double c;}; #pragma pack(push) #pragma pack(1) struct A1  { int a; char b[13]; double c;}; #pragma pack(2) struct A2  { int a; char b[13]; double c;}; #pragma pack(4) struct A4  { int a; char b[13]; double c;}; #pragma pack(8) struct A8  { int a; char b[13]; double c;}; #pragma pack(16) struct A16 { int a; char b[13]; double c;}; #pragma pack(pop) int main() {     printf("AD.a %d\n",field_offset(AD,a));     printf("AD.b %d\n",field_offset(AD,b));     printf("AD.c %d\n",field_offset(AD,c));     printf("\n");     printf("A1.a %d\n",field_offset(A1,a));     printf("A1.b %d\n",field_offset(A1,b));     printf("A1.c %d\n",field_offset(A1,c));     printf("\n");     printf("A2.a %d\n",field_offset(A2,a));     printf("A2.b %d\n",field_offset(A2,b));     printf("A2.c %d\n",field_offset(A2,c));     printf("\n");     printf("A4.a %d\n",field_offset(A4,a));     printf("A4.b %d\n",field_offset(A4,b));     printf("A4.c %d\n",field_offset(A4,c));     printf("\n");     printf("A8.a %d\n",field_offset(A8,a));     printf("A8.b %d\n",field_offset(A8,b));     printf("A8.c %d\n",field_offset(A8,c));     printf("\n");     printf("A16.a %d\n",field_offset(A16,a));     printf("A16.b %d\n",field_offset(A16,b));     printf("A16.c %d\n",field_offset(A16,c));     printf("\n");     return 0; } //AD.a 0 //AD.b 4 //AD.c 24 // //A1.a 0 //A1.b 4 //A1.c 17 // //A2.a 0 //A2.b 4 //A2.c 18 // //A4.a 0 //A4.b 4 //A4.c 20 // //A8.a 0 //A8.b 4 //A8.c 24 // //A16.a 0 //A16.b 4 //A16.c 24 // //

引用 楼主 qq_31880427 的回复:typedef struct { 	uchar year;    //年,芯片以2000年为基数,如2014年,只需要赋值14即可 	uchar month;   //月 	uchar day;     //日 	uchar hour;    //时 	uchar minute;  //分 	uchar second;  //秒 	uchar weekn;   //星期几(星期日0) }TDS1302;   复制这个结构体，并打印出来  能不能用memcpy函数。


Question: 起步新手一枚，请教前辈一个赋值问题

这个问题现在弄明白了   跟大家分享下  是我gcc路劲错误，大家也要注意

引用 5 楼 wzting 的回复:[quote=引用 3 楼 paschen 的回复:] 程序没问题，不知你说什么意思 好吧   版主大大 我用codeblocks显示上面截图  用vs2008则正常  一样的代码  是不是编译器的问题？[/quote]  我没试哦，你卸载了重新安装一下，不知什么原因

引用 3 楼 paschen 的回复:程序没问题，不知你说什么意思 好吧   版主大大 我用codeblocks显示上面截图  用vs2008则正常  一样的代码  是不是编译器的问题？

引用 3 楼 paschen 的回复:程序没问题，不知你说什么意思 就是正常的应该是我build后输入俩个变量 然后程序判断输出结果  但是照上面的程序build后没有输入变量这个过程了，直接显示上面截图所示的

程序没问题，不知你说什么意思

引用 1 楼 u012033027 的回复:scanf是需要输入的，你没有输入啊。 输入了啊   照视频输入的是变量a和b俩个数啊

scanf是需要输入的，你没有输入啊。


Question: 链表操作问题

malloc分配失败表示的是内存中已经无法获得满足你需要大小的连续空间了，链表结点通常不会发生

线性表链式存储基本是不会出现表满情况的，除非结点多到计算机无法承受，不能再给一个新结点动态分配内存，就是堆满了。这个时候如果不判断链表是否为满然后做出处理的话，而是让他继续逼着分配内存，那就不是程序出错这么轻松了。应该会是计算机的崩溃。 和顺序线性表的表满判断还是有区别的。  这是我个人的理解，并没有尝试过。如果有说的不对的地方希望大神指出，虚心学习。

这个表示堆空间已满，无法开辟新的空间来储存链表结点了。

嗯 这里是我之前的理解有误，这里的意思是无法分配内存放节点为真，注释有些误导。 感谢各位。


Question: MYSQL 使用了mysql_store_result之后， 使用mysql_free_result，内存还是持续增长

在线等啊，急啊啊 ~~~~~~~~~~~~~~~~~


Question: switch 语句没有default 分支会怎么处理？

引用 4 楼 u010165006 的回复:[quote=引用 3 楼 paschen 的回复:] 另推荐看《C++反汇编与逆向分析中》对switch反汇编的分析 汇编不熟，只有n年前微机原理8086汇编的一点印象不过我了解结果就可以了。 我看到有人说switch语句是顺序往下执行，default在最后，我把default分支放在最前面，default也不会被先执行，跟放在后面也是一样的。不知道switch反汇编处理各个case的方法。[/quote]  一样可以看，看了就知编译器在后面都做了什么事了

引用 8 楼 u010165006 的回复:[quote=引用 4 楼 u010165006 的回复:] [quote=引用 3 楼 paschen 的回复:] 另推荐看《C++反汇编与逆向分析中》对switch反汇编的分析 汇编不熟，只有n年前微机原理8086汇编的一点印象不过我了解结果就可以了。 我看到有人说switch语句是顺序往下执行，default在最后，我把default分支放在最前面，default也不会被先执行，跟放在后面也是一样的。不知道switch反汇编处理各个case的方法。[/quote] 我想反汇编是顺序比较、执行、跳转，编译的时候default分支始终被放到最后？ [/quote]  defualt是在最后，其他选项按你定义的排 switch在分支大于3之后就不会一一比较了，会进行优化，跟据你的选项是否是线性的，相差是否大于255等用不同的方法，通过查表来取得对应的跳转地址，在多路选择时效率会比 if 好

引用 4 楼 u010165006 的回复:[quote=引用 3 楼 paschen 的回复:] 另推荐看《C++反汇编与逆向分析中》对switch反汇编的分析 汇编不熟，只有n年前微机原理8086汇编的一点印象不过我了解结果就可以了。 我看到有人说switch语句是顺序往下执行，default在最后，我把default分支放在最前面，default也不会被先执行，跟放在后面也是一样的。不知道switch反汇编处理各个case的方法。[/quote] 我想反汇编是顺序比较、执行、跳转，编译的时候default分支始终被放到最后？

引用 4 楼 u010165006 的回复:[quote=引用 3 楼 paschen 的回复:] 另推荐看《C++反汇编与逆向分析中》对switch反汇编的分析 汇编不熟，只有n年前微机原理8086汇编的一点印象不过我了解结果就可以了。 我看到有人说switch语句是顺序往下执行，default在最后，我把default分支放在最前面，default也不会被先执行，跟放在后面也是一样的。不知道switch反汇编处理各个case的方法。[/quote] 我想反汇编是顺序比较、执行，编译的时候default分支始终被放到最后？

就不会执行switch语句了

引用 3 楼 paschen 的回复:另推荐看《C++反汇编与逆向分析中》对switch反汇编的分析 汇编不熟，只有n年前微机原理8086汇编的一点印象不过我了解结果就可以了。 我看到有人说switch语句是顺序往下执行，default在最后，我把default分支放在最前面，default也不会被先执行，跟放在后面也是一样的。不知道switch反汇编处理各个case的方法。

引用 1 楼 user-3 的回复:为什么不亲自试试 试了，想确定一下。

跳到switch最后，和defualt: break一样

另推荐看《C++反汇编与逆向分析中》对switch反汇编的分析

为什么不亲自试试


Question: vc编译器哪里下载?

引用 1 楼 paschen 的回复:建议楼主用VS2010  http://blog.csdn.net/cometnet/article/details/19551125  下载后直接安装就行，一路下一步到完成  MSDN可以在VS中的帮助菜单下获得 大哥给的连接2010不能下载。

引用 7 楼 paschen 的回复:[quote=引用 3 楼 paschen 的回复:] [quote=引用 2 楼 csdnxinshou2 的回复:] [quote=引用 1 楼 paschen 的回复:] 建议楼主用VS2010  http://blog.csdn.net/cometnet/article/details/19551125  下载后直接安装就行，一路下一步到完成  MSDN可以在VS中的帮助菜单下获得 下载不了好象。。。[/quote]  你要下载哪个版本[/quote]  你下载VS2010吧，XP可以用[/quote] 又可以下载了。。。

引用 7 楼 paschen 的回复:[quote=引用 3 楼 paschen 的回复:] [quote=引用 2 楼 csdnxinshou2 的回复:] [quote=引用 1 楼 paschen 的回复:] 建议楼主用VS2010  http://blog.csdn.net/cometnet/article/details/19551125  下载后直接安装就行，一路下一步到完成  MSDN可以在VS中的帮助菜单下获得 下载不了好象。。。[/quote]  你要下载哪个版本[/quote]  你下载VS2010吧，XP可以用[/quote] 大哥给的  引用 8 楼 fly140554 的回复:可以去msdn itellyou下载 msdn上怎么下载英文不好。

引用 4 楼 zhao4zhong1 的回复:Visual C++ 2010 Express简体中文版http://pan.baidu.com/s/1bnwRVLt 带MSDN吗?MSDN怎么安装?

引用 3 楼 paschen 的回复:[quote=引用 2 楼 csdnxinshou2 的回复:] [quote=引用 1 楼 paschen 的回复:] 建议楼主用VS2010  http://blog.csdn.net/cometnet/article/details/19551125  下载后直接安装就行，一路下一步到完成  MSDN可以在VS中的帮助菜单下获得 下载不了好象。。。[/quote]  你要下载哪个版本[/quote] XP哪个版本可以用?大哥。

可以去msdn itellyou下载

引用 3 楼 paschen 的回复:[quote=引用 2 楼 csdnxinshou2 的回复:] [quote=引用 1 楼 paschen 的回复:] 建议楼主用VS2010  http://blog.csdn.net/cometnet/article/details/19551125  下载后直接安装就行，一路下一步到完成  MSDN可以在VS中的帮助菜单下获得 下载不了好象。。。[/quote]  你要下载哪个版本[/quote]  你下载VS2010吧，XP可以用

引用 2 楼 csdnxinshou2 的回复:[quote=引用 1 楼 paschen 的回复:] 建议楼主用VS2010  http://blog.csdn.net/cometnet/article/details/19551125  下载后直接安装就行，一路下一步到完成  MSDN可以在VS中的帮助菜单下获得 下载不了好象。。。[/quote]  你要下载哪个版本

引用 1 楼 paschen 的回复:建议楼主用VS2010  http://blog.csdn.net/cometnet/article/details/19551125  下载后直接安装就行，一路下一步到完成  MSDN可以在VS中的帮助菜单下获得 下载不了好象。。。


Question: 有点错误 请看一下

引用 4楼user-1 的回复:加上b[11] = '\0';   #include<stdio.h>   int main() { 	char a[]="Dahhk,sknhz"; 	char b[99999]; 	printf("%s\n",a); 	printf("请输入解密字符:\n"); 	if(getchar()=='T') 	{ 		for(int i=0;i<11;i++) 			if(a[i]==' ') b[i]=' '; 			else if(a[i]>='w'&&a[i]<='z'||a[i]>='W'&&a[i]<='Z') b[i]=(a[i]-22); 			else if(a[i]==',') b[i]=','; 			else if(a[i]=='.') b[i]='.'; 			else 				b[i]=(a[i]+4); 			b[11] = '\0'; 			printf("%s",b); 	}  	else printf("error!");   	return 0; }  谢谢 解决了

引用 1楼user-1 的回复:图片不方便看啊，贴代码上来啊，初步判断你输出的字符串是否未以\0结尾#include<stdio.h> int main() { char a[]="Dahhk,sknhz"; char b[99999]; printf("%s\n",a); printf("请输入解密字符:\n"); if(getchar()=='T') { for(int i=0;i<11;i++) if(a[i]==' ') b[i]=' '; else if(a[i]>='w'&&a[i]<='z'||a[i]>='W'&&a[i]<='Z') b[i]=(a[i]-22); else if(a[i]==',') b[i]=','; else if(a[i]=='.') b[i]='.'; else b[i]=(a[i]+4); printf("%s",b); }  else printf("error!");   return 0; }

图片不方便看啊，贴代码上来啊，初步判断你输出的字符串是否未以\0结尾


Question: 二维数组中查找某个值的实现思路

引用 8 楼 FightForProgrammer 的回复:[quote=引用 7 楼 paschen 的回复:] int t[m][n]可以有那么大？？m和n都千万级别，不说栈暴了，堆都暴了  如果要想查找快，你放数据就应该用关联式容器（如哈希表等储存），否则你查找时只能逐个遍历 确实没那么大，也不是数组，一共2g左右把。就用内存映射咯？[/quote]  2G 是2*1000 000 000 int[m][n]是 4 *千万*千万 或者 8  *千万*千万*是 千万*千万 = 1000 *1000 * 1000 * 1000* 100 = 100T；共400T或者800T 和2G不是一个数量级的。 一个磁盘也就1T,2T,市面上最大的也就4T 你可能需要B+树这一类的数据结构.噢，估计还是不行 你还是用数据库，放服务器上吧

引用 7 楼 paschen 的回复:int t[m][n]可以有那么大？？m和n都千万级别，不说栈暴了，堆都暴了  如果要想查找快，你放数据就应该用关联式容器（如哈希表等储存），否则你查找时只能逐个遍历 确实没那么大，也不是数组，一共2g左右把。就用内存映射咯？

引用 5 楼 zhao4zhong1 的回复:[quote=引用 4 楼 FightForProgrammer 的回复:] [quote=引用 3 楼 zhao4zhong1 的回复:] [quote=引用 1 楼 lm_whales 的回复:] 用文件当数组使用吧 英雄所见略同！[/quote] 多谢，能指点一下大概的实现框架吗？[/quote] // 创建文件句柄 HANDLE hFile = ::CreateFile(lpszFileName, GENERIC_READ, NULL, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); // 创建文件映射 HANDLE hMap = ::CreateFileMapping(hFile, NULL, PAGE_READONLY | SEC_COMMIT, NULL, NULL, NULL); // 读取映射中的内存 LPVOID lpBuffer = ::MapViewOfFile(hMap, FILE_MAP_READ, NULL, NULL, NULL);  // 好了文件的内存已经获取了，你可以随意处理了  // 释放映射内存 ::UnmapViewOfFile(lpBuffer); // 关闭文件映射 ::CloseHandle(hMap); // close file handle ::CloseHandle(hFile);   Linux下参考 void * mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset);    [/quote]  嗯。这是把数据准备好把。其实想问的是如何组织数据，高效查询，难道只有逐个遍历这一条路吗？

引用 4 楼 FightForProgrammer 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] [quote=引用 1 楼 lm_whales 的回复:] 用文件当数组使用吧 英雄所见略同！[/quote] 多谢，能指点一下大概的实现框架吗？[/quote] // 创建文件句柄 HANDLE hFile = ::CreateFile(lpszFileName, GENERIC_READ, NULL, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); // 创建文件映射 HANDLE hMap = ::CreateFileMapping(hFile, NULL, PAGE_READONLY | SEC_COMMIT, NULL, NULL, NULL); // 读取映射中的内存 LPVOID lpBuffer = ::MapViewOfFile(hMap, FILE_MAP_READ, NULL, NULL, NULL);  // 好了文件的内存已经获取了，你可以随意处理了  // 释放映射内存 ::UnmapViewOfFile(lpBuffer); // 关闭文件映射 ::CloseHandle(hMap); // close file handle ::CloseHandle(hFile);   Linux下参考 void * mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset);

引用 3 楼 zhao4zhong1 的回复:[quote=引用 1 楼 lm_whales 的回复:] 用文件当数组使用吧 英雄所见略同！[/quote] 多谢，能指点一下大概的实现框架吗？

引用 1 楼 lm_whales 的回复:用文件当数组使用吧 英雄所见略同！

没有规律，你还是要遍历一遍的。

用文件当数组使用吧


Question: 急~各位大牛万能的CSDN，请教一个关于xml字符串解析的问题

引用 4 楼 realmardrid 的回复:http://bbs.csdn.net/topics/380115580 那个问题也可以这样用啊，不过我没有试过。

#include <stdio.h> #include <string.h> char s[]=     "\n"     "b\n"     "<C>c</C>\n"     "<D>d</D>\n"     "\n"; char t[100]; char *p,*q; int main() {     p=strstr(s,"");     q=strstr(p+3,"");     strncpy(t,p+3,q-p-3);t[q-p-3]=0;     printf("%s",t);     return 0; } // //b //<C>c</C> //<D>d</D> //

解析xml是一件非常简单的事情.你别看别人的帖子了,去研究一个例子吧.我使用xml的时候也就花了半天时间去看一个使用tinyxml的类解析的文件的例子.网上很多,你去百度一下:tinyxml!

引用 2 楼 baijiaheizhiganmao 的回复:[quote=引用 楼主 realmardrid 的回复:]  b <C>c</C> <D>d</D>   C语言处理  现有这样一个串只去掉最外层，得到b、<C>c</C>、<D>d</D>这样的串？谢谢 这个啊B和b等都是可以获取的。假如你使用tinyxml等读写xml文件的类的时候，你获取的时候是不带<>括号的。需要你在获取了之后重新组合他们。 假如你使用普通文件读写的时候就更简单了，只需要依次按行读，读出来后与最外成的皮对比一下，不相同则是你需要的。[/quote]http://bbs.csdn.net/topics/380115580

引用 1 楼 sand6174 的回复: boost的 ptrre pt; read_xml("a.xml",pt); pt = pt.get_child("A");  ///这里就是去掉外层的数据 for ( ptree::assoc_iterator iter = pt.ordered_begin() ; iter != pt.not_found() ; ++iter ) {   } 参考了这个http://bbs.csdn.net/topics/380115580

引用 楼主 realmardrid 的回复: b <C>c</C> <D>d</D>   C语言处理  现有这样一个串只去掉最外层，得到b、<C>c</C>、<D>d</D>这样的串？谢谢 这个啊B和b等都是可以获取的。假如你使用tinyxml等读写xml文件的类的时候，你获取的时候是不带<>括号的。需要你在获取了之后重新组合他们。 假如你使用普通文件读写的时候就更简单了，只需要依次按行读，读出来后与最外成的皮对比一下，不相同则是你需要的。


Question: 关于Code blocks的问题

引用 3 楼 paschen 的回复:重新建个工程，换个路径看下

重新建个工程，换个路径看下

引用 1 楼 zhao4zhong1 的回复:以管理员身份运行 以XP兼容模式运行  关掉UAC、防火墙、杀毒软件、…… 還是一樣不行欸

以管理员身份运行 以XP兼容模式运行  关掉UAC、防火墙、杀毒软件、……

必要的话，重启电脑。


Question: C语言 fgets()和getc()读取文件流的区别

谢谢赵老师 书上好像提过短路，不过没注意，现在吸取教训了:)

搜“逻辑短路”  用fgets受MAX限制


Question: 地址分配的问题。

malloc返回的是void*，是个地址值，转换成int*，之后这块内存上的内容将按int类型去解释

引用 3 楼 jk_101 的回复:[quote=引用 1 楼 adlay 的回复:] p1 是变量，怎么返回值？ 你是想问 malloc 的返回值吧  malloc 返回的是地址，类型是 void*    (int*) 把 void* 转换成 int*  不好意思啊  我想问的是p1的值是返回的地址吗？谢谢。[/quote]  p1 的值是这串内存空间的地址

引用 1 楼 adlay 的回复:p1 是变量，怎么返回值？ 你是想问 malloc 的返回值吧  malloc 返回的是地址，类型是 void*    (int*) 把 void* 转换成 int*  不好意思啊  我想问的是p1的值是返回的地址吗？谢谢。


Question: 求一个程序，输入一个整数，依次输出它的每位数的英文单词

你可以把他%10求余，算出的数存到数组里面（存的时候从后往前存），用一个for循环加指针进行switch判断输出对应的英文字母。

无profiler不要谈效率！！尤其在这个云计算、虚拟机、模拟器、CUDA、多核 、多级cache、指令流水线、多种存储介质、……满天飞的时代！

引用 6 楼 zhao4zhong1 的回复: 小心驶得万年船！ //输入一个非负整数，依次输出它的每位数对应的的英文单词 #include <stdio.h> #include <string.h> #include <locale.h> char s[20]; char t[20]; int i; char c; char *en[10]={"zero","one","two","three","four","five","six","seven","eight","nine"}; int main() {     setlocale(LC_ALL,"chs");     while (1) {         printf("输入一个非负整数:");fflush(stdout);         rewind(stdin);         fgets(s,80,stdin);         if (strlen(s)>10) {             printf("输入太长(>9)!\n");             continue;         }         if (2==sscanf(s,"%d%c",&i,&c)) {             if ('\n'==c && i>=0) {                 sprintf(t,"%d\n",i);                 if (0==strcmp(s,t)) {                     printf("%s",en[t[0]-'0']);                     for (i=1;t[i]!='\n';i++) printf(" %s",en[t[i]-'0']);                     printf("\n");                     break;                 }             }         }         if ('\n'==s[strlen(s)-1]) s[strlen(s)-1]=0;         printf("\"%s\" 不是非负正整数!\n",s);     }     return 0; } //输入一个非负整数:abc //"abc" 不是非负正整数! //输入一个非负整数:哈 //"哈" 不是非负正整数! //输入一个非负整数:10a //"10a" 不是非负正整数! //输入一个非负整数:-1 //"-1" 不是非负正整数! //输入一个非负整数:001 //"001" 不是非负正整数! //输入一个非负整数:1234567890 //输入太长(>9)! //输入一个非负整数:123456789 //one two three four five six seven eight nine //  效率太低

我的代码健壮性应该更好--- # include <stdio.h>   # define N 30 //如果要录入X个字节则 N=X     int Getchar(char A[],int min,int max);//直到用户输入的字符串长度在[min,max]之间时 函数结束 返回字符串A的长度     int Check(char A[]);   int main(){         char A[N+1],B[][6]={"zero","one","two","three","four","five","six","seven","eight","nine"}; 	int L,i;  	while(1) 	{     do{     printf("输入数字(1--%d)位:\n",N);     L=Getchar(A,1,N);     }while(Check(A));     i=0;     while(i<L)       printf("%s ",B[A[i++]]);     printf("\n");     }     return 0;     }     int Check(char A[]){ 	int i=-1; 	while(A[++i]) 	  if(A[i]>'9'||A[i]<'0') 	    return printf("输入有误!请重新"); 	    else A[i]-='0'; 	return 0; } int Getchar(char *A,int min,int max)//长度在[min,max]  <闭区间>  之间时 函数结束 返回字符串A的长度         {             int B,C;        do{                 A[max]=B=C=0;             while((A[B++]=getchar())!='\n'&&B<max);             if(A[B-1]!='\n')while(getchar()!='\n'&&++C);                 else A[--B]=0;          if(C||B&&B<min)            printf("您录入的字符串长度:%d字节\n只录入(%d--%d)个字节!\n",B+C,min,max);             }while(C||B<min);             return B;       }

你用二维数组不是更简单

我是来学习学习的

“多一少一”问题占程序员常犯错误的10%以上！ 避免“多一少一”问题的方法之一是将比如<10甚至<5的数代入程序片断，掰手指头心算验证一下程序到底应该写为 x、x-1、x+1中的哪个？ <、<=、==、>、>=中的哪个？

#include <stdio.h> #include <stdlib.h> int main() { 	  char *p[10]={"zero","one","two","three","four","five","six","seven","eight","nine","ten"};       long n,m;       int i,j;       scanf("%ld",&n);       for(j=0;n>=0;j++)       {         m=n;         for(i=0;m>=10;i++)            {             m=m/10;            }        if(n>=10)         {           n=n-m*(pow(10,i));           printf("%s\n",p[m]);               if(n<pow(10,i-1)&&n>0)              {               printf("%s\n",p[0]);              }          }         if(n<10&&n>=0)           {            printf("%s\n",p[n]);            break;           }       } 	system("pause"); 	return 0; } 请帮帮忙，看看错在那里，新手刚学1周。谢谢

在现实世界中，除时间和空间可能是无限的以外，其它任何事物都是有限的。

你的输入函数你写成了  scanf_s();    正确的输入函数应该是  scanf("%d",&n);

//输入一个非负整数，依次输出它的每位数对应的的英文单词 #include <stdio.h> #include <string.h> #include <locale.h> char s[20]; char t[20]; int i; char c; char *en[10]={"zero","one","two","three","four","five","six","seven","eight","nine"}; int main() {     setlocale(LC_ALL,"chs");     while (1) {         printf("输入一个非负整数:");fflush(stdout);         rewind(stdin);         fgets(s,20,stdin);         if (strlen(s)>10) {             printf("输入太长(>9)!\n");             continue;         }         if (2==sscanf(s,"%d%c",&i,&c)) {             if ('\n'==c && i>=0) {                 sprintf(t,"%d\n",i);                 if (0==strcmp(s,t)) {                     printf("%s",en[t[0]-'0']);                     for (i=1;t[i]!='\n';i++) printf(" %s",en[t[i]-'0']);                     printf("\n");                     break;                 }             }         }         if ('\n'==s[strlen(s)-1]) s[strlen(s)-1]=0;         printf("\"%s\" 不是非负整数!\n",s);     }     return 0; } //输入一个非负整数:abc //"abc" 不是非负整数! //输入一个非负整数:哈 //"哈" 不是非负整数! //输入一个非负整数:10a //"10a" 不是非负整数! //输入一个非负整数:-1 //"-1" 不是非负整数! //输入一个非负整数:001 //"001" 不是非负整数! //输入一个非负整数:1234567890 //输入太长(>9)! //输入一个非负整数:123456789 //one two three four five six seven eight nine //

引用 32 楼 zhao4zhong1 的回复://... echo 01|这个程序.exe

不错。。。。

引用 24 楼 zhao4zhong1 的回复:[quote=引用 23 楼 paschen 的回复:] [quote=引用 6 楼 zhao4zhong1 的回复:]  小心驶得万年船！ //输入一个非负整数，依次输出它的每位数对应的的英文单词 #include <stdio.h> #include <string.h> #include <locale.h> char s[20]; char t[20]; int i; char c; char *en[10]={"zero","one","two","three","four","five","six","seven","eight","nine"}; int main() {     setlocale(LC_ALL,"chs");     while (1) {         printf("输入一个非负整数:");fflush(stdout);         rewind(stdin);         fgets(s,80,stdin);         if (strlen(s)>10) {             printf("输入太长(>9)!\n");             continue;         }         if (2==sscanf(s,"%d%c",&i,&c)) {             if ('\n'==c && i>=0) {                 sprintf(t,"%d\n",i);                 if (0==strcmp(s,t)) {                     printf("%s",en[t[0]-'0']);                     for (i=1;t[i]!='\n';i++) printf(" %s",en[t[i]-'0']);                     printf("\n");                     break;                 }             }         }         if ('\n'==s[strlen(s)-1]) s[strlen(s)-1]=0;         printf("\"%s\" 不是非负正整数!\n",s);     }     return 0; } //输入一个非负整数:abc //"abc" 不是非负正整数! //输入一个非负整数:哈 //"哈" 不是非负正整数! //输入一个非负整数:10a //"10a" 不是非负正整数! //输入一个非负整数:-1 //"-1" 不是非负正整数! //输入一个非负整数:001 //"001" 不是非负正整数! //输入一个非负整数:1234567890 //输入太长(>9)! //输入一个非负整数:123456789 //one two three four five six seven eight nine //   非常严谨，不过如果输入的字符太长不是会溢出s吗[/quote] 不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！ [/quote]  赵老师又忽悠我了

经典！

rewind(stdin);//清除输入缓冲区中的剩余内容  说linux下不行？ 说“跨平台一定比不跨平台好”就和说“双性恋一定比异性恋好”一样！

引用 25 楼 mewiteor 的回复:[quote=引用 6 楼 zhao4zhong1 的回复:]  小心驶得万年船！ //... char s[20]; //...     setlocale(LC_ALL,"chs"); //...         fgets(s,80,stdin); //...  1：前面s[20],后面就fgets(s,80,stdin); 2：chs好像只在windows下有效吧，linux下好像没什么用吧。 3：最后没有清输入流，如果输入超过80字符，超过的部分会用于下一次输入。[/quote] 谢谢斧正！应该统一用20

引用 6 楼 zhao4zhong1 的回复: 小心驶得万年船！ //... char s[20]; //...     setlocale(LC_ALL,"chs"); //...         fgets(s,80,stdin); //...  1：前面s[20],后面就fgets(s,80,stdin); 2：chs好像只在windows下有效吧，linux下好像没什么用吧。 3：最后没有清输入流，如果输入超过80字符，超过的部分会用于下一次输入。


Question: c语言中文件操作

while(ch = getc(fp1) != EOF)   ===>  while((ch = getc(fp1)) != EOF)

现补充点，这一句 if((fp1 = fopen("mycopy.c","r")) == NULL) 原文 是    if( fp1 = fopen(argv[1],"r") == NULL); 是发现问题后改的   运行程序后打开文件成这样


Question: if (fp!=NULL) { fclose(fp); fp = NULL; }为什么fclose不直接置为null，需要外部置为null？

引用 3 楼 taric_ma 的回复:补充一个疑问，我这边 写代码的时候，首先是fopen，例如，if((fp1=fopen("file1","r")) == NULL)，这样也就对fp1做了非NULL检查，那么在关闭文件的时候，还用显示的判断fp1 != NULL吗？ 判断的目的是避免代码多了之后不小心在多处fclose多次引发运行时错误。

当然你不把他置为空也是可以滴，只是置空是一种好的习惯

引用 1 楼 user-4 的回复:fclose没法设置, 传入的是FILE*, 不是 FILE ** 一语道破天机！

fclose没法设置, 传入的是FILE*, 不是 FILE **


Question: 关于十六进制转化成十进制的问题

引用 7 楼 dsq2753919456 的回复:明白了，居然会犯这样的错误，而且十六进制数字符至多为F，我也没注意  学习的时候可以自己写了练习下，实际用一般就用标准库中的就行，这些基本函数标准库中都已经实现好了

明白了，居然会犯这样的错误，而且十六进制数字符至多为F，我也没注意

另外，htoi的返回值应该是int不是char吧   # include <stdio.h> # define N 100 int htoi(char s[]); int main() { 	char a[N]; 	printf("请输入十六进制数的字符串"); 	gets(a); 	htoi(a); 	printf("十进制数为：%d", htoi(a)); 	return 0; } int htoi(char s[]) { 	int i; 	int n; 	int sum; 	sum = 0; 	for (i = 0; s[i] != '\0'; i++) 	{ 		if (s[i] >= '0' && s[i] <= '9') 			n = s[i] - '0'; 		else if (s[i] >= 'a' && s[i] <= 'z') 			n = s[i] - 87; 		else if (s[i] >= 'A' && s[i] <= 'Z') 			n = s[i] - 55; 		sum = 16 * sum + n; 	} 	return sum; }

if (s[i] >= '0' || s[i] <= '9')  应该是用&&而不是 || 吧，其他几个if中的也对应改了

还是不能解决我的问题啊，运行出来的值不对

仅供参考：#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汉

你的函数声明和定义时返回的是char值，然而实际上你在函数里返回的是 int值

int htoi(char s[]){...}


Question: 【混分贴】山寨vb中的split函数

不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！ #include <stdio.h> #include <string.h> char string[80]; char seps1[3]; char seps2[3]; char *token; char *zzstrtok (     char *string,     const char *control1,//连续出现时视为中间夹空token     const char *control2 //连续出现时视为中间无空token     ) {     unsigned char *str;     const unsigned char *ctrl1 = control1;     const unsigned char *ctrl2 = control2;     unsigned char map1[32],map2[32];     static char *nextoken;     static char flag=0;     unsigned char c;     int L;      memset(map1,0,32);     memset(map2,0,32);     do {         map1[*ctrl1 >> 3] |= (1 << (*ctrl1 & 7));     } while (*ctrl1++);     do {         map2[*ctrl2 >> 3] |= (1 << (*ctrl2 & 7));     } while (*ctrl2++);      if (string) {         if (control2[0]) {             L=strlen(string);             while (1) {                 c=string[L-1];                 if (map2[c >> 3] & (1 << (c & 7))) {                     L--;                     string[L]=0;                 } else break;             }         }         if (control1[0]) {             L=strlen(string);             c=string[L-1];             if (map1[c >> 3] & (1 << (c & 7))) {                 string[L]=control1[0];                 string[L+1]=0;             }         }         str=string;     }     else        str=nextoken;      string=str;     while (1) {         if (0==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 string++;                 str++;             } else {                 flag=1;                 str++;             }         } else if (1==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=0;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=2;                 break;             } else str++;         } else {//2==flag             if (!*str) return NULL;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=str;                 flag=0;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=str;             } else {                 string=str;                 str++;                 flag=1;             }         }     }     nextoken=str;      if (string==str) return NULL;     else             return string; } int main() {    strcpy(string,"azbzczdzff");    strcpy(seps1,"b");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"azbzczdzff");    strcpy(seps1,"z");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     return 0; } // //[azbzczdzff] //Tokens: // <az> <zczdzff> //[azbzczdzff] //Tokens: // <a> <b> <c> <d> <ff>

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

引用 1 楼 zhao4zhong1 的回复:仅供参考：#include <stdio.h> #include <string.h> char string[80]; char seps1[3]; char seps2[3]; char *token; char *zzstrtok (     char *string,     const char *control1,//连续出现时视为中间夹空token     const char *control2 //连续出现时视为中间无空token     ) {     unsigned char *str;     const unsigned char *ctrl1 = (const unsigned char *)control1;     const unsigned char *ctrl2 = (const unsigned char *)control2;     unsigned char map1[32],map2[32];     static char *nextoken;     static char flag=0;     unsigned char c;     int L;      memset(map1,0,32);     memset(map2,0,32);     do {         map1[*ctrl1 >> 3] |= (1 << (*ctrl1 & 7));     } while (*ctrl1++);     do {         map2[*ctrl2 >> 3] |= (1 << (*ctrl2 & 7));     } while (*ctrl2++);      if (string) {         if (control2[0]) {             L=strlen(string);             while (1) {                 c=string[L-1];                 if (map2[c >> 3] & (1 << (c & 7))) {                     L--;                     string[L]=0;                 } else break;             }         }         if (control1[0]) {             L=strlen(string);             c=string[L-1];             if (map1[c >> 3] & (1 << (c & 7))) {                 string[L]=control1[0];                 string[L+1]=0;             }         }         str=(unsigned char *)string;     }     else str=(unsigned char *)nextoken;      string=(char *)str;     while (1) {         if (0==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 string++;                 str++;             } else {                 flag=1;                 str++;             }         } else if (1==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=0;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=2;                 break;             } else str++;         } else {//2==flag             if (!*str) return NULL;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;                 flag=0;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;             } else {                 string=(char *)str;                 str++;                 flag=1;             }         }     }     nextoken=(char *)str;      if (string==(char *)str) return NULL;     else             return string; } void main() {    strcpy(string,"A \tstring\t\tof ,,tokens\n\nand some  more tokens, ");    strcpy(seps1,",\n");strcpy(seps2," \t");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"1234| LIYI|China | 010 |201110260000|OK");    strcpy(seps1,"|");strcpy(seps2," ");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"1234|LIYI||010|201110260000|OK");    strcpy(seps1,"");strcpy(seps2,"|");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"1234|LIYI||010|201110260000|OK");    strcpy(seps1,"|");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"a");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"a,b");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"a,,b");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",a");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"a,");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",a,,b");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",,a,,b,,");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",,");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",,,");    strcpy(seps1,",");strcpy(seps2," ");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    } } // //[A      string          of ,,tokens // //and some  more tokens,] //Tokens: // <A>, <string>, <of>, <>, <tokens>, <>, <and>, <some>, <more>, <tokens>, <>, //[1234| LIYI|China | 010 |201110260000|OK] //Tokens: // <1234>, <LIYI>, <China>, <010>, <201110260000>, <OK>, //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234>, <LIYI>, <010>, <201110260000>, <OK>, //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234>, <LIYI>, <>, <010>, <201110260000>, <OK>, //[a] //Tokens: // <a>, //[a,b] //Tokens: // <a>, <b>, //[a,,b] //Tokens: // <a>, <>, <b>, //[,a] //Tokens: // <>, <a>, //[a,] //Tokens: // <a>, <>, //[,a,,b] //Tokens: // <>, <a>, <>, <b>, //[,,a,,b,,] //Tokens: // <>, <>, <a>, <>, <b>, <>, <>, //[,] //Tokens: // <>, <>, //[,,] //Tokens: // <>, <>, <>, //[,,,] //Tokens: // <>, <>, <>, <>,  我测试过了，偶尔会对，偶尔会错，这么不稳定就不要拿出来献丑了。 1、 	strcpy(string,"azbzczdzff"); 	token=zzstrtok(string,"b",""); 2、 	strcpy(string,"azbzczdzff"); 	token=zzstrtok(string,"z",""); 总之把zzstrtok第二个参数改来改去，结果飘忽不定，有时对有时错。


Question: 邮件是应用层，为什么，还可以http的形式提供服务给用户呢？

“邮箱全程加密” 我理解就是即使是邮箱系统管理员，也无法获知使用该邮箱的用户发送和接收邮件的具体内容。

那应该就是传输过程加密，使用ssl连接。只是保证传输的过程，客户端到邮件服务器是安全的。

引用 2 楼 akirya 的回复:1  发送邮件流程 客户端将邮件内容编码  smtp 邮件发送服务器   浏览器 使用 http将邮件的内容 传送到www服务器，www后台将邮件编码 -> 邮件发送服务器  其中 www后台将邮件编码 -> 邮件发送服务器 这个过程，可以使用文件共享 数据库 等等。可以说一个公司一个做法。  2 指的安全电子邮件，是指对邮件内容加密和数字签名。只有接受者才能解密，并且保证邮件不是伪造的。  对于你说的第一点，是不是这么理解：  web形式的邮箱，其不是走stmp, pop之类的协议，  而客户端的，比如桌面程序，手机app， 是用stmp的协议。   第2点，大神，你没有看清楚我的问题。  我其实知道 有的邮件是可以通过，数字签名，证书一类的手段，防止篡改，不可抵赖性。    有的邮件厂商，号称，邮件都加密， 似乎我们没有选择证书来发送邮件啊。  我们没有选择证书，没有签名，  软件厂商，声称邮件安全，保密。  所以让我很奇怪。

这种问题应该在http://bbs.csdn.net/forums/IP_Protocolconfiguration问。


Question: 写了一个返回结构体指针的函数，编译时总是提醒没有初始化q，但是初始化了。

恩恩。太感谢大家了，问题解决了。定义q的时候就让q=NULL.

你这是一个函数，当呼叫这个函数是 n=0，那么返回什么呢？  你运行时的 n 只是一个特里，编译器要保证所有的分支。  简单说，if(n) 语句，你可以在 else 里面有语法错误吗？  if(n) { p = 1; } else { p = 0; //这里也要赋值，赋值编译器会认为没有初始化。 }  其实，你只需要在定义的时候，初始化就可以了。这是最好的做法。

恩恩，谢谢Saleayas。加了#define n 26后就可以执行了。但是Cfree为什么不加也可以呢？

感觉没啥错 或许可以在编译器里配置 忽略这个错误吧

编译器保证所有分支是什么意思我不太明白，刚才用CFree试了一下程序可以了，但是VS2013就是不行

你把 n 强制修改成 26 就没有错误。 因为此时编译器知道没有不执行赋值的块。

编译器需要保证所有的分支。 这是编译不是运行。

我调用函数的时候，n为26

循环肯定执行了

当你的循环不执行的时候， q  就没有初始化。

你的q并没有初始化，刚申请完空间，就开始使用q->data

编译提示贴出来看看


Question: C 语言是否可以实现在固定的虚拟地址分配内存

引用 8 楼 Z_R_Z_798205 的回复:引用 7楼赵4老师 的回复:听说指针操作符可以重载的。请提供实例，谢谢 不过操作符重载是C++的内容。 https://www.baidu.com/s?wd=CPP%20%E6%8C%87%E9%92%88%E8%BF%90%E7%AE%97%E7%AC%A6%E9%87%8D%E8%BD%BD&rsv_spt=1&rsv_iqid=0xe9b3121000006af4&issp=1&f=8&rsv_bp=1&rsv_idx=2&ie=utf-8&tn=baiduhome_pg&rsv_enter=0&oq=cpp%20%E6%8C%87%E9%92%88%E8%BF%90%E7%AE%97%E7%AC%A6%E9%87%8D%E8%BD%BD&rsv_t=3177BPpKGrWD59QCy79HFeNk%2FZmaF58%2Bj5lkLxnb9BQrl3ho63z5aXH%2FKEbl7uEkK1q6&rsv_pq=bc51d27500007875&inputT=44844&rsv_sug4=44844  运算符重载是语法糖。 语法糖越甜，编译调试查错越苦！ 把有限的生命浪费在品尝/品鉴无穷多种的语法糖中，我认为不值当。

引用 7楼赵4老师 的回复:听说指针操作符可以重载的。请提供实例，谢谢

听说指针操作符可以重载的。

引用 13 楼 a174787252 的回复:逻辑地址 和 物理地址 你要的是哪个?? 我要匿名映射的虚拟地址(这里虚拟地址就是你所说的逻辑地址) 不要文件映射的虚拟地址.

逻辑地址 和 物理地址 你要的是哪个??

引用 11楼sand6174 的回复:可以是可以，但我不知道有什么api。自己写系统就可以，内存分页就有。我想看看标准 C 库能否支持我想要的功能，不能的话，我就只能自己写代码从内核去支持这个功能了

可以是可以，但我不知道有什么api。自己写系统就可以，内存分页就有。

引用 9楼赵4老师 的回复:引用 8 楼 Z_R_Z_798205 的回复:[quote=引用 7楼赵4老师 的回复:]听说指针操作符可以重载的。请提供实例，谢谢 不过操作符重载是C++的内容。 https://www.baidu.com/s?wd=CPP%20%E6%8C%87%E9%92%88%E8%BF%90%E7%AE%97%E7%AC%A6%E9%87%8D%E8%BD%BD&rsv_spt=1&rsv_iqid=0xe9b3121000006af4&issp=1&f=8&rsv_bp=1&rsv_idx=2&ie=utf-8&tn=baiduhome_pg&rsv_enter=0&oq=cpp%20%E6%8C%87%E9%92%88%E8%BF%90%E7%AE%97%E7%AC%A6%E9%87%8D%E8%BD%BD&rsv_t=3177BPpKGrWD59QCy79HFeNk%2FZmaF58%2Bj5lkLxnb9BQrl3ho63z5aXH%2FKEbl7uEkK1q6&rsv_pq=bc51d27500007875&inputT=44844&rsv_sug4=44844  运算符重载是语法糖。 语法糖越甜，编译调试查错越苦！ 把有限的生命浪费在品尝/品鉴无穷多种的语法糖中，我认为不值当。 [/quote]谢谢你的回复，我只需要针对运行在 Linux 下的 C 解决办法，谢谢

引用 3 楼 zhao4zhong1 的回复:void * mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset);  int mlock(const void *addr, size_t len); 我使用了该函数后,该函数只能是文件映射,不能实现匿名映射的方法.这样的结果就是当我直接使用这部分内存时,不能通过指针直接使用,而只能使用read 或 write 区进行操作. 我想要的就是使用匿名内存操作的方式.通过指针直接操作内存. 谢谢赵4老师

引用 3 楼 zhao4zhong1 的回复:void * mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset);  int mlock(const void *addr, size_t len); 已经试了,可以符合要求,谢谢

虽然是虚拟模式，显存地址也还是可以直接拿来用的

引用 1楼赵4老师 的回复:VirtualAllocEx The VirtualAllocEx function reserves, commits, or both, a region of memory within the virtual address space of a specified process. The function initializes the memory it allocates to zero, unless the MEM_RESET flag is set.   The difference between the VirtualAllocEx function and the VirtualAlloc function is that VirtualAlloc allocates memory within the address space of the calling process, while VirtualAllocEx lets you specify a process.   LPVOID VirtualAllocEx(   HANDLE hProcess,  // process within which to allocate memory   LPVOID lpAddress, // desired starting address of allocation   DWORD dwSize,     // size, in bytes, of region to allocate   DWORD flAllocationType,                     // type of allocation   DWORD flProtect   // type of access protection );   Parameters hProcess  Handle to a process. The function allocates memory within the virtual address space of this process.  You must have PROCESS_VM_OPERATION access to the process. If you do not, the function fails.   lpAddress  Pointer that specifies a desired starting address for the region of pages that you want to allocate.  If you are reserving memory, the function rounds this address down to the nearest 64-kilobyte boundary.   If you are committing memory that is already reserved, the function rounds this address down to the nearest page boundary. To determine the size of a page on the host computer, use theGetSystemInfo function.   If lpAddress is NULL, the function determines where to allocate the region.   dwSize谢谢你的答复，但我的代码跑在 Linux 下。谢谢


Question: 编写单链表出现的Debug   Assertion   Failed，网上说什么用了野指针，可是我不明白，望高手解答！

引用 8 楼 赵4老师的回复:崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 嗯，太谢谢你了，我最后调试成功了

引用 6 楼 lm_whales的回复:// combine two Links 这句后面这段程序里，多打几个打断点 嗯，调试后，free那里出问题了。

搜“单链表合并”

引用 7 楼 lm_whales的回复: if(pa->data <= pb->data){ pc->next = pa;//这段可能会有问题，因为你的所有节点都没有做脱链处理。 pc = pa; pa = pa->next; } else{ pc->next = pb; pc = pb; pb = pb->next; }  合并链表 可以分为，破坏式合并，和非破坏式合并。 破坏式合并，原链表被拆开， 节点从链表中取出。  1）一种方法是每个节点从链上取出，保持链的完整（取下节点后，还是一个链表） 然后，插入到新链表中 2）第二种方法是，一条链作基础，从另一条链上取出节点，插入进去。 这些是利用原来节点，破坏性合并 3）还有一种，非破坏式合并，分配新节点，每次从链表中取数据。合并到链表中。 得到一个新链表，原链表以及节点保持不变。 我采用的是第二种方法，请问我要怎样进行脱链处理呢？由于数据结构是用伪代码写的，用C语言把思路实现会出现一系列的问题....请教一下，怎么改啊？

// combine two Links 这句后面这段程序里，多打几个打断点

测试数据是什么

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

引用 11 楼 赵4老师的回复:将两个有序链表合并成一个有序链表 http://blog.csdn.net/lalor/article/details/7429989 你说的调用我真的不是很明白，但是你说的我今完要试一下的，试玩我再回复。

引用 3 楼 user-5的回复:你的VS没装好吧 那就单步调试 写其他程序可以啊，你能运行的出来吗？

你的VS没装好吧 那就单步调试

引用 1 楼 user-5的回复:按“重试”打开默认调试器进行调试 不行啊，一重试直接没了。

按“重试”打开默认调试器进行调试


Question: 声卡放音

MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO http://pan.baidu.com/s/1bnGo0Vl 先下载安装MSDN98 再参考： MSDN98\SAMPLES\VC98\SDK\GRAPHICS\AUDIO\REVERSE\REVERSE.C MSDN98\SAMPLES\VC98\SDK\GRAPHICS\VIDEO\AVIEDIT\AUDIO.C MSDN98\SAMPLES\VC98\SDK\GRAPHICS\VIDEO\AVIVIEW\AUDPLAY.C MSDN98\SAMPLES\MSDN\TECHART\2899\SRC\WAVEODEV.CPP MSDN98\SAMPLES\MSDN\TECHART\3014\SRC\WAVEODEV.CPP MSDN98\SAMPLES\MSDN\TECHART\3015\SRC\WAVEODEV.CPP MSDN98\SAMPLES\MSDN\TECHART\3215\SRC\WAVEODEV.CPP MSDN98\SAMPLES\MSDN\TECHART\3228\SRC\WAVEODEV.CPP MSDN98\SAMPLES\MSDN\TECHART\4245\SRC\WAVEODEV.CPP MSDN98\SAMPLES\MSDN\TECHART\4246\SRC\WAVEODEV.CPP MSDN98\SAMPLES\MSDN\TECHART\4247\SRC\WAVEODEV.CPP

使用BASS库？ 或者参考MSDN里面的： Example of Writing Waveform Data The following example illustrates the steps required to allocate and set up a WAVEHDR structure and write a block of data to a waveform output device.   // Global variables.   HANDLE hData  = NULL;  // handle of waveform data memory  HPSTR  lpData = NULL;  // pointer to waveform data memory    void WriteWaveData(void)  {      HWAVEOUT    hWaveOut;      HGLOBAL     hWaveHdr;      LPWAVEHDR   lpWaveHdr;      HMMIO       hmmio;      UINT        wResult;      HANDLE      hFormat;      WAVEFORMAT  *pFormat;      DWORD       dwDataSize;       // Open a waveform device for output using window callback.       if (waveOutOpen((LPHWAVEOUT)&hWaveOut, WAVE_MAPPER,                      (LPWAVEFORMAT)pFormat,                      (LONG)hwndApp, 0L, CALLBACK_WINDOW))      {          MessageBox(hwndApp,                     "Failed to open waveform output device.",                     NULL, MB_OK | MB_ICONEXCLAMATION);          LocalUnlock(hFormat);          LocalFree(hFormat);          mmioClose(hmmio, 0);          return;      }        // Allocate and lock memory for the waveform data.        hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, dwDataSize );      if (!hData)      {          MessageBox(hwndApp, "Out of memory.",                     NULL, MB_OK | MB_ICONEXCLAMATION);          mmioClose(hmmio, 0);          return;      }      if ((lpData = GlobalLock(hData)) == NULL)      {          MessageBox(hwndApp, "Failed to lock memory for data chunk.",                     NULL, MB_OK | MB_ICONEXCLAMATION);          GlobalFree(hData);          mmioClose(hmmio, 0);          return;      }        // Read the waveform data subchunk.        if(mmioRead(hmmio, (HPSTR) lpData, dwDataSize) != (LRESULT)dwDataSize)      {          MessageBox(hwndApp, "Failed to read data chunk.",                     NULL, MB_OK | MB_ICONEXCLAMATION);          GlobalUnlock(hData);          GlobalFree(hData);          mmioClose(hmmio, 0);          return;      }        // Allocate and lock memory for the header.       hWaveHdr = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,          (DWORD) sizeof(WAVEHDR));      if (hWaveHdr == NULL)      {          GlobalUnlock(hData);          GlobalFree(hData);          MessageBox(hwndApp, "Not enough memory for header.",              NULL, MB_OK | MB_ICONEXCLAMATION);          return;      }        lpWaveHdr = (LPWAVEHDR) GlobalLock(hWaveHdr);      if (lpWaveHdr == NULL)      {          GlobalUnlock(hData);          GlobalFree(hData);          MessageBox(hwndApp,              "Failed to lock memory for header.",              NULL, MB_OK | MB_ICONEXCLAMATION);          return;      }        // After allocation, set up and prepare header.        lpWaveHdr->lpData = lpData;      lpWaveHdr->dwBufferLength = dwDataSize;      lpWaveHdr->dwFlags = 0L;      lpWaveHdr->dwLoops = 0L;      waveOutPrepareHeader(hWaveOut, lpWaveHdr, sizeof(WAVEHDR));        // Now the data block can be sent to the output device. The      // waveOutWrite function returns immediately and waveform      // data is sent to the output device in the background.        wResult = waveOutWrite(hWaveOut, lpWaveHdr, sizeof(WAVEHDR));      if (wResult != 0)      {          waveOutUnprepareHeader(hWaveOut, lpWaveHdr,                                 sizeof(WAVEHDR));          GlobalUnlock( hData);          GlobalFree(hData);          MessageBox(hwndApp, "Failed to write block to device",                     NULL, MB_OK | MB_ICONEXCLAMATION);          return;      }  }


Question: 用OpenGL写了一个关于碰撞的小程序期间遇到的麻烦

参考开源打砖块游戏项目的源代码片断。

设绿块前进方向向量为v, 反射向量为r , 法向n, r= v -  2n(v dot n)


Question: 求解！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

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

下面是我写的一个程序，可供参考 #include<stdio.h> #include<stdlib.h>  #define max 100  void mystrcmp(char str1[],char str2[],char *s);  int main() { 	char str1[max],str2[max]; 	char c; 	char *s,*s1; 	s1=(char *)malloc(100*sizeof(char)); 	s=s1; 	int i=0,j=0; 	while((c=getchar())!='\n'&&i<max) 		str1[i++]=c; 	str1[i]='\0'; 	while((c=getchar())!='\n'&&i<max) 		str2[j++]=c; 	str2[j]='\0'; 	mystrcmp(str1,str2,s1); 	printf("%s\n",s); 	return 0; }  void mystrcmp(char str1[],char str2[],char *s) { 	int i=0,j; 	 	while(str2[i]!='\0') 	{ 		j=0; 		while(str1[j]!='\0'&&str1[j]!=str2[i]) 			j++; 		if(str1[j]=='\0') 			*s++=str2[i]; 		i++; 	} 	*s='\0'; }


Question: 从控制台输入两个字符串，判断第一个字符串中是否包含第二个字符串，并把结果输出来          求解！！！

仅供参考： 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);  }

引用 2 楼 user-2 的回复: #include <stdio.h> #include "Header.h" #include <conio.h> int main() { 	char arr[100]; char arr2[100]; int i,j,n; 	printf("输入字符:\n"); 	gets_s(arr); 	printf_s("输入要去除的字符：\n"); 	gets_s(arr2); 	for (i = 0; arr2[i]; i++) 	{ 		for ( j = 0, n=0; arr[j]; j++) 		{ 			if (arr[j]!=arr2[i]) 			{ 				arr[n++] = arr[j]; 			} 			else 			{ 				 			} 		} 		arr[n] = '\0'; 	} 	printf_s("%s", arr);  	char c; 	c =_getch(); 	 }  额(⊙﹏⊙)b  看错 以为你要删除相同的 你要是打印出来在else函数里面打印就行了


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

RegQueryValueEx The RegQueryValueEx function retrieves the type and data for a specified value name associated with an open registry key.   LONG RegQueryValueEx(   HKEY hKey,           // handle to key to query   LPTSTR lpValueName,  // address of name of value to query   LPDWORD lpReserved,  // reserved   LPDWORD lpType,      // address of buffer for value type   LPBYTE lpData,       // address of data buffer   LPDWORD lpcbData     // address of data buffer size ); …… lpcbData  Pointer to a variable that specifies the size, in bytes, of the buffer pointed to by the lpData parameter. When the function returns, this variable contains the size of the data copied to lpData.  If the data has the REG_SZ, REG_MULTI_SZ or REG_EXPAND_SZ type, then lpcbData will also include the size of the terminating null character.   The lpcbData parameter can be NULL only if lpData is NULL.   If the buffer specified by lpData parameter is not large enough to hold the data, the function returns the value ERROR_MORE_DATA, and stores the required buffer size, in bytes, into the variable pointed to by lpcbData.   If lpData is NULL, and lpcbData is non-NULL, the function returns ERROR_SUCCESS, and stores the size of the data, in bytes, in the variable pointed to by lpcbData. This lets an application determine the best way to allocate a buffer for the value's data.

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

我先在遇到了和楼主一样的问题，也是读取到的REG_SZ数据是乱码。。。请问你解决这个问题了么？求助啊~

请判断每个函数的返回值。

引用 2 楼 user-3 的回复:要读多长的数据，就new多少个char出来，不要用string 能不能麻烦大侠帮忙调试一下程序

引用 2 楼 user-3 的回复:要读多长的数据，就new多少个char出来，不要用string 对RegQueryValueEX不太会用，我用这个函数size设为定值13读取mac地址可以成功，但是现在我要读的数据不是定值，也没办法每次去new

要读多长的数据，就new多少个char出来，不要用string

程序需要管理员权限，UAC执行级别里面需要设为require administrator，RegQueryValueEX这个函数返回错误代码234，经过查阅MSDN得出是data长度不够的问题，但是我怎么改都无法正常运行，求大侠帮忙


Question: 数据溢出

用long long存储

恩恩 我明白了  对于int来说20的阶乘太大了

数值溢出了会取短，int型32位，超过32位的会被抛弃，只取后32位， 数据的最高位是符号位，如果最高位是1，就是负数。