Mxode/CSDN-C_Language-2013_2023 huggingface dataset:
user-0 提问: 结构题数组问题求助

回复:
user: user-1
content: 引用 3 楼 sunglina 的回复:[quote=引用 2 楼 starytx 的回复:] 没有初始化，你想获得什么值？你想让编译器给你初始化吗？结构体也可以弄个默认构造函数嘛，相当于自动初始化了   我是想直接给结构体赋值，如果没有初始化，那么是不是不能直接这样用 b[1].p = "hello"[/quote]  可以直接：b[1].p = "hello"

user: user-1
content: 引用可以直接b[1].i,b[1].p这样使用吗  可以

user: user-1
content: 引用请问第二个元素是怎么处理初始化的  第二个元素用0填充

user: user-2
content: 其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。

user: user-3
content: 引用 3 楼 sunglina 的回复:[quote=引用 2 楼 starytx 的回复:] 没有初始化，你想获得什么值？你想让编译器给你初始化吗？结构体也可以弄个默认构造函数嘛，相当于自动初始化了   我是想直接给结构体赋值，如果没有初始化，那么是不是不能直接这样用 b[1].p = "hello"[/quote]可以啊，我只是说不能引用，赋值当然是可以的

user: user-0
content: 引用 2 楼 starytx 的回复:没有初始化，你想获得什么值？你想让编译器给你初始化吗？结构体也可以弄个默认构造函数嘛，相当于自动初始化了   我是想直接给结构体赋值，如果没有初始化，那么是不是不能直接这样用 b[1].p = "hello"

user: user-3
content: 没有初始化，你想获得什么值？你想让编译器给你初始化吗？结构体也可以弄个默认构造函数嘛，相当于自动初始化了

user: user-4
content: 当我们定义一个结构体后,没有初始化就使用,就会访问到内存的垃圾数据,而且这种错误很难发现。 对于定义的任何变量,在使用之前都先初始化是个良好的习惯。

user: user-5
content: #include <stdio.h>  struct a {     int i;     char *p; };  //struct a b[2] = { {1,"we"}}; int main() {     struct a b[2] = { {1,"we"}};          printf("%d\n", b[1].i);     if (b[1].p == NULL)     printf("p == NULL\n");      return 0; } 可以通过这个小程序验证自己的猜测； 若struct a b[2]如此初始化，那么b[1].i为0，b[1].p= NULL；即第一个结构体成员初始化，第二个默认是都为0；类似 int array[10] = { 1, 2, 3 };  后面array[3], .... array[9]都为0
user-0 提问: printf函数中没有修改变量的值，却会影响相关变量的值吗？

回复:
user: user-1
content: VS和GDB都有数据断点功能专门用来解决此类问题。 关键是看楼主学不学得会了。

user: user-2
content: 深究这个问题还是挺有意思的。不要只抓着那些编程的原则不放。看看编译器，看看进程运行的内存状态，再来研究这个有趣的问题，蛮好玩的。

user: user-0
content: 感谢各位大神回复。 主要是想弄清楚，有printf与没有printf，为什么造成后面的输出不一致。当然，++p确实不应该这样使用，但这个不是本问题的重点。 经过提示，再进行跟踪调试发现，VS在有无printf编译后，变量位置没有发生变化，所以有没有printf没有影响输出。而gcc在有无printf的编译结果，变量的位置是不一样的，所以造成两次输出不一致。

user: user-3
content: 变量怎么排是未定义的，VS调试时，各变量地址之间有12字节的间隔，所以++p 这种写法没什么意义

user: user-1
content: #include <time.h> #include <stdlib.h> #include <windows.h> int main() {     int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]      srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。     while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。         b[(a=rand()%11)]=0;         Sleep(100);         b[(a=rand()%11)]=1;         Sleep(100);         b[(a=rand()%11)]=2;         Sleep(100);         b[(a=rand()%11)]=3;         Sleep(100);         b[(a=rand()%11)]=4;         Sleep(100);     }     return 0; }

user: user-4
content: 以上正解，而且编译器可以自由实现这些细节，没必要关心。

user: user-5
content: 同意2楼，*(++p)会随机对应到内存中的某块数据 这是非安全的操作

user: user-6
content: 不用试图找什么原因。 代码中使用 *(++p) 就是错的，除非p是数组，否则任何可能的后果都要自负。 不要对编译器做什么假设，因为编译器实现的只是语言的标准，标准不会规定一些细节的，原因在于C语言的设计原则，追求效率，相信程序员。即使是同一编译器，在不同的OS上，实现细节也有不同；即使是同一OS上，同一编译器的不同版本，实现细节也可能有不同。 一句话，不要做无意义的讨论。

user: user-7
content: #include <stdio.h> int main() {     int *p, z = 43, a=100, b=1767, c=15164;     p = &a;     //printf(" %p,%p,%p,%p,%p\n", &p,&z,&a,&b,&c);//本行注释与否对结果有影响？     printf("%p, %p\n", &b, &c);     printf("%d\n",*p);     printf("%p\n", p);     printf("%d\n",*(++p));      printf("%d\n",a);     printf("%p, %p\n", &b, &c);      return 0; } 打印地址，建议使用%p或%P; 加上printf行应该是改变了函数栈上变量的位置。
user-0 提问: 新手问题，求解决

回复:
user: user-1
content: vc6.0是比较早的产物了。建议采用vs2008建一个空项目，把代码贴进去编译。不是你代码的问题

user: user-2
content: 在VC6中新建一个Win32 Console空项目，将你的代码添加到Source Files中，……

user: user-3
content: 应该是函数库的问题吧
user-0 提问: 如何交换函数指针数组里的元素呢？

回复:
user: user-1
content: 引用 4 楼 qq_34287840 的回复:[quote=引用 3 楼 paschen 的回复:] 和交换普通常量一样的原理呗   	void(*TMP)(PSchedule) = XXX[0]; 	XXX[0] = XXX[1]; 	XXX[1] = TMP;  那个，我的意思是用一个swap函数来交换，但是我搞不懂swap的参数到底应该怎么来表示，感觉有点复杂，请大大赐教！[/quote]  void Swap(void(**A)(PSchedule), void(**B)(PSchedule))

user: user-0
content: 引用 1 楼 cfjtaishan 的回复:函数指针数组，那么每个函数指针就是存放一个地址，即函数的首地址。 如果交换，应该就是交换里面的地址值， 类似这样： 交换第一和第二个的地址值   void (*pfunc) (PSchedule);  pfunc = XXX[0]; XXX[0] = XXX[1]; XXX[1] = pfunc;  我的想法是用一个swap函数来交换，但是我搞不懂swap的参数到底应该怎么来表示，麻烦大神赐教！

user: user-0
content: 引用 3 楼 paschen 的回复:和交换普通常量一样的原理呗   	void(*TMP)(PSchedule) = XXX[0]; 	XXX[0] = XXX[1]; 	XXX[1] = TMP;  那个，我的意思是用一个swap函数来交换，但是我搞不懂swap的参数到底应该怎么来表示，感觉有点复杂，请大大赐教！

user: user-1
content: 和交换普通常量一样的原理呗   	void(*TMP)(PSchedule) = XXX[0]; 	XXX[0] = XXX[1]; 	XXX[1] = TMP;

user: user-2
content: 仅供参考：#include <stdio.h> #define SWAP(a,b) do ((&(a))!=(&(b)))?((a)^=(b)^=(a)^=(b)):((a)=(a)); while (0) char   *p1="1" ,*p2="2" ; char    c1=1   , c2=2   ; short   s1=1   , s2=2   ; int     i1=1   , i2=2   ; __int64 I1=1i64, I2=2i64; float   f1=1.0f, f2=2.0f; double  d1=1.0 , d2=2.0 ; void main() {     SWAP((int)p1,(int)p2);                printf("char *     %5s,   %5s\n",p1,p2);     SWAP(c1,c2);                          printf("char       %5d,   %5d\n",c1,c2);     SWAP(s1,s2);                          printf("short      %5d,   %5d\n",s1,s2);     SWAP(i1,i2);                          printf("int        %5d,   %5d\n",i1,i2);     SWAP(I1,I2);                          printf("__int64 %5I64d,%5I64d\n",I1,I2);     SWAP(*(int     *)&f1,*(int     *)&f2);printf("float      %5g,   %5g\n",f1,f2);     SWAP(*(__int64 *)&d1,*(__int64 *)&d2);printf("double    %5lg,  %5lg\n",d1,d2);      SWAP(c1,c1);     printf("%d\n",c1); } //char *         2,       1 //char           2,       1 //short          2,       1 //int            2,       1 //__int64     2,    1 //float          2,       1 //double        2,      1 //2

user: user-3
content: 引用 5 楼 qq_34287840 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 函数指针数组，那么每个函数指针就是存放一个地址，即函数的首地址。 如果交换，应该就是交换里面的地址值， 类似这样： 交换第一和第二个的地址值   void (*pfunc) (PSchedule);  pfunc = XXX[0]; XXX[0] = XXX[1]; XXX[1] = pfunc;  我的想法是用一个swap函数来交换，但是我搞不懂swap的参数到底应该怎么来表示，麻烦大神赐教！[/quote]   typedef void (*pfunc)(PSchedule); void swap(pfunc *a, pfunc *b) {     pfunc c;     c = *a;     *a = *b;     *b = c; } //调用： swap(&XXX[0], &XXX[1]);

