Mxode/CSDN-C_Language-2013_2023 huggingface dataset:
user-0 提问: C语言函数问题

回复:
user: user-1
content: 函数还能在main中声明啊？

user: user-0
content: 引用 2 楼 paschen 的回复:Research函数中，把InsertSort(int *arr, int n);改成：void InsertSort(int *arr, int n);  要有返回类型，这才算一个函数声明 回答到点子上了，改了之后就编译成功了，是我太粗心了，谢谢

user: user-2
content: Research函数中，把InsertSort(int *arr, int n);改成：void InsertSort(int *arr, int n);  要有返回类型，这才算一个函数声明

user: user-3
content: #include<stdio.h> #include<stdlib.h> #include<string.h>  struct Number { 	int a; 	struct Number *next; };  /*    函数声明，Insert（）是插入函数，Delete（）是删除函数，Research（）是查询函数    InsertSort（）是插入排序函数  */ void Insert(struct Number *first,int x); void Delete(struct Number *first,int x); void Research(int *arr,int n,int x,struct Number *first); void InsertSort(int *arr,int n);  int main() { 	int n,x; 	char ch; 	int i; 	struct Number *first=(struct Number *)malloc(sizeof(struct Number));//头结点，初始化头结点 	first->a=0; 	first->next=NULL; 	while(scanf("%d",&n)!=EOF) 	{ 		int *arr=(int *)malloc(sizeof(int)*(n+1));//用一个数组来放与x异或的值，初始化 		memset(arr,0,sizeof(int)*(n+1)); 		for(i=0;i<n;i++) 		{ 			scanf(" %c %d",&ch,&x); 			switch(ch) 			{ 				case '+': Insert(first,x);break; 				case '-': Delete(first,x);break; 				case '?': Research(arr,n,x,first);break; 			} 		} 		printf("%d\n",arr[1]); 	} } void Insert(struct Number *first,int x) { 	struct Number *p=first; 	while(p!=NULL) 	{ 		p=p->next; 	} 	struct Number *s=(struct Number *)malloc(sizeof(struct Number)); 	s->a=x; 	p=s; 	s->next=NULL; } void Delete(struct Number *first,int x) { 	struct Number *q=first; 	struct Number *p=q->next; 	while(p!=NULL) 	{ 		if(p->a==x) 		{ 			q->next=p->next; 			free(p); 			return; 		} 		q=q->next; 		p=p->next; 	} } void Research(int *arr,int n,int x,struct Number *first) { 	//InsertSort(int *arr,int n); 	int i=1; 	struct Number *p=first; 	while(p!=NULL) 	{ 		arr[i]=p->a^x;//与链表中的每个数异或求最大值 		p=p->next; 		i++; 	} 	InsertSort(arr,n);//排序，是数组第一个数为最大值 }  void InsertSort(int *arr, int n) { 	int i,j; 	for(i=2;i<=n;i++) 	{ 		arr[0]=arr[i]; 		for(j=i-1;arr[j]<arr[0];j--) 			arr[j+1]=arr[j]; 		arr[j+1]=arr[0]; 	} } 参考一下吧  函数声明建议放在函数外，不建议放在main函数内，这样只会让main函数逻辑更乱。 若被调用函数在调用函数之下，建议在调用函数外，前面提前声明一下即可。
user-0 提问: 关于结构体和共用体的数组成员初始化问题

回复:
user: user-1
content: char *t1="str";//编译器支持：将t1的值初始化为常量字符串"str"的起始地址 char t2[5]="str";//编译器不支持：将常量字符串"str"的内容复制一份到&t2[0]开始处  我猜。

user: user-0
content: 引用 15 楼 zhao4zhong1 的回复:对结构体某一成员初始化是语法糖。 语法糖越甜，编译调试查错越苦！ 把有限的生命浪费在品尝/品鉴无穷多种的语法糖中，我认为不值当。 这不是什么语法糖为了找方便捷径什么的事情。这是我认为我对这个知识点有问题，我想要解决它，才来问问题，难道我心里明明对这个地方不懂。要装着没这个问题一样过了它吗？ 或者，老师，这个问题能不能帮助我一下，我问了很多人，还是无法解决

user: user-1
content: 对结构体某一成员初始化是语法糖。 语法糖越甜，编译调试查错越苦！ 把有限的生命浪费在品尝/品鉴无穷多种的语法糖中，我认为不值当。

user: user-0
content: 引用 13 楼 xcv163169 的回复:[quote=引用 12 楼 weixin_39587157 的回复:] 打错了      a.t  代表的是字符数组t 的首地址  首地址这个问题。我也不知道具体的。但是初始化的时候应该可以吧。毕竟共用体里是可以这样初始化的。你说的第二点是我觉得是赋值吧，赋值跟初始化不一样吧。。[/quote]  我看的教材上有这样的话 C99标准允许对某一成员初始化，如： struct Student b={.name="xxxxxx"}；前面声明的时候struct Student{  long int num; char name[20] };

user: user-0
content: 引用 12 楼 weixin_39587157 的回复:打错了      a.t  代表的是字符数组t 的首地址  首地址这个问题。我也不知道具体的。但是初始化的时候应该可以吧。毕竟共用体里是可以这样初始化的。你说的第二点是我觉得是赋值吧，赋值跟初始化不一样吧。。

user: user-2
content: 打错了      a.t  代表的是字符数组t 的首地址

user: user-2
content: struct Stu a={.t="sss"};  这样初始化是不行的，因为a.t  代表的是字符数组a的首地址，相当于常量，怎么可以给 a.t 赋值呢？  1.如果你想初始化,最好整体初始化 struct Stu ={5,"sss" }; 2.如果你想单个成员初始化的话；加头文件#include<string.h> struct Stu *a,t; a=&t; a->s=5; strcpy(a->t,"sss");

user: user-3
content: 调试，或者依次输出共用体里那个数组的元素看看，不用字符串输出，(我一般这么查问题)

user: user-0
content: 引用 8 楼 no_emotion 的回复:楼主，你试试把.t改为.t[ ]  .t表示的是a中的成员a.t，t已经定义好了[5]个长度，我也试了这样是不行的

user: user-3
content: 楼主，你试试把.t改为.t[ ]

user: user-4
content: 引用 5 楼 xcv163169 的回复:引用 3 楼 no_emotion 的回复:初始化字符数组，如果输出用%s，初始化最后必须主动加\0，结构体和共用体应该都这样，但是你用四个字符初始化5数量的数组，为什么能成功就不知道了(新手，水平有限).对字符数组初始化的时候不是会在最后加上\0算一个元素吗 '\0'和数值0是相等的。即'\0'字符的ASCII值对应的十进制是0，即0 == ‘\0'， 你在判断字符串结束标记时，可以直接判断是否等于0 比如下面就是计算字符串的长度的逻辑代码，  char src[] = "hello"; int i = 0; while (src[i] != 0)    /*也可以直接while (src[i])*/     i++;

user: user-0
content: 引用 4 楼 cfjtaishan 的回复:估计你的编译器不是支持C99的， C99标准支持这样的结构体的初始化。如果不支持，建议你一个个的赋值，或者先这样初始化 struct Stu a = { 0 }; 可是对共用体指定第二项数组成员初始化的时候那里不是c99才支持的么。额。我用的是DEV-CPP 5.4.0

user: user-0
content: 引用 3 楼 no_emotion 的回复:初始化字符数组，如果输出用%s，初始化最后必须主动加\0，结构体和共用体应该都这样，但是你用四个字符初始化5数量的数组，为什么能成功就不知道了(新手，水平有限).对字符数组初始化的时候不是会在最后加上\0算一个元素吗

user: user-4
content: 估计你的编译器不是支持C99的， C99标准支持这样的结构体的初始化。如果不支持，建议你一个个的赋值，或者先这样初始化 struct Stu a = { 0 };

user: user-3
content: 初始化字符数组，如果输出用%s，初始化最后必须主动加\0，结构体和共用体应该都这样，但是你用四个字符初始化5数量的数组，为什么能成功就不知道了(新手，水平有限)

user: user-3
content: 引用 1 楼 FOR_SEEK的回复:结构体可以对某个变量赋值，用{.变量名=值...}就行，共用体是共用一个地址，只需要初始化一个即可， 刚没加载出来，没看完，不懂

user: user-3
content: 结构体可以对某个变量赋值，用{.变量名=值...}就行，共用体是共用一个地址，只需要初始化一个即可，
user-0 提问: 杭电OJ出现Runtime Error (ACCESS_VIOLATION)，麻烦各位前辈帮我看下原因~

