Question: 诸神请看：第二次调用malloc给结构指针分配空间时出错  0xC0000374: 堆已损坏。

仅供参考//将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>

引用 6 楼 zhao4zhong1 的回复:函数shuzhuangfuzhi改为： struct node *shuzhuangfuzhi(struct node *p, char *word,int weizhi) {     int a;     if (p == NULL) {          p = talloc();         p->biaozhi = 0;         p->p = strup(word);         p->zuo = NULL;         p->you = NULL;     } else if ((a = bijiao(p->p, word)) > 0) {         if (a > weizhi)p->biaozhi = 0;         else p->biaozhi = 1;         p->zuo=shuzhuangfuzhi(p->zuo, word, weizhi);     } else if (a  < 0) {         if (a > weizhi)p->biaozhi = 0;         else p->biaozhi = 1;         p->you=shuzhuangfuzhi(p->you, word, weizhi);     }     return p; }  试试看。不保证对。 我改过了，还是没有用~~~~ 问题我还没找到，我用其他方式代替了，我写了一个包含这个错误的很简单的程序，如果您有时间的话可以试着找找原因，找到了请告诉我一声，非常感谢。 #include<stdio.h> #include <ctype.h> #define MAXLEN 1000 #include <string.h> #include <stdlib.h>  struct node {     int biaozhi;     char *p;     struct node *zuo;     struct node *you; }; int shuzhuangfuzhi(struct node *, char *word); int main() {     struct node *p = NULL;     int  c = 0,i=0;     char word[MAXLEN];     char *fuzhi[MAXLEN] = {"hello","man",NULL};     while (fuzhi[i]!=NULL)     {     p = shuzhuangfuzhi(p, fuzhi[i++]);     }      system("pause"); }   struct node *talloc(void); char *strup(char *);  int shuzhuangfuzhi(struct node *p, char *word) {     int a;     if (p == NULL)     {          p = talloc();         p->biaozhi = 0;         p->p = strup(word);         p->zuo = NULL;         p->you = NULL;     }     else          shuzhuangfuzhi(p->zuo, word);     return p; }  struct node *talloc(void) {     return (struct node *) malloc(sizeof(struct node)); }   char *strup(char *s) {     char *p;     p = (char *)malloc(strlen(s) + 1);     if (p != NULL)         strcpy_s(p, 50, s);     return p; }

整个程序如下  #include<stdio.h> #include <ctype.h> #define MAXLEN 1000 #include <string.h> #include <stdlib.h>  struct node { 	int biaozhi;     char *p; 	struct node *zuo; 	struct node *you; }; int shuzhuangfuzhi(struct node *, char *word,int weizhi);//返回一个正负数，正负号表示大于或小于，位数表示具体在哪一位出现的不相等 int getword(char *word, int lim); int bijiao(char *p, char *q); int bijiao1(char *p[], char *q); void printree(struct node *); int main(int argc, char *argv[]) { 	struct node *p=NULL; 	char *duizhao[] = { "void", "int", "char", "float", "double", "unsigned", "signed",NULL }; 	int weishu,a=0,b=0,c=0; 	if (argc == 1)weishu = 6; 	else if (argc > 2)printf("wrong use \n"); 	else { 		++argv; 		while ((a = *(*argv)++) != ' ') 			if (a<'0'&&a>'9') 			{ printf("wrong usage"); 		      return -1; 			} 			else b = b * 10 + a - '0'; 			weishu = b; 		} 	char word[MAXLEN]; 	while (getword(word, MAXLEN) != EOF) 	{ 			if (bijiao1(duizhao, word) == 0) 			{ 			while ((c = getword(word, MAXLEN) )!= ';'&& bijiao1(duizhao, word) != 0) 				if (isalpha(c)) 					p=shuzhuangfuzhi(p, word, weishu); 			} 	}  	printree(p); 	system("pause"); } void printree(struct node *p) { 	if (p != NULL) 	printree(p->zuo); 	if (p->biaozhi==1) 	printf("\n%s  ", p->p); 	else printf("%s  ", p->p); 	if (p->you!=NULL) 	printree(p->you);   } struct node *talloc(void); char *strup(char *);  int shuzhuangfuzhi(struct node *p, char *word,int weizhi) { 	int a; 	if (p == NULL) 	{ 		 		p = talloc(); 		p->biaozhi = 0; 		p->p = strup(word); 		p->zuo = NULL; 		p->you = NULL; 	} 	else if ((a = bijiao(p->p, word)) > 0) 	{ 		if (a > weizhi)p->biaozhi = 0; 		else p->biaozhi = 1; 		shuzhuangfuzhi(p->zuo, word, weizhi); 	} 	else if (a  < 0) 	{ 		if (a > weizhi)p->biaozhi = 0; 		else p->biaozhi = 1; 		shuzhuangfuzhi(p->you, word, weizhi); 	} 	return p; }  int bijiao(char *p, char *q) { 	int a=0; 	while (*(p + a) == *(q + a) && *(p + a)!='\0') 		a++; 	a += 1; 	if (*(p + a) == *(q + a)) 		return 0; 	if (*(p + a) > *(q + a)) 		return a; 	if (*(p + a) < *(q + a)) 		return -a; } int bijiao1(char *p[], char *q) { 	while (*p != NULL) 	{ 		if (strcmp(*p++, q) == 0) 			return 0; 	} 	return -1; } int getword(char *word, int lim) { 	int c, getch(void); 	void ungetch(int); 	char *w = word; 	while (isspace(c = getch())); 	if (c != EOF) 		*w++ = c; 	if (!isalpha(c)) 	{ 		*w = '\0'; 		return c;  	} 	for (; --lim > 0;w++) 		if (!isalnum(*w = getch())) 		{ 		ungetch(*w); 		break; 		} 	*w = '\0'; 	return word[0]; }  #define BUFSIZE 10000  char buf[BUFSIZE]; int bufp = 0; int getch(void) { 	return (bufp > 0) ? buf[--bufp] : getchar(); }   void ungetch(int c) { 	if (bufp >= BUFSIZE) 		printf("ungetch:too many"); 	else 		buf[bufp++] = c; }      struct node *talloc(void) { 	return (struct node *) malloc(sizeof(struct node)); }   char *strup(char *s) { 	char *p; 	p = (char *)malloc(strlen(s) + 1); 	if (p!= NULL) 		strcpy_s(p,50,s); 	return p; }

引用 4 楼 zhao4zhong1 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] 函数shuzhuangfuzhi应该返回a吧。 或者返回p，但函数应返回struct node *类型吧。[/quote] 谢谢，目前我通过struct node *p[]代替每次对malloc（）的调用来分配内存地址，然后可以成功的运行了。 指出的问题确实是一个错误，我把int shuzhuangfuzhi 改为struct node *shuzhuangfuzhi，shuzhuangfuzhi(p->zuo, word, weizhi);改为p->zuo=shuzhuangfuzhi(p->zuo, word, weizhi);把shuzhuangfuzhi(p->you, word, weizhi);改为p->you=shuzhuangfuzhi(p->you, word, weizhi);还是出现了上述问题。以下是我成功运行的程序： //我要做的编写一个程序，读入一个C语言程序，并按字母顺序分组打印变量名，要求每一组内各变量名的前6个字符相同 //其余字符不同，将6作为一个可在命令行中设定的参数    #include<stdio.h> #include <ctype.h> #define MAXLEN 1000 #include <string.h> #include <stdlib.h>  struct node { 	char *p; 	struct node *zuo; 	struct node *you; };//采用树状结构存取变量     int shuzhuangfuzhi(struct node *, char *word, int weizhi, struct node *pn[]);//该函数用来排序，将新得到的单词和已有结构中的单词相比较， //单词小于已有单词，则传入结构中的*zuo指针中，之后继续比较，若大于则传入*you指针中，如相等则不进行任何操作，通过这种方式进行树状排序 int getword(char *word, int lim);//读入一个单词 int bijiao(char *p, char *q);//返回一个正负数，正负号表示大于或小于，位数表示具体在哪一位出现的不相等 int bijiao1(char *p[], char *q);//用来将所得的单词和已设变量名相比较，如单词和某一个变量相等，则返回0，否则返回-1 void printree(struct node *, int weishu);//用来打印排序好的树状结构中的字符串 int main(int argc, char *argv[]) { 	struct node *budeyi[100]; 	int ab = 0; 	for (ab = 0; ab < 20; ab++) 	{ 		budeyi[ab] = (struct node *) malloc(sizeof(struct node)); 	} 	char *pk[1000]; 	for (ab = 0; ab < 100; ab++) 	{ 		pk[ab] = (char *)malloc(sizeof(char *)); 	}   	struct node *p = NULL; 	char *duizhao[] = { "void", "int", "char", "float", "double", "unsigned", "signed", NULL }; 	int weishu, a = 0, b = 0, c = 0; 	if (argc == 1)weishu = 6; 	else if (argc > 2)printf("wrong use \n"); 	else { 		++argv; 		while ((a = *(*argv)++)) 			if (a<'0'&&a>'9') 			{ 			printf("wrong usage"); 			return -1; 			} 			else b = b * 10 + a - '0'; 			weishu = b; 	} 	char word[MAXLEN]; 	while (getword(word, MAXLEN) != EOF) 	{ 		if (bijiao1(duizhao, word) == 0) 		{ 			while ((c = getword(word, MAXLEN)) != ';'&& bijiao1(duizhao, word) != 0) 				if (isalpha(c)) 					p = shuzhuangfuzhi(p, word, weishu, budeyi, pk); 		} 	}  	printree(p, weishu); 	printf("\n"); 	system("pause"); }   char last[] = { "" }; void printree(struct node *p, int weishu) { 	int a; 	if (p != NULL) 	{ 		printree(p->zuo, weishu); 		if ((a = bijiao(last, p->p)) < 0) 			a = -a; 		if (a > weishu) 			printf("%s  ", p->p); 		else 			printf("\n%s   ", p->p); 		strcpy_s(last, 50, p->p); 		if (p->you != NULL) 			printree(p->you, weishu); 	}  } struct node *talloc(void); char *strup(char *);  int shuzhuangfuzhi(struct node *p, char *word, int weizhi, struct node *pn[], char *pl[]) { 	int a; 	if (p == NULL)//将所得变量名放入结构中，若结构指针为null，则说明此节点的字符指针没有赋值，则将变量名放入字符指针p->中 	{  		p = talloc(pn);//若之前结构指针p为null，则调用talloc函数为其分配内存地址，###我就是在第一次调用talloc函数时，给我分配了指针地址，当以第二次调用talloc（即读入的第三个字符）时， 		//没有给我分配指针地址。 		p->p = strup(word, pl); 		p->zuo = NULL; 		p->you = NULL; 	} 	else if ((a = bijiao(p->p, word)) > 0)//若该结构指针不是NULL说明此节点的字符指针已赋值，则将变量名与字符指针中的字符进行比较，若大于，则将 		//变量名与右节点即*you结构指针进行比较 	{ 		p->zuo = shuzhuangfuzhi(p->zuo, word, weizhi, pn, pl); 	} 	else if (a  < 0)//若小于，变量名与左节点即*zuo结构指针进行比较 	{ 		p->you = shuzhuangfuzhi(p->you, word, weizhi, pn, pl); 	} 	return p;//将变量地址返回 }  int bijiao(char *p, char *q) { 	int a = 0; 	while (*(p + a) == *(q + a) && *(p + a) != '\0') 		a++; 	if (*(p + a) == *(q + a)) 		return 0; 	if (*(p + a) > *(q + a)) 		return a + 1; 	if (*(p + a) < *(q + a)) 		return -(a + 1); } int bijiao1(char *p[], char *q) { 	while (*p != NULL) 	{ 		if (strcmp(*p++, q) == 0) 			return 0; 	} 	return -1; } int getword(char *word, int lim) { 	int c, getch(void); 	void ungetch(int); 	char *w = word; 	while (isspace(c = getch())); 	if (c != EOF) 		*w++ = c; 	if (!isalpha(c)) 	{ 		*w = '\0'; 		return c;  	} 	for (; --lim > 0; w++) 		if (!isalnum(*w = getch())) 		{ 		ungetch(*w); 		break; 		} 	*w = '\0'; 	return word[0]; }  #define BUFSIZE 10000  char buf[BUFSIZE]; int bufp = 0; int getch(void) { 	return (bufp > 0) ? buf[--bufp] : getchar(); }   void ungetch(int c) { 	if (bufp >= BUFSIZE) 		printf("ungetch:too many"); 	else 		buf[bufp++] = c; }    int m = 0;  struct node *talloc(struct node *p[]) { 	return p[m++]; }  int q = 0; char *strup(char *s, char *ph[]) { 	char *p; 	p = ph[q++]; 	if (p != NULL) 		strcpy_s(p, 50, s); 	return p; }

引用 3 楼 zhao4zhong1 的回复:函数shuzhuangfuzhi应该返回a吧。 或者返回p，但函数应返回struct node *类型吧。

函数shuzhuangfuzhi应该返回a吧。

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


Question: 问一道很奇怪的数据结构的题目

才画到40。你至少要画到几万几亿再来说增长吧

函数求导


Question: c primer plus 第十一章11.8命令行参数 关于这一小节的疑问

要把文件的路径全部写出来 如果你用的是windows的话。例如，Desktop/asd.exe这表示桌面的asd可执行程序

给一个c的main函数传递参数是可以的    但就不是你写代码的部分了 一个c的程序，只有一个主函数，这个主函数运行起来后，就会形成一个进程   你给这个主函数传递参数，其实就是要从系统的角度给这个进程通信    在windows系统下有两个办法 要么就像楼上给你的连接那样 还有个傻瓜办法就是用鼠标拖    你可以新建一个txt文件  然后把这个文件用鼠标拖动到你的project上   然后松开鼠标  你的程序就开始运行了   这个时候你的这个程序的主函数接受到的参数就是这个txt文件


Question: 自定义函数从主函数定义的数组中取出两个数相加，请问add这个方法怎么写?谢谢！！