user: user-3
content: 函数指针数组，那么每个函数指针就是存放一个地址，即函数的首地址。 如果交换，应该就是交换里面的地址值， 类似这样： 交换第一和第二个的地址值   void (*pfunc) (PSchedule);  pfunc = XXX[0]; XXX[0] = XXX[1]; XXX[1] = pfunc;
user-0 提问: 关于stc可仿真芯片用keil debug调试 

回复:
user: user-0
content: 引用 1楼赵4老师 的回复:有源代码改源代码，没源代码改设置，改不了设置加ahk脚本，加ahk脚本无效就Hook，Hook不了就Crack，…… ahk脚本参考http://www.autohotkey.com……不懂你说的啊

user: user-1
content: 有源代码改源代码，没源代码改设置，改不了设置加ahk脚本，加ahk脚本无效就Hook，Hook不了就Crack，…… ahk脚本参考http://www.autohotkey.com
user-0 提问: 数据结构，树的转换

回复:
user: user-0
content: 引用 3 楼 赵4老师的回复:百度搜相关关键字。 谢谢

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

user: user-0
content: 引用 1 楼 赵4老师的回复: 谢谢

user: user-1
user-0 提问: 关于简单的c语言的问题，请各位大佬纠正一下，为什么循环只循环了一遍

回复:
user: user-1
content: #include"stdio.h" #include"stdlib.h"  struct student {     int number;     char name[20];     int brithyear;     struct student *next; }*a; FILE *fp;  void cage(struct student *a, int n, int nf) {     int aa,b,c,d;     aa = nf - a->brithyear;     printf("aa = %d, nf = %d, birthday = %d\n", aa, nf, a->brithyear);     if (aa>20)     {         fprintf(fp,"%d,%s,%d\n",a->number,a->name,a->brithyear);     }     a=a->next;     b=nf-a->brithyear;     printf("b = %d, nf = %d, birthday = %d\n", b, nf, a->brithyear);     if (b>20)     {         fprintf(fp,"%d,%s,%d\n",a->number,a->name,a->brithyear);     }     a=a->next;     c=nf-a->brithyear;     printf("c = %d, nf = %d, birthday = %d\n", c, nf, a->brithyear);     if (c>20)     {         fprintf(fp,"%d,%s,%d\n",a->number,a->name,a->brithyear);     }     a=a->next;     d=nf-a->brithyear;     printf("d = %d, nf = %d, birthday = %d\n", d, nf, a->brithyear);     if (d>20)     {         fprintf(fp,"%d,%s,%d\n",a->number,a->name,a->brithyear);     } };  int main() {     struct student a[4];     int m;     int num=15030521;     char studentname[]={"孙璐"};     printf("请输入4个学生的学号、姓名和出生年份\n");     int i=0;     for (i = 0; i < 4; i++)     {         scanf("%d%s%d", &a[i].number, a[i].name, &a[i].brithyear);         if (i <= 2)             a[i].next = &a[i+1];         else             a[i].next = NULL;      }     if((fp=fopen("bj1.txt","w"))==NULL)     {         printf("can't open file");         return -1;     }     printf("请输入年份\n");     scanf("%d",&m);     printf("下面是年龄大于20的学生信息\n");     cage(a,4,m);     fprintf(fp,"%d,%s\n",num,studentname);     fclose(fp);      return 0; } 链表知识还需要巩固一下，没有对next指针进行初始化，怎么在cage里直接运用呢？

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

回复:
user: user-1
content: 仅供参考：#include <stdio.h> double A[300][100]; double valuex[300]; double valuey[300]; int i; double fun00(double x,double y) {return x  +   y  ;}; double fun01(double x,double y) {return x*x+ 3*y  ;}; double fun02(double x,double y) {return x  + 2*y*x;}; //...  fun03(double x,double y) {return ...+...   ;}; //... //...  fun98(double x,double y) {return ...+...   ;}; double fun99(double x,double y) {return x/2+20*y  ;}; double (*funNN[100])(double,double)={     fun00,     fun01,     fun02, //  fun03, //  ... //  fun98,     fun99, }; int main() {     double x,y;     int f,FN;      for (i=0;i<300;i++) {         valuex[i]=(double)i;         valuey[i]=(double)i;     }     FN=3;     for (i=0;i<300;i++) {          x=valuex[i];          y=valuey[i];          for (f=0;f<FN;f++) A[i][f]=funNN[f](x,y);     }     for (i=0;i<3;i++) {         for (f=0;f<FN;f++) printf("%lg ",A[i][f]);         printf("\n");     } 	return 0; } //0 0 0 //2 4 3 //4 10 10  #include <stdio.h> #include <vector> #include <algorithm> using namespace std; int i; int L; void main(int argc,char **argv) { 	if (argc<2)	{ 		printf("%s 要排列的字符串\n",argv[0]); 		return; 	}     L=strlen(argv[1]);     vector<char> P(L);     vector<char>::iterator b,e,it;     b=P.begin();     e=P.end();     for (i=0;i<L;i++) P[i]=argv[1][i]; 	sort(b,e);     i=0;     do {         printf("%10d: ",++i);         for(it=b;it!=e;it++) printf("%c",*it);         printf("\n");     } while (next_permutation(b,e));     printf("The total: %d",i); }

user: user-2
content: 建议用函数指针数组，将四个函数赋值到函数指针数组里，通过对数组元素（函数指针变量）进行排列组合，这样就可以把函数所有组合都执行一遍。
user-0 提问: 非正常结束的程序执行 UnhookWindowsHookEx 失败

回复:
user: user-1
content: 引用 4 楼 Icy_Ybk 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] http://bbs.csdn.net/topics/390787357 这... 跟我的问题有什么关系..[/quote] 没必要追求正常结束。

user: user-0
content: 引用 3 楼 zhao4zhong1 的回复:http://bbs.csdn.net/topics/390787357 这... 跟我的问题有什么关系..

user: user-1
content: http://bbs.csdn.net/topics/390787357

user: user-0
content: 估计与按 CTRL+C 的时候也会被钩子函数处理吧？是不是跟这个有关呢？

user: user-0
content: 正常结束的意思是，按了 Q 键。程序里写了有在按 Q 键的时候发送一个退出消息。
user-0 提问: 最大公约数a和b交换次数

回复:
user: user-1
content: http://blog.csdn.net/canhui_wang/article/details/50760510

user: user-0
content: 引用 1楼幻夢之葉 的回复:http://blog.csdn.net/canhui_wang/article/details/50760510？？
user-0 提问: （新手）关于随机数

回复:
user: user-1
content: http://www.cnblogs.com/yeahgis/archive/2012/07/15/2592687.html  均匀分布使用最常规的就可以了。 指数分布可以参考上述链接，先使用均匀分布生成某随机数，然后进行某个算法改变它所生成的随机值，使这个随机算法看起来是指数分布的

user: user-2
content: 搜“线性同余”

user: user-2
content: C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\rand.c /*** *rand.c - random number generator * *       Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *       defines rand(), srand() - random number generator * *******************************************************************************/  #include <cruntime.h> #include <mtdll.h> #include <stddef.h> #include <stdlib.h>  /*** *void srand(seed) - seed the random number generator * *Purpose: *       Seeds the random number generator with the int given.  Adapted from the *       BASIC random number generator. * *Entry: *       unsigned seed - seed to seed rand # generator with * *Exit: *       None. * *Exceptions: * *******************************************************************************/  void __cdecl srand (         unsigned int seed         ) {         _getptd()->_holdrand = (unsigned long)seed; }   /*** *int rand() - returns a random number * *Purpose: *       returns a pseudo-random number 0 through 32767. * *Entry: *       None. * *Exit: *       Returns a pseudo-random number 0 through 32767. * *Exceptions: * *******************************************************************************/  int __cdecl rand (         void         ) {         _ptiddata ptd = _getptd();          return( ((ptd->_holdrand = ptd->_holdrand * 214013L             + 2531011L) >> 16) & 0x7fff ); }

user: user-2
content: http://www.cplusplus.com/reference/random/index.html

user: user-3
content: srand((unsigned)time(NULL));   rand();

user: user-4
content: random()*k + b  k = (N-M)/65536      b = M-0

user: user-5
content: 下面这篇文章是关于随机数生成的，请多指教 http://blog.csdn.net/hou09tian/article/details/54630443

user: user-6
content: 这个问题，建议楼主先写一个程序用random获取随机数。 然后执行几次，你会发现获取到的随机数都是一样，没有随机性。 想要获取不同的随机数据，就得设不一样的种子数才行.  常用设随机数种子的方法:   srand(getpid()); //以进程号作随机数种子， 每个进程号是唯一的   srand(time()); //以系统时间作随机数种子
user-0 提问: 小白求助 关于字符数组占内存的问题

回复:
user: user-1
content: 可以参考一下这个资料 http://blog.csdn.net/libing403/article/details/72971863

user: user-2
content: http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