回复:
user: user-1
content: #include <stdio.h> #include <stdlib.h>  int main(int argc, char* argv[]) {     int i,j,n,m;     int num = 0;     float sum = 0, aver = 0;     float **stu, *course_avr_list;      while(scanf("%d %d", &m, &n) == 2)     {         course_avr_list = (float *)malloc(sizeof(float) * n);         if (!course_avr_list)             exit(0);         stu = (float **)malloc(sizeof(float *) * m);         if (!stu)             exit(0);         for(i = 0; i < n; i++) {             stu[i] = (float *)malloc(sizeof(float)*(n + 1));             if (!stu[i])                 exit(0);             course_avr_list[i] = 0;         }         for(i = 0; i < m; i++)         {             for(j = 0; j < n; j++) {                 scanf("%f", &stu[i][j]);                 sum += stu[i][j];                 course_avr_list[j] += stu[i][j];             }             aver = sum / m;             stu[i][n] = aver;             sum = 0;         }         for (i = 0; i < m; i++)             printf("%.2f\t", stu[i][n]);         printf("\n");          for (j = 0; j < n; j++) {             course_avr_list[j] /= n;             printf("%.2f\t", course_avr_list[j]);         }         printf("\n");          for (i = 0; i < m; i++) {             for (j = 0; j < n; j++)                 if (stu[i][j] < course_avr_list[j])                     break;             if (j >= n)                 num++;         }         printf("\n%d\n",num);         num = 0;         for (i = 0; i < n; i++)             free(stu[i]);         free(stu);         free(course_avr_list);      }     return 0; }  参考一下吧 对于学生成绩，不建议是用double类型，因为float类型完全能够表示，double比float多占内存空间； 建议减少循环次数，能将循环次数合并的则合并，循环次数增加会导致时间复杂度高，也一定原因上会加剧running time。 malloc需要多少就申请多少，没必要都要多申请一个。 malloc申请的空间需要手动释放，因此使用完之后要记着释放。如果有多次测试数据，那么若不释放会导致内存泄露。

user: user-2
content: a=(double **)malloc(sizeof(double *)*(i+1)); for(n=0;n<j;n++)  a[n] = 上面分配了  i+1个指针单元， 下面0～j, 当j大于i+1时，下面就越界了  输入的参数应先做判断是否合法， 比如上面输入负数会出什么问题？ 分配的缓冲区应及时清理 变量最好是起个比较知意的名字， 这样不容易出错  后面的自己慢慢分析吧  还有

user: user-0
content: 对了，分配内存那里，一开始写的分配的大小都是i个和j个，后来实在找不出问题乱改就试了试多分配一个...
user-0 提问: char *src = "Hello";是合法的语句吗？

回复:
user: user-1
content: char* src = "hello"; VS2017实测不合法。 如果需要内容可修改，可用数组，如果用指针的话我真想不出来编译器怎么分配内存，如果访问越界怎么办 如果不需要修改，为什么不加const，你这样编码风格就不对

user: user-2
content: char *src = "Hello";是合法的语句吗？ 是合法的； Hello是常量字符串，存储在常量区，常量字符串是不能修改的。  加上赵4老师：#pragma comment(linker,"/SECTION:.rdata,RW")以后，确实能修改了。但//加这句可以让常量区可写，后果自负！

user: user-3
content: 单纯看这一点，完全合法。

user: user-4
content: 不要纠结各种常量了，这个世界上唯一不变的就是变化。用API WriteProcessMemory还能修改正运行的其它进程的内存里面的所谓常量呢！

user: user-4
content: 引用 9 楼 shihengzhen101 的回复:[quote=引用 8 楼 zhao4zhong1 的回复:] [quote=引用 6 楼 shihengzhen101 的回复:] [quote=引用 4 楼 zhao4zhong1 的回复:] #pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！  你这句话可是分发了大半个论坛[/quote] 我哪句话不是分发了大半个论坛？[/quote] 说的也对啊，我竟无言以对！[/quote]

user: user-5
content: 引用 8 楼 zhao4zhong1 的回复:[quote=引用 6 楼 shihengzhen101 的回复:] [quote=引用 4 楼 zhao4zhong1 的回复:] #pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！  你这句话可是分发了大半个论坛[/quote] 我哪句话不是分发了大半个论坛？[/quote] 说的也对啊，我竟无言以对！

user: user-4
content: 引用 6 楼 shihengzhen101 的回复:[quote=引用 4 楼 zhao4zhong1 的回复:] #pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！  你这句话可是分发了大半个论坛[/quote] 我哪句话不是分发了大半个论坛？

user: user-5
content: 引用 1 楼 cfjtaishan 的回复:是。在有些编译器里可能会报错，加上const就不会报错。 因此写成这样是最完备的： const char *src = "Hello"; +1

user: user-5
content: 引用 4 楼 zhao4zhong1 的回复:#pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！  你这句话可是分发了大半个论坛

user: user-6
content: 最好别这样写。一般写成 char src[] = "Hello";

user: user-7
content: 字符串最好还是加上const

user: user-8
content: 地址指向常量区 指向的内容不可修改 最好还是定义成数组

user: user-9
content: 是的.  char *src = "Hello";  // Hello存放在文字常量区，指针src指向H这个字节的地址

user: user-10
content: 合法，变量src指向字符串Hello的首地址。

user: user-4
content: #pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！

user: user-11
content: 本来不合法，但由于历史原因以前的编译器可以通过编译，VS2017默认是不支持，要把符合模式设置为否才行

user: user-12
content: 是。在有些编译器里可能会报错，加上const就不会报错。 因此写成这样是最完备的： const char *src = "Hello";
user-0 提问: 关于指针操作的问题

回复:
user: user-0
content: 引用 1 楼 qq_36751214 的回复:计算机存储数据时安装16进制，或者2进制不是10进制，所以应该是int a=0x123456;  char *p=&a; *p=0x20; cout<<hex<<a<<endl;  仅供参考  明白啦，谢谢

user: user-0
content: 引用 2 楼 yxwsbobo 的回复:楼上的是对的，十进制的123456 中的56，并非是一个字节，你改变第一个字节是不会把56替换的  十进制 123456 的 十六进制是 0x1E240  第一个字节清零变成 0X1E200 也就是十进制的 123392 ，所以你给第一个字节赋值多少， 就相当于用10禁止的 123392加多少  明白啦明白啦，茅塞顿开呀...谢谢啦

user: user-1
content: 楼上的是对的，十进制的123456 中的56，并非是一个字节，你改变第一个字节是不会把56替换的  十进制 123456 的 十六进制是 0x1E240  第一个字节清零变成 0X1E200 也就是十进制的 123392 ，所以你给第一个字节赋值多少， 就相当于用10禁止的 123392加多少

user: user-2
content: 计算机存储数据时安装16进制，或者2进制不是10进制，所以应该是int a=0x123456;  char *p=&a; *p=0x20; cout<<hex<<a<<endl;  仅供参考
user-0 提问: 关于二级指针的问题

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

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

user: user-2
content: void test(int *p){        *p = 20;  } 可以简单地考虑一下上述这种情况，你  int  a;  然后调用test(&a)不会有问题，而int *p_a,test(p_a)就会错误，因为你的p_a现在指向的是一个不确定的内存位置，就会非法访问。 所以说你先定义 void *haha，再void **result = &haha，再调用pthread_join(t,result)也是不会报错的。    具体pthread_join函数里怎么用了result你可以看源码

user: user-3
content: 解引指针前要先想一下指针有没指向有效的内存，否则类型是一致了，解引了无效的指针自然可能导致你程序崩溃

user: user-4
content: 引用 2 楼 yxwsbobo 的回复:并非是类型一样就可以了，这个函数调用会修改 result  本身的值，内部使用的时候会进行 *result = ... 而你直接定义二级指针，那么天知道解引用会解到哪里，所以出错了。 你可以试试  pthread_t t; void **result; *result = new (void*); if((pthread_join(t,result))==0) {     printf("thread terminated,result is: %s\n",((char*)*result)); }  并非是类型一样就可以了，这个函数调用会修改 result  本身的值，内部使用的时候会进行 *result = ... 而你直接定义二级指针，那么天知道解引用会解到哪里，所以出错了。 你可以试试  pthread_t t; void **result = new (void*); if((pthread_join(t,result))==0) {     printf("thread terminated,result is: %s\n",((char*)*result)); }  应该是这样

user: user-4
content: 并非是类型一样就可以了，这个函数调用会修改 result  本身的值，内部使用的时候会进行 *result = ... 而你直接定义二级指针，那么天知道解引用会解到哪里，所以出错了。 你可以试试  pthread_t t; void **result; *result = new (void*); if((pthread_join(t,result))==0) {     printf("thread terminated,result is: %s\n",((char*)*result)); }

user: user-5
content: pthread_join第二个参数是作为传出参数用的，如果要想得到完整的解释就需要查看pthread_join是如何实现的。 但是，我们可以通过第一种定义一重指针，传递一重指针的地址进去可以推测： int pthread_join(pthread_t thread, void **retval); pthread_join函数对于第二个参数的运用，是*result指向一个全局错误号变量。即将错误号的地址带出来，就可以当出现错误时（执行pthread_join失败）打出错误码从而得到错误原因。因此在pthread_join里的实现，应该是 *retval = &errno_code;即result = &errno_code; 若定义的result是二重指针，并且result是野指针，那么在pthread_join中，*result也是野指针（一重），所以会导致段错误；
user-0 提问: 将h264视频封装到mxf文件中，播放不出来？