int add(int *a,int *b) { 	//两个数相加arr[1]+arr[2]，将结果存在arr[1]中 	*a += *b; } 按题设要求，其实可以不用返回值，结果保存在array[1]中。

#include<stdio.h>  int add(int *a,int *b) {     (*a)=(*a)+(*b);//两个数相加arr[1]+arr[2]，将结果存在arr[1]中     return (*a); } void main() {     int arr[3]={1};     int *p=&arr[1];     int *q=&arr[2];      printf("please input\n");     printf("opr1: ");     scanf("%d",&arr[1]);     printf("opr2: ");     scanf("%d",&arr[2]);     add(p,q);     printf("%d",*p);//输出结果 }

*a+=*b;

直接加呀,有什么问题？


Question: 有关指针的问题

哪里都有你。

C语言上机课，某女同学偷偷吃起牛肉干。   有一粒牛肉干掉到了键盘上，卡在7和8键之间。   女同学就在键盘上抠啊、抠啊、抠啊……   程序里一行代码变成这个样子：   int *pa=&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&a;   后来的结局是  ————程序顺利通过编译，运行结果正确！

左值指示对象，而值不是。 这个问题和地址没有多大关系，表达式(int *) 0x123bb2的结果是一个值，一个指针类型的值，或者说指针值，但并不指示对象，但是表达式* (int *) 0x123bb2的结果是一个左值，指示一个对象。 大学里的教育通常是杯具。很多人歪着嘴又是地址又是变量啥的，解释不了这个问题。 如果需要变量啥的，下面这个表达式需要多少变量？： int x; *&*&*&*&*&*&*&*&*&*&*&*&*&*&x = 0;

赋值可以是这样：*p=&a 也可以是*p=2

计算机组成原理→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

(int*)0x123bb2，好了，0x123bb2这个值被强制转换成了一个指针变量，这个指针变量保存着的值是多少？是0x123bb2 那么这个指针指向的地址就是0x123bb2。指针变量所保存着的地址值，就是该指针指向的地址。 就像(int)0x123bb2一样，0x123bb2这个值被强制转换成了一个int变量，这个Int变量保存着的值是多少？是0x123bb2

引用 1 楼 user-6 的回复:在0x123bb2前加(int*)，就把它变为了储存整型的地址；再在前面加一个*，就可以对这个地址存储的内容进行操作了。在问题里就是对其赋值为2。还有什么不懂的吗？ 也就是说，(int *)强制转化的意思是把这个地址转化为一个存储int类型的内存区域？但是网上大多数说的是这个是把它强制转化为一个指针变量啊，指针变量内部没有所指向，就是这迷糊，如果按您这种解释的话，是可以解释通的，我的理解就是*0x123bb2 = 2,但我知道这个肯定不对，却又不知为何


Question: 如何用for循环实现文件路径动态变化

你需要用到sprintf函数

PIMAGE img[N]; int i; char fn[256]; for(i=0;i<N;i++) {    img[i] = newimage();    sprintf(fn,".\\pukeImage1\\%d.jpg",i+1);    getimage(img[i],fn); }


Question: UVA401字符串的题但是WA了好几次

引用 3 楼 Sean10 的回复:[quote=引用 1 楼 user-1 的回复:] int is_mirror  for(i=0;i<n/2;i++){  奇数长度最中间那个字符不判？ 我查到的一些AC的解题报告这里也是直接略过的。[/quote] reverse略过没问题。mirror能略？

引用 1 楼 user-1 的回复:int is_mirror  for(i=0;i<n/2;i++){  奇数长度最中间那个字符不判？ 我查到的一些AC的解题报告这里也是直接略过的。

引用 1 楼 user-1 的回复:int is_mirror  for(i=0;i<n/2;i++){  奇数长度最中间那个字符不判？ 中间那个也要判吗，不是一定满足的吗


Question: 求所有组合情况 用C语言解决

仅供参考：//qplw.cpp #include <stdio.h> #include <string.h> #include <stdlib.h> int v=0; int w=0; int m;//记录字符串长度 int n;//记录字符串中的字符种类数 char map[256];//记录是哪几种字符 int count[256];//记录每种字符有多少个 int stack[1000];//递归用的栈，并记录当前生成的排列 void Make_Map(char *str) {//统计字符串的相关信息     int s[256];     int i;     memset(s,0,sizeof(s));     memset(count,0,sizeof(count));     m=strlen(str);     if (w<1 || m<w) w=m;     while(*str) {         s[*str]++;         str++;     }     n=0;     for (i=0;i<256;i++)         if (s[i]) {             map[n]=i;             count[n]=s[i];             n++;         } } void Find(int depth) {//递归式回溯法生成全排列     if (depth==w) {         int i;         for (i=0;i<depth;i++) putchar(map[stack[i]]);         putchar('\n');     } else {         int i;         if (v && depth>0) {             for (i=0;i<depth;i++) putchar(map[stack[i]]);             putchar('\n');         }         for (i=0;i<n;i++)             if (count[i]) {                 stack[depth]=i;                 count[i]--;                 Find(depth+1);                 count[i]++;             }     } } void main(int argc,char**argv) {     if (argc<2) {         printf("%s 要产生全排列的字符串 [限定长度|-1]\n",argv[0]);         return;     }     if (argc>=3) w=atoi(argv[2]);     if (-1==w) v=1;     Make_Map(argv[1]);     Find(0); } //C:\test>qplw //qplw 要产生全排列的字符串 [限定长度|-1] // //C:\test>qplw 123 //123 //132 //213 //231 //312 //321 // //C:\test>qplw 123 2 //12 //13 //21 //23 //31 //32 // //C:\test>qplw 122333 3 //122 //123 //132 //133 //212 //213 //221 //223 //231 //232 //233 //312 //313 //321 //322 //323 //331 //332 //333 // //C:\test>qplw 123 -1 //1 //12 //123 //13 //132 //2 //21 //213 //23 //231 //3 //31 //312 //32 //321 //

参考：http://www.jb51.net/article/54443.htm  排列组合问题


Question: 求找错

[color=#FF00FF]accept[/color ] #include <stdio.h> #include <string.h> #include <ctype.h>  int isspecial(char c) {     char str[] = "~!@#$%^";     int i;      for(i = 0; i < 7; i ++)     {         if(c == str[i])             return 1;     }     return 0; }  int main() {     int m,flag;     int a[10], cnt;     char c;      scanf("%d", &m);     getchar();     while(m --)     {         flag = 0;         cnt = 0;         a[0] = a[1] = a[2] = a[3] =a[4] =0;         while((c = getchar()) != '\n')         {             if(isupper(c))                 a[0]++,cnt ++;             else if(islower(c))                 a[1]++,cnt ++;             else if(isdigit(c))                 a[2]++,cnt ++;             else if(isspecial(c))                 a[3]++,cnt ++;             else cnt ++;          }         if(a[0]>0)             flag++;         if(a[1]>0)             flag++;         if(a[2]>0)             flag++;         if(a[3]>0)             flag++;         if((8<=cnt&&cnt<=16)&&flag>=3)             printf("YES\n");         else printf("NO\n");     }     return 0; }

引用 6 楼 neverthinkaboutit 的回复:楼主请看四楼 除了cnt 没有清零之外还有后面的判断楼主写错了 if((cnt >= 8) && (cnt <= 16) && (flag >= 3))楼主脑残了，O(∩_∩)O谢谢

正如楼上所说，，楼主你初始化cnt的时候没给它赋值，里面是个随机的垃圾值，运行肯定出错。

引用 3 楼 u012421456 的回复:输入数据第一行包含一个数M，接下有M行 楼主的代码不是这样啊 ++ 楼主的是输入一个立即判断一个

cnt没清零

输入数据第一行包含一个数M，接下有M行 楼主的代码不是这样啊

百度一下，断点调试 或者，我最近写了一个算法分析器，你可以试试 http://yun.baidu.com/share/link?shareid=3030815990&uk=2988004704

代码贴的有点问题 #include <stdio.h> #include <string.h> #include <ctype.h>  int isspecial(char c) {     char str[] = "~!@#$%^";     int i;      for(i = 0; i < 7; i ++)     {         if(c == str[i])             return 1;     }     return 0; }  int main() {     int m,flag;     int a[10], cnt;     char c;      scanf("%d", &m);     getchar();     while(m --)     {         flag = 0;         a[0] = a[1] = a[2] = a[3] =a[4] =0;         while((c = getchar()) != '\n')         {             if(isupper(c))                 a[0]++,cnt ++;             else if(islower(c))                 a[1]++,cnt ++;             else if(isdigit(c))                 a[2]++,cnt ++;             else if(isspecial(c))                 a[3]++,cnt ++;             else cnt ++;          }         if(a[0]>0)             flag++;         if(a[1]>0)             flag++;         if(a[2]>0)             flag++;         if(a[3]>0)             flag++;         if((8<=cnt&&cnt>=16)&&flag>=3)             printf("YES\n");         else printf("NO\n");     }     return 0; }


Question: Visual C++中释放动态分配的二维数组为什么会出现中断？编译无错。

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

引用 4 楼 user-4 的回复:第3点的意思是，如果你所使用的内存是由动态连接库中申请的，那么释放亦应该由该库释放 在 debug 模式下可能不会有什么问题，但在 release 模式下会报错 之前的相关代码是这样的  t_x = (double**)malloc(sizeof(double*)*num_rowx); ... t_x[i] = projection(begin_x[i], end_x[i], 2 * r);  没有使用动态链接库啊。。

可以试试智能指针，auto_ptr<>, shared_ptr<> 之类的

引用 7 楼 CharlesSimonyi 的回复:t_x = (double**)malloc(sizeof(double*)*num_rowx); 一次malloc对应一次free t_x[i] = projection(begin_x[i], end_x[i], 2 * r); 你的projection()函数内有没有malloc 有啊：  double *projection(double a, double b, double d) { 	double *c; 	int i = 0; 	c = (double*)malloc(sizeof(double)*((int)ceil(((b - a) / d)) + 1)); 	c[0] = a; 	while (c[i++] < b) 		c[i] = c[i - 1] + d;  	c[i] = 0; 	return c; }

1、内存在释放前的操作过程中存在越界操作 2、内存之前已经释放过了，你出错时释放的地址为无效地址 3、该段内存不是你申请的你不能访问

IDE为visual stdio 2013。大家新年快乐~


Question: 为什么以下这个程序必须用getchar()？

是不是因为getchar读取每个字符，而scanf会跳过换行符，空格，制表符。（我也是刚学，说的可能不对，一起讨论下）

ch是一个char类型，只能存储一个字符，在第一层while循环中，每一次循环ch只能接受到输入端的一个字符，比如你输入了个adsas，只有第一a被存入到了ch中，然后再进行循环内的下部操作，但是如果少了最后的那个while语句，下一次循环的时候a后面的字符d就会被存储到ch中，显然这不是程序设计者的意图，但造成这种情况的原因是由于用户的不规范的输入，所以必须使用第二个while语句在用户输入回车之前将前面所有的字符内容滤掉，以保证下次输入的时候是新读取的一行。  （感觉说的好像不是很对，，可能也说的不是很清楚，，楼主看看就好，，各位大神也轻喷！谢谢。。）

你是这样写的吧  ch=getchar()!='\n' 原因：使用getchar()函数   你输入一个字符，然后回车，资格字符被getchar()接收，但是还有个回车符留在缓冲区，这样再有一个getchar（）就会接收这个回车。所以  本来你是应该输入的次数跟实际不一样的是吧 解决方案：每次使用getchar（）之后应该再使用一次getchar()接收回车，像scanf()就不会接收回车，你可以记下来他们的区别

你是这样写的吧  ch=getchar()!='\n'

用来过滤这一行的的除首字符以外其余输入的字符

接收回车的。。。

你自己跟踪程序一步步分析可以看懂的。


Question: 渣渣求助大神，为什么下面的程序进行到第一个scanf就停止了？

scanf ("%d%", &width); 在你输入的数字后面加上“%”

应该不止一个问题，楼上说的都是第二个吧。

求给分数。 第一个scanf后要补上一行getchar（）.不然在你输入第一个数字敲下回车时，那个／n字符会传给下一个scanf。应该还有其他解决办法，我习惯用这个笨办法了。

scanf是很严格按照格式输入的，格式化字符一定要匹配，数据在内存中的存储方式不一样，按照不同方式解析的结果也就不一样，int %d  unsigned %u float %f double %lf …… 请参考：格式化说明符部分http://baike.baidu.com/view/1390039.htm

scanf的那个地方错了吧 应该是%u

使用unsigned width,precision;输出的时候应该用%u\n, 还有%d%是哪里也错了。 其他错误还不清楚，没细看。。最近在学习C++ ，没有怎么研究C语言 希望可以帮到你

输入格式问题： scanf ("%d%", &width); usigned int 类型输入用"%u" unsigned width; scanf("%u", &width); printf("%u\n", width);

“%d%”是什么意思？


Question: 关于scanf的一个用法，很久都没弄懂。

%c 前面加空格可以过滤掉换行

在每个scanf后面加上while循环去掉会车符试试

%c前面加个空格。" %c"

引用 8 楼 szdphsw 的回复:引用 4 楼 Automation_dmu 的回复:%c 前面加空格可以过滤掉换行确实是可以，可是不知道为什么语法啊

引用 3 楼 mymtom 的回复:scanf("%c",vex[i]); ===> scanf("%c",&vex[i]);我是打错了，不好意思，不过加上&还是解决不到问题

引用 1 楼 FancyMouse 的回复:%c前面加个空格。" %c"按照你这样确实可以解决问题，但是不知道为什么

也可以把内容都输完再摁回车，但还是会读一个回车。其实不用遍历，直接读取字符串就好了。


Question: 有谁能和我解释下这个复杂的函数是什么意思吗

楼上犀利..的确是这样..

fun的参数类型是void (*)(void *), 返回值类型是void (*)(void *) 给个简单例子 void p1(void *) {} void (*fun(void (*p)(void *)))(void *){     return p; } auto f =fun(&p1);

*p是什么？发出来还能帮你参考下

不会 就算会了又有什么意义。楼主不要在这种方面浪费时间为好


Question: 新人求助。

【转自一个前辈的博客，忘记名字了，抱歉】1. c、c++相关 C语言问题一般都是在笔试题中出现，面试题中问的比较少。首先是下面这三本经典的C语言书： 《C和指针》 《C专家编程》 《C缺陷与陷阱》 这里还要极力推荐的是： 《C语言深度剖析》 这本书是国内人写的，重点讲解了C语言里的一些晦涩的问题。 上面这几本书应该基本上就可以熟练掌握C语言的各种问题了，笔试题基本都能从容应对。 下面首先推荐三本C++相关的书： 《深度探索C++对象模型》 《Effective C++》 《STL源码剖析》 我觉得这三本是C++方向找工作必备的，这几本看熟了（我觉得至少认真看个3、5遍吧）至少可以搞定90%的C++笔试面试题。 下面这两本我也极力推荐： 《More Effective C++》 《C++反汇编与逆向分析技术》 如果这两本书也掌握了我觉得面试中一般没有什么C++问题能难倒你了。 当然还有很多其他经典的C++的书，有精力都可以好好去读一下，我就不一一列举了。 小结：C、C++知识是很重要的，是绝大数公司笔试面试中重点考察的知识，除了Google、微软等一些公司面试中基本不考察编程语言外，其他大多数公司都会把C++作为重点考察的内容之一，我面过的公司：百度、阿里巴巴、腾讯、网易游戏、雅虎等等都会问C++问题，当然具体问不问也可能跟你的简历、面试官的喜好有关。 2. 算法、数据结构相关 谈到算法自然少不了圣经了 《算法导论》 当然这本书我只是偶尔翻翻，但是我觉得这个应该从头到尾认真看一遍、好好做一下练习题。 下面是几本跟面试中的算法最相关的一些书籍： 《编程珠玑》 《编程之美》 这两本是最经典的了，这里面注重的是解决问题的思路，看的时候里面的问题要认真思考再参考解答。 下面两本是对具体的面试题做一些解答，同时有详细代码实现的。 《剑指Offer》 《Cracking the coding interview》 上面这四本我觉得都是必备的，里面的题目解决思路要数量掌握，能够举一反三、解决相关变种问题。同时，里面的题目，应该都要在纸上实现，然后再在电脑里实现、测试。Bug-free是面试中重点考察，面试官也会经常让面试者写测试用例，所以，平时我们要养成这些好的习惯。 下面也推荐一本经典书吧， 《算法艺术与信息学竞赛》 当然不适合算法薄弱的人看，这一般是ACM大牛的家常饭。不过，能看多少是多少，总归是会有收获的。 小结：算法是重中之重了，各个公司都把算法作为考察重点，甚至有的公司只考察算法。应该早点开始积累，比如多刷一下POJ，LeetCode等等，后面也会提到这些在线编程网站。 3. 数学相关 这方面我看的也不多，当然，我觉得这几本都很重要，对笔试面试都会很有好处的，而且这方面的内容笔试面试中考察的也很多。 《组合数学》 《具体数学》 《数学之美》 4. 操作系统相关 操作系统也是笔试面试考察的重点，我看的相关书的也不多，主要推荐下面两本吧 《深入理解计算机系统》 《操作系统精髓与设计原理》 我没有linux相关经验，但是我觉得linux内核应该好好研究一下，这方面我不懂，就不多说了。 我稍微研究过一点点windows内核源码，这里推荐 《Windows内核原理与实现》 还有和windows编程相关的 《Windows核心编程》 5. 网络相关 我基本就只看了一本 《TCP/IP详解卷1：协议》 6. 软件开发、设计相关 首先是设计模式，我觉得设计模式是很重要的，对以后工作也很有好处。当然面试中考察的不是特别深，一般就是问一下你熟悉的模式是哪一个，然后稍微问一下，估计Singleton是问的最多的。我还是极力推荐大家熟练掌握设计模式。下面这两本书配合一起看，效果相当好 《Head First设计模式》 《设计模式—可复用面向对象软件的基础》 然后是 《代码大全》 这个就不多说了，也是必备的。 我再极力推荐两本重构相关的书 《重构—改善既有代码的设计》 《重构与模式》 这两本可能对面试没有直接的帮助，但是应该会有潜移默化的影响吧，对以后工作肯定是相当有好处的。 7. 搜索引擎 这个不是必备的了，但是我为了丰富一下简历，也看了几本书，主要两本吧 《搜索引擎—信息检索实践》 《这就是搜索引擎—核心技术讲解》 这两本配合着看，就可以把搜索引擎原理、相关技术了解得差不多了，我简历上写了这个，面试中也经常被问到，应该是可以加分的。 8. 数据库 数据库也是重要的内容之一，尤其是数据库底层实现相关的一些东西，索引啊等等。 首先是大家最熟悉的 《数据库系统概念》 还有一本很好的，就是讲解数据库底层内容的 《数据库系统实现》 9. 其他 这里主要是推荐一本《垃圾收集》，这个算是比较底层的东西了，但是这个绝对的会给面试加分，我也很受益于这一点，同时可以稍微研究一下JVM的垃圾收集机制，可以参考《深入理解Java虚拟机》以及一些相关文章。 还有《CDN技术详解》，我觉得也不错，可以很好的了解一些大型网站使用的一些技术等等，面试中也常常会问到一些大型的网站系统设计问题，负载均衡等等。 二、推荐网站 1.LeetCode http://leetcode.com/ 这个网站里有很多经典面试题的讲解，当然最主要的是它的OJ系统，里面有100多道题目，和ACM OJ不同的是，这里面的题目都是来自于面试题，所有更有针对性，建议至少刷3遍，我刷了差不多5,6遍，多刷几遍不丢人。 2.POJ http://poj.org/ 这是北大的OJ，leetcode满足不了你，就可以来这刷了，如果还满足不了就找国外的OJ吧，USACO、URAL等。 3. NOCOW http://www.nocow.cn/ 这里也有不少acm相关的资料，推荐看一下USACO和URAL的题解。 4. Careercup http://www.careercup.com/ 国外著名的帮助找工作的网站，里面有很多Google，MS，FB，Amazon等等名企的面试题，有精力就一道一道做吧。 5.CSDN http://www.csdn.net/ 有不少人的博客还是不错的，总结很多笔试面试相关的东西，比如v_JULY_v。也常关注一下热门博客。   等学了框架就可以写点界面程序了，现在不知道能干什么是因为，黑洞洞的窗口，很枯燥。通大一新生，共勉。

找个实际的需求去做！光看书看代码是不够的，首先必须要动手写。其次，光写几个练习题程序也是没意义的，必须找个实际的需求去解决，才能让你真正找到写代码产生效用的感觉，然后才能步入边写边学、不会就查手册文档的正轨！ 我给你提供个需求（我读大一时写过的）：写一个c程序，读取一个文本文件里的数学公式（简单的四则运算加一些三角函数），以及对应公式里各个变量的几组参数，算出每一组的结果。这程序的实际用途就是解决物理实验课交报告的作业问题。

书后面不都是有练习题么，做个什么管理系统啊，聊天系统，科学计算器..也可以做些简单的游戏，比如贪吃蛇，2048等等，好多呢，网上资源很多的~如果看代码看不懂，最好找个人带你一下，或者自己多看书，触类旁通，加油！

最好有具体的方向。此前网上有各种上机题，可多做一下。

同迷茫中= =，哎，有啥好的书能推荐下吗

C语言能做底层开发 大学期间，学C主要是为了对编程有一个了解，如果你想学好C，数据结构与算法等等，要看的东西有很多


Question: Presentation Error

accept #include <stdio.h> #include <string.h>  void fun(int a[],int n) {     int i, j, t;      for(i = 0; i < n-1; i ++)     {         for(j = 0; j < n-1-i; j ++)         {             if(a[j] > a[j+1])                 t = a[j], a[j] = a[j+1], a[j+1] = t;         }     } } int main() {     int a[100], b[100];     int n, m, i, j, cnt, flag;      while(scanf("%d %d", &n, &m), m || n)     {         cnt = 0;         for(i = 0; i < n; i ++)         {             scanf("%d", &a[i]);         }         fun(a,n);         for(i = 0; i < m; i ++)         {             scanf("%d", &b[i]);         }         if(m == 0)             {                 for(i = 0; i < n; i ++)                 {                     printf("%d ", a[i]);                 }                 printf("\n");                 continue;             }         fun(b,m);         for(i = 0; i < n; i++)         {             flag = 0;             for(j = 0; j < m; j ++)             {                 if(a[i] == b[j])                 {                     flag = 1;                     break;                 }             }             if(flag == 0)                 {                     cnt ++;                     printf("%d ",a[i]);                 }         }         if(cnt == 0)             printf("NULL\n");         else printf("\n");     }     return 0; }

为了简化问题，每个元素后面跟一个空格.  好像最后一个元素后面也有一个空格？


Question: C语言如何让结束指定进程中的指定线程

引用 1 楼 dengyejing 的回复:BOOL WINAPI TerminateThread(   _Inout_  HANDLE hThread,   _In_     DWORD dwExitCode ); 可以结束线程。至于线程的句柄从哪里来，就看是什么线程了，如果是你自己创建的，那你从返回值就可以得到，如果是其它程序创建的，你可以先枚举出来，再从中选择。枚举线程参考https://msdn.microsoft.com/en-us/library/windows/desktop/ms686852(v=vs.85).aspx  还能结束其他进程的线程？


Question: 求大神指点！！！怎样可以编写个程序，让电脑把我写的程序中的输出的内容读出来

_popen, _wpopen Creates a pipe and executes a command.  FILE *_popen( const char *command, const char *mode );  FILE *_wpopen( const wchar_t *command, const wchar_t *mode );  Routine Required Header Compatibility  _popen <stdio.h> Win 95, Win NT  _wpopen <stdio.h> or <wchar.h> 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  Each of these functions returns a stream associated with one end of the created pipe. The other end of the pipe is associated with the spawned command’s standard input or standard output. The functions return NULL on an error.  Parameters  command  Command to be executed  mode  Mode of returned stream  Remarks  The _popen function creates a pipe and asynchronously executes a spawned copy of the command processor with the specified string command. The character string mode specifies the type of access requested, as follows:  "r"  The calling process can read the spawned command’s standard output via the returned stream.  "w"  The calling process can write to the spawned command’s standard input via the returned stream.  "b"  Open in binary mode.  "t"  Open in text mode.  Note   The _popen function returns an invalid file handle, if used in a Windows program, that will cause the program to hang indefinitely. _popen works properly in a Console application. To create a Windows application that redirects input and output, read the section "Creating a Child Process with Redirected Input and Output" in the Win32 SDK.  _wpopen is a wide-character version of _popen; the path argument to _wpopen is a wide-character string. _wpopen and _popen behave identically otherwise.  Generic-Text Routine Mappings  TCHAR.H Routine  _UNICODE & _MBCS Not Defined _MBCS Defined _UNICODE Defined  _tpopen _popen _popen _wpopen    Example  /* POPEN.C: This program uses _popen and _pclose to receive a   * stream of text from a system process.  */  #include <stdio.h> #include <stdlib.h>  void main( void ) {     char   psBuffer[128];    FILE   *chkdsk;          /* Run DIR so that it writes its output to a pipe. Open this     * pipe with read text attribute so that we can read it           * like a text file.      */    if( (chkdsk = _popen( "dir *.c /on /p", "rt" )) == NULL )       exit( 1 );     /* Read pipe until end of file. End of file indicates that      * CHKDSK closed its standard out (probably meaning it           * terminated).     */    while( !feof( chkdsk ) )    {       if( fgets( psBuffer, 128, chkdsk ) != NULL )          printf( psBuffer );    }     /* Close pipe and print return value of CHKDSK. */    printf( "\nProcess returned %d\n", _pclose( chkdsk ) ); }   Output   Volume in drive C is CDRIVE  Volume Serial Number is 0E17-1702   Directory of C:\dolphin\crt\code\pcode  05/02/94  01:05a                   805 perror.c 05/02/94  01:05a                 2,149 pipe.c 05/02/94  01:05a                   882 popen.c 05/02/94  01:05a                   206 pow.c 05/02/94  01:05a                 1,514 printf.c 05/02/94  01:05a                   454 putc.c 05/02/94  01:05a                   162 puts.c 05/02/94  01:05a                   654 putw.c                8 File(s)          6,826 bytes                              86,597,632 bytes free  Process returned 0   Process and Environment Control Routines  See Also   _pclose, _pipe

写文件吧  简单点

搜索重定向    ~

cmd打开，直接重写向 如 hello > look.txt, 这个look.txt就是你的结果


Question: 结构体中含有指针，并写入文件，该如何读取

你的程序写的一塌糊涂, 本想给你改改, 看了一会果断放弃了.... 给你修改比重新写一个还累, 等晚上有空再说吧

引用您好，我还是有些地方不清楚，难道fwrite之后就得将指针free掉，fread的时候再给指针分配空间？这样好像不行啊 我的程序初次运行时没有错误，数据内容感觉都正确的写入文件了，但是关闭后再次运行时，它连par[i].count数值都错了，这是为什么呢？还有如果这时给指针分配空间，感觉也读不出文件里的内容 麻烦你了，谢谢~  1. 运行时数据存放在内存中, malloc, free操作是针对内存的操作, 你创建的局部变量, 全局变量等等都是存放在内存中, 程序重启或者内存掉电都会重新分配内存. 2. fwrite和fread是IO接口, 读写的是存储设备,也就是掉电或者程序重启不会丢失数据的东西.  当你的程序重新启动后, 结构中的para指针指向的数据已经不复存在, 即便你知道你上一次运行程序时的内存地址, 也读不到原来的数据了. 因此需要将数据按可读可写的规则存放在存储设备中, 以备下次使用. 事实上我给出的那个方案真的很简单. 由两部分组成的一条协议,  第一部分是4个字节长度, 存放的是第二部分的长度,  第二部分是不定长的一堆数据.  因为是fread和fwrite是FIFO的, 因此一定要先写第一部分, 再写第二部分. 读的时候先读第一部分, 再读第二部分. 如果这样还不能解释... 我黔驴技穷了.

首先, 你这个结构体 引用struct paragraph { char *para;//每段写入字符个数不确定，所以用指针，能动态解决这一问题 int count;//每段字符个数 }; 大小为8个字节, 也就是说 sizeof(struct paragraph) 等于8. 这里读出来的count是有效的, para是无效的. 我就说一下简单的存取这个结构的思路.  1. 写 //struct paragraph st = xxx; fwrite(&st .count, 4, 1, p_file); fwrite(st.para, st .count, 1, p_file);  2.读 struct paragraph st = {0}; fread(&st.count, 4, 1, p_file); st.para= (char*)malloc(st.count); fread(st.para, st.count, 1, p_file);


Question: 如何解决switch(ch)(ch为字符型变量)中，输入选择后，程序把enter键当输入信息的问题？

消除\n,看这个行不  char c; while ( (c=getchar()) == '\n')         continue;

再来个问题，红色是问题所在


Question: 入门问题，求解答

number定义为双精度浮点数 (long)number 表示什么意思呢？   是不是这样定义的呀？ double number; (long)number;  如果是的话，(long)number表示将number强制转换为长整形。

强制转换为long


Question: 我想在C语言中建立一个数组，这个数组中每一个格子  都存放一个数组  求解怎么写？

vc6.0中正常运行

//在堆中开辟一个4×5的二维int数组 #include <stdio.h> #include <malloc.h> int **p; int i,j; void main() {     p=(int **)malloc(4*sizeof(int *));     if (NULL==p) return;     for (i=0;i<4;i++) {         p[i]=(int *)malloc(5*sizeof(int));         if (NULL==p[i]) return;     }     for (i=0;i<4;i++) {         for (j=0;j<5;j++) {             p[i][j]=i*5+j;         }     }     for (i=0;i<4;i++) {         for (j=0;j<5;j++) {             printf(" %2d",p[i][j]);         }         printf("\n");     }     for (i=0;i<4;i++) {         free(p[i]);     }     free(p); } //  0  1  2  3  4 //  5  6  7  8  9 // 10 11 12 13 14 // 15 16 17 18 19

1楼应该是对的吧，初始化一个指向字符变量的的指针数组，然后把每个字符串的地址存进该数组内。

引用 6 楼 shenshihao520 的回复:似乎是printf的问题  printf("%s\n", arr[0]);  arr[0]需要以‘\0’结尾   问题是怎么把他加上去   arr[0]+'\0'行吗  求各位大神指点 printf函数没问题，估计是终端编码问题。也不是你所说的arr[0]需要以"\0"结尾，arr[0]里面存放的是字符串字面量"shen"的地址，而且"shen"作为字符串的话，本身在其后面就有一个隐式的"\0"。

引用 6 楼 shenshihao520 的回复:似乎是printf的问题  printf("%s\n", arr[0]);  arr[0]需要以‘\0’结尾   问题是怎么把他加上去   arr[0]+'\0'行吗  求各位大神指点  不可以，数组不能直接拿来运算，也不能初始化，用strcat函数，将"\0"连接到字符串字面量"shen"后面，strcat(arr[0],"\0")

就是二维数组

char array[16][256]

引用 3 楼 shenshihao520 的回复:[quote=引用 1 楼 user-9 的回复:] #include<stdio.h>  int main(){ 	char* arr[4];   //4是字符串指针的数量，数组大小 	char* name = "shen"; 	arr[0] = name; 	printf("%s\n", arr[0]); } [/quote]为什么输出是这样的？

引用 1 楼 user-9 的回复:#include<stdio.h>  int main(){ 	char* arr[4];   //4是字符串指针的数量，数组大小 	char* name = "shen"; 	arr[0] = name; 	printf("%s\n", arr[0]); }

引用 9 楼 jeaham 的回复:[quote=引用 6 楼 shenshihao520 的回复:] 似乎是printf的问题  printf("%s\n", arr[0]);  arr[0]需要以‘\0’结尾   问题是怎么把他加上去   arr[0]+'\0'行吗  求各位大神指点 printf函数没问题，估计是终端编码问题。也不是你所说的arr[0]需要以"\0"结尾，arr[0]里面存放的是字符串字面量"shen"的地址，而且"shen"作为字符串的话，本身在其后面就有一个隐式的"\0"。[/quote]那您的意思就是一楼是正解 只要解决终端编码问题就OK了？

按1楼编译运行正常

试试二维数组。


①首先，第33行和第41行有个小错误，应该是x-1>=1，y-1>=1，而不是x-1>=0，y-1>=0。 ②然后回到主要矛盾上，关键在第11行，不能通过新读入的字符是'Z'而判断程序的结束，因为square中的字母是可以包含字符'Z'的，比如输入  ZRGSJ XDOKI M VLN WPABE UQHCF ARRBBL0  输出应该是  Puzzle #1: Z R G S J X O K L I M D V B N W P   A E U Q H C F  ③然后再注意第16、17行，如果i==1,j==1时直接continue，那么当空格正好处于p[1][1]的位置时，x、y的值能得到正确计算吗？  问题的解决方法很多，我帮你稍微改了下，AC代码：http://acm.hust.edu.cn/vjudge/problem/viewSource.action?id=3374194，建议你自己再整理下输入部分的处理。


Question: 才入门，一程序问题求解答

太棒了！！^_^^_^^_^，对的诶

好像还是不行

楼上正解； 1.问题一： scanf("%c ",&answer);    %C后多了一个空格，去掉空格。 2.问题二：（是在问题一解决后的情况） scanf("%lf", &value); 会在输入缓冲区留下一个回车符，scanf("%c ",&an/wer);读取了这个回车符.  因此，解决方法如下： （1）方法1： printf(" \n Enter a value:"); scanf("%lf", &value); total += value ; ++count; fflush(stdin);                        加这句，刷新标准输入缓冲区  printf("\n Do you want to enter another value ? (Y or N):"); scanf(" %c",&answer);  printf("\n %c",answer); fflush(stdin);                        加这句，刷新标准输入缓冲区 if(answer == 'N') break; （2）方法2： scanf(" %c",&answer); 在%c前边加空格； 说明第一个里的空格用来过滤空白符。本句效果，读取首个不为空白符的字符。 3.补充： （1）scanf("%d",&number);等，可以自动忽略先导空白符。 scanf("%c ",&answer);不忽略空白符的原因，可能是因为，空白符本身就是字符，而%c本来就是用来接受字符的，而且有时需要统计这些空白符。 （2）获取字符可以使用getchar()函数;

试试接收前清空键盘缓冲区。


Question: 队列输出的时候崩溃

3处的=改成==  if (Q->Front == Q->Rear)


Question: 请问这个结构那里有问题，还有我想把BanQi[8]初始化成那样要怎么办？

引用 1 楼 sholber 的回复:声明的语法都没搞清。 能说说哪里错了吗？ typedef struct students { 	char name[10]; 	int num; 	float chinese; 	float math; 	float english; 	float physics; 	float chemistry; 	float average; 	float sum; 	struct students *next; }student; 像这个就是对的，我对比了下没看出什么问题

声明的语法都没搞清。

引用 4 楼 LS1jun 的回复:[quote=引用 3 楼 user-2 的回复:] 那样定义没有错，你想初始化 BanQi[8]可以这样：HangBan.BanQi[8]={0,0,0,0,0,0,0,0}; 谢谢回答，我现在已经编译好了，是其他错误让编译程序对结构报错了。[/quote] 嗯嗯，么么哒。。我也是刚刚开始学C++呀。迷茫。

引用 3 楼 user-2 的回复:那样定义没有错，你想初始化 BanQi[8]可以这样：HangBan.BanQi[8]={0,0,0,0,0,0,0,0}; 谢谢回答，我现在已经编译好了，是其他错误让编译程序对结构报错了。


Question: 关于Qt

信号的实现在moc_xxx.cpp里面，由moc自动生成，参考：http://doc.qt.io/qt-5/qobject.html


Question: 做金融行业软件开发的新人，有些迷茫，求大神们指点迷津？

楼主这是正常的··· 你想提升技术的话可能也就只能抽象各种业务逻辑，抽象共同点，抽象出来成为框架 不过这东西可真不是那么容易的

引用 8 楼 Evankaka 的回复:[quote=引用 1 楼 Raffin 的回复:] 做C哪里LOW了，做JAVA的都是智商低的。 后一句可不敢苟同了，语言这东西，和人的智商有关系么？[/quote]  当然有关系，连指针都搞不懂，给你看一串*&**就晕的人还能说自己智商高？ 我不是说所有做JAVA的智商都低，做C的智商都高，但是比例上肯定做C的人智商高。

楼主是自学成才吗？还是大学是混出来的？  随便一个计算机专业，老师都会告诉你，程序设计的整个工作流程中，写代码的工作量只有20%

引用 1 楼 Raffin 的回复:做C哪里LOW了，做JAVA的都是智商低的。   +10086  学会java然后来学c和c++的   想自杀 学会c/c++的再去学java   简单一b

C语言本来就是用来做系统、嵌入式、硬件开发的，那样才high，用C语言来做业务逻辑，当然就发挥不出来了，如果我是搞C语言的，肯定不会选择金融行业。

使用飞机这种工具的人智商一定比使用汽车这种工具的人智商高。

引用 9 楼 Raffin 的回复:[quote=引用 8 楼 Evankaka 的回复:] [quote=引用 1 楼 Raffin 的回复:] 做C哪里LOW了，做JAVA的都是智商低的。 后一句可不敢苟同了，语言这东西，和人的智商有关系么？[/quote]  当然有关系，连指针都搞不懂，给你看一串*&**就晕的人还能说自己智商高？ 我不是说所有做JAVA的智商都低，做C的智商都高，但是比例上肯定做C的人智商高。[/quote] 我也不争了，语言这东西只是个工具，为什么你们老喜欢喷来喷去的呢？

引用 1 楼 Raffin 的回复:做C哪里LOW了，做JAVA的都是智商低的。 后一句可不敢苟同了，语言这东西，和人的智商有关系么？

难度一般都在需求分析整理

引用 2 楼 user-8 的回复:一半的功夫花在了解银行业务方面了， ===> 这就对了！ 如果工作3年后，你发现百分之八十的功夫花在了解银行业务方面，那么，恭喜你，你是银行业务专家了。可是技术上提升不是很大，我感觉做金融的写代码的难度不是很大！

引用 1 楼 Raffin 的回复:做C哪里LOW了，做JAVA的都是智商低的。现在不知道做c要学什么了，给点意见呗?

引用 楼主 u012343001 的回复:入职两个月的新人，现在有点迷茫，本人做的是金融行业的软件开发，用的是c,最近接触的两个项目，一个是给银行做数转，另一个配报文做交易，感觉代码难度不大，一半的功夫花在了解银行业务方面了，感觉学的东西太少，不知道有没有做过这方面的大神给点建议，我总觉得做c的比做Java呀，android呀等一些语言要low一些，自己毕业后参加了半年的嵌入式培训，c,lsd,java,android都学过，不知道做哪个方向好，如果做c从事哪些方面比较好呢？现在感觉做c不知道要学些什么东西了，给点建议呗？

引用 5 楼 u012343001 的回复:[quote=引用 2 楼 user-8 的回复:] 一半的功夫花在了解银行业务方面了， ===> 这就对了！ 如果工作3年后，你发现百分之八十的功夫花在了解银行业务方面，那么，恭喜你，你是银行业务专家了。可是技术上提升不是很大，我感觉做金融的写代码的难度不是很大！[/quote]  既然碰到了也算有缘，我就说点关于技术和业务的事情。 我是开发SAP（一种ERP软件）的，ERP开发的一大特点是处于业务和技术的交界处。 C开发是搞底层为主，JAVA开发搞Web为主，SAP开发侧重业务本身。 SAP的开发很多在技术方面只是停留在写业务逻辑和使用框架上，跟你碰到的情况类似。  如果你是喜欢技术想往技术路线发展（特指IT技术），那么就不要去了解太多业务的知识，因为你今天做了银行项目，你不能保证下次还是做银行项目，假如你下次做个零售业的项目，你的银行知识就一点用处都没有。只有IT技术本身才是跨行业的。  假如你觉得你不擅长编程，那么会使用开发工具进行一些逻辑开发就已经足够，之后早点选定一个行业，学习它的业务知识转为业务专家兼懂IT的人。  我个人觉得C语言去搞企业企业应用级别的开发应该项目不多，应用级别的开发一般都用更高级的语言了，C语言应该是用来开发底层驱动和算法之类的。

做C哪里LOW了，做JAVA的都是智商低的。


Question: 字符串常量放在静态区？

引用 27 楼 li1983243109 的回复:[quote=引用 11 楼 ren0065 的回复:] [quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote] +1[/quote]  不懂就不要急着发言。

引用 11 楼 ren0065 的回复:[quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote] +1

引用 18 楼 sholber 的回复:[quote=引用 17 楼 micropentium6 的回复:] [quote=引用 14 楼 sholber 的回复:] [quote=引用 13 楼 ren0065 的回复:] [quote=引用 12 楼 sholber 的回复:] [quote=引用 11 楼 ren0065 的回复:] [quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote]  这是C标准上的原话。你看不懂，说明你还需要努力加强科学文化知识的学习呀。[/quote]  原文出处链接请求!!!![/quote]  ISO/IEC 9899:201x Committee Draft — April 12, 2011 N1570 6.4.5 String literals 6 In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. The multibyte character sequence is then used to initialize an array of static storage duration and length just sufficient to contain the sequence. [/quote]  U only got the literal meaning here, no to mentions the fact that it is up to the compiler to implement this so called "static storage duration" behavior on string literal, such as leaving such an "arrary" in .rodata section if ELF  Steed horse'so statement is legit in practice. In fact, C FAQ 1.32 probably has the most comprehensive explanation and by my opinion, it is way better than the c0x specification...    [/quote]  实现是靠不住的。这就是为什么我最讨厌那些用汇编输出说话的人。 话说 老习惯规定拉完屎要用纸擦，而有些人（实现）为了图方便根本不擦屁股。 你这种认识我们没有讨论的基础。bye-bye.[/quote]  LOL, by browsing your previous replies, you definitely have a history of leaving critical comments with you weird emotional pains of the illusion to be the only person on this planet who holds the truth!   It appears "屁股" and "屎" are two particular words you prefer to facilitate explaining your theory. I feel sad for you!  "实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组"  What you said here is totally by the book and without any context, it's bullshit!  实现是靠不住的。这就是为什么我最讨厌那些用汇编输出说话的人。  I am not sure if you are the author of <x86汇编语言：从实模式到保护模式> and <穿越计算机的迷雾>. If so, it would be so ironic that assembly is not your sword of "truth and justice" but the hoodoo magic trick played by the wizard!  "读过这本书的朋友，也就是你，可能会有话要说，比如发发牢骚、提几点建议；或者谈谈看法，说说感想。无论是什么，都请畅所欲言，我都绝对欢迎，即使是难听的我也不会生气。"  you spoke very sincerely there. I can't connect it with whatever you are performing here at all!  We say people get wiser with age. You seems to be the opposite!  back to this topic: the output in assembly format might not be trustworthy but it gives you the clue to explore the implementation of whatever the language spec says. Totally interpret the behavior based upon the specification, imho, is stupid. This is not a holy war, we are developers.  Anyway, please don NOT use the phrase like "shit" or "ass", they are disgusting!

引用 13 楼 ren0065 的回复:[quote=引用 12 楼 sholber 的回复:] [quote=引用 11 楼 ren0065 的回复:] [quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote]  这是C标准上的原话。你看不懂，说明你还需要努力加强科学文化知识的学习呀。[/quote]  原文出处链接请求!!!![/quote]  顺便说一下，我喜欢C的原因之一就是，它是为数不多的没有被实现绑架的语言。事实上怎样和理论上应该怎样不是一回事。不要拿汇编来架空C语言。

引用ISO/IEC 9899:201x Committee Draft — April 12, 2011 N1570 6.4.5 String literals 6 In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. The multibyte character sequence is then used to initialize an array of static storage duration[/color] and length just sufficient to contain the sequence. 这只说明了 char* xxx = "xxx"; 的存在方式. char xxx[10] = "xxx"; 是一个赋值的过程, 请见 6.7.9

引用 17 楼 micropentium6 的回复:[quote=引用 14 楼 sholber 的回复:] [quote=引用 13 楼 ren0065 的回复:] [quote=引用 12 楼 sholber 的回复:] [quote=引用 11 楼 ren0065 的回复:] [quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote]  这是C标准上的原话。你看不懂，说明你还需要努力加强科学文化知识的学习呀。[/quote]  原文出处链接请求!!!![/quote]  ISO/IEC 9899:201x Committee Draft — April 12, 2011 N1570 6.4.5 String literals 6 In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. The multibyte character sequence is then used to initialize an array of static storage duration and length just sufficient to contain the sequence. [/quote]  U only got the literal meaning here, no to mentions the fact that it is up to the compiler to implement this so called "static storage duration" behavior on string literal, such as leaving such an "arrary" in .rodata section if ELF  Steed horse'so statement is legit in practice. In fact, C FAQ 1.32 probably has the most comprehensive explanation and by my opinion, it is way better than the c0x specification...    [/quote]  实现是靠不住的。这就是为什么我最讨厌那些用汇编输出说话的人。 话说 老习惯规定拉完屎要用纸擦，而有些人（实现）为了图方便根本不擦屁股。 你这种认识我们没有讨论的基础。bye-bye.

引用 14 楼 sholber 的回复:[quote=引用 13 楼 ren0065 的回复:] [quote=引用 12 楼 sholber 的回复:] [quote=引用 11 楼 ren0065 的回复:] [quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote]  这是C标准上的原话。你看不懂，说明你还需要努力加强科学文化知识的学习呀。[/quote]  原文出处链接请求!!!![/quote]  ISO/IEC 9899:201x Committee Draft — April 12, 2011 N1570 6.4.5 String literals 6 In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. The multibyte character sequence is then used to initialize an array of static storage duration and length just sufficient to contain the sequence. [/quote]  U only got the literal meaning here, no to mentions the fact that it is up to the compiler to implement this so called "static storage duration" behavior on string literal, such as leaving such an "arrary" in .rodata section if ELF  Steed horse'so statement is legit in practice. In fact, C FAQ 1.32 probably has the most comprehensive explanation and by my opinion, it is way better than the c0x specification...

程序未运行的时候，字符串this is a test在可执行文件中。运行该可执行文件，字符串this is a test被加载到内存的一个静态只读存储区，假设该地址为A。当main函数被调用时，array在堆栈上分配内存，然后从A处拷贝"this is a test"到array，此时array便存放了该字符串的一个副本

引用 1 楼 Lion1946 的回复:char array[]         栈区 "this is a test "    常量区 说到点上了！  int main(int argc, char *argv[]) {     char array[]=" this is a test ";     return 0; }  生成的汇编类似下面      .file   "foo.c"     .section    .rodata .LC0:     .string " this is a test "     .text     .p2align 4,,15 .globl main     .type   main, @function main:     leal    4(%esp), %ecx     andl    $-16, %esp     pushl   -4(%ecx)     pushl   %ebp     movl    %esp, %ebp     pushl   %ecx     subl    $32, %esp     movl    .LC0, %eax     movl    %eax, -21(%ebp)     movl    .LC0+4, %eax     movl    %eax, -17(%ebp)     movl    .LC0+8, %eax     movl    %eax, -13(%ebp)     movl    .LC0+12, %eax     movl    %eax, -9(%ebp)     movzbl  .LC0+16, %eax     movb    %al, -5(%ebp)     movl    $0, %eax     addl    $32, %esp     popl    %ecx     popl    %ebp     leal    -4(%ecx), %esp     ret     .size   main, .-main     .ident  "GCC: (GNU) 4.2.1 20070719  [FreeBSD]"

引用 13 楼 ren0065 的回复:[quote=引用 12 楼 sholber 的回复:] [quote=引用 11 楼 ren0065 的回复:] [quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote]  这是C标准上的原话。你看不懂，说明你还需要努力加强科学文化知识的学习呀。[/quote]  原文出处链接请求!!!![/quote]  ISO/IEC 9899:201x Committee Draft — April 12, 2011 N1570 6.4.5 String literals 6 In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. The multibyte character sequence is then used to initialize an array of static storage duration and length just sufficient to contain the sequence.

引用 12 楼 sholber 的回复:[quote=引用 11 楼 ren0065 的回复:] [quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote]  这是C标准上的原话。你看不懂，说明你还需要努力加强科学文化知识的学习呀。[/quote]  原文出处链接请求!!!!

引用 11 楼 ren0065 的回复:[quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote]  这是C标准上的原话。你看不懂，说明你还需要努力加强科学文化知识的学习呀。

引用 7 楼 sholber 的回复:[quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云

常量存放在常量区。

引用 3 楼 qq_16650397 的回复:char array[]   实际上是系统自动申请内存给array[], "this is a test "    放在字符静态常量区 不知所云。 什么叫自动申请内存 什么叫字符静态常量区

引用 5 楼 steedhorse 的回复:这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。

引用 1 楼 Lion1946 的回复:char array[]         栈区 "this is a test "    常量区  不知所云。

。。。。 看一下编译后的结果就知道，否则容易盲人摸象


Question: 关于数集的子集

路过的，表示没看出（2,3）出现的最多。

引用 3 楼 czarten 的回复:我看了半天没看出为什么是2 3 就是（1 5）（2 6）（2 3）里有（2 3） 共出现3次最多

我看了半天没看出为什么是2 3

引用 1 楼 user-3 的回复:统计最多出现的次数吗？ 恩

统计最多出现的次数吗？


Question: char str[4];  str = "abc"; error

引用 14 楼 cfjtaishan 的回复:但是你能用arr=xx这样操作？我们对于概念可能有误解或者理解有差异，但是实际操作，arr = xx;是不可以的。arr是数组名。。 arr = XX;是不可以的  不妨碍 arr 可以是一个左值 数组名有一个特点 在某些情况下会做强制类型转换  转换结果不是左值 所以不可以 而且 不是所有左值都可以写在赋值符号左边的  能写在赋值符号左边的仅仅是 可修改左值

引用 13 楼 lin5161678 的回复:[quote=引用 12 楼 cfjtaishan 的回复:]  左值，我的理解是赋值号的左边，你的理解呢？ 你的理解完全是错的  以前也许是这样  但C语言发展到现在 这个说法已经不能自洽了  早就被废除了  现在的说法是  引用An lvalue is an expression (with an object type other than void) that potentially designates an object; 一个指定对象的非void类型的表达式  arr这个表达式 指定了一个数组对象 是一个左值  符合规定的[/quote] 但是你能用arr=xx这样操作？我们对于概念可能有误解或者理解有差异，但是实际操作，arr = xx;是不可以的。arr是数组名。。

引用 11 楼 lin5161678 的回复:引用 10 楼 cfjtaishan 的回复:[quote=引用 6 楼 lin5161678 的回复:] [quote=引用 5 楼 cfjtaishan 的回复:] 数组名是不能做左值的。数组名有时候可以做左值 有时候不行 别一竿子都打死 for example? [/quote] int arr[10]; &arr  一元&运算符的操作数只有2种可能 不是 函数名 就是 左值  arr 不是函数名  那么这个arr 就只能是左值了  [/quote] 左值，我的理解是赋值号的左边，你的理解呢？

引用 10 楼 cfjtaishan 的回复:引用 6 楼 lin5161678 的回复:[quote=引用 5 楼 cfjtaishan 的回复:] 数组名是不能做左值的。数组名有时候可以做左值 有时候不行 别一竿子都打死 for example? [/quote] int arr[10]; &arr  一元&运算符的操作数只有2种可能 不是 函数名 就是 左值  arr 不是函数名  那么这个arr 就只能是左值了

引用 12 楼 cfjtaishan 的回复:左值，我的理解是赋值号的左边，你的理解呢？ 你的理解完全是错的  以前也许是这样  但C语言发展到现在 这个说法已经不能自洽了  早就被废除了  现在的说法是  引用An lvalue is an expression (with an object type other than void) that potentially designates an object; 一个指定对象的非void类型的表达式  arr这个表达式 指定了一个数组对象 是一个左值  符合规定的

引用 6 楼 lin5161678 的回复:引用 5 楼 cfjtaishan 的回复:数组名是不能做左值的。数组名有时候可以做左值 有时候不行 别一竿子都打死 for example?

数组名和指针名不是同一个概念，两者有一定的区别

引用Except when it is the operand of the sizeof operator or the unary & operator, or is a string literal used to initialize an array, an expression that has type ‘‘array of type’’ is converted to an expression with type ‘‘pointer to type’’ that points to the initial element of the array object and is not an lvalue. If the array object has register storage class, the behavior is undefined. 引用An assignment operator shall have a modifiable lvalue as its left operand.  str ="abc"; 右边表达式"abc"类型是char [4], 转换为char *；  左边表达式str的类型char [4], 也会转换为char*, 但是不是一个左值， 不满足第二条。

另外 答题  数组可以通过类型转换 转换为指针 指针不能通过类型转换 转换为数组 完毕

初始化不是赋值 各自适用不同的语法条款  没什么可比性  别看到 = 就瞎凑上去 C里面成吨的符号重用 一个符号在不同上下文 意思是不一样的

数组都不可以直接用 = 来赋值，除非是初始化

错了 <string.h>

strcpy使用这个函数，头文件包含  #include <stdio.h>

数组名是不能做左值的。


Question: 编译错误，求帮助

#include "graphics.h"


挨个检查修改吧 编译提示的错误比较清楚了

void str_sort (const char * [], int);  //function prototype char * pS [NUM_P]; //Array of string pointers 参数的类型是指向 const char * 的指针；ps的类型是指向char *的指针。形参和实参所指向的类型不兼容。 参见以下这个帖子的46楼：http://bbs.csdn.net/topics/390946225


Question: 求教，怎样用vs2013用fwrite把数据正确地写入文件？

楼主的结构体，写入文件后是二进制的，用记事本当然是这个样子啊。

fopen_s(&fp, "D:\\tese1.txt", "wb")     //以二进制方式操作文件。 把b去掉

fwrite 写的时候把 &stu[i] 解析为 unsigned char 数组 由于结构里面有不同的类型，分开写入文件 size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream ); Internally, the function interprets the block pointed by ptr as if it was an array of (size*count) elements of type unsigned char.


Question: 字符指针的引用问题

代码一堆问题，给你指出其中一个： for(;str != '\0' ;++i) ---------------------------> for(;(*str) != '\0' ;++i)

可以考虑用另外一个指针处理，或者使用一个新的字符数组来拷贝str

arr[idx]='\0';    str = &str[i];    //这个地方的问题；    printf ("split str is %s \n",str);    spstr = arr;

知道我的问题在哪了  传的是个指针 没错，但我在splitstr函数里改了str指针的值   但没有改更改函数splitstr2stack中的值     想问下 我应该怎么样做呢？

“按指针传递 应该修改原字串” char * 可以修改指针指向的字符串内容，而不是指针本身 char ** 可以  char * foo(char * p) {     p = 1;     // 根本不影响外面的指针     *p = 'a'; // 可以修改 p 指向的内容     return p; }  foo(pStr);


Question: while循环进入的次数疑惑

引用 11 楼 wenpinglaoyao 的回复:楼主你的源代码里面，struct student *q 根本就没有初始化。 所以那句【 q->next = pi; 】就是非法地址。。。 我也觉得这个q怪怪的，出现过，只是声明了而已

恩 10楼方法可以的，fflush在不同平台实现方式不同，scanf在VC下微软还搞了个scanf_s，优化了这个比较bug的缓冲区处理。 另外，给个建议啊，代码缩进注意点，一般像初始化这种int a = 1;空一格就好了吧。 PS 昨天木有上班，今天上班才来看下- -

引用 9 楼 u013990248 的回复:成功了吗？我输入一个字符，比如‘w’回车，程序输出就是a=w b=回车，直接不能输入下一个字符了 windows下是好用的 貌似fflush这个函数实现的不一样  可以自己过滤类似这样void clean_stdin(void) { int c; do { c = getchar(); } while (c != '\n' && c != EOF); }

引用 6 楼 u013990248 的回复:恩，懂了，但是我尝试了使用fflush（stdin）始终清除缓存区的内容，一个最简单的例子： #include <stdio.h> #include <string.h>  int main(void) {         char    a;         char    b       = 'x';         scanf("%c", &a);         fflush(stdin);         b       = getchar();         printf("a=%c, b=%c", a, b);         return 0; }  你这个成功了啊 q回车 w回车 //如果没有flush,a=q, b=回车

始终无法清除缓存区的内容

scanf这玩意不是到换行为止的么，你用scanf("%ld%s", &(pi->num), pi->name);读长整形和char*木有问题是因为第二次缓冲区进来的是\n%ld%s啊，然后又有个回车\n在缓冲区里，循环继续你这时去scanf("%c", &ch);，自然这个\n就进来了，然后又非y非n就走下面逻辑了，然后循环继续，缓冲区木有东西，自然等待你输入了。 所以出现两次printf("你要创建结点吗 y/n \n");，所以各大C的书籍里的代码里都会清空缓冲的代码在，无论是while空循环或者fflush(stdin)。

缓存区有东西？能否说得详细点呢？

我也是很久没写了，今天翻书来看看，刚刚发现自己程序上有错误的地方， #include <stdio.h> #include <stdlib.h> #include <string.h>  // 创建单链表、遍历单链表 // 存储学生的信息，包括姓名和学号 struct student {         long      num;         char      name[30];         struct    student *next; };  int main(void) {         //-----------------------创建单链表----------------------------------------------//          struct student   *head; // 头结点         struct student   *tail; // 尾节点         struct student   *pi;   // 可操作的指针变量         struct student   *q;    // 指向当前结点的下一个结点         char   ch;              // 接收键盘的输入         int    first    = 0;    // 判断是否为头结点          // 创建接下来的结点         while(1){                 printf("你要创建结点吗 y/n \n");                 scanf("%c", &ch);                 if(ch=='y'||ch=='Y'){                         pi      = (struct student *)malloc(sizeof(struct student));                         // 判断分配内存是否成功                         if(!pi){                                 printf("分配内存失败，退出程序\n");                                 exit(-1);                         }                          scanf("%ld%s", &(pi->num), pi->name);                         first++;                         pi->next        = NULL;                 }else if(ch=='n'||ch=='N'){                         break; // 跳出循环                 }else{                         continue;                 }                 if(first==1){                         head    = pi;                 }else if(first>1){                         tail->next      = pi; // 建立中间的那条链                 }                 tail    = pi; // 并且将尾指针指向他         }          // -----------------------------------------遍历单链表----------------------------------//         if(first>0){                 pi      = head;                 while(pi){                         printf("%ld     %s\n", pi->num, pi->name);                         pi      = pi->next;                 }         }          // 释放这些内存         if(first>1){                 pi      = head;                 while(pi){                         q       = pi;                         pi      = pi->next;                         free(q);                 }         }else if(first==1){                 free(head);         }          // 当没有创建结点的时候就可以直接返回了          return  0; } 至于为什么会出现两次“要求输入字符的提示”还是没想通。

额 上面手贱发快了... scanf("%ld%s", &(pi->num), pi->name); 因为你在这步执行后缓冲区还是有东西的

好久不写C了..都快不会写了..


Question: shell脚步里面sh和bash有什么区别

bash是sh的增强版 http://en.wikipedia.org/wiki/Unix_shell


Question: n个节点的平衡二叉树的深度，与这些节点 理想平衡二叉树的深度  相差不能超过多少？  求围观 求大神解答！

平衡二叉树高度跟完全二叉树的确是不同的。 也并不是差1. 因为平衡二叉树在高度为h情况下 最小节点数为Fibonacci数列（下标并不恰好对应），最多节点数则为2^h 所以在节点数为n的情况下其最大高度应该为对应刚好比他大fibonacci数列所对应的高度（反证法）

其实这个平衡二叉树是用在哪个方面的？除了纯理论研究外。

好像可以参考一下堆排序的原理。

除了最后一层其他都得是满的  你可以试试来个层序遍历 看看哪层少了

不知道表达清楚了没有， 先自顶一个， 有大神要看代码的话，我再发代码


Question: windows 和 linux 下，文件字符串长度问题

何故?  只需要把文件以二进制方式打开, 然后看里面的内容即知.    C库函数  fopen("1.txt", "rb");  二进制方式打开 , 然后读取出来即可知道了.

linux的end of line是'\n', windows的end of line是\r\n


Question: 关于变量名和函数名从文件读取的问题

《程序员的自我修养——链接、装载与库》

我觉得你首先最应该考虑的是你的需求是否真有必要这样实现

1.用条件语句，根据输入选择执行相应的函数就行了。 2.用dl库动态加载库，把从文件读取的函数名作为dlsym()的第二个参数。

用条件语句，根据输入选择执行函数就行了。既然你都想到要拿到函数地址，强转类型再去执行。难道就不能直接用函数名么，要知道函数名就是函数地址呀。还有个办法就是用dl库动态加载，把从文件读取的函数名作为dlopen()的第二个参数。

1.参照.ini文件读取函数； 2.参照显示载入DLL中的GetProcAddress;

你愿意写一些if的话, 到时可以简单的实现.   这样就类似一个脚本解析器

C++用std::map C没有map, 自己实现一个

需要 pdb 文件， exe 文件里面通常不包含符号信息的

可执行文件中的函数并未真正与地址绑定，此操作要延迟到动态装载器载入程序之时。  或者你能实现相当于装载器的功能，就可知道函数的实际加载地址，再根据符号表，动态链接也是能实现的！

别想太多了  就一堆if 别去想什么变量名函数名了  直接字符串比较   大体思路是行不通的 exe里面哪里来的函数名


Question: 菜鸟关于变长数组（VLA）的问题

函数参数跟定义变量不同, 也不遵循先左后右的规则. 将定义中的数组改为 int **a 或者 int *a[] and, 把你函数定义的分号去掉

『我试着写了一个例子，但是VC报错，求原因』

把参数的a[m][n]改成**a就行了。c++只传数组指针，不管长度，所以括号里的m,n没用。

引用 2 楼 user-5 的回复:[quote=引用 1 楼 sholber 的回复:]  int a [sizeof (int)];                //非法。 这个a 不是VLA 为什么会非法? [/quote] 手误。sorry。 还有，第二个例子应该是m而不是n

引用 1 楼 sholber 的回复:int a [sizeof (int)];                //非法。 这个a 不是VLA 为什么会非法?

If an identifier is declared to be an object with static or thread storage duration, it shall not have a variable length array type. That is，若一个标识符被声明为具有静态存储期或者线程存储期，则它不能是变量长度数组类型。 int a [sizeof (int)];                //非法。 int main (void) {/* …… */} void f (int m) {     int a [n];                            //合法。     /* …… */ }


Question: getopt_long参数struct option

struct option {   const char *name;   /* has_arg can't be an enum because some compilers complain about      type mismatches in all the code that assumes it is an int.  */   int has_arg;   int *flag;   int val; };

帖子没人回复怎么办？


Question: 菜鸟对于const和常量指针的困惑！

把里面的*理解成指向。。。就很容易理解了，比如 const int * a 解读出来就是：a指向const int，也就是指针a指向的是一个常整型。所以。。a是可写的，a指向的那个变量，是不可写的。

root@jusse ~/develop# cat -n cc_const.c       1  #include <stdio.h>      2      3  int main(int argc, char *argv[])      4  {      5      int a = 10;      6      int b = 20;      7      const int *cpa = &a;      8      int * const pca = &a;      9      const int * const cpca = &a;     10     11      cpa = &b;     12      *cpa = 30;     13      pca = &b;     14      *pca = 40;     15      cpca = &b;     16      *cpca = 50;     17     18      printf("a: %d, b: %d\n", a, b);     19     20      return 0;     21  }  root@jusse ~/develop# gcc -Wall -g -o cc_const ./cc_const.c  ./cc_const.c: In function ‘main’: ./cc_const.c:12:5: error: assignment of read-only location ‘*cpa’ ./cc_const.c:13:5: error: assignment of read-only variable ‘pca’ ./cc_const.c:15:5: error: assignment of read-only variable ‘cpca’ ./cc_const.c:16:5: error: assignment of read-only location ‘*cpca’  从上面代码你就可以知道哪个可以变哪个不能变了。 我是这么简单记的，const离哪个近哪个就不能变，比如const int *a，那么int不可变，int * const a，那么a不可变，const int * const，那么int和a都不可变。

const是告诉编译器修饰的是一个常量，不可以修改，修改了编译器就会报告出错。但是和常量还是有区别的。 const int a;是指a的值不可以改变，但是可以在定义时进行初始化； 另外，const的位置不一样，修饰的内容也会有所不同。

这儿有个老帖子。 int const *p和int *const的区别 http://bbs.csdn.net/topics/310124559

是不是这样，const 跟着什么，什么的值就不能变？ 理不清楚  下面是在百度搜索【int * const 】找到的  const int a; int const a; 这两个写法是等同的，表示a是一个int常量。 const int *a; 表示a是一个指针，可以任意指向int常量或者int变量，它总是把它所指向的目标当作一个int常量。也可以写成int const* a;含义相同。 int * const a; 表示a是一个指针常量，初始化的时候必须固定指向一个int变量，之后就不能再指向别的地方了。 int const * const a;表示a是一个指针常量，初始化的时候必须固定指向一个int常量或者int变量，之后就不能再指向别的地方了，它总是把它所指向的目标当作一个int常量。也可以写成const int* const a;含义相同。


Question: 【求助】大神请留步，关于数组问题

哦, 上边 *t[n] 说错了, t[n]是这个数组的第n个元素, *t[n]表示 t[n] 这个指针指向的内存的值. 拆解一下  char* p = t[n]; char c = *p;

引用我想问的是在gettext函数中，gets(t[n])是什么意思，读入文本行的话为什么是一个【一维数组】呢？而且*t[n]又是什么意思？ 1. gets(t[n]) 是获取一行字符串, 遇到换行符或EOF时停止. t[n]是字符串首地址, 读到的内容是从t[n]开始到换行或EOF结束. 2. 参数char (*t)[LEN] 可以理解为一个指针的指针, 它有LEN个, 每一个都指向一个字符串数组. 3. *t[n]  数组下标[]的优先级大于*的优先级, 因此这是一个指向数组的指针. 即一个指向数组t[n]的指针.

*t[n]是第n行的第一个字符，类似与t[n][0]

gets(t[n])是char text[MAXLINE][LEN];数组text的第n行，数组text是有MAXLINE行和LEN列（char类型长度）；

gets(t[n])的意思是获取字符，就是运行程序时你从键盘上输入的字符。是stdio.h头文件里面包含的获取字符的函数。 (*t)[LEN]的意思是指向一维数组的的指针变量。而*t[n]是一个指针数组，两个是不一样的。一个是指针变量，一个是指针数组。

先搞清楚t的类型 ，t的类型是 char(*)[LEN], 也就是它是一个指针，指向的内容类型是char[len]的一维数组，不容易理解的话你可以把它当做二维数组，那么t[0]对应的地址就是text[0],*t[n]的意思就是t[n][0]


Question: C语言函数 strlen

这是个常见的问题。 1. 用fgets读出的内容，通常都带着换行符； 2. 在fgets(buf, sizeof(buf), fp)之前初始化buf是个很蛋疼的做法； 3. 遇到这种问题，把buf按字节打印出来，一切问题都会真相大白，这是最基本的调试方法。

如果文件内容就是123那么串长就应该是3啊，有空格的话应该就不一样了！

buf中多了个'\n'

楼上的各位观众 别说什么没初始化了行嘛 fgets 毫无疑问会添加字符串结束的 \0 有没有初始化没什么影响  打开 1.txt 然后用ctrl+a 全选之后检查有没有换行 用 %d 输出 buf 看看读取到什么数据

引用 10 楼 wenpinglaoyao 的回复:应该不关buf是否初始化的事，以下是我的机器运行结果—— #include "stdio.h" #include "string.h" #include "windows.h" FILE *sp;  char *p = "123"; void main() {     char buf[100]; 	if( (sp = fopen("1.txt","r")) == NULL) 		exit(1);  	while( fgets(buf,100,sp) != NULL ) 		printf("buf = %d\n",strlen(buf));  	printf("p = %d\n",strlen(p)); 	fclose(sp); 	scanf("%c",&buf[2]); } 以上是源代码，运行结果都是3，跟楼主的不一样，buf不是4【我的记事本里也只有“123”这些内容】  我用的是linux下的运行，你好像是微软的

strlen计算的是从第一个字符开始，直到遇到结束符'\0'，计算有问题的就是没有正确的结束符。给buf初始化就好了

那是因为使用fgets会在最后，'\0'之前加一个'\n'，所以'\0'之前就是4个字符了。

引用 2 楼 cutmelon 的回复:再看看你的代码，还存在一个问题，你的buf没有初始化，直接读3个字节之后，buf[3]不见得是0，所以你的strlen(buf)是个危险的家伙一语中的，也就是说fgets是否自动添加终结符（'\0'），这是一个需要确认的问题。

一是自己分配的内存需要初始化。这是个好习惯。虽然不一定出问题，但出问题查起来就很麻烦。  二是，如果 123.txt 不止一行文字，那么fgets() 获取一行的字符串时后面是有个换行符和字符串结束符的。如果只有一行只有三个字符123，那么长度应该是3。

跟踪下fgets(buf, 100, fp)这个函数获得buf内容就知道了

引用 12 楼 SEESEECN 的回复:[quote=引用 9 楼 mujiok2003 的回复:] buf中多了个'\n' 应该是源文件的问题吧。跟buf的初始化没关系。msdn上有解释[/quote] 没有说跟初始化有关。  char * fgets ( char * str, int num, FILE * stream );  Get string from stream  Reads characters from stream and stores them as a C string into str until (num-1) characters have been read or either a newline or the end-of-file is reached, whichever happens first.   A newline character makes fgets stop reading, but it is considered a valid character by the function and included in the string copied to str.   A terminating null character is automatically appended after the characters copied to str.

引用 9 楼 mujiok2003 的回复:buf中多了个'\n' 应该是源文件的问题吧。跟buf的初始化没关系。msdn上有解释

引用 10 楼 wenpinglaoyao 的回复:应该不关buf是否初始化的事，以下是我的机器运行结果—— #include "stdio.h" #include "string.h" #include "windows.h" FILE *sp;  char *p = "123"; void main() {     char buf[100]; 	if( (sp = fopen("1.txt","r")) == NULL) 		exit(1);  	while( fgets(buf,100,sp) != NULL ) 		printf("buf = %d\n",strlen(buf));  	printf("p = %d\n",strlen(p)); 	fclose(sp); 	scanf("%c",&buf[2]); } 以上是源代码，运行结果都是3，跟楼主的不一样，buf不是4【我的记事本里也只有“123”这些内容】 呃，fgets是用来读字符串的吗？很久没用这套函数，都忘了，习惯用系统提供的api按字节处理

这个要看你的文件是怎么存的吧，有些程序可能存一个文件结束符在后头，你可以断点看都出来的内容啊，再不济在文件夹里直接看这个文件有多少个字节总会吧


Question: 求助，关于编译通过，运行失败，修改再次编译出问题

原因确实是程序在后台运行，但是无法直接在任务管理器里找到。找到了一种解决办法：打开控制台->输入taskkill -IM XXX.exe /F强制关闭所有XXX.exe相关的服务。  不知道还有没有大神有更好的解决办法

引用 3 楼 zhao4zhong1 的回复:崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 不是这样的，我的意思是编译后的可执行程序崩溃后，就不能再次修改了（我知道问题出在哪，修改源代码编译就通不过），感觉是在后台运行着，但是在任务管理器里也找不到，编译时的提示信息为：ld.exe||cannot open output file bin\Debug\Caesar.exe Permission denied|

引用 1 楼 NexTor 的回复:是不是任务管理器中还有caesar.exe在运行呀，应该不用重启电脑，先在任务管理器中把那个caesar.exe停掉再试一下 任务管理器里没有

是不是任务管理器中还是有caesar.exe没有停掉，应该不用重启电脑的，可以先看看任务管理器中有没有caesar.exe，然后去停掉caesar.exe再试

引用 1 楼 NexTor 的回复:是不是任务管理器中还有caesar.exe在运行呀，应该不用重启电脑，先在任务管理器中把那个caesar.exe停掉再试一下+1，lz可能写的时GUI程序，然后程序没显示界面

把你工程里的DEBUG文件夹里的东西都删除了，重新编译链接就行了


Question: C/C++ printf变参函数的实现机制和源代码

多谢赵老师 @zhao4zhong2 ,@赵4老师 。

理解和讨论之前请先学会如何观察！  计算机组成原理→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对应的汇编并单步执行观察相应内存和寄存器变化。）

一个普通的函数，看源码推荐看VC的，在crt/src目录下就有


Question: 帮忙用c语言解一个sin,cos 的方程式

解方程，高中时候应该会这个，但现在，不会了……

这个是非线性问题，可以用牛顿法（拟牛顿法）求解，你可以搜一下非线性方程组求解，一般会提到的

大哥，这是纯数学题


Question: C指针内存泄露

偶！我明白了，谢谢

p       = num; 这句把p的地址改变了

先malloc后得到内存地址然后赋给p，然后这句p = num又把num的地址赋给p，从而导致之前malloc的内存泄露，最后free(p)是释放num的内存而不是之前malloc得到的内存，也是错误的。


Question: 不明白了，帮忙看看，求解释.

函数声明是为了告诉编译器参数的类型，即使你不写后面的参数的名字也没关系，编译器在检查声明的时候是不检查参数名的，只检查类型。 这里你第一个参数是POINT类型，说明你告诉编译器第一个参数是POINT结构体，而不是一个指针。 //void RotatePoint (POINT pt[], int iNum, int iAngle) //上面和下面效果是是一样的（在函数声明的时候） //void RotatePoint (POINT , int iNum, int iAngle) /***************************************************************************/ 如果你要传入指针，就必须告诉编译器你的参数类型是指针，和参数名没关系。 //void RotatePoint (POINT* pt[], int iNum, int iAngle) //表示你传入了一个指针数组

POINT pt[]  说明pt变量是一个POINT类型的数组   这有啥问题吗？

数组也可以理解为一个指针。传参也是传地址过去咯


Question: BPS基础入门题提交一直runtime error，提交了好多次了

引用 1 楼 user-2 的回复:首先这词是叫bfs…… 其次吧，!vis[x*2]&&x<=50000这么写是要越界访问的。你得两个条件倒一下。 噢噢，明白了

是bfs吧，RE一般就是越界了


Question: 新人求助

先弄清楚scanf_s，它之所以是scanf的安全版本，就是因为加入了长度检测，防止缓冲区溢出 所以scanf_s比scanf 要多一个参数，就是限制的长度  此外scanf_s不是标准库函数，是VS的函数，所以不是很建议使用

后面我了解到的三种读入读出字符串：1 在自己的cpp最上一行加 #define _CRT_SECURE_NO_WARNINGS，这样即可在后面用scanf读取字符串。2，使用scanf_s 但是后面scanf_s("%s", s);即第二个S后面要变成scanf_s("%s",s,400);。3，就是使用fgets，具体用法不祥说


Question: getchar() != EOF返回值问题

getchar()是返回int类型的值，返回-1表示出错或者结尾，然后由getchar()！=EOF运算得true或false来执行while循环。

单独的‘\0’也是无法输出的，VC下会输出a，楼主可以试下

c的值相当于是1，1对应的字符是不可打印的，输出的内容也就不可预测！

引用 5 楼 paschen 的回复:关于可打印字符：  http://zhidao.baidu.com/link?url=Fxh5WHbfIzUqDHYRdZriTmpsilLXMl2rjIOhTpN262s8GWKY7wiLkH2ANydV9VQEoMVMkMVrDPX4Ta65lcWGr_  isprint() 函数用来判断一个字符是否为打印字符  我要的并非特定字符的打印值，是条件语句执行返回值，后来我修改了下while和打印函数，获取到了1或者0两种返回值，直接打印EOF值为-1。

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

引用 楼主 falocn 的回复:  OS环境：win7 64位 软件环境：dev 4.9.9.2  判断文件结束符返回值应该是一个布尔类型值吧0或者1，为什么我这里当输入的不是结束符的时候返回的是笑脸，是结束符的时候第二个putchar（）函数返回的空格？ 我后来以为是变量c的定义应该定义为bool类型，改完之后还是这样~


Question: 请教c51如何提取unicode编码的短信中的数字，存入数组

老师：我想在C51单片机使用，能再指教一下吗。

作为一个C程序员，对  scanf,sscanf,fscanf  printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离手，曲不离口”的。 #include <stdio.h> char s[]="0036003300370032003200330031"; char d[32]; char *p; int i; int main() {     p=s;     i=0;     while (1) {         if (1!=sscanf(p,"003%1d",&d[i])) break;         d[i]+='0';         i++;         p+=4;     }     d[i]=0;     printf("%s",d);//6372231     return 0; }


Question: memcpy优化问题

memcpy(str, "123456789", 100-1); 数组越界了 未定义行为 结果没有意义

memcpy(str, "123456789", 100-1); 这句确实越界操作 了。

太多了，分两部分发  从 src 4B -> dst 4B 你发现确实很快，有尾巴的时候单独处理一下 但是很奇怪你发现有时候性能反而更低了 原来有些平台下内存访问需要对齐的，从 0 开始取 4 字节，一次就完成了，从 3 开始取 4 字节居然要访问两次内存 先从内存取 0~3，扔掉 0~2，再从内存取 4~7，扔掉7，拼出一个 3~6 那肯定不能无脑的从 src 开始搞 4 字节了，你会怎么修改你的 memcpy？ 先想办法把 src 按字节取到某个边界上，再开始 4B copy 好，那么回头看一下你的代码，为什么结果是随机的呢，这与你的 src 和 dst 地址的起始位置是有关系的， 其中部分按字节copy了，另一部分又按 4B copy 了，而且触发的条件是不一样的

哦，还是你啊，那就接着聊聊，首先指出一个问题，你上一个帖子说编译器优化，这是不对的 库函数的优化与编译器的优化是两种概念 假设库函数 memcpy 是你来实现的，按字节来copy基本都能写的出来 但是很快有开发人员向你抱怨 memcpy 性能低下， 因为内存的访问位宽不断在增加，内存很快，但相对于 CPU 终究还是瓶颈 一次访问一个字节压力太大（不考虑 Cache 等问题） 实际上一次内存的访问可以取到 4B，8B ... 那么你怎么来优化你的 memcpy 呢？ 你肯定想设计一个能一次 copy 4B 的 memcpy，不足 4B 或者不是 4B整数倍数怎么办？ 那就特殊处理一下（不可能用除法这种东西的 ^^）

msdn上解释的很清楚。src和dst存储空间重叠的场合，执行结果是未知的。 memcpy(str+2, "123456789", 9)；

void * memcpy ( void * destination, const void * source, size_t num );  To avoid overflows, the size of the arrays pointed by both the destination and source parameters, shall be at least num bytes, and should not overlap (for overlapping memory blocks, memmove is a safer approach).

楼上解释得很清楚了 还有第一个memcpy也有问题，字符串没有那么大，你访问了不属于你的内存

引用 10 楼 zhao4zhong1 的回复: 因为 copy的语义是操作后新目标和旧源内容相同且旧源的内容保持不变。 move的语义是操作后新目标和旧源内容相同且旧源的内容不一定保持不变。  所以 在源和目标内存覆盖的情况下，根本不可能实现copy！只能实现move    如果连这两者的语义都分不清的码农非要在不可能实现copy的情况下使用copy，那只能后果自负了！


Question: c语言入门中，遇到一疑惑求解答

因为减号两边的操作数是两个表达式，这两个表达式的求值顺序是不确定的


Question: 求大家帮忙看看这段代码哪里出错了？

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

double用%lf float用%f

仅供参考#include <stdio.h> char s[]="123 ab 4"; char *p; int v,n,k; void main() {     p=s;     while (1) {         k=sscanf(p,"%d%n",&v,&n);         printf("k,v,n=%d,%d,%d\n",k,v,n);         if (1==k) {             p+=n;         } else if (0==k) {             printf("skip char[%c]\n",p[0]);             p++;         } else {//EOF==k             break;         }     }     printf("End.\n"); } //k,v,n=1,123,3 //k,v,n=0,123,3 //skip char[ ] //k,v,n=0,123,3 //skip char[a] //k,v,n=0,123,3 //skip char[b] //k,v,n=1,4,2 //k,v,n=-1,4,2 //End.


Question: 关于未知长度的数组定义

哎，我试了一下，无论如何都需要知道一个需要的空间大小，否则怎么都不行的！谢谢各位的回答，让我也学习到不少东西！

引用 7 楼 shenwansan_gz 的回复:lz的意思是定义一个完美的字符数组，可以储存任意长度的字符串？ 如果是这个意思的话，malloc也是要求知道分配内存的长度的吧！       比较简单的一个做法是，使用加一个参数来说明数组长度，以便分配内存 但是我需要的长度会随程序的运行和用户输入来决定的啊，用户说啥时候结束就啥时候结束输入，这样的话malloc就不好用了！

引用 4 楼 Sean10 的回复:定义指针形式，再具体使用动态分配内存就好了。 不过这里还是需要知道你输入元素的长度，一般还是需要另外定义一个数组a[MAX]来判断需要分配的内存； 所以一般情况下一维数组不太用malloc，在二维及以上的时候用得比较多 我们拿二维举个例子，比如一个arr[][8]，我现在需要一个字符串数组，但是我不知道几个字符串，只知道是每个字符串有最多7个字符。而且字符串个数随用户输入而变的。我该怎么办，如果我就像前面那样定义的话，二维数组是连续存放的，后续定义的一些空间就会接在他后面，再往arr里写字符串就会覆盖后面的数据。

引用 2 楼 paschen 的回复:用标准模板库的std::string，它会根据你的字符串长度在堆上自动分配内存，而且效率也挺高，LZ可以研究下! 好的，需要深入研究下！

引用 1 楼 anlory 的回复:p = (int *) malloc (sizeof(int));这就是动态数组的模型， 但是这样的话在内存中由于是动态数组，我事先什么都没有写，只是一个int大小的空间，我后面又分配了一个其他空间，会不会在int的空间后面接着分配出来？如果这样的话我写第二个int的时候会不会把第二次分配的空间覆盖掉？


Question: 关于结构体字段名已参数传入的问题

直接写成成员函数不就行了嘛

进行比较，如果结构体中字段较多的话，用一个switch case语句，当字符串是A，在A字段赋值，当字符串是B，在B字段赋值......

http://bbs.csdn.net/topics/390887494 这个帖子和楼主需求相似，该帖一楼回答得分。  Idle_ 回复于： 2014-09-17 09:21:08 c/c++可不是解释执行的语言。编译后结构体中并不存在什么名字。 想实现目的那么需要你手工建立一个名字字符串和结构中偏移量的对照表然后查表从名字获取偏移量再根据偏移量去读取具体数据。

上面各位回答似乎没对需求。 楼主是想通过参数指定要赋值的结构体变量， 难点应该是判断结构体变量名是否与输入参数一致。但是，这个问题似乎不好办。 关注，等高人解答。

struct helloworld{    char hello[32];    char world[32]; }test;  set_default(test.hello, "123321"); 只会这样

结构体内字段偏移量的问题是可以解决的 有一个经典的宏 #define offsetof(TYPE, FIELD)  ((size_t)&((TYPE *)0)->FIELD) 这是计算 FIELD 在结构中的偏移量，利用了 0 地址的一个小把戏  你可以用结构指针再加这个偏移量取得字段地址，用来赋值 你这个问题我还是不建议这么搞

用strncpy确保数组拷贝不越界

set_default("hello", "123321"); set_default("world", "12321"); 你是要这两条语句分别赋值hello和world？那在函数里边写个字符串判断就行了吧。还是你要动态的改变变量名？那好像不行吧

引用 2 楼 zhao4zhong1 的回复:小心驶得万年船：set_default(struct helloworld * str,  const char *item, const char *value) {         strncpy(str->hello, item ,31);(str->hello)[31]=0;         strncpy(str->world, value,31);(str->world)[31]=0; }  先不管item和value是否为NULL 就你这种作风，就像揩完屁股之后还要验一下是否擦净 唉。 赵老湿啊赵老湿， 你好湿 好诗！！

set_default(struct helloworld * str,  const char *item, const char *value) {         strcpy(str->hello, item);         strcpy(str->world, value); }   是这个意思吗


Question: 新手入门，求教一个简单的问题

引用 9 楼 wplink 的回复:我搜了，没搜到  谷歌我又打不开（不小心删掉了goagent） 感谢感谢 84.15.64.35

引用 7 楼 u012421456 的回复:4楼是对的 最好按着要求的格式写 int main() {         ////         return 0; }  --是自减1 其实这种问题，你可以自己通过搜索找到答案的我搜了，没搜到  谷歌我又打不开（不小心删掉了goagent） 感谢感谢

return 0不写是错误的，只不过编译器容忍了这个错误，你应该写上

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

我只能看懂简单的回复。。。我刚学呢。。谢谢各位了。。。学完再重来一遍应该问题会少一点。。大家新年快乐

举一个常用得main函数返回值得作用 :在linux系统中  C程序 常常和shell脚本集合 做一些事情，而shell调用C程序得时候  可以通过 echo $? 取出一个程序得返回值,而且返回值可以得到程序得执行状态,进行一些处理。这个时候就显得有用了。  第二点 楼上有人说 main 函数主动给你加retrun 0;在我记忆里， 这是好像是一个错误得说法，大多数编译器假设 在x86系统下 是返回ax 中得值 (如果不加return 0);

int main（）{...}本来就是一个要求有返回int型数据的一个函数，所以说要求有return 0；你写void main（）{...}就不用了。

1.编译器自动给你加了return 0 2.“--”就是自减一的意思

刚刚学习，不懂的就上来问下了，望不吝赐教啊。。感谢。。


Question: c语言小问题

引用 4 楼 zhao4zhong1 的回复:关于自己是否适合编程的很简单的测试： 在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案：  A里面有10处以上文字或标点错误 B里面没有文字或标点错误并敢为此跟人打赌 C里面没有文字或标点错误并且字体和排版完全与原稿一致 D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感  A不适合编程（理由：打字准确度偏低、粗心大意） B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念） C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证） D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！）  如果想从A变成B的话，到我的资源http://download.csdn.net/detail/zhao4zhong1/4084259里面下载“适合程序员的键盘练习”  理解和讨论之前请先学会如何观察！  计算机组成原理→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对应的汇编并单步执行观察相应内存和寄存器变化。）  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！+1

随便找本讲c或者c++的书，前三章之内必会告诉你反斜杠+数字是什么意思的............

最好找本教材来熟悉一下语法。

这是啥输出啊！没看到这样输出的。 printf(" %c  %c  %c  %c" , '41','\41',"41",41")中，‘41’，‘\41’，"41",41分别是什么意思！ %c是输出单个字符 \表示的是转义符 你可以将他设置为变量，一一输出。 初学C时，最后找本教材来熟悉一下语法。

查MSDN是Windows程序员必须掌握的技能之一。

这是个蛮有意思的问题，一般情况下单引号表述的是字符而不是字符串。 所以第一个的‘41’就有点费解，不过编译器既然能够编译过就有他的道理。 用VC6.0试验分析了下，发现在VC6.0环境下‘41’实际上是个32位的值0x00003431 这样第一个就有答案了0x00003431 强制类型转换为char型值就是0x31就是字符‘1’ 再举个例子 int a = '1234' 那么a的值就是0x31323334 这样可能更容易理解‘xxxx'的含义，但如果int a = '12345' 那么编译器就会报错了。  第二个‘\41’这个实际上就是转义字符\ddd 八进制的应用，八进制的41就是十进制的33，十六进制的0x21也就是字符'!'  第三个"41"的值是不固定的，因为返回的是字符串"41"地址的低8bit值，可能debug & release版本值就不一样了，要看编译器把"41"字符串放在哪儿。  第四个41就很简单了，十进制的41也就是十六进制的0x29也就是字符')'

你在哪看到这么输出的

1  !  �  )


Question: 统计数组中重复的元素（简易版统计单词频率，有图有真相）

应该是int *end=numbers +100吧？引用 3 楼 fly_dragon_fly 的回复:1 . 直接加起来减去5050（1+..100) 2.  int receptionist(int numbers[]) {      int s=0;      int *end=numbers +101;      while(numbers!=end)            s +=*numbers++;      return s-5050; }

唉妈, 怎么老写秃噜....  int fun(int* nums, int count) {   map<int, int> m;   for(int n = 0; n < count; n++)   {     auto ret = m.insert(std::pair<int,int>(nums[n], nums[n]));     if(ret.second == false)       return ret.first->second;   }   return 0; }

求和减去1-100的和

直接求和减去5050

由于数的范围是100，计数会比较简单  #include <stdio.h> #include <stdlib.h> #include <time.h>  #define N 100  int receptionist(int numbers[]) {     int i;     int count[N] = {0};      for (i = 0; i < N + 1; i++)     {         if (count[numbers[i]]++)         {             return numbers[i];         }     }      return 0; }  int main(int argc, char *argv[]) {     int i, j;     int numbers[N + 1];     int pos, num;      srand(time(NULL));      pos = rand() % 101;     num = rand() % 100 + 1;      numbers[pos] = num;     j = 1;     for (i = 0; i < N + 1; i++)     {         if (i != pos)         {             numbers[i] = j++;         }     }      for (i = 0; i < N + 1; i++)     {         printf("%3d ", numbers[i]);         if (i % 10 == 9)         {             printf("\n");         }                  }     printf("\n=======================================\n");      printf("%d\n", receptionist(numbers));     return 0; }

方法一：将101个正整数相加，再减去“1到100的和”。 方法二：遍历101个正整数，用一个位序列记录某个数是否出现过。 方法一要作固定次数的加法运算和一次减法运算，方法二可能会提前发现重复数。

全加起来减去 n*(n+1)/2 就行了吧，n==100.

#include <stdio.h> #include <windows.h> #include <ctime>  //计算的原理 //(101个数字的和)-(1至100的和)==重复的那个数   int receptionist(int numbers[]) {     int sum101 = 0;     for (int i = 0; i < 101; ++i)     {         sum101 += numbers[i];     }      //自然数前n项[0-n]和公式n*(n-1)/2     //前101项和[0-100]     int sum100 = 101*(101 - 1)/2;      return sum101 -sum100; } int main() {     //初始化101个数     int arr[101] = {0};     for (int i = 0; i < 100; ++i)     {         arr[i] = i + 1;     }     srand(unsigned(time(0)));     arr[100] = (rand() % 99) + 1;//这个是重复的数      //计算     printf("实际重复的是 %d\n", arr[100]);     printf("计算重复的是 %d\n", receptionist(arr));     system("pause"); }

//不考虑空间复杂度的话 int receptionist(int numbers[]) { 	int N[101]; 	for(int a = 0; a < 101; a++) 	{ 		N[a] = 0; 	} 	for(int i = 0; i < 101; i++) 	if(N[numbers[i]] > 0) 	{ 		return numbers[i]; 	} 	else 	{ 		N[numbers[i]]++; 	} 	return 0; }


Question: 一道ＡＣＭ题的疑惑

两个输出有空行，应该\n\n吧

fgets(s,80,stdin);if ('\n'==s[strlen(s)-1]) s[strlen(s)-1]=0;//去掉字符串末尾的'\n'

引用 18 楼 zhao4zhong1 的回复:所以建议楼主读串时不能用scanf("%s",s)而要用fgets(s,80,stdin); 的确有你说的那个输入数据中存在Ｈ　Ｈ　Ｈ　 的问题，我再试试

Each test case will contain a single character string of up to 80 non-blank characters.  这句话里面的non-blank characters只能按下面两种意思中的一种来理解；而不能按两种意思同时成立来理解。 ①非空格字符组成的字符串（字符串中没有空格，但可能是空串） ②非空的字符串（字符串不是空串，但可能其中包含空格） 而你的代码无论按①来理解还是按②来理解都通不过。  你试试最简单的输入 1  a ba b 你的代码能不能如期输出3

引用 13 楼 zhao4zhong1 的回复:也可能 每项测试数据包含一个最长80个非空的字符串  但你 考虑了每行字符由一个空行间隔了吗？ 考虑了字符串中有空格的情况了吗？ 比如输入文件是： 2  H_ H_ H_   HaHaHa 上面的下划线实际不是下划线而是空格，为表达清楚用下划线代替。 ．．题目说了ｎｏｎ－ｂｌａｎｋ　ｃｈａｒａｃｔｅｒ

引用 12 楼 user-3 的回复:Two consecutive output are separated by a blank line. 它没说最后一个数据后面也要输出空行  代码暂时没看出啥问题 我尝试下把最后一次空行给弄掉

引用 11 楼 zhao4zhong1 的回复:The first line of the input file will contain a single integer N indicating how many test case that your program will test followed by a blank line. Each test case will contain a single character string of up to 80 non-blank characters. Two consecutive input will separated by a blank line. 输入文件的第一行是一个整数，表示后面有多少项测试数据。 第二行是空行。 每项测试数据包含一个最长80个非空格字符组成的字符串。两个连续的测试数据之间用一个空行间隔。  所以输入文件可能是： 1  HoHoHo 也可能是 2  HoHoHo  HaHaHa 也可能是 3    HoHoHo  HaHaHa 我觉得。 可是就算是这样，我在自己机子上测试得到的答案还是对的，提交测评机就不行了．．您能帮我看看我贴的代码么，我弄了一天还是没找出问题所在．谢谢

引用 9 楼 zhao4zhong1 的回复:题目中没有说测试数据没有空串。   Each test case will contain a single character string of up to 80 non-blank characters

题目中没有说测试数据没有空串。

引用 5 楼 zhao4zhong1 的回复:a aa aaa ？ 取最小周期，．．测试数据没有空串

引用 3 楼 zhao4zhong1 的回复:abababab 的最小周期应该是几？  ababab最小周期为２ hello最小周期为５

空串 ？

a aa aaa ？

#include<stdio.h> #include<string.h>  #define MAX 90 void periodic(const char *s);  int main(void){ int n; char s[MAX]; scanf("%d",&n); for(int i=0;i<n;i++){ scanf("%s",s); periodic(s); } return 0; }  void periodic(const char *s){ int len,k; len=strlen(s); for(int i=1;i<=len/2;i++){ char b[MAX]=""; if(len%i==0){ k=len/i; //重复次数 for(;k>0;k--){ strncat(b,s,i); } if(!(strcmp(s,b))){ printf("%d\n",i); goto next; } } } printf("1\n"); next: printf("\n"); }  不好意思．．刚来，没弄成代码．．这样可能清楚点

abababab 的最小周期应该是几？

我的思路如下：如果一个字符串（Ａ）能由某个字符串（Ｂ）重复，那么那个字符串Ａ的长度必然是Ｂ的整数倍，那就可以求出Ｂ需要ｎ次才能变成Ａ．．重复那个次数使字符串ｂ变成重复ｎ次Ｂ，再判断ｂ和Ａ是否相等． 我自己做的测试得到的答案都是对的（也可能只是我认为），但是提交之后总是ｗｒｏｎｇ　ａｎｓｗｅｒ


Question: 关于数据结构中广义表搜索的问题。。

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


Question: 清空链表时候程序崩溃

引用 5 楼 cutmelon 的回复:[quote=引用 4 楼 u012309996 的回复:] [quote=引用 1 楼 cutmelon 的回复:] 崩溃在最后一句了吧，当时p==NULL，你还调用p->pnext 去掉还是崩溃[/quote] 呵呵，我没仔细看所有的代码，就看了最后一个函数，最明显会崩溃的地方就上面说的了 如果还崩溃，估计就是free这句了，当时的p是否一个无效指针，自己调试一下吧[/quote] 闲着无聊帮你看了一遍，你这个问题啊，哈哈 你不要只是把 p->pnext=NULL;去掉了事，要把它改成 pHead->pnext=NULL; 因为你的主函数在释放之后又遍历了一次，这次是会崩溃的哦，因为你的链表头后续了一个无效指针。 另外主函数退出之前没有释放pHead，有内存系泄露啊

引用 4 楼 u012309996 的回复:[quote=引用 1 楼 cutmelon 的回复:] 崩溃在最后一句了吧，当时p==NULL，你还调用p->pnext 去掉还是崩溃[/quote] 呵呵，我没仔细看所有的代码，就看了最后一个函数，最明显会崩溃的地方就上面说的了 如果还崩溃，估计就是free这句了，当时的p是否一个无效指针，自己调试一下吧

引用 1 楼 cutmelon 的回复:崩溃在最后一句了吧，当时p==NULL，你还调用p->pnext 去掉还是崩溃

好吧，我上面说的话有些不负责任，你可以搜索，如果不清楚再来问。

跟踪调试可以解决绝大多数的问题。 想知道怎么跟踪吗？网络搜索吧。满世界都是。

崩溃在最后一句了吧，当时p==NULL，你还调用p->pnext


Question: 新手 数组 问题求助

引用 1 楼 a1193561652 的回复:c，d未初始化。然而二楼早已看穿真相

谢谢啊 这错误太低级了

c，d未初始化。


Question: 怎么入手蓝牙开发？

到kernel里面翻翻源码吧   肯定有的

bluez 开源蓝牙代码

可以看一下中国电子网

坐等，也想学习

引用 1 楼 user-5 的回复:如果硬件可以不用关心得话，做单片机c语言控制蓝牙得代码应该挺多，再搞懂一下蓝牙的通讯协议，就可以测试一下了，当然用arm,安卓嵌入式得系统，更方便了，直接用封装好了的通讯socket多谢回复，有这方面比较好的源码网站推荐么，我上pudn里搜了几个都不是完整的


Question: 在快速使用WM_LBUTTONDOWN的时候怎么不触发WM_LBUTTONDBLCLK

createwindow是WS_风格，不能修改CS的，确实是不需要CS_DBLCLKS,这需要在RegisterClass的时候修改 比如 ：      WNDCLASS  wc;    wc.style =0 ; // 就是这里    ...    RegisterClass(&wc);    CreateWindow 用这个注册的窗口就可以了

我会告诉你在双击时发送单击消息也可么

CreateWindow()函数创建窗口，其中有一个参数是窗口风格，把这个参数改成没有CS_DBLCLKS的就行了。

引用 1 楼 a1193561652 的回复:窗口不加CS_DBLCLKS风格就好了。  初学者 能不能具体一点


Question: 求找错！！！

引用 7 楼 wanbinbing 的回复:怎么没贴出正确答案？ Result : Accept #include <stdio.h>  int gcd(int a, int b) {     int tmp, r, mul;     if(a < b)         tmp = a, a = b, b = tmp;     while(b!=0)     {         r = a % b;         a = b;         b = r;     }     return  a; }  int lcm(int a, int b) {     return a/gcd(a, b)*b; }  int main() {     int n, i, min;     int str[120];      while(scanf("%d",&n) != EOF)     {         for( i = 0; i < n; i ++)         {             scanf("%d",&str[i]);         }         if(n == 1)         {             printf("%d\n",str[0]);             continue;         }         min = lcm(str[0], str[1]);         for(i = 2; i < n; i ++)         {             min=lcm(min,str[i]);         }         printf("%d\n",min);     }     return 0; }

0和1已经得到公倍数了，i应该从2开始， WA的原因我想应该是有溢出 在求lcm时，不应该先做乘法，可以会溢出 ，应该差不多这样  int lcm(int a,int b) {     return a/gcd(a,b) * b; }

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

怎么没贴出正确答案？

引用 3 楼 adusuccessfully 的回复:1、求最小公倍数最起码涉及到两个数，所以我认为没必要判断n=1的情况； 2、1楼的解答是对的，第二个for循环n要从0开始； 3、我对楼主的程序加了一些说明性的汉字，如下：  #include <stdio.h> int gcd(int a, int b) { 	int tmp, r, mul; 	mul = a * b; 	if(a < b) 		tmp = a, a = b, b = tmp; 	while(b!=0) 	{ 		r = a % b; 		a = b; 		b = r; 	} 	return mul / a; }  int main() { 	int n, i, min; 	int str[120]; 	printf("请输入要输入数的个数n(n>=2):"); 	while(scanf("%d",&n) != EOF) 	{ 		printf("请输入%d个数:",n); 		if(n == 1) 		{ 			printf("要求最小公倍数，至少要有两个数\n"); 			printf("请输入要输入数的个数n(n>=2):"); 			//printf("%d\n",str[0]); 			continue; 		} 		for( i = 0; i < n; i ++) 		{ 			scanf("%d",&str[i]); 		} 		min = gcd(str[0], str[1]); 		for(i = 0; i < n; i ++) 		{ 			min=gcd(min,str[i]); 		} 		printf("这%d个数的最小公倍数是：%d\n",n,min); 		printf("请输入要输入数的个数n(n>=2):"); 	} 	return 0; }  下面是测试结果： 其实我是想说的是i从2开始，因为他前面有一句min = gcd(str[0], str[1])；不过应该不影响结果，只是做一次无用的运算，但是楼主说有问题我想会不会是a*b溢出了。

100000 100000

for(i = 1; i < n; i ++)  {         min=gcd(min,str[i]);  } i从1开始？


Question: 求助：关于debug error的问题！

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

引用 4 楼 xingxing991219 的回复:[quote=引用 1 楼 user-4 的回复:] 我之前因为SCANF 浮点变量也老是出现这个问题。你试下把DOUBLE 变量先赋初值。在SCANF前面加句fahrenheit=0;  就是这样：（我加了一个fahrenheit = 0;） [/quote] double的要换成%lf就可以了。  #include<stdio.h>  int main() {     int input_type;  //用于判断输入是否为数字  是为1，否为0     double fahrenheit=0;       input_type = scanf("%lf",&fahrenheit);     printf("%d\t%lf",input_type, fahrenheit);       return 0; }

引用 1 楼 user-4 的回复:我之前因为SCANF 浮点变量也老是出现这个问题。你试下把DOUBLE 变量先赋初值。在SCANF前面加句fahrenheit=0;  就是这样：（我加了一个fahrenheit = 0;）

引用 1 楼 user-4 的回复:我之前因为SCANF 浮点变量也老是出现这个问题。你试下把DOUBLE 变量先赋初值。在SCANF前面加句fahrenheit=0;  可是我初始化了之后，fahrenheit的值就一直变成了0，scanf完了也不会改变，初始化的值是多少它就一直是多少

出现的问题是这个 “runtime error R6002   - floating point not loaded” 像楼上那样写就可以解决这个问题。 下面是从网上找到的解答这是由于scanf的一个bug造成， 在前面一行加入float fahrenheit=0; 使得scanf使用浮点数前先初始化过浮点数就OK.


Question: 帮忙写个程序

问题描述的不清楚，而且，要代码干什么，学习不是这么干的，还是自己好好看看书吧

这个可以有引用 1 楼 wenpinglaoyao 的回复:#include<windows.h> #include <stdio.h>   int piao[8];  void toupiao(int k) { 	int a[8]={0}; 	int i,j;  	for(i=0;i<6;i++) 	{ chongxin: 		scanf("%d",&j);  		if(a[j]==1) 		{ 			printf("您的投票重复，请再次重新投票\n"); 			goto chongxin; 		} 		if(j==k) 		{ 			printf("您不可以投自己的票，请重新投票\n"); 			goto chongxin; 		} 		if(j>=8||j<0) 		{ 			printf("无法识别的编号，请重新投票\n"); 			goto chongxin; 		}  		piao[j]++; 		a[j] = 1; 	} }   int main() {     int i; 	for(i=0;i<8;i++) 	{ 		printf("现在请%d号选手投票:\n",i); 		toupiao(i); 	}  	for(i=0;i<8;i++) 	printf(" %d",piao[i]); 	scanf("%d",&i); }