user: user-3
content: 因为变量是是在栈上，栈为其分配空间这个是不固定的。假如第一运行，栈分配了A地址开始的空间用于运行，运行结束后A地址的空间就会释放，即其他程序可以继续利用A地址开始的栈空间，第二次运行时，A地址开始的栈空间可能就被其他函数占用，所以有可能获取的变量地址值是不一样的。

user: user-2
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执行停在该断点处的时候。

user: user-4
content: 地址值由操作系统自动分配，并不是每次都一样的。

user: user-5
content: 其实这个问题与换行符无关，是因c,d,e变量都是在栈里分配空间的，栈是重复用的。也就是说你现在程序执行分配的空间有可能是上一个进程刚用过的. c,d,e变量的值就是上次使用留下的值。
user-0 提问: 关于mysql_close()对mysql_real_connect()的断开连接

回复:
user: user-0
content: 感谢您的指教，真是解决了我一个大问题，但是我还想更深入了解这个问题，能不能分析一下这个问题，或者在哪可以有相关的知识，因为我在网上找了很久都没找到有关的知识。谢谢！！！

user: user-1
content: 再做一次mysql_init然后再realconnect
user-0 提问: 【求助】为什么没有运行第一个gets直接运行第二个去了

回复:
user: user-0
content: 引用 3楼自信男孩 的回复:gets调用前，如果有输入，建议见gets前加一句getchar();因为，gets是遇到回车符停止输入，然后返回。如果在gets前有输入，那么在输入缓冲区里就残留上次输入留下的回车符，所以，gets遇到这个回车符直接返回了。getchar()的作用就是接收输入缓存里残留的回车符，后面就会正常输入了。 gets是遇到回车就返回，这个是需要注意的。谢谢啦！

user: user-1
content: gets调用前，如果有输入，建议见gets前加一句getchar();因为，gets是遇到回车符停止输入，然后返回。如果在gets前有输入，那么在输入缓冲区里就残留上次输入留下的回车符，所以，gets遇到这个回车符直接返回了。getchar()的作用就是接收输入缓存里残留的回车符，后面就会正常输入了。 gets是遇到回车就返回，这个是需要注意的。

user: user-0
content: 说错了     应该是在p1里gets（b1）用不了，但是引用过去后e=getchar（）用不了反到一直在运行gets（b1）

user: user-0
content: 就是在p1里gets（比1）用不了，但是引用过去后e=getchar（）用不了反到一直在运行gets（p1）
user-0 提问: c  的scanf() 函数

回复:
user: user-0
content: 感谢各位大佬，我以后会注意这个问题

user: user-1
content: //请今后要用 char c; scanf("%c",&c); //时，都改为 char s[2]; char c; scanf("%1s",s); c=s[0];

user: user-2
content: fflush(stdin); 刷新输入缓冲区，  scanf("%c",&(sample.vertexs[i])); 会读取回车。

user: user-3
content: 引用 2 楼 lcqqcllcqqcl 的回复:你提的那个建议很好，也符合我输入的习惯； 我还有一个问题  printf("请输入各边的长度（权重），格式为：顶点号，顶点号，边长\n"); for(j=0;j<sample.amount_edges;j++) { scanf("%d,%d,%f",&i,&k,&(sample.edges[i][k]));      /*若是无向图，则edges[j][i]*=edges[i][j]*/ }; 这一段代码，为什么会错？而我换成  	float temp; 		scanf("%d,%d,%f",&i,&k,&temp); 		sample.edges[i][k]=temp; 就可以正常运行。。。。。。。 －－－循环里面，这里i,k的值还没有输入，所以不能实现取二维数组的地址 &(sample.edges[i][k])

user: user-4
content: scanf("%d,%d,%f", &i, &k, &(sample.edges[i][k])); 这里分成两条scanf来写  否则，&(sample.edges[i][k]) 这里的k还没初始化就使用了

user: user-0
content: 但是通过scanf()函数不是给i,k,  sample.edges[i][k]值了吗？而i,k在数组元素之前；。。[size=24px]

user: user-5
content: 引用 2 楼 lcqqcllcqqcl 的回复:你提的那个建议很好，也符合我输入的习惯； 我还有一个问题  printf("请输入各边的长度（权重），格式为：顶点号，顶点号，边长\n"); for(j=0;j<sample.amount_edges;j++) { scanf("%d,%d,%f",&i,&k,&(sample.edges[i][k]));      /*若是无向图，则edges[j][i]*=edges[i][j]*/ }; 这一段代码，为什么会错？而我换成  	float temp; 		scanf("%d,%d,%f",&i,&k,&temp); 		sample.edges[i][k]=temp; 就可以正常运行。。。。。。。 scanf("%d,%d,%f",&i,&k,&(sample.edges[i][k])); 时，i、k是什么值？还没有确定的值，就往sample.edges[i][k]中存东西，肯定出错了

user: user-0
content: 你提的那个建议很好，也符合我输入的习惯； 我还有一个问题  printf("请输入各边的长度（权重），格式为：顶点号，顶点号，边长\n"); for(j=0;j<sample.amount_edges;j++) { scanf("%d,%d,%f",&i,&k,&(sample.edges[i][k]));      /*若是无向图，则edges[j][i]*=edges[i][j]*/ }; 这一段代码，为什么会错？而我换成  	float temp; 		scanf("%d,%d,%f",&i,&k,&temp); 		sample.edges[i][k]=temp; 就可以正常运行。。。。。。。

user: user-6
content: getchar();    /*加这句，这句用于接收残留在输入缓冲区里的回车符（上一次输入留下的，就是因为接下来要用%c格式输入）*/ for(i=0;i<sample.amount_nodes;i++) { scanf("%c",&(sample.vertexs[i]));    /*去掉\n*/  }    /*去掉这儿的分号，因为不需要*/ 如果还是按照你的目前输入方式，for循环里的输入每输入一次就一次回车，建议在每次输入vertex[i]之后都要加一句getchar();像这样   getchar(); for(i=0;i<sample.amount_nodes;i++) { scanf("%c",&(sample.vertexs[i])); getchar();  } 原因和第一次没有输入一样； 如果for循环里的数据是在不换行的情况下，一次输入（每次都以空格隔开）则不需要getchar();
user-0 提问: for循环中scanf函数使用出错！！请大神赐教！

回复:
user: user-1
content: 在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 char c; scanf("%c",&c); //时，都改为 char s[2]; char c; scanf("%1s",s); c=s[0];

user: user-2

user: user-0
content: 引用 3 楼 自信男孩的回复:[quote=引用 2 楼 TFLiu666 的回复:] [quote=引用 1 楼 cfjtaishan 的回复:] 把fflush(stdin);用getchar();替换；第一个没有输入是因为第一个输入是上一个循环的回车符；即scanf_s的 原因是fflush(stdin);对标准输出还可以，但是对于标准输入stdin，操作是不可预知的。所以，用getchar();可以吸收scanf_s输入之后残留在输入缓冲区里的回车符   谢谢大神，这个问题解决掉了。但是又出现了一个,还请大神在帮帮忙 问题： 就是在利用for循环建立边表的时候，程序无条件总是中断，即进行不了《i，j》的录入。这又是为什么啊？  	printf("读入边《i，j》的顶点对应序号:\n");      //建立边表          	for (k = 0;k < G->EdgeNum;k++) 	{ 		printf("请输入（vi，vj）的顶点序号："); 	//	fflush(stdin);//清除标准输入输出缓冲区  		scanf_s("%d,%d", &i, &j);//读入边《i，j》的顶点对应序号      //问题出现在此处                            	//	getchar(); 		p = (EdgeNode*)malloc(sizeof(EdgeNode)); 		p->adjvertex = j; 		p->next = G->adjlist[i].firstedge; 		G->adjlist[i].firstedge = p;  		p = (EdgeNode*)malloc(sizeof(EdgeNode)); 		p->adjvertex = i;                    //邻接序号为i 		G->adjlist[j].firstedge = p; 	}[/quote] 在这个地方scanf_s就不要加getchar();了，因为加getchar();是针对下一个输入是以%c的。[/quote] 还想请教最后一个问题：是不是以后遇到这种情况都要用getchar()吞掉回车符？？

user: user-3
content: 引用 2 楼 TFLiu666 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 把fflush(stdin);用getchar();替换；第一个没有输入是因为第一个输入是上一个循环的回车符；即scanf_s的 原因是fflush(stdin);对标准输出还可以，但是对于标准输入stdin，操作是不可预知的。所以，用getchar();可以吸收scanf_s输入之后残留在输入缓冲区里的回车符   谢谢大神，这个问题解决掉了。但是又出现了一个,还请大神在帮帮忙 问题： 就是在利用for循环建立边表的时候，程序无条件总是中断，即进行不了《i，j》的录入。这又是为什么啊？  	printf("读入边《i，j》的顶点对应序号:\n");      //建立边表          	for (k = 0;k < G->EdgeNum;k++) 	{ 		printf("请输入（vi，vj）的顶点序号："); 	//	fflush(stdin);//清除标准输入输出缓冲区  		scanf_s("%d,%d", &i, &j);//读入边《i，j》的顶点对应序号      //问题出现在此处                            	//	getchar(); 		p = (EdgeNode*)malloc(sizeof(EdgeNode)); 		p->adjvertex = j; 		p->next = G->adjlist[i].firstedge; 		G->adjlist[i].firstedge = p;  		p = (EdgeNode*)malloc(sizeof(EdgeNode)); 		p->adjvertex = i;                    //邻接序号为i 		G->adjlist[j].firstedge = p; 	}[/quote] 在这个地方scanf_s就不要加getchar();了，因为加getchar();是针对下一个输入是以%c的。