回复:
user: user-1
content: https://www.baidu.com/s?wd=h264打包成mxf

user: user-0
content: 但是我查百度并没有关于h264,打包成mxf格式的，我一个学生初次接触这个视频解析打包，有点难，有好多地方都不是特别懂

user: user-0
content: 引用 1 楼 zhao4zhong1 的回复:百度搜相关关键字。 但是我查百度并没有关于h264,打包成mxf格式的，我一个学生初次接触这个视频解析打包，有点难，有好多地方都不是特别懂

user: user-1
content: 百度搜相关关键字。
user-0 提问: oc中关于如何调用已经输入的数据

回复:
user: user-0
content: 引用 1 楼 cfjtaishan 的回复:一个是将addMark函数中需要在show中打印的数据以返回值的形式给show（对于show来讲是传入参数）； 一个是定义全局的数据，这样show方法来讲，全局的数据也是可见的。关于这两个回答。1不是很明白如何把多个参数做为返回值传入show中，2我是通过运行程序后输入的数据去传递给addmark，保存在其中，在通过这个数据在show中执行一个运算过程。怎样定义全局数据呢

user: user-1
content: 一个是将addMark函数中需要在show中打印的数据以返回值的形式给show（对于show来讲是传入参数）； 一个是定义全局的数据，这样show方法来讲，全局的数据也是可见的。
user-0 提问: C程序分段错误

回复:
user: user-1
content: #include<stdio.h> #include<stdlib.h> #include<string.h>  #define MAXSIZE 1000  void Trans(const int *arry, int NUM, int **p) {     int i, num = NUM;     *p = (int *)malloc(sizeof(int)*NUM);     if(!(*p))     {         perror("malloc fail");         return;     }     for(i=0; i<NUM; i++)     {         (*p)[i] = arry[--num];   /*注意改成(*p)[i]， *p是一个整体，需要加括号，否则会p和[]先结合*/     } }  int main() {     int NUM, i;     int *p = NULL;     int arry[MAXSIZE];      bzero(&arry, sizeof(arry));      printf("please input NUM(1·1000):\n");     scanf("%d", &NUM);     printf("please input all:\n");     for(i=0; i<NUM; i++)     {         scanf("%d", &arry[i]);     }      Trans(arry, NUM, &p);     for(i=0; i<NUM; i++)     {         printf("arry[%d] = %d\n", i, p[i]);     }     printf("\n");     free(p);     p = NULL;     return 0; }  参考一下吧 给(*p)赋值时需要注意下
user-0 提问: C语言怎么实现鼠标事件啊，就是响应鼠标的操作，在VC6.0里面

回复:
user: user-1
content: https://zhidao.baidu.com/question/181505908.html https://www.cnblogs.com/lxl0928/p/3807262.html http://www.bianceng.cn/Programming/C/201501/47580.htm 只要肯努力还是能找到相关资料的。如果说找不到，说明还不够努力。  如果想要找到完全符合你的要求的，那就是搜集资料自己做～
user-0 提问: 求助

回复:
user: user-1
content: dest-1，在初始时，dest指向第一个指针，而dest-1则不可预测

user: user-2
content: dest-1得出的是一个值，即右值（C++里面的说法），然后进行自增操作，而自增自减操作是对一个变量才可以的。  PS：此处错误跟1楼内存的的说法没有必然联系，这是编译错误不涉及运行时错误

user: user-3
content: 是的，这两个表达式的区别是很容易看出来的。 *dest++ = *src++ 这个表达式是现将src指向的字符赋值给dest指向的内存，然后src++, dest++; 但是*(dest-1)++ = *src++就不一样了。这个表达式是将src指向的字符赋值给dest-1指向的内存，如果dest指向的是以0x11223344开始的内存，那么dest-1就是指向0x11223343.很明显越界了（左越界）；越界的写入是未定义了，如果这个一字节的内存单元不可写，那么就会出现这样的错误。
user-0 提问: 关于strtok函数的问题

回复:
user: user-1
content: 这要理解的话 ，涉及strtok函数的实现原理代码，你可以 理解p = strtok(NULL, ".");  为继续分割 第一次分割时在p后面追加，NULL 等到最后一次分割时while（）遇到NULL后，结束循环

user: user-0
content: 引用 3 楼 weixin_39587157 的回复:这要理解的话 ，涉及strtok函数的实现原理代码，你可以 理解p = strtok(NULL, ".");  为继续分割 第一次分割时在p后面追加，NULL 等到最后一次分割时while（）遇到NULL后，结束循环  通俗易懂

user: user-0
content: 引用 2 楼 jianwen0529 的回复:strtok实现中，是会对即将要截取的字符串修改的，通常做法是对分割字符用\0替代，并记录某些状态 strtok(NULL, ".");会根据上一次的状态，再对剩余的子串分割  你可以看看你的编译器下对这个函数实现的源码  依据楼上的说法，这个函数不是线程安全的，因为一个线程可能对另一个线程的状态进行改写，也可能造成数据竞争或冲突  明白啦，谢谢啦

user: user-0
content: 引用 1 楼 cfjtaishan 的回复:当第一个参数传递NULL时，则表示从剩余的字符串里找到子串，并将子串前的返回；strtok函数里会保存第一次调用之后（使用静态变量static保存）剩余的字符串的地址（或称为位置）。 个人建议使用strtok_r代替strtok，因为strtok_r函数是strtok函数的可重入版本，strtok_r是linux平台下的strtok函数的线程安全版。  char *strtok_r(char *str, const char *delim, char **saveptr); 这个是strtok_r的原型，第三个参数saveptr就是上次调用之后剩余的字符串首地址。使用strtok_r可应该会更好理解字符串分割。  明白啦，谢谢啦

user: user-2
content: strtok实现中，是会对即将要截取的字符串修改的，通常做法是对分割字符用\0替代，并记录某些状态 strtok(NULL, ".");会根据上一次的状态，再对剩余的子串分割  你可以看看你的编译器下对这个函数实现的源码  依据楼上的说法，这个函数不是线程安全的，因为一个线程可能对另一个线程的状态进行改写，也可能造成数据竞争或冲突

user: user-3
content: 当第一个参数传递NULL时，则表示从剩余的字符串里找到子串，并将子串前的返回；strtok函数里会保存第一次调用之后（使用静态变量static保存）剩余的字符串的地址（或称为位置）。 个人建议使用strtok_r代替strtok，因为strtok_r函数是strtok函数的可重入版本，strtok_r是linux平台下的strtok函数的线程安全版。  char *strtok_r(char *str, const char *delim, char **saveptr); 这个是strtok_r的原型，第三个参数saveptr就是上次调用之后剩余的字符串首地址。使用strtok_r可应该会更好理解字符串分割。
user-0 提问: 有序链表的合并问题

回复:
user: user-1
content: 引用 4 楼 Lraxer 的回复:谢谢大家，我已经找到问题了。二楼讲的第一个问题就是主要的问题，第二个问题我的程序62行写了。 看来你没有很好理解第二个问题。你有没有考虑到两个链表不一样长，或者说两个链表的长度相差多个节点，比如5个，10个节点， 如果你用下面的测试用例试试你的代码能否正常合并： 链表1:3个节点，分别1， 2， 3，链表2：5个节点，分别：2， 3， 4， 5， 6， 正确的结果合并之后应该是：1， 2， 3， 4， 5， 6 我估计用你的逻辑不是完全输出。不信的话可以试一下

user: user-0
content: 谢谢大家，我已经找到问题了。二楼讲的第一个问题就是主要的问题，第二个问题我的程序62行写了。

user: user-2
content: else {             p3->next = p1;             p3 = p1;             p1 = p1->next;      //这里少了一句，p1未指向下一节点             Num* temp = p2->next;             free(p2);             p2 = temp;         }

user: user-1
content: 去掉getchar();这儿加getchar()没有意义。你可能考虑到，输入一个整型数时会将'\n'残留在输入缓冲里，但是'\n'是字符，不会与%d匹配的。因此不用担心这个。

user: user-1
content: #include <stdio.h> #include <stdlib.h>  #define len sizeof(Num)  typedef struct Number {     int value;     struct Number* next; }Num;  Num* CreatList() {     int m;     Num* head, *p, *p1;     head = (Num*) malloc(len);     if (!head)         exit(0);     head->next = NULL;     p = head;      printf("how many items would you like to input?\n");     scanf("%d", &m);      for (int i=0;i<m;i++) {         p1 = (Num*) malloc(len);         if (!p1)             exit(0);         printf("Input the value:\n");         scanf("%d", &p1->value);         p->next = p1;         p = p1;     }     p->next = NULL;      return head; }  void MergeLists(Num* head1, Num* head2) {     Num *p1 = head1->next, *p2 = head2->next, *p3;     p3 = head1;      while (p1 && p2) {         if(p1->value > p2->value) {             p3->next = p2;             p3 = p2;             p2 = p2->next;         }         else if (p1->value < p2->value) {             p3->next = p1;             p3 = p1;             p1 = p1->next;         }         else {             p3->next = p1;             p3 = p1;             //不要忘了让p1也只想下一个节点             p1 = p1->next;             Num *tmp = p2->next;             free(p2);             p2 = tmp;         }     }      while (p1) {         p3->next = p1;         p3 = p1;         p1 = p1->next;     }     while (p2) {         p3->next = p2;         p3 = p2;         p2 = p2->next;     } }  void PrintList(Num* head) {     Num* p = head->next;     while (p) {         printf("%d\t", p->value);         p = p->next;     }     putchar(10); }  int main() {     Num* head1, * head2;     printf("写入两个有序表\n");     head1 = CreatList();     PrintList(head1);     head2 = CreatList();     PrintList(head2);      MergeLists(head1, head2);     printf("After merge: \n");     PrintList(head1);     return 0; } 参考一下吧 两个问题： 问题1：当p1的value和p2的value相等时，将p1的节点给了p3->next，但是p1没有指向下一个节点，既没有操作p1 = p1->next；p2删除了相等的节点，指向了下一个节点； 问题2：当p1或p2为NULL时，即其中一个链表先结束时，第二个链表还没有结束，应该将剩余的节点直接链到p3上，即新的链表上。
user-0 提问: C语言指针

回复:
user: user-1
content: 理解和讨论之前请先学会如何观察！  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！

user: user-2
content: 当一个函数的参数列表里有多个参数的时候，C语言没有规定实参的进栈顺序和计算顺序，而是由编译器自行决定的。#include <stdio.h> int a() { 	printf("a\n"); 	return 1; }  int b() { 	printf("b\n"); 	return 2; }  int main(void) { 	printf("%d, %d\n", a(), b()); 	return 0; }  //MSVC 下编译结果 b a 1, 2  // Ubuntu GCC 下编译结果 b a 1, 2  // LLVM Clang 下编译结果 a b 1, 2

user: user-3
content: 这个和入栈顺序没有关系，根据调用约定肯定是从右向左入栈，但这解释不了为什么3个地址都一样  事实上问题出在了函数调用中求值顺序，对于每一个参数的求值顺序C++标准中并没有规定，也就是这个行为是未定义的，任何情况都有可能发生  printf("%p,%p,%p,",p++,p++,p++); 这个在不同编译器下表现的结果都不一样的

user: user-4
content: 看结果来说应该是从右向左入栈了，但这个好像不是硬性规定，不同的编译器可能实现不同，写程序时不要依赖这样的副作用！

user: user-5
content: int 无意义的操作 = 0; int 无意义的问题 = 0; printf("%d, %d, %d\n", 无聊的操作, 无聊的操作++, (无聊的问题++) + 无聊的问题);

user: user-6
content: 由于ptr_num++或++ptr_num有副作用，因此不建议这么写: printf("%p\t %d \t %p\n", ptr_num, *(ptr_num++), ptr_num); 不同的编译器入栈的顺序可能不一样，因此在传参数时去掉后增++

user: user-6
content: 首先不是数字加1了，而是ptr_num指向了第二个元素的地址，即2所在的位置首地址，因此第二个输出的是2； 因为ptr_num的指向的第一个元素的地址，即nums的首地址是：0x0041FB84，少4个字节（若是64位系统应该是0x0041FB80,少8个字节）； 在两个printf之前加一句： printf("%p\n", ptr_num); 就可以知道nums的首地址是多少了。

user: user-7
content: 就如一楼所说，楼主心里默认为函数参数的求值顺序是从左到右，但其实标准并没有对这个顺序有什么规定。每个编译器都可能做出适合自己的与别家编译器不一样的选择。 换个编译器，说不定楼主看到的输出又不一样了

user: user-8
content: 第一个printf执行时，编译器实际先计算了*ptr_num++，执行后ptr_num已经自增，此后三个参数才依次入栈，所以两个printf实际显示的都是已经自增了之后的ptr_num
user-0 提问: 请教一个c语言链表问题，请懂的人回答一下下

回复:
user: user-1
content: 这是由于函数的副本机制，函数的传递都是值传递，实参的值是拷贝给形参的，修改形参不能改变实参，只能传递地址

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

user: user-3
content: 因为传入函数里的是指向结构体的指针，存储的是结构体的地址;你说的那种情况要传入该指针的地址（指针的指针）才行。

user: user-4
content: 在调用函数的时候，这里的node就从传入的变量拷贝了一份。只是用来暂时存放结点的地址。 除非你加引用。

user: user-5
content: 原因是node是List Length函数里的局部变量，参数传递，就是值传递，即实参的值赋值给形参（形参是函数内的局部变量），那么若是指针给指针传值，就是传的地址值。node是指针，它用于存放地址，而内存空间（节点的存放位置）是在堆上，不在函数栈上。而node只是用于存放堆上节点的地址。所以，node = node->next修改的是node指向的位置，而没有修改堆上节点的next指向节点。

user: user-6
content: C语言中，函数的传递都是值传递，也就是说，实参的值是拷贝给形参的，所以修改形参的值，改变不了实参的值。
user-0 提问: 用c语言求真值表以及主析取式，请大神指点

回复:
user: user-1
content: https://bbs.csdn.net/topics/380157851

user: user-2
content: x[z++]='|';x[z++]='(';x[z++]='!';x[z++]=c[0];x[z++]='&';x[z++]='!';x[z++]=c[1];x[z++]='&';x[z++]=c[2];x[z++]=')'; 这么写代码不感觉看着都费劲吗？

user: user-1
content: int L=sprintf(x+z,"|(!%c&!%c&%c)",c[0],c[1],c[2]);z+=L;

user: user-0
content: 引用 2 楼 自信男孩的回复:x[z++]='|';x[z++]='(';x[z++]='!';x[z++]=c[0];x[z++]='&';x[z++]='!';x[z++]=c[1];x[z++]='&';x[z++]=c[2];x[z++]=')'; 这么写代码不感觉看着都费劲吗？ 累啊，但是小白刚入门，想不到什么更好的方法。。

user: user-0
content: 用vc++6.0编译的
user-0 提问: winfrom  对象转xml

回复:
user: user-1
content: 自己再写一段代码，读取xml文件，将其中的<?xml version="1.0"?>改为<? Xml version="1.0" encoding="UTF-8"?>  所谓修改删除文件a某位置的内容，其实是读打开文件a，再将‘a中修改删除位置之前的内容＋修改删除的内容＋a中修改删除位置之后的内容’保存到文件b，关闭文件a，删除文件a，将文件b改名为与之前文件a相同的名字，仅此而已。http://bbs.csdn.net/topics/391975224
user-0 提问: 动态结构体数组的问题

回复:
user: user-0
content: 引用 1 楼 cfjtaishan 的回复:tu=(student*)malloc(M*sizeof(student*)); 改一下这句，改成这样：去掉sizeof括号内的* stu=(student*)malloc(M*sizeof(student)); 因为加上*则是申请了M * sizeof(int)个字节的空间，因为加上*就是申请M个指针，指针变量的大小和int类型占用内存的大小一样。 从你的接下来的代码来看，你要申请的不是M个指针，而是申请M个student类型的变量，即M * sizeof(student)  欸没问题了，谢谢老师！

user: user-1
content: 如果申请的是sizeof(student *)，根据长度计算，很明显会越界。注意 sizeof(student *)的长度和sizeof(student)的长度不一样，差距很大，如果结构体成员越多，差距会越大； sizeof(student *)若是在32位系统里，该值为4；sizeof(student)在精简版源文件定义结构体里，为12

user: user-1
content: tu=(student*)malloc(M*sizeof(student*)); 改一下这句，改成这样：去掉sizeof括号内的* stu=(student*)malloc(M*sizeof(student)); 因为加上*则是申请了M * sizeof(int)个字节的空间，因为加上*就是申请M个指针，指针变量的大小和int类型占用内存的大小一样。 从你的接下来的代码来看，你要申请的不是M个指针，而是申请M个student类型的变量，即M * sizeof(student)
user-0 提问: c语言数据结构线性表

回复:
user: user-0
content: 引用 1 楼 自信男孩的回复:建议把代码贴出来，对于代码的问题不要贴图片。 好的，我弄到下面去。。。。

user: user-1
content: 再供参考： 数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633

user: user-1
content: 仅供参考：#include <algorithm> #include <iostream> #include <functional> #include <cstring> using namespace std; int main() {     char *Alphabet = "abcdefghijklmnopqrstuvwxyz" ;     char *Vowels   = "aeiou" ;     char *AlphaNum = "0123456789abcdef" ;     char result[45] ;     char *last ;      int lenA  = strlen(Alphabet) ;     int lenV  = strlen(Vowels  ) ;     int lenAN = strlen(AlphaNum) ;      cout << "Alphabet = " << Alphabet << endl ;     cout << "Vowels   = " << Vowels   << endl ;     cout << "AlphaNum = " << AlphaNum << endl ;      cout << "\nusing non-predicate versions" << endl ;      //non-predicate set_difference     last = set_difference(Alphabet, Alphabet+lenA,                           AlphaNum, AlphaNum+lenAN,                           result) ;     *last = 0 ;     cout << "set_difference(Alphabet, AlphaNum) =  " << result << endl ;      //non-predicate set_intersection     last = set_intersection(Alphabet, Alphabet+lenA,                             AlphaNum, AlphaNum+lenAN,                             result) ;     *last = 0 ;     cout << "set_intersection(Alphabet, AlphaNum) =  " << result << endl ;      //non-predicate set_symmetric_difference     last = set_symmetric_difference(Alphabet, Alphabet+lenA,                                     Vowels  , Vowels  +lenV,                                     result) ;     *last = 0 ;     cout << "set_symmetric_difference(Alphabet, Vowels) =  " << result << endl ;      //non-predicate set_union     last = set_union(Alphabet, Alphabet+lenA,                      AlphaNum, AlphaNum+lenAN,                      result) ;     *last = 0 ;     cout << "set_union(Alphabet, AlphaNum) =  " << result << endl ;      cout << "\nusing predicate versions" << endl ;      //predicate set_difference     last = set_difference(Alphabet, Alphabet+lenA,                           AlphaNum, AlphaNum+lenAN,                           result  , less<char>()) ;     *last = 0 ;     cout << "set_difference(Alphabet, AlphaNum) =  " << result << endl ;      //predicate set_intersection     last = set_intersection(Alphabet, Alphabet+lenA,                             AlphaNum, AlphaNum+lenAN,                             result  , less<char>()) ;     *last = 0 ;     cout << "set_intersection(Alphabet, AlphaNum) =  " << result << endl ;      //predicate set_symmetric_difference     last = set_symmetric_difference(Alphabet, Alphabet+lenA,                                     Vowels  , Vowels  +lenV,                                     result  , less<char>()) ;     *last = 0 ;     cout << "set_symmetric_difference(Alphabet, Vowels) =  " << result << endl ;      //predicate set_union     last = set_union(Alphabet, Alphabet+lenA,                      AlphaNum, AlphaNum+lenAN,                      result  , less<char>()) ;     *last = 0 ;     cout << "set_union(Alphabet, AlphaNum) =  " << result << endl ;      return 0 ; }

user: user-2
content: 哥们看不清楚啊。

user: user-3
content: 建议把代码贴出来，对于代码的问题不要贴图片。
user-0 提问: 求高效率随机算法

回复:
user: user-1
content: 建议楼主搜索“洗牌算法”或者shuffle算法，这是符合你要求的一类做法

user: user-2
content: 长度为10000的数组src_data，初始化为0到9999 整数src_len初始化为10000 重复6000次： 	生成从0到src_len-1的随机数index 	src_data[index]放入目标数组中 	src_data[index]=src_data[src_len-1] 	src_len=src_len-1

user: user-3
content: 随机必然有重复，所谓“不重复的随机”实际上是洗牌。洗牌算法参考下面： #include <stdio.h> #include <stdlib.h> #include <time.h> int d[6]; int i,n,a,b,t; int c,j; void main() {     srand(time(NULL));     printf("shuffle 0..n-1 demo\n");     for (n=1;n<=5;n++) {/* 测试1～5个元素 */         printf("_____n=%d_____\n",n);         j=1;         for (c=1;c<=n;c++) j=j*c;/* j为n! */         j*=n*2;         for (c=1;c<=j;c++) {/* 测试n*2*n!次 */             for (i=0;i<n;i++) d[i]=i;/* 填写0～n-1 */             for (i=n;i>0;i--) {/* 打乱0～n-1 */                 a=i-1;b=rand()%i;                 if (a!=b) {t=d[a];d[a]=d[b];d[b]=t;}             }             printf("%04d:",c);             for (i=0;i<n;i++) printf("%d",d[i]);             printf("\n");         }     }     printf("shuffle 1..n demo\n");     for (n=1;n<=5;n++) {/* 测试1～5个元素 */         printf("_____n=%d_____\n",n);         j=1;         for (c=1;c<=n;c++) j=j*c;/* j为n! */         j*=n*2;         for (c=1;c<=j;c++) {/* 测试n*2*n!次 */             for (i=1;i<=n;i++) d[i]=i;/* 填写1～n */             for (i=n;i>1;i--) {/* 打乱1～n */                 a=i;b=rand()%i+1;                 if (a!=b) {t=d[a];d[a]=d[b];d[b]=t;}             }             printf("%04d:",c);             for (i=1;i<=n;i++) printf("%d",d[i]);             printf("\n");         }     } }
user-0 提问: 怎么两次输出都一样啊。。。。。

回复:
user: user-1
content: 个人建议最好不要轻易使用goto语句，goto语句使用多了对于代码的可读性不好。所以，能不用则不用，尽量避免。goto语句可以用其他方式替换

user: user-2
content: 楼主需要了解goto正确使用方法，但是这只限于学习，在实际工作中，一份代码的优劣与goto的使用比例是成反比的。

user: user-3
content: 引用 3 楼 cfjtaishan 的回复:个人建议最好不要轻易使用goto语句，goto语句使用多了对于代码的可读性不好。所以，能不用则不用，尽量避免。goto语句可以用其他方式替换估计这是初学的时候的作业吧，课程都会先学goto，在继续学while和for

user: user-1
content: #include <stdio.h> #include <stdlib.h> #include <string.h>  int main() { 	char St[20] = "asdasd"; 	goto ASD; aaa:  	printf("%s\n",St); 	goto end; ASD: 	{ 		printf("%s\n",St); 		goto asd; 	} asd: 	{ 		//St[20]="dfg"; 		strcpy(St, "dfg"); 		goto aaa; 	} end: 	system("pause"); 	return 0; } 参考一下吧  字符串赋值，不能用St[20] = "dfg"；再说数组St下表是从0~19，St[20]很明显越界了。 总的来讲，字符串赋值，不能以这种形式（除非是定义时赋值），需要借助字符串拷贝函数。

user: user-4
content: 把        St[20]="dfg";改成strcpy("St","dfg0");试试
user-0 提问: 算是服了vs2015了，这段程序为什么不打印？

回复:
user: user-1
content: #include <stdio.h> int main(void) {     int i, j, k;     char letter;     printf("shuru:");     scanf_s("%c", &letter, 1);     k = letter - 'A' + 1;      for (i = 0; i < k; i++)     {         for (j = 0; j < k - i; j++)             printf(" ");         for (j = 0; j <= i; j++)             printf("%c", 'A' + j);         for (j = i - 1; j >= 0; j--)             printf("%c", 'A' + j);         printf("\n");     }     return 0; } 参考一下吧   for (j = i - 1; j >= 0; j--)             printf("%c", 'A' + j); 注意j--，你写成j++,会导致死循环和溢出；

user: user-1
content: 引用 2 楼 qq_30519247 的回复:[quote=引用 1 楼 user-3 的回复:] scanf_s("%c", &letter);  改成：  scanf_s("%c", &letter, 1);  for (j = i - 1; j >= 0; j++)  改成：  for (j = i - 1; j >= 0; j--) 我是不是该放弃vs2015，为什么scanf_s("%c", &letter, 1);还要加1啊。[/quote] 这是因为scanf_s和scanf是不一样的，scanf_s比scanf更安全，更安全体现在它比scanf多一个输入字符数的要求上。因此对于%c需要确定其字符数。

user: user-2
content: 引用 2 楼 qq_30519247 的回复:[quote=引用 1 楼 user-3 的回复:] scanf_s("%c", &letter);  改成：  scanf_s("%c", &letter, 1);  for (j = i - 1; j >= 0; j++)  改成：  for (j = i - 1; j >= 0; j--) 我是不是该放弃vs2015，为什么scanf_s("%c", &letter, 1);还要加1啊。[/quote] 你可以在vs2015里继续用scanf，套路参考http://blog.csdn.net/fantasydreams/article/details/45250627

user: user-2
content: #include <stdio.h> #include <stdlib.h> int main(void) {     int i, j, k;     char letter;     printf("shuru:");     scanf_s("%c", &letter,1);     k = letter - 'A' + 1;     for (i = 0; i < k; i++)     {         for (j = 0; j < k - i; j++)printf(" ");         for (j = 0; j <= i; j++)printf("%c", 'A' + j);         for (j = i - 1; j >= 0; j--)printf("%c", 'A' + j);         printf("\n");     }     system("pause");     return 0; } 建议楼主参考下面的链接，学学scanf_s和scanf的区别 https://msdn.microsoft.com/en-us/library/w40768et.aspx

user: user-0
content: 引用 1 楼 user-3 的回复:scanf_s("%c", &letter);  改成：  scanf_s("%c", &letter, 1);  for (j = i - 1; j >= 0; j++)  改成：  for (j = i - 1; j >= 0; j--) 我是不是该放弃vs2015，为什么scanf_s("%c", &letter, 1);还要加1啊。

user: user-3
content: scanf_s("%c", &letter);  改成：  scanf_s("%c", &letter, 1);  for (j = i - 1; j >= 0; j++)  改成：  for (j = i - 1; j >= 0; j--)
user-0 提问: 指令引用“0xcccccccc”,该内存不能为“written”

回复:
user: user-1
content: scanf("\t%d", St1[i].sex); 要改成： scanf("\t%d", &St1[i].sex);  同理其他%d格式的地方

user: user-1
content: scanf("\t%s", filename); 这里的filename并不是个字符数组或缓冲区，而是一个函数指针，实际指向filename函数，运行时将会崩溃

user: user-2
content: 单步调试
user-0 提问: 求助帖 C语言链表输出

回复:
user: user-1
content: #include <stdio.h> #include <stdlib.h>  struct student {     long no;     char name[20];     char add[30];     struct student *next; };  typedef struct student LIST; LIST *CreateList(); void DispList(LIST *h);  int main() {     LIST *head;     head=CreateList();     DispList(head);  }  LIST* CreateList() {     LIST *h,*prev,*cur;     int i,n;     h=NULL;     printf("输入节点个数：\n");     scanf("%d",&n);      for(i=0; i<n; i++) {         cur = (LIST*)malloc(sizeof(LIST));         cur->next = NULL;         if(h == NULL) {             h = cur;             prev = h;         } else {             prev->next = cur;             prev=cur;         }         printf("输入 学号  姓名 地址\n");         scanf("%ld %s %s",&cur->no,cur->name,cur->add);     }      return h; }  void DispList(LIST *h) {     LIST *p=h;      printf("学号  姓名 地址\n");     while(p) {         printf("%ld  %s  %s\n",p->no,p->name,p->add);         p = p->next;     } }  参考一下吧  注意链表创建时的逻辑。否则会出现段错误

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

user: user-3
content: void DispList(LIST *h) {  后面就没大括号了。

user: user-4
content: if (h = NULL)  改成  if (h == NULL)
user-0 提问: 如何保存链表中的数据到文件中

回复:
user: user-1
content: 读写文件逻辑没多大的问题。 建议查一下写之前，链表是否有节点。

user: user-2
content: 百度搜相关关键字。

user: user-3
content: 既然是链表，那就得是有数据和保存指针的节点 if (fread(newNode, sizeof(USER), 1, file) != 1) 这样写newNode不是真正的数据吧，newNode->data(自己定义的节点结构可能是其他变量)才是保存的数据吧  if (fread(newNode->data, sizeof(USER), 1, file) != 1) 试试呢

user: user-3
content: 回复完想到可能理解错了，楼主说的保存数据可能是保存整个节点的信息，整个结构体

user: user-0
content: //从文件中读入数据到链表中 int readUserFromFile() { 	FILE *file = NULL; 	USER* newNode = NULL;//新建一个结点用于从文件读入的数据加入链表中 	USER* lastNode = head;//定义尾结点，用于将数据放入链表后面  	if ((file = fopen("work.txt", "rb")) == NULL)//rb以二进制的方式进行读取//文件打开不成功----文件不存在     { 		if ((file = fopen("work.txt", "wb")) == NULL)//创建一个空文件 		{ 			return -1; 		} 	} 	else 	{ 		while (1) 		{ 			newNode = (USER*)malloc(sizeof(USER)); 			if (fread(newNode, sizeof(USER), 1, file) != 1)//读入数据，从file中每次读取1块USER大小，放入newNode中//判定返回值是否为1 			{ 				free(newNode); 				newNode = NULL; 				break; 				return -2; 			} 			else 			{ 				newNode->next = NULL; 				lastNode->next = newNode; 				lastNode = newNode; 			} 		} 	} 	return 0; }  这是读取数据的代码

user: user-0
content: 想问一下这样保存数据，可以执行，但是数据存不到文件当中
user-0 提问: scanf能从中间提前跳出等待输入吗（不在循环中）

回复:
user: user-1
content: 仅供参考：#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.

user: user-1
content: printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。  在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 char c; scanf("%c",&c); //时，都改为 char s[2]; char c; scanf("%1s",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。

user: user-2
content: 我的思路是用字符串输入后期判断然后去掉小数点 个人的建议是不用转换整数，直接字符输出 萌新一枚，求大佬指点

user: user-2
content: #include<stdio.h> #include<string.h> #include<math.h>  int main(){ 	char a[1000]; 	int z=0,x=0,i,k = 0; 	scanf("%s",&a); 	for(i = 0; i < strlen(a); i ++ ){//判断是否有小数点  		if(a[i] == '.') break; 	} 	if(i == strlen(a)){//是整数  		for(int j=strlen(a)-1;j>=0;j--){ 			z+=((int)a[k]-48)*((int)pow(10,j)); 			k++; 		}  		printf("%d",z); 	} 	else{//是小数  		k=i+1;//小数点是第i位，从第i+1位开始是小数  		for(int j=strlen(a)-1;j>i;j--){ 			x+=((int)a[k]-48)*((int)pow(10,j-i-1));//幂次减去第一位  			k++; 		}  		k = 0; 		for(int j=i-1;j>=0;j--){ 			z+=((int)a[k]-48)*((int)pow(10,j)); 			k++; 		}  		printf("%d.%d",z,x); 	} 	 	return 0; }   /* #include<stdio.h> #include<string.h> #include<math.h>  int main(){ 	char a[100]; 	scanf("%s",a); 	int i,m=0,k=0; 	for(i=strlen(a)-1;i>=0;i--){ 		m+=((int)a[k]-48)*((int)pow(10,i)); 		k++; 	}  	printf("%d",m) ; 	return 0; } 我写的一个字符串变整数的程序，供参考 */
user-0 提问: 请帮我理解一下这段代码

回复:
user: user-1
content: 引用 1 楼 user-5 的回复:这个时候，我想呼唤赵老师。。。。。 楼主啊，建议你去看反汇编 “给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出

user: user-2
content: #include<stdio.h>  int f(int x,int y) {     return((y-x)*x); } int main() {     int a = 3, b = 4, c = 5, d; #if 0     d=f(f(a,b),f(a,c)); #else     int m, n, d;     m = f(a, b);     n = f(a, c);     d = f(m, n); #endif     printf("%d\n",d); } 参考一下吧 这一句：d=f(f(a,b),f(a,c)); 等价：     m = f(a, b);     n = f(a, c);     d = f(m, n);

user: user-3
content: 这种代码完全可以从纯c/c++语言层次考虑，为何要看汇编，自己挖坑自己埋？ #include<stdio.h> int f(int x,int y) {     return((y-x)*x); } main() {     int a=3,b=4,c=5,d;     d=f(f(a,b),f(a,c));     printf("%d\n",d); } 相当于 d=f(f(3,4),f(3,5)); f(3,4) = (4-3)×3 =3 f(3,5)= (5-3)*3=6 因此 d=f(3,6)=(6-3)*3=9

user: user-4
content: 先看main函数，然后遇到f()，就开始带入值，这里先把f()中的两个f()分别带入值，然后讲这两个返回值再代入f()中，最后把返回值输出

user: user-5
content: 这个时候，我想呼唤赵老师。。。。。 楼主啊，建议你去看反汇编
user-0 提问: PAT 1021 个位数统计

回复:
user: user-1
content: #include<stdio.h> #include <ctype.h>  int main() {     char chr[1001];     int s[10]={0}, i;      scanf("%s", chr);      for(i = 0; chr[i]; i++)     {         if (isdigit(chr[i]))             s[chr[i]- '0']++;      }     for(i = 0; i < 10; i++)     {         if(s[i])             printf("%d:%d\n", i, s[i]);     }      return 0; }

user: user-2
content: #include <stdio.h>  int main() {   int c, s[10] = {0};   while ((c = getchar()) != EOF) if (c > 47 && c < 58) s[c - 48]++;   for (c = 0; c < 10; c++) if (s[c]) printf("%d:%d\n", c, s[c]);    return 0; }

user: user-3
content: 楼主的代码看起来没有大问题，就是char chr[1000]空间分配可能不够，如果输入的是个1000位整数，那么最后的'\0'就越界存储了 #include<stdio.h> int main() {     char chr[1001];     scanf("%s", chr);     int s[10] = { 0 }, num = 0;     for (int i = 0; chr[i] != '\0'; i++)     {         num = chr[i] - '0';         s[num]++;      }     for (int j = 0; j < 10; j++)     {         if (s[j] == 0)             continue;         printf("%d:%d\n", j, s[j]);     }     return 0; }
user-0 提问: 如何用socket模拟http post文件

回复:
user: user-1
content: 百度搜“POST 发送文件”。

user: user-0
content: 网上找了好多例子，都失败了，发送普通的文字参数，类似于get的id=12，这样的文本是可以成功接收，但是要POST发送文件老是接不到，应该是head头没有写对。哪位大神能给个帮助不  引用 1 楼 zhao4zhong1 的回复:百度搜相关关键字。

user: user-1
content: 百度搜相关关键字。
user-0 提问: 函数调用时没有函数声明为什么·没有报错

回复:
user: user-1
content: 虽然没有报错，但是你有没有发现它会给予警告。如果没有警告，建议编译时加上-Wall参数。 没有报错，是因为它能在代码里找到调用函数对应的函数名。

user: user-2
content: 只要编译器能正确找到函数就好了

user: user-3
content: c就是这样子，参考下面的（ps::c++）就不会这样 http://blog.csdn.net/smstong/article/details/50523120

user: user-4
content: 在调用前没有声明会   隐式声明吧

user: user-4
content: 跟编译器有关的
user-0 提问: 请问C语言下执行sql dual，这个数据类型是什么？怎么插入到变量里面呢？！

回复:
user: user-1
content: 逐个解析，按照字符串的形式解析成整型等类型

user: user-2
content: 了解ado！

user: user-3
content: dual是个表吧

user: user-0
content: 引用 2 楼 cfjtaishan 的回复:逐个解析，按照字符串的形式解析成整型等类型  不知道怎么才能获取dual表里面这个hour的值啊？！

user: user-0
content: 引用 1 楼 kobehahaha 的回复:dual是个表吧  是的，问题怎么提取这个 HOUR 出来放到变量里面呢？！
user-0 提问: 关于Linux和Windows中++a + a++ 的运算结果，请大神指点

回复:
user: user-1
content: 引用 10 楼 HelloCppWorld 的回复:[quote=引用 8 楼 qq_41607490 的回复:] 纠结这种问题确实是没有意义的，归根结底的原因要么是编译器机制不同，要么是系统区别，但不管是什么问题都是没有太大意义的，除非你以后当一个老师，还可以给学生说点这种类似脑筋急转弯的题，对于问题本事，本人觉得你指需要了解a++,++a，的却别，以及，在你用的比较的多的系统中(例如本人是在Linux下工作)运算符的使用，好的程序往往是简单，明了，这样才能提高工作效率，以及开发效率。  之前朋友去面试的时候，有一家公司的面试题里就有几道这种类似的题，然后回来和我聊，所以我才想研究研究其中的原理[/quote]  单独的a++和++a是有区别的，实际的运算过程也是不同的，这个是需要知道的，但是这两种运算的组放到一起、或者作为函数参数、或者作为printf输出，这种类似的问题结果是不确定的，研究起来也没有太大意思

user: user-0
content: 引用 5 楼 shihengzhen101 的回复:不用纠结这种表达式是怎么算的，结果你也看到了，不同的平台计算结果不同，所以我们不建议写这样的代码 以上几位也提到了，这个和求值顺序有关，但是有些表达式在标准中是未定义顺序的，并不能保证每次的计算顺序都一致 从结果推过程也许说的通，但是只看表达式，很难准确猜出它下一次的计算结果  主要是之前在一份面试题里看到的，所以才想搞明白

user: user-0
content: 引用 1 楼 jianwen0529 的回复:建议查找表达式计算顺序的有关资料 这种表达式是未定义的，任何处理结果都可以  ++a + a++ 可以分解为两个子表达式 ++a 和 a++，但是标准并没有规定是从左至右求解子表达式还是从右至左  嗯..谢谢

user: user-2
content: 这种问题每个月至少有一个人问

user: user-0
content: 引用 9 楼 qq_33302340 的回复:搞明白求值顺序就行了 也没必要研究这么细致   主要是搞不清为什么，心里别扭

user: user-0
content: 引用 4 楼 zhao4zhong1 的回复:关于C,C++表达式求值顺序 http://blog.csdn.net/fefe82/article/details/37833767，http://bbs.csdn.net/topics/370153775  这个确实很有用，谢谢啦

user: user-0
content: 引用 8 楼 qq_41607490 的回复:纠结这种问题确实是没有意义的，归根结底的原因要么是编译器机制不同，要么是系统区别，但不管是什么问题都是没有太大意义的，除非你以后当一个老师，还可以给学生说点这种类似脑筋急转弯的题，对于问题本事，本人觉得你指需要了解a++,++a，的却别，以及，在你用的比较的多的系统中(例如本人是在Linux下工作)运算符的使用，好的程序往往是简单，明了，这样才能提高工作效率，以及开发效率。  之前朋友去面试的时候，有一家公司的面试题里就有几道这种类似的题，然后回来和我聊，所以我才想研究研究其中的原理

user: user-3
content: 不同的编译器算出来的结果不同

user: user-4
content: 搞明白求值顺序就行了 也没必要研究这么细致

user: user-5
content: 纠结这种问题确实是没有意义的，归根结底的原因要么是编译器机制不同，要么是系统区别，但不管是什么问题都是没有太大意义的，除非你以后当一个老师，还可以给学生说点这种类似脑筋急转弯的题，对于问题本事，本人觉得你指需要了解a++,++a，的却别，以及，在你用的比较的多的系统中(例如本人是在Linux下工作)运算符的使用，好的程序往往是简单，明了，这样才能提高工作效率，以及开发效率。

user: user-6
content: 关于C,C++表达式求值顺序 http://blog.csdn.net/fefe82/article/details/37833767，http://bbs.csdn.net/topics/370153775

user: user-7
content: 对于这样的表达式研究起来意义不大，也不建议写这样的代码。因为自增运算符本身就有副作用，副作用用好了可以，用不好会出错。  ++a + a++ = 5 ++b + ++b + ++b + ++b = 15 像这样的表达式，研究起来有啥用？平时写这样的表达式不被批都怪了。作为程序员建议还是老老实实写一些别人一眼就能看懂的代码吧

user: user-8
content: 回字有4种写法，还是5种写法，还是6种写法？

user: user-1
content: 不用纠结这种表达式是怎么算的，结果你也看到了，不同的平台计算结果不同，所以我们不建议写这样的代码 以上几位也提到了，这个和求值顺序有关，但是有些表达式在标准中是未定义顺序的，并不能保证每次的计算顺序都一致 从结果推过程也许说的通，但是只看表达式，很难准确猜出它下一次的计算结果

user: user-9
content: 不是系统，而是编译器的处理不同~

user: user-10
content: 建议查找表达式计算顺序的有关资料 这种表达式是未定义的，任何处理结果都可以  ++a + a++ 可以分解为两个子表达式 ++a 和 a++，但是标准并没有规定是从左至右求解子表达式还是从右至左
user-0 提问: 自己编写的c语言程序有问题，急求解决。程序能运行，但运行途中输入某些菜单选项经常停止运行，急求各位大神解决，谢谢了。

回复:
user: user-1
content: 代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。  崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。

user: user-2
content: typedef struct Classroom {     int num;     int snum;     char tv;     char use; }CLA; 结构体是这样定义的，但是对于tv 和use为啥要用%s格式输入呢，这样肯定会导致越界，程序异常。

user: user-3
content: 首先你要明確輸入什麽會導致停止運行，然後對這個分支的程序做一個輸出調試和代碼檢查。通常停止運行都是内存問題引起的，比如數組越界運行等。檢查一下再説吧。 另外發代碼時最好做一下排版，特別是這麽長的代碼。
user-0 提问: 哪位大神解答下这块代码是啥意思

回复:
user: user-0
content: 你好！我最近在写一个关于用matlab编写图像分形维度计算的小程序，一些算法的代码可以去哪里搜寻参考下，谢谢

user: user-0
content: 大牛    方便私信吗

user: user-1
content: 这是matlab代码  前三行在求二值图像并取反，后面你拷贝的代码是有问题的

user: user-0
content: 这是其他人写的matlab代码，用来分形的，没看懂啥意思

user: user-2
content: 这应该是伪代码，不符合C语言语法。不过也可能是脚本语言的语法。 但是代码可读性不好～
user-0 提问: 两个有序链表序列的合并【做了一下午加一晚上，仍有错！求大神看看错在哪】

回复:
user: user-1
content: 数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633

user: user-2
content: #include<stdio.h> #include<stdlib.h>  typedef struct ListNode *node;  struct ListNode {     int num;     node next; };  node readlist(); node merge(node s1, node s2 ); node apply(); void show_list(node head);  int main() {     node s1,s2,s3;     //s1 = apply();     //s2 = apply();     //s3 = apply();     s1 = readlist();     show_list(s1);     s2 = readlist();     show_list(s2);     s3 = merge(s1,s2);     show_list(s3);      return 0; }  node apply() {     node L;     L=(node)malloc(sizeof(struct ListNode));     L->next = NULL;    /* L = NULL导致内存泄露*/     return L; }  void show_list(node head) {     node p = head;      while (p) {         printf("%d ", p->num);         p = p->next;     }     putchar(10); }  node readlist() {     int n;     node head,p,last;     head=last=NULL;     scanf("%d",&n);     while(n!=-1){         p = (node)malloc(sizeof(struct ListNode));         p->num = n;         if(last)             last->next=p;         else             head = p;         last = p;         scanf("%d",&n);     }     last->next = NULL;      return head; }  node merge(node s1, node s2 ) {     node s3 = NULL, head;      while(s1 && s2) {         if(s1->num >= s2->num) {             if (!s3) {                 s3 = s2;                 head = s3;             } else {                 s3->next = s2;                 s3 = s2;             }             s2 = s2->next;         } else {             if (!s3) {                 s3 = s1;                 head = s3;             } else {                 s3->next = s1;                 s3 = s1;             }             s1 = s1->next;         }     }      while (s1){         s3->next = s1;         s3 = s1;         s1 = s1->next;     }     while (s2) {         s3->next = s2;         s3 = s2;         s2 = s2->next;     }      return head; } 参考一下吧  链表如果不是很熟，不建议直接去写合并排序。建议先从简单链表的创建，输出，查询，删除等等； apply函数是申请空间，但是该函数会导致内存泄漏，比如L申请了空间之后，L指向了堆上的空间，但是接下来L = NULL;就是用NULL覆盖了L的地址值。这样刚才申请的空间首地址就找不到了。

user: user-3
content: http://blog.csdn.net/lixiaogang_theanswer/article/details/61197884
user-0 提问: 菜鸡求助大佬，为什么printf()影响了结构函数的定义

回复:
user: user-1
content: 因为你用的是c语言 C89 中，任何复合语句（块作用域）中的声明必须出现在块的开头，在任何语句之前。 注意“任何语句”，包括printf

user: user-2
content: 变量要遵循先声明后使用的原则，有些编译器（版本较早的）还会要求，变量声明（定义时声明）必须在前面，不论变量在函数的什么地方使用，都要遵循声明在前，否则编译不成功。

user: user-3
content: 跟C语言版本有关   换个不同编译器这个问题可能就不存在了

user: user-4
content: 语言定义的，声明在前。你用。c++就没问题。
user-0 提问: 初学者第一次遇到这种问题，求大佬解答

回复:
user: user-0
content: 谢谢大佬教训。。。 第二句话的意思是要把参数 int a[]改成int* a吗。 第一句话的意思实在不理解  刚接触C语言半个多月  萌新很尴尬。@赵4老师

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

user: user-1
content: 在占用内存空间较大的局部数组声明的前面加static将其从堆栈数据段挪到全局数据段即可避开因局部数组大小超过默认堆栈大小1MB造成程序不能正常运行的问题。

user: user-2
content: 容器是否平放，容量是不一样的

user: user-1
content: 数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633  崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。
user-0 提问: 新手写的程序， 请高手指点

回复:
user: user-1
content: NE = salary - (capital * a * (1 + a) ^ i / ((1 + a) ^ i - 1)); //等额本息还款公式 error: invalid operands of types 'double' and 'int' to binary 'operator^'|

user: user-2
content: 如果进行int 型，还可以采取循环的方法

user: user-3
content: C语言的^不是幂运算，而是异或运算符。建议从网上查一下^符号的用法； 对于幂运算，建议使用数学函数库中的pow函数，double pow(double x, double y);第一个参数x是底数，y是幂数，即数学里的x^y；返回值就是x^y值。
user-0 提问: 菜鸟求助

回复:
user: user-1
content: Enter、Ctrl+Z、Enter

user: user-2
content: #include <stdio.h> #include <stdlib.h> #include <ctype.h> #include <unistd.h>  #define BUFSIZE 100 #define MAXOP 100 #define NUMBER '0' #define MAXVAL 100 /* maximum depth of val stack */  int sp = 0; /* next free stack position */ double val[MAXVAL]; /* value stack */ char buf[BUFSIZE]; /* buffer for ungetch */ int bufp = 0; /* next free position in buf */  int getop(char []); void push(double); double pop(void); void ungetch(int); int getch(void);  /*  *  */ int main() {     int type;     double op2;     char s[MAXOP];     while ((type = getop(s)) != EOF) {         switch (type) {             case NUMBER:                 push(atof(s));                 break;             case '+':                 push(pop() + pop());                 break;             case '*':                 push(pop() * pop());                 break;             case '-':                 op2 = pop();                 push(pop()-op2);                 break;             case '/':                 op2 = pop();                 if (op2 != 0.0)                     push(pop() / op2);                 else                     printf("error: zero divisor\n");                 break;             case '\n':                 printf("\t%.8g\n", pop());                 break;             default:                 printf("error: unknown command %s\n", s);                 sleep(1);                 break;         }     }     return 0; }  /* push: push f onto value stack */ void push(double f) {     if (sp < MAXVAL)         val[++sp] = f;     else         printf("error: stack full, can't push %g\n", f); }  /* pop: pop and return top value from stack */ double pop(void) {     if (sp > 0) {         //printf("%.8f", val[sp]);         return val[sp--];     } else {         printf("error: stack empty\n");         return 0.0;     } }  int getop(char s[]) {     int i, c;     while ((s[0] = c = getch()) == ' ' || c == '\t')         ;     s[1] = '\0';     if (!isdigit(c) && c != '.')         return c; /* not a number */     i = 0;      if (isdigit(c)) /* collect integer part */         while (isdigit(s[++i] = c = getch()))             ;     if (c == '.') /* collect fraction part */         while (isdigit(s[++i] = c = getch()))             ;     s[i] = '\0';     if (c != EOF)         ungetch(c);     return NUMBER; }  int getch(void) {     return (bufp > 0) ? buf[--bufp] : getchar(); }  void ungetch(int c) {     if (bufp >= BUFSIZE)         printf("ungetch: too many characters\n");     else         buf[bufp++] = c; }  参考一下吧 虽然是抄的源码，但是在抄的过程中还是有两个地方抄错了。这三个地方导致了死循环； 如果不输入EOF，会一直进行运算，比如算过加法，可以继续算减法，如果想退出程序，可以输入EOF退出，方法：如上面的回复，使用键盘组合键。  对比一下这两个地方： int getch(void) {     return (bufp > 0) ? buf[--bufp] : getchar(); }  double pop(void) {     if (sp > 0) {         //printf("%.8f", val[sp]);         return val[sp--];     } else {         printf("error: stack empty\n");         return 0.0;     } }

user: user-3
content: 如果是windows系统，可以参考楼上的做法 ubuntu下的话，请用ctrl+d来输入eof

user: user-4
content: 试试 Ctrl-Z 结束输入。
user-0 提问: 小白求教！！1请问哪里错了，我想写一个点击物体出现文本再点击就消失

回复:
user: user-1
content: 这是C#吧。

user: user-2
content: 引用 1 楼 zhao4zhong1 的回复:这是C#吧。 赵老师竟然使用了不确定的句式
user-0 提问: c51 一个工程下两个c代码文件 建立文件时出现了警告

回复:
user: user-1
content: 多个c文件放在同一个工程下，就是整个工程都可以用到的，这里有两个main肯定要去掉一个的， 把各种功能的代码封成独立的文件，这些独立文件里面都不需要main函数 然后main函数独立一个文件，  你把你的这两个c文件里面的main函数都屏蔽掉，然后再建立一个main.c的文件添加到工程里面，然后把那两个c文件#include进来， 在这里面实现main函数的功能。 比如这样的代码结构，把各种功能独立出来

user: user-0
content: 引用 5 楼 gspuser 的回复:多个c文件放在同一个工程下，就是整个工程都可以用到的，这里有两个main肯定要去掉一个的， 把各种功能的代码封成独立的文件，这些独立文件里面都不需要main函数 然后main函数独立一个文件，  你把你的这两个c文件里面的main函数都屏蔽掉，然后再建立一个main.c的文件添加到工程里面，然后把那两个c文件#include进来， 在这里面实现main函数的功能。 比如这样的代码结构，把各种功能独立出来   就目前学的还不是很懂，不过还是很谢谢你的耐心解答

user: user-0
content: 引用 2 楼 jianwufeng26 的回复:重复定义，看错误行。  应该怎么改呢

user: user-0
content: 引用 1 楼 gspuser 的回复:MULTIPLE PUBLIC DEFINITIONS 就是重复定义了，比如typedef unsigned int u16;  typedef unsigned char u8; u16 i;这些把这些公用的定义放在独立的一个h文件里面，然后其它都是包含这个头文件 还有同一个工程里面怎么两个c文件里面都有main函数  刚开始学51，用的keil4，都是建立一个c文件，没有分出写h文件，还有两个c文件在一个工程下不是相互独立的吗

user: user-2
content: 重复定义，看错误行。

user: user-1
content: MULTIPLE PUBLIC DEFINITIONS 就是重复定义了，比如typedef unsigned int u16;  typedef unsigned char u8; u16 i;这些把这些公用的定义放在独立的一个h文件里面，然后其它都是包含这个头文件 还有同一个工程里面怎么两个c文件里面都有main函数