user: user-0
content: 引用 1 楼 cfjtaishan 的回复:把fflush(stdin);用getchar();替换；第一个没有输入是因为第一个输入是上一个循环的回车符；即scanf_s的 原因是fflush(stdin);对标准输出还可以，但是对于标准输入stdin，操作是不可预知的。所以，用getchar();可以吸收scanf_s输入之后残留在输入缓冲区里的回车符   谢谢大神，这个问题解决掉了。但是又出现了一个,还请大神在帮帮忙 问题： 就是在利用for循环建立边表的时候，程序无条件总是中断，即进行不了《i，j》的录入。这又是为什么啊？  	printf("读入边《i，j》的顶点对应序号:\n");      //建立边表          	for (k = 0;k < G->EdgeNum;k++) 	{ 		printf("请输入（vi，vj）的顶点序号："); 	//	fflush(stdin);//清除标准输入输出缓冲区  		scanf_s("%d,%d", &i, &j);//读入边《i，j》的顶点对应序号      //问题出现在此处                            	//	getchar(); 		p = (EdgeNode*)malloc(sizeof(EdgeNode)); 		p->adjvertex = j; 		p->next = G->adjlist[i].firstedge; 		G->adjlist[i].firstedge = p;  		p = (EdgeNode*)malloc(sizeof(EdgeNode)); 		p->adjvertex = i;                    //邻接序号为i 		G->adjlist[j].firstedge = p; 	}

user: user-3
content: 把fflush(stdin);用getchar();替换；第一个没有输入是因为第一个输入是上一个循环的回车符；即scanf_s的 原因是fflush(stdin);对标准输出还可以，但是对于标准输入stdin，操作是不可预知的。所以，用getchar();可以吸收scanf_s输入之后残留在输入缓冲区里的回车符
user-0 提问: 在windows上使用dir命令获取的文件绝对路径，在linux上无法加载该文件

回复:
user: user-1
content: linux路径里用的是斜杠/ win路径用的是反斜杠\

user: user-2
content: "/home/pic/000001.jpg"→"//home//pic//000001.jpg" 试一试

user: user-3

user: user-4
content: \替换为/ ？

user: user-3

user: user-5
content: “发现报错，找不到这些文件” 具体报什么错，加载图片的代码可否贴出

user: user-6
content: 是不是权限的问题，在/home/pic/下存放文件和读取文件是需要root的权限的
user-0 提问: c语言小白求助，小黑框秒退，看不到结果

回复:
user: user-1
content: 代码没有错误，顺利执行完成， 所以直接退出了 在return 0之前加上getchar()

user: user-2
content: 按照1楼的做法，窗口不会闪退的

user: user-3
content: 现在的码农竟然99%都不会在cmd窗口中输入cd命令设置当前目录为程序所在目录，输入程序名运行程序了！

user: user-4
content: 最简单的办法，在return 0前面加几个getchar() 我就不解释了  慢慢的你就懂了

user: user-5
content: 应该是环境问题，程序逻辑和语法都没有问题。建议检查一下编译和运行环境是不是有问题。（比如，打印一个helloworld看是否有问题）。

user: user-0
content: 加头文件 #include<iostream> 再在return前加 system("pause");
user-0 提问: 一个程序，折腾了很久，来个大神看看

回复:
user: user-1
content: #include <stdio.h> #include <stdlib.h> #include <time.h>  int i,j,r,c; int s_a1[11],c_a1[5];  void s_a(int a[][5]); void c_a(int a[][5]); int  search_(int a[][5]); double jariance(void);  int main() {     int s[11][5];      srand(time(NULL));     for(i=1;i<=10;i++)     {         printf("student %d:\n",i);         for(j=0;j<=4;j++)         {             //scanf("%d",&s[i][j]);             s[i][j] = rand() % 100;         }     }     s_a(s);     c_a(s);     printf("\n");     printf("class     \t1\t2\t3\t4\t5\taverage\n");     for(i=1;i<=10;i++)     {         printf("student %d\t",i);         for(j=0;j<=4;j++)         {             printf("%d\t",s[i][j]);         }         printf("%d\n", s_a1[i]);     }     printf("\t\t");     for(j=0;j<=4;j++)     {         printf("%d", c_a1[j]);     }     printf("\n");      printf("the student: %d\t the class: %d\t, the highest: %d\n", r, c, search_(s));    /*根据参数压栈顺序：从右向左压栈，所以改变一下输出顺序，否则r c的值一直为0*/     printf("the jariance: %.2lf\n",jariance());    /*输出格式：double应用%lf,.2表示保留2位有效数字*/     return 0; }  /* aver col */ void s_a(int a[][5]) {     int sum;     for(i = 1; i <= 10; i++)     {         sum=0;         for(j=0;j<=4;j++)         {             sum=sum+a[i][j];         }         s_a1[i]=sum/5;     }  }  /* aver row */ void c_a(int a[][5]) {     int sum;     for(j = 0; j <= 4; j++)     {         sum = 0;         for(i = 1; i <= 10; i++)    /*这儿改一下，j++改成i++，手误吧*/         {             sum = sum + a[i][j];         }         c_a1[j] = sum/10;     }  }  int  search_(int a[][5]) {     int x=0;     for(i=1;i<=10;i++)     {         for(j=0;j<=4;j++)         {             if(x<a[i][j])             {                 x=a[i][j];                 r = i;                 c = j + 1;    /*如果上面是手误，这个地方就说不过去了，我想应该是将值赋值给全局变量c*/             }         }     }     return(x); }   double jariance(void) {     double sum=0,sum2=0,x;     for(i=1;i<=10;i++)     {         sum+=s_a1[i];         sum2+=s_a1[i]*s_a1[i];     }     x=sum2/10-(sum/10)*(sum/10);     return(x); }  有问题的地方，上面已一一描述了。 最后，建议函数声明不要放在main函数里，这个习惯不好。

user: user-2
content: void c_a(int a[][5]) { int sum; for(j=0;j<=4;j++) {  sum=0;  for(i=1;i<=10;j++)  {  sum=sum+a[i][j];  }   c_a1[j]=sum/10; }    细看这一行 for(i=1;i<=10;j++)
user-0 提问: Huffman编码树！！！

回复:
user: user-0
content: 引用 4 楼 zhao4zhong1 的回复:百度搜相关关键字。 谢谢

user: user-0
content: 引用 3 楼 cfjtaishan 的回复:for(j=0;j<n;j++)         {             scanf("%d", &w[j]); /*这儿需要加一个&，因为scanf要求的是地址*/         }  错了，错了，刚才我发的是下面这个题目的程序，但是测试答案很多组都是对的，但是交到openjudge上就是wrong answer，麻烦帮我看一下，谢谢 题目是这样子的： 树的转换  描述 我们都知道用“左儿子右兄弟”的方法可以将一棵一般的树转换为二叉树，如：       0                             0   /   |  \                         /  1  2  3       ===>     1     / \                           \   4   5                           2                                    / \                                  4   3                                   \                                    5  现在请你将一些一般的树用这种方法转换为二叉树，并输出转换前和转换后树的高度。 输入输入包括多行，最后一行以一个#表示结束。 每行是一个由“u”和“d”组成的字符串，表示一棵树的深度优先搜索信息。比如，dudduduudu可以用来表示上文中的左树，因为搜索过程为：0 Down to 1 Up to 0 Down to 2 Down to 4 Up to 2 Down to 5 Up to 2 Up to 0 Down to 3 Up to 0。 你可以认为每棵树的结点数至少为2，并且不超过10000。输出对于每棵树，按如下格式输出转换前和转换后树的高度： Tree t: h1 => h2 其中t是树的编号（从1开始），h1是转换前树的高度，h2是转换后树的高度。 样例输入 dudduduudu ddddduuuuu dddduduuuu dddduuduuu #  样例输出 Tree 1: 2 => 4 Tree 2: 5 => 5 Tree 3: 4 => 5 Tree 4: 4 => 4

user: user-0
content: 引用 3 楼 cfjtaishan 的回复:for(j=0;j<n;j++)         {             scanf("%d", &w[j]); /*这儿需要加一个&，因为scanf要求的是地址*/         }  这道题测试答案对了之后交到openjudge上是wrong answer，差不多找到哪里错了之后，又重新写了一个程序，测了很多组数据之后都对，但是还是错了，能麻烦给我看一下么，谢谢  这是重写的： #include<stdio.h> #include<string.h> #define N 2000 int h,len; int forest(char a[],int num_d,int num_u,int i) { 	num_d=0; 	while(a[i]=='d') {num_d++; i++;} 	if(num_d-num_u>=0) h+=num_d-num_u; 	num_u=0; 	while(a[i]=='u') {num_u++; i++;} 	if(i!=len) return forest(a,num_d,num_u,i); 	return h; } int tree(char a[],int depth,int num_d,int num_u,int i) { 	num_u=0; num_d=0; 	while(a[i]=='u') {num_u++; i++;} 	while(a[i]=='d') {num_d++; i++;} 	if(num_d-num_u>=0) depth+=1; 	if(i!=len) return tree(a,depth,num_d,num_u,i); 	return depth; } int main() { 	char a[N]; 	int i,j,k,t; 	int h1[N],h2[N]; 	for(i=0;;i++) 	{ 		scanf("%s",a); 		len=strlen(a);	 		for(j=0;j<len;j++) 		{ 			if(a[j]=='u')  			{ 				t=j; 				break; 			} 		} 		if(a[0]=='#') break; 		else 		{ 			h1[i]=forest(a,0,0,0); 			h=0; 			k=h1[i]; 			h2[i]=tree(a,k,0,0,t); 		} 	} 	for(j=0;j<i;j++) 	{ 		printf("Tree %d: %d => %d\n",j+1,h1[j],h2[j]); 	} 	return 0; }

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

user: user-2
content: for(j=0;j<n;j++)         {             scanf("%d", &w[j]); /*这儿需要加一个&，因为scanf要求的是地址*/         }

user: user-0
content: 交到openjudge上一直是wrong answer

user: user-0
content: 我的错找出来了，运行结果也对了，但是交上去显示wrong answer，请各位大神看看，谢谢
user-0 提问: 数组应该如何赋值和输出

回复:
user: user-1
content: 第一段输出的是数组a的首地址值，相当于&a[0]的值。

user: user-2
content: 哈哈，我也犯了这个低级错误

user: user-3
content: 数组只有初始化的时候可以使用大括号方式的语法，你第二段代码不能这样用，只能一个元素一个元素的赋值

user: user-3
content: 要输出数组要用for循环  for (int i = 0; i < 3; ++i)         cout << a[i] << endl;

user: user-4
content: 打酱油，漂过

user: user-5
content: int a[3]是定义数组，a[3]是指a[3]这个元素，你说有何区别

user: user-6
content: “变量赋值”和“变量初始化”不是一回事！ “变量赋值”发生在运行期，其写法遵循赋值语法规定。 “变量初始化”发生在编译期或运行期，其写法遵循初始化列表语法规定。

user: user-7
content: 第一种方式： #include "stdafx.h" #include <iostream> using namespace std;   int a[3] = { 1, 2, 3 }; void main() {     for (int i = 0; i < 3; i++)         cout << a[i] << endl; } 第二种方式： #include "stdafx.h" #include <iostream> using namespace std;   int a[3]; void main() {     for (int i = 0; i < 3; i++)         a[i] = i+1;     for (int i = 0; i < 3; i++)         cout << a[i] << endl; }

user: user-8
content: int a[3] = {1,2,3};这个[3]表示数组的个数；  a[3] = {1,2,3};这个[3]表示下标三
user-0 提问: 请问为什么这个字符串一输出就会崩溃？

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

user: user-2
content: %s 需要的是 char*类型的字符串，但你提供的是char类型的字符

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

user: user-3
content: *&el                                 哇哈哈哈哈哈~~

user: user-4
content: #include <stdio.h> #include <string.h>  void main(void) {     char *el[] = { "无" };     char *e1 = el[0];      printf("%s\n", e1); }  el是字符指针数组，el数组的每个元素都是指针。因此e1就需要是指针。

user: user-5
content: el[0]表示你字符串第一个字符，*el[0]表示访问e1[0]地址的值；比如你字符串第一个字符时‘A’（65），那么e1 = *el[0];表示去65这个地址的数据出来给e1，而这个地址是OS内核空间，不允许你程序访问的；这是你报错的原因；  我觉得你的初衷肯定是把字符串第一个字符赋值给e1，那么直接用e1 = el[0]；即可；
user-0 提问: 请问16进制在编写程序时有什么用？

回复:
user: user-1
content: 16进制表示方便，便于理解字节序。计算机中的都是二进制

user: user-2
content: 二进制是基础，位运算比较高效，有时还更方便，比如掩码

user: user-3
content: 计算机中数据都是用二进制存储，而八进制与十六进制可以比十进制更方便的表示二进制

user: user-4
content: 当你在做数据传输, (比如网络数据传输,串口等),  并且要自定义一些协议时, 你就会发现16进制非常有用. 你要明确知道某个字节是表示什么东西, 以16进制打印出来看时, 就会更清晰.  存在即是合理

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

user: user-6
content: 对于一个32位数或buffer，16进制可以看到每个字节的值，这个用途比较常见的是wireshark抓到协议包，显示的就是16进制。

user: user-7
content: 计算机内部存储、总线上传输、CPU处理的每一位都是二进制数，0或者1，电平的高或者低（正逻辑或者负逻辑），8位二进制数构成一字节。

user: user-8
content: 在你想知道每个bit是0还是1的时候  1C8  可能一看就知道是   0001 1100 1000 456  根本看不出来

user: user-7
content: 计算机的数制基础是二进制（利用TTL电平的高或低，简单，抗干扰强），二进制难以书写和记忆，4位二进制数等价于一位16进制数，3位二进制数等价于一位8进制数，所以16进制很常用。
user-0 提问: 使用了系统禁止的操作系统调用，看看是否越权访问了文件或进程等资源，求大牛解答

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

回复:
user: user-1
content: 引用 5 楼 zhao4zhong1 的回复:[quote=引用 2 楼 mark_qzh 的回复:] [quote=引用 1楼赵4老师 的回复:]两者均可  pop是val=*--p 搭配 push是p++;*p=val  pop是val=*p-- 搭配 push是*p=val;p++;val=*--p不是先--吗？如果先--了，val的值还是栈顶的值吗？[/quote] 那我就是张冠李戴了，你自行交换一下。[/quote] 正解！

user: user-0
content: 引用 7楼paschen 的回复:看你栈怎么设计的，如果栈在压入元素后，指向的是栈顶元素前一个元素的话，出栈就用val=*--p嗯，我准备看一下数据结构

user: user-2
content: 看你栈怎么设计的，如果栈在压入元素后，指向的是栈顶元素前一个元素的话，出栈就用val=*--p

user: user-3
content: 反正就是看你的p指向哪儿了，如果出栈是 val=*--p 代表的p指向的是栈顶后的一个元素。  在C语言里，我们习惯用第一个入界点和第一个出界点来描述一段数值范围，所以我们经常看到一段循环遍历数组的代码为： for (int i = 0; i < n; ++i)  此时数组下标范围为[0, n), 这是一个半开半闭的区间，n - 1 才是最后一个元素。  在《C陷阱与缺陷》的《3.6 边界计算与不对称边界》有讲到这一点，并且还讨论了为什么习惯用这种方式，楼主感兴趣可以看看。

user: user-1
content: 引用 2 楼 mark_qzh 的回复:[quote=引用 1楼赵4老师 的回复:]两者均可  pop是val=*--p 搭配 push是p++;*p=val  pop是val=*p-- 搭配 push是*p=val;p++;val=*--p不是先--吗？如果先--了，val的值还是栈顶的值吗？[/quote] 那我就是张冠李戴了，你自行交换一下。

user: user-3
content: 引用 1 楼 zhao4zhong1 的回复:两者均可  pop是val=*--p 搭配 push是p++;*p=val  pop是val=*p-- 搭配 push是*p=val;p++;  这个反了吧，val=*--p 搭配的push 应该是 *p=val;p++; 这个吧。

user: user-4
content: 主要看你的栈是什么类型的，val = *--p；优先级是先--在计算--之后的p指向空间的值。  val = *p--;是先*，后-- 至于用哪个，要根据你的栈的结构，若p指向栈顶元素（已压栈的元素），那么用val = *p--；反之用val = *--p;

user: user-0
content: 引用 1楼赵4老师 的回复:两者均可  pop是val=*--p 搭配 push是p++;*p=val  pop是val=*p-- 搭配 push是*p=val;p++;val=*--p不是先--吗？如果先--了，val的值还是栈顶的值吗？

user: user-1
content: 两者均可  pop是val=*--p 搭配 push是p++;*p=val  pop是val=*p-- 搭配 push是*p=val;p++;
user-0 提问: c语言程序调试结果为什么会和运行结果不一致

回复:
user: user-0
content: 引用 7 楼 zhao4zhong1 的回复:num不初始化，里面有对应内存中以前的值。  恩，非常感谢。

user: user-0
content: 引用 6 楼 user-3 的回复:[quote=引用 4 楼 a501900309 的回复:] [quote=引用 2 楼 user-3 的回复:] char num[M] = {0}; 初始化一下字符串数组 /******  确实就正常了，非常感谢。 但是为什么用这 for(i = 0;i < M;i++) if(!(num[i] >= '0' && num[i] <= '9')) num[i] = 0; 把非‘0’到‘9’的值改为0，则会出现运行和调试不一致的问题呀？[/quote]因为你没有初始化，所以num里边的值不确定，debug模式下和release模式对未初始化的变量处理不一样，所以要养成初始化变量的好习惯。顺便说一下，如果像我那样初始化了，第一个for循环就没有啥必要了。[/quote]   恩恩，非常感谢

user: user-1
content: #include <stdio.h> #include <string.h>  #define M 50  int main() {     char num[M];     //int n,mask,t,d,index,count,i;     int i;     int sum = 0;      scanf("%s", num);     for(i = 0; i < strlen(num); i++)         if(!(num[i] >= '0' && num[i] <= '9'))             num[i] = 0;     // puts(num);     for(i = 0;i < M;i++){         if(num[i] >= '0'&&num[i] <='9' )             sum += (num[i] - '0');     }     printf("%d\n",sum);     return 0; } 输入的不到M（50）个，后面的数据都是随机值。所以第一个for循环的判断条件用strlen计算一下输入的字符个数；scanf会自动加上字符串的结束标记'\0'（值等价与0） 若输入的非'0'~'9'，num[i] = 0;0和'\0'是一样的，所以后面puts调试的输出遇到'\0'结束输出，调试的和sum 的结果不一致。

user: user-2
content: num不初始化，里面有对应内存中以前的值。

user: user-3
content: 引用 4 楼 a501900309 的回复:[quote=引用 2 楼 user-3 的回复:] char num[M] = {0}; 初始化一下字符串数组 /******  确实就正常了，非常感谢。 但是为什么用这 for(i = 0;i < M;i++) if(!(num[i] >= '0' && num[i] <= '9')) num[i] = 0; 把非‘0’到‘9’的值改为0，则会出现运行和调试不一致的问题呀？[/quote]因为你没有初始化，所以num里边的值不确定，debug模式下和release模式对未初始化的变量处理不一样，所以要养成初始化变量的好习惯。顺便说一下，如果像我那样初始化了，第一个for循环就没有啥必要了。

user: user-0
content: 引用 3 楼 zhao4zhong1 的回复:其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。  我还是小白，前面一句是看懂了，但能不能麻烦结合具体语句解释下，比如哪条语句会让计算机因为什么原因而出错了，我

user: user-0
content: 引用 2 楼 user-3 的回复:char num[M] = {0}; 初始化一下字符串数组 /******  确实就正常了，非常感谢。 但是为什么用这 for(i = 0;i < M;i++) if(!(num[i] >= '0' && num[i] <= '9')) num[i] = 0; 把非‘0’到‘9’的值改为0，则会出现运行和调试不一致的问题呀？

user: user-2
content: 其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。

user: user-3
content: char num[M] = {0}; 初始化一下字符串数组

user: user-2
content: #include<stdio.h> #define M 50 //int vmask(int n); int main(){ //char str[][10] ={"ling","yi","er","san","si","wu","liu","qi","ba","jiu"}; char num[M]; int n,mask,t,d,index,count,i; int sum = 0; for(i = 0;i < M;i++)num[i] = 0; scanf("%s",num); //	puts(num); for(i = 0;i < M;i++){ if(num[i] >= '0'&&num[i] <='9' ) sum += (num[i] - '0');  } printf("%d\n",sum); return 0; }
user-0 提问: c语言多重for循环如何优化

回复:
user: user-1
content: nested for loops can be reduced to one level. 只要循环之间没有额外语句，多少重的循环都可以写成一层的，但是未必一定会更有效，得看情况。

user: user-2
content: 试了一下，应该可以把上面的四重循环改成二重循环，如下：  	int h = height - sw - sw, w = width - sw - sw,num= (sw * 2 + 1); 	for (a = 0; a < h * w; a++) { 		i = a / h + sw; 		j = a % h + sw; 		sum = 0; 		calGaussCoef(pGaussCoef); 		for (b = 0; b < num*num; b++) { 			m = b / num - sw; 			n = b %num- sw; 			indexI = (i + m) * width + j + n; 			indexG = (m + sw) * slen + n + sw; 			sum += pSrcImg[indexI] * pGaussCoef[indexG]; 		} 		pDstImg[i * width + j] = (unsigned char)(sum); 	}

user: user-3
content: 先讲一下你的代码准备实现什么效果

user: user-4
content: 代码上看  1 calGaussCoef(pGaussCoef);  这个是多次重复调用，完全可以扔到循环外面去  2 最内层循环里面的这两句 indexI = (i+m)*width + j+n; indexG = (m+sw)*slen + n+sw; 乘法完全可以用加法来替代掉  从算法上看， 从一个大图片上取sw*sw的一个小正方形里面的所有像素 和 一个固定的系数矩阵挨个乘法后求和后放到一个新的图像数据去 这个乘法的过程没有重复发生的地方， 算法就无法优化  能优化的是可以考虑利用现代计算机多核的特性做并行计算了， 上述乘法之间的数据彼此之间互不影响，并行计算是可行的

user: user-5
content: 循环切换类似函数调用，会涉及到出栈/入栈操作，所以可以通过减少循环切换达到优化 大循环在里面，小循环在外面，减少切换次数 把不是重复操作的指令放到循环外面，减少循环体本身开销

user: user-1
content: 引用 1 楼 user-10 的回复:两层循环也叫多层？ 废话流

user: user-6
content: 过早的优化是万恶之源！  无profiler不要谈效率！！尤其在这个云计算、虚拟机、模拟器、CUDA、多核 、多级cache、指令流水线、多种存储介质、……满天飞的时代！

user: user-3
content: 引用 12 楼 optimistiveho 的回复:引用 9楼bravery36 的回复:四层就四层，也没有什么大不了的，而且只有优化算法才能减少运算量，这种代码没有什么好优化的，你能想到的编译器早就做了。但我们老师说还能优化 能 普通变量 改为 寄存器变量 i++ 改为 ++i 换一下内外层循环 简单函数改宏函数  加减乘除计算改用位运算 但都意义不大  这种代码 不改逻辑  真想优化是 自己动手嵌入汇编

user: user-0
content: 引用 9楼bravery36 的回复:四层就四层，也没有什么大不了的，而且只有优化算法才能减少运算量，这种代码没有什么好优化的，你能想到的编译器早就做了。但我们老师说还能优化

user: user-7
content: 优化的策略是：内大外小，即循环次数是内层大，外层小；

user: user-7
content: 优化的策略是：内大外小，即循环次数是内存大，外层小； http://blog.csdn.net/caolipeng_918/article/details/38453761

user: user-8
content: 四层就四层，也没有什么大不了的，而且只有优化算法才能减少运算量，这种代码没有什么好优化的，你能想到的编译器早就做了。

user: user-0
content: 引用 6楼lin5161678 的回复:[quote=引用 5 楼 optimistiveho 的回复:] [quote=引用 4楼ckc 的回复:]把外层可以计算的尽可能放到外层，减少在内层的运算， 比如indexI = (i+m)*width + j+n; 就可以把 (i+m)*width + j 放到一个临时变量里，在外层就计算好，这样在n循环的时候就只计算 indexl=临时变量+n 不过这个是小技巧，有些编译器也许会帮你处理过了先谢谢，如果将两个for变成用一个for和一个if来判断行不行呢，怎么样改[/quote]只调整循环层次没意义 影响效率的是循环次数 没办法降低循环次数 考虑修改循环层数  大部分是炫技游戏[/quote]大神，要是我把去掉第四层的话可以吗

user: user-3
content: 引用 1 楼 qq_36409192 的回复:两层循环也叫多层？仔细看是四层  ps 没缩进是楼主的问题了

user: user-3
content: 引用 5 楼 optimistiveho 的回复:[quote=引用 4楼ckc 的回复:]把外层可以计算的尽可能放到外层，减少在内层的运算， 比如indexI = (i+m)*width + j+n; 就可以把 (i+m)*width + j 放到一个临时变量里，在外层就计算好，这样在n循环的时候就只计算 indexl=临时变量+n 不过这个是小技巧，有些编译器也许会帮你处理过了先谢谢，如果将两个for变成用一个for和一个if来判断行不行呢，怎么样改[/quote]只调整循环层次没意义 影响效率的是循环次数 没办法降低循环次数 考虑修改循环层数  大部分是炫技游戏

user: user-0
content: 引用 4楼ckc 的回复:把外层可以计算的尽可能放到外层，减少在内层的运算， 比如indexI = (i+m)*width + j+n; 就可以把 (i+m)*width + j 放到一个临时变量里，在外层就计算好，这样在n循环的时候就只计算 indexl=临时变量+n 不过这个是小技巧，有些编译器也许会帮你处理过了先谢谢，如果将两个for变成用一个for和一个if来判断行不行呢，怎么样改

user: user-9
content: 把外层可以计算的尽可能放到外层，减少在内层的运算， 比如indexI = (i+m)*width + j+n; 就可以把 (i+m)*width + j 放到一个临时变量里，在外层就计算好，这样在n循环的时候就只计算 indexl=临时变量+n 不过这个是小技巧，有些编译器也许会帮你处理过了

user: user-0
content: 有没有大神帮忙

user: user-0
content: 引用 1楼user-10 的回复:两层循环也叫多层？然后呢，怎么优化

user: user-10
content: 两层循环也叫多层？
user-0 提问: 麻烦c语言老师们解惑

回复:
user: user-1
content: 主要是取模运算，是得到余数。 另外， 如果不取模，某个数的阶层已经大于factorial的取值范围了，取模能够保证数据的值不越界

user: user-2
content: 即factorial = (factorial * j % MOD); 从25为0； 感觉您自己应该已经找到答案了呀

user: user-2
content: 因为24的各级数之和是94313，之后所有数取模值为0，即25! % 1000000 = 0，之后所有的都一样
user-0 提问: 求教能否在允许阶段生成宏？

回复:
user: user-1
content: 宏是条件编译阶段就已经确定了， 它不能在运行的时候再区分运行那个分支。 如果在运行的时候来确定使用哪个分支，建议使用全局变量。

user: user-2
content: 不行的，　宏只能用常量的，不能用变量赋值。 l但宏可以在编译时指定宏的值，如：　gcc test.c -Ddirc=0x7788    // 相当于在源码里"#define dirc 0x7788"
user-0 提问: 指针函数怎么释放calloc? 为什么calloc创建后可以放入比创建空间更多的内容？

回复:
user: user-1
content: 其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。

user: user-2
content: calloc free 管理的内存，术语称作堆 用个不恰当的比方来形容堆的话 你可以把他想象为飞机或者火车的座位！callo 和 free就是售票程序 并不是calloc创造了指针，free不是销毁了指针。 而是类似于售票程序只是给你一张票。并且在系统中标记那个座位有人定了 如果中途有人改签之类的情况，free只是把那个座位重新标记为可以再给别人 所以，你用calloc订购一个座位，如果这个航班乘员比较少。那么你也可以做到别的座位上。

user: user-3
content: calloc 申请的内存用 free 释放  越界没出错只能证明运气好，不能说明什么

user: user-4
content: 首先，在main函数里这样释放是可以，因为释放calloc申请的空间，只需要将申请的地址传递给free形参即可释放。strtime返回的即申请的空间的首地址。 其次，calloc申请2个字节，很明显不够，":0%d"至少要用3个字节才能存放，再加上字符串的'\0'也要占用一个字节的空间，所以至少需要4个，这样申请会导致存放的数据溢出，有可能会出现多错误或覆盖后面的数据或数据被覆盖； 建议申请足够使用的空间；

user: user-5
content: ":0%d"这不是三个字节，这是3个字符（至少，因为后边的time不知道是几位数） 编译器不管放不放的下，放多了可能会破坏其他数据，存在安全隐患 动态申请的内存，需要手动释放（放弃控制权）的，否则直到程序退出会一直占用着系统空间
user-0 提问: 发现个有趣的现象，关于gcc -O编译优化和多线程资源共享的问题

回复:
user: user-1
content: 据我所知，在多核CPU环境下，即使寄存器，仍需考虑线程安全。

user: user-2
content: -O 优化会使去掉代码段某些内容。

user: user-1
content: 引用 1 楼 zhao4zhong1 的回复:据我所知，在多核CPU环境下，即使寄存器，仍需考虑线程安全。 当然此时总比内存在概率上更不易发生访问冲突。

user: user-3
content: 这个问题我也遇到过，加了-O后多线程的冲突减少，但是不知道原因呢……关注关注
user-0 提问: 大哥帮看看

回复:
user: user-1
content: Windows: 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  Linux： 进程意外退出会在当前目录下产生‘core’文件或形如‘core.数字’的文件比如‘core.1234’ 使用命令 gdb 运行程序名 core或core.数字 进入gdb然后使用bt命令 可以查看进程意外退出前函数调用的堆栈，内容为从上到下列出对应从里层到外层的函数调用历史。 如果进程意外退出不产生core文件，参考“ulimit -c core文件最大块大小”命令

user: user-1
content: Junly→July

user: user-1
content: 理解和讨论之前请先学会如何观察！  //char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf("typeid(x).name() is %s\n",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]

user: user-1
content: 搜“C语言 函数指针”

user: user-2
content: 没有看懂   <a href=" http://www.gzlxjk.com">关注两性健康</a> <a href=" http://www.hotzx.cn">热点资讯</a>

user: user-3
content: #include <stdio.h>  char y(char *p[],int x);  int main(void) {     char *e[12]={"Jan","Feb","Mar","Apr","May","June","July","Aug","Sep","Oct","Nov","Dec"};     int n;     char (*l)(char**, int);     l = y;     scanf("%d",&n);     l(e, n);      return 0; } char y(char *p[],int x) {     printf("%s %d\n",*(p+x+1),x);     return 0; } 定义的函数指针，与函数y的类型不匹配。首先需要明白，函数指针是指向函数的指针，那么定义的函数指针l不能指向e，因为e是一个字符指针数组。注意名称都不一样的。 另外，定义的函数指针l的参数类型也不匹配。需要定义成 char (*l)(char **, int);因为函数y的形参是char**类型的。 另外，建议再对上面的代码做一些优化：如下， #include <stdio.h>  int print_month_name(char **p,int x);  int main(void) {     char *e[12] = {"Jan", "Feb", "Mar", "Apr", "May",         "June", "July", "Aug", "Sep", "Oct", "Nov", "Dec"};     int n;     int (*pfunc)(char**, int);      pfunc = print_month_name;      scanf("%d", &n);     pfunc(e, n);      return 0; } int print_month_name(char **p, int x) {     if (x > 12 || x < 0) {         printf("Input error!\n");         return 0;     }     printf("%s %d\n",*(p + x - 1), x);     return 0; } 加上对x的判断，防止输入的数据导致读取e的元素越界，提示段错误；
user-0 提问: reverse_singly_linked_list

回复:
user: user-1
content: int main() { 	struct node *head = (struct node *)malloc(sizeof(struct node));; 	head->next = NULL; 	head->value = 0; 	 	/*for (int n = 7; n > 0; --n)*/ 		push(&head, 7); 		push(&head, 5); 		push(&head, 4); 		print_list(&head);    void push(struct node* *head_ref, int value)           //带头结点的 { 	struct node *new_node = (struct node *)malloc(sizeof(struct node)); 	new_node->value = value; 	if ((*head_ref)->next== NULL) 	{ 	    (*head_ref)->next = new_node; 		new_node->next = NULL; 		return; 	} 	new_node->next = (*head_ref)->next; 	(*head_ref)->next = new_node; 	 }    void print_list(struct node **head) { 	for (struct node *curr = (*head)->next; curr != NULL; curr = curr->next) 		printf("%d ", curr->value); }

user: user-2
content: 主函数 中  head是NULL，之后调用push(&head, n);传入head的地址  push函数中，new_node->next = (*head_ref)->next;，这里head_ref实际就是head的地址，(*head_ref)为NULL  (*head_ref)->next; 访问空指针，故会导致崩溃

user: user-3
content: 进程意外退出会在当前目录下产生‘core’文件或形如‘core.数字’的文件比如‘core.1234’ 使用命令 gdb 运行程序名 core或core.数字 进入gdb然后使用bt命令 可以查看进程意外退出前函数调用的堆栈，内容为从上到下列出对应从里层到外层的函数调用历史。 如果进程意外退出不产生core文件，参考“ulimit -c core文件最大块大小”命令

user: user-4
content: #include <stdio.h> #include <stdlib.h>  struct node {     int value;     struct node *next; };  void push(struct node **head_ref, int value);  void print_list(struct node *head);  void reverse(struct node **head_ref);  void reverse_with_recursion(struct node **head_ref);  int main() {     struct node *head = NULL;     int n;      head = (struct node *)malloc(sizeof(struct node));     if (!head)         return -1;     head->next = NULL;     for (n = 7; n > 0; --n)         push(&head, n);     print_list(head);     reverse(&head);     printf("after reverse: \n");     print_list(head);      reverse_with_recursion(&head);     print_list(head);      return 0; }  void push(struct node **head_ref, int value) {     struct node *new_node = (struct node *)malloc(sizeof(struct node));     new_node->value = value;     new_node->next = (*head_ref)->next;     (*head_ref)->next = new_node;    /* 将新节点插入头节点之后*/ }  void print_list(struct node *head) {     struct node *curr;     for (curr = head; curr != NULL; curr = curr->next)         printf("%d ", curr->value);     putchar(10); }  void reverse(struct node **head_ref) {     struct node *prev = NULL;     struct node *curr = *head_ref;     while (curr != NULL) {         struct node *next = curr->next;         curr->next = prev;         prev = curr;         curr = next;     }     *head_ref = prev; }  void reverse_with_recursion(struct node **head_ref) {     struct node *first = *head_ref;     struct node *rest = (*head_ref)->next;     if (rest == NULL)         return;     reverse_with_recursion(&rest);     first->next->next = first;     first->next = NULL;     *head_ref = rest; }  在push函数里，传入的head是指向NULL，所以若对(*head_ref)->next引用next必然会导致段错误； 既然是定义带哨兵的链表，先在main函数里定义哨兵节点，并初始化next指针。

user: user-1
content: struct node *new_node =（struct node *） malloc(sizeof(struct node));  malloc函数默认返回值为void*  然后编译就没有问题了
user-0 提问: C#如何调用dll（C语言）中全局变量

回复:
user: user-1
content: 我就喜欢教听话的乖孩纸。

user: user-0
content: 引用 5 楼 zhao4zhong1 的回复:不要做A语言代码修改为B语言代码的无用功。 也不要做用A语言代码直接调用B语言代码库这样复杂、这样容易出错的傻事。 只需让A、B语言代码的输入输出重定向到文本文件，或修改A、B语言代码让其通过文本文件输入输出。 即可很方便地让A、B两种语言之间协调工作。 比如： A将请求数据写到文件a.txt，写完后改名为aa.txt B发现aa.txt存在时，读取其内容，调用相应功能，将结果写到文件b.txt，写完后删除aa.txt，改名为bb.txt A发现bb.txt存在时，读取其内容，读完后删除bb.txt 以上A可以替换为任何一种开发语言或开发环境，B可以替换为任何一种与A不同的开发语言或开发环境。 除非A或B不支持判断文件是否存在、文件读写和文件更名。 但是谁又能举出不支持判断文件是否存在、文件读写和文件更名的开发语言或开发环境呢？ 可以将临时文件放在RamDisk上提高效率减少磨损磁盘。 数据的结构很复杂的话，文本文件的格式问题可参考json或xml  共享临时文本文件这种进程之间的通讯方法相比其它方法的优点有很多，下面仅列出我现在能想到的： ·进程之间松耦合 ·进程可在同一台机器上，也可跨机，跨操作系统，跨硬件平台，甚至跨国。 ·方便调试和监视，只需让第三方或人工查看该临时文本文件即可。 ·方便在线开关服务，只需删除或创建该临时文本文件即可。 ·方便实现分布式和负载均衡。 ·方便队列化提供服务，而且几乎不可能发生队列满的情况（除非硬盘空间满） ·……  “跨语言、跨机，跨操作系统，跨硬件平台，跨国，跨*.*的”苦海无边， 回头是“使用共享纯文本文件进行信息交流”的岸！  谢谢5L dalao给的建议，两种语言互调对我来说确实是复杂且易出错的傻事，根据5L dalao的意见，我决定采用文本输入输出，直接调用C的exe文件来运行，这样简单很多，而且修改也方便。 也谢谢其他dalao的回答，让我知道了动态库其实就是函数库的基本知识。感叹一句，不是计算机专业的学生编程困难真是多多！不过还是谢谢大家的热心回答！

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

user: user-2
content: 建议还是使用函数比较合适，从模块化和便于维护代码的角度上考虑，建议定义函数。

user: user-3
content: 在c中把全局变量的读写封装成函数 c#通过P/Invoke来调用函数

user: user-4
content: 建议采用函数封装的方式实现，动态库其实就是函数库，主要提供函数的封装。全局变量可以通过函数的接口的方式提供。

user: user-5
content: 在你需要调用的源文件中加 extern double temperature

user: user-5
content: 在你需要调用的源文件中加 extern double temperature
user-0 提问: 能不能在if语句中定义宏

回复:
user: user-1
content: 引用 8 楼 qazaq408 的回复:[quote=引用 7 楼 cfjtaishan 的回复:] if else是需要在函数体里才能使用的，独立函数体外，可以考虑使用条件编译。#ifdef #else #endif 这样的操作是否满足你的要求： #include <stdio.h>    int main(void) {     int flag = 0;  #if flag == 1 #define VAR #else #define HOR #endif   #ifdef VAR     printf("Hello!\n"); #else     printf("World\n"); #endif     return 0; } 谢谢  我还想顺便问下，在宏定义是如果 #if 的条件是个枚举值 #if OS == QType::Window 然后编译的时候说 error: token "::" is not valid in preprocessor expressions 是不是预编译里不能包含:: 这个符号？[/quote] 在C语言里没有遇到过这个符号，C++会有。

user: user-0
content: 引用 7 楼 cfjtaishan 的回复:if else是需要在函数体里才能使用的，独立函数体外，可以考虑使用条件编译。#ifdef #else #endif 这样的操作是否满足你的要求： #include <stdio.h>    int main(void) {     int flag = 0;  #if flag == 1 #define VAR #else #define HOR #endif   #ifdef VAR     printf("Hello!\n"); #else     printf("World\n"); #endif     return 0; } 谢谢  我还想顺便问下，在宏定义是如果 #if 的条件是个枚举值 #if OS == QType::Window 然后编译的时候说 error: token "::" is not valid in preprocessor expressions 是不是预编译里不能包含:: 这个符号？

user: user-1
content: if else是需要在函数体里才能使用的，独立函数体外，可以考虑使用条件编译。#ifdef #else #endif 这样的操作是否满足你的要求： #include <stdio.h>    int main(void) {     int flag = 0;  #if flag == 1 #define VAR #else #define HOR #endif   #ifdef VAR     printf("Hello!\n"); #else     printf("World\n"); #endif     return 0; }

user: user-0
content: 引用 4 楼 zgp891206 的回复:2楼正解，使用条件编译 通过宏实现条件编译我知道，但我现在的问题是如何通过代码判断生成不同的宏?

user: user-0
content: 引用 4 楼 zgp891206 的回复:2楼正解，使用条件编译 那想楼上这种情况，如何根据不同的代码定义不同的宏？

user: user-2
content: 2楼正解，使用条件编译

user: user-0
content: 引用 2 楼 hdt 的回复:if else 是运行时确定的 #define 是编译期 不能混用 c有条件编译 #ifdef #else #endif 实际情况差不对是这样的，比如c++的Qt里，有个功能是通过区分系统  #ifden Q_OS_WINDOW //调用window的api函数修改系统时间 #endif #ifdef Q_OS LINUX //调用linux的api函数修改系统时间 #endif  这样代码就可以不做修改在不同的系统上编译，运行时调用对应的系统api函数，但这里问题是他的这两个宏是怎么定义的？ 是在前面的代码里有  if(/*判断操作系统类型函数*/ == Window)     #define Q_OS_WINDOW if(/*判断操作系统类型函数*/ == Linux)     #define Q_OS_LINUX  他是用这样的形式么？我现在遇到到类似的情况，我就不知道这两个红Q_OS_WINDOW和Q_OS_LINUX他是通过什么方式定义的？

user: user-3
content: if else 是运行时确定的 #define 是编译期 不能混用 c有条件编译 #ifdef #else #endif

user: user-0
content: 第一段代码不知道为什么试反色。。。全选可以看见
user-0 提问: 初学，请教float数据类型问题。

回复:
user: user-1
content: 使用精度更高的double   int main(void) { 	double weight; 	double value; 	weight = 7.00000000001; 	value = 7.00000000004; 	printf("%.12f\n", weight + value); 	if (weight == value) 	{ 		printf("true\n"); 	} 	return 0; }

user: user-2
content: 浮点的不要直接 == 来比较，通常的做法是取差值，然后判断是否在一个已定义好的误差内，小于定义的误差就认为是相等的。

user: user-3
content: 浮点数格式 http://bbs.csdn.net/topics/390676437

user: user-4
content: 直接用float类型是很难做到精确的，因为float有效位是小数点后面6位。需要考虑其他方式，使用double是能够做到更接近，但是也做不到完全的精确。

user: user-5
content: 浮点只能近似保存如果要精度高，要么就提高浮点的长度，比如用double，或者就事先放大倍数，加法后再除去倍数。
user-0 提问: 总和固定的多个随机数

回复:
user: user-0
content: 引用 1 楼 wanggui2015 的回复:在0-4095之间随机15个数，排序，这15个数将0-4095分为16个区间，取每个区间的范围长度就是你要的16个随机数 多谢，有用！

user: user-1
content: 引用 1 楼 wanggui2015 的回复:在0-4095之间随机15个数，排序，这15个数将0-4095分为16个区间，取每个区间的范围长度就是你要的16个随机数 这个办法也是比较可行的～

user: user-2
content: 在0-4095之间随机15个数，排序，这15个数将0-4095分为16个区间，取每个区间的范围长度就是你要的16个随机数

user: user-3
content: 仅供参考 #define MAX_NUM 4095		// 总和 #define NUM 16			// 随机数总个数 #define BLOCK 5			// 分的块数，如果觉得随机数不均匀，可以调大块数  int _tmain(int argc, _TCHAR* argv[]) { 	srand((unsigned)time(0)); 	int num = MAX_NUM; 	int numPerBlock = NUM/BLOCK; 	int test = 0;		// 测试随机结果是否正确 	for (int k = 0; k < BLOCK; ++k) 	{ 		int n = MAX_NUM / BLOCK; 		for (int i = 0; i < numPerBlock; ++i) 		{ 			int nTemp = 0; 			if (i == numPerBlock - 1 && NUM%BLOCK == 0) 			{ 				nTemp = n; 			} 			else 				nTemp = rand() % (n - (numPerBlock - i)+1) + 1; 			printf("第%d个= %d\n", k*numPerBlock +i+1, nTemp); 			test += nTemp; 			n -= nTemp; 			num -= nTemp; 		} 	}  	// 处理余下的 	for (int m = 0; m < NUM%BLOCK;++m) 	{ 		int nTemp = 0; 		if (m == NUM%BLOCK - 1) 		{ 			nTemp = num; 		} 		else 			nTemp = rand() % (num  - (NUM%BLOCK -m) + 1) + 1; 		printf("第%d个= %d\n", numPerBlock*BLOCK + m + 1, nTemp); 		test += nTemp; 		num -= nTemp; 	} 	test == MAX_NUM ?printf("随机结果正确！\n"):printf("随机结果有误！\n"); 	return 0; }