Mxode/CSDN-C_Language-2013_2023 huggingface dataset:
user-0 提问: 段错误哪位大神能够解释一下，这是为什么？

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

user: user-2
content: 引用 8 楼 qq_36179095 的回复:[quote=引用 6 楼 自信男孩的回复:]p指向的是只读数据段的数据"world",所以只读数据段的数据不能被修改，修改了（strcpy)就会提示段错误； &p是在栈上的地址，因为char *p是在栈上申请的一个指针变量，该变量是存放"world"只读数据段的地址。所以&p看到的地址是栈上的地址。 第二张图片，那个地址是什么呢？[/quote] 这个地址应该是段错误出现的内存位置

user: user-0
content: 引用 6 楼 自信男孩的回复:p指向的是只读数据段的数据"world",所以只读数据段的数据不能被修改，修改了（strcpy)就会提示段错误； &p是在栈上的地址，因为char *p是在栈上申请的一个指针变量，该变量是存放"world"只读数据段的地址。所以&p看到的地址是栈上的地址。 第二张图片，那个地址是什么呢？

user: user-0
content: 引用 5 楼 学习是无止境的的回复:[quote=引用 4 楼 Intel0011的回复:]char *p = "world";改为char p[] = "world"; char *p = "world";这样定义后p指向常量区，不能修改 char p[] = "world";这样定义后p指向栈区，可以修改 你看看这个图片呢，，，，，，，，，[/quote] 第二张图片，那个地址是什么呢？

user: user-2
content: p指向的是只读数据段的数据"world",所以只读数据段的数据不能被修改，修改了（strcpy)就会提示段错误； &p是在栈上的地址，因为char *p是在栈上申请的一个指针变量，该变量是存放"world"只读数据段的地址。所以&p看到的地址是栈上的地址。

user: user-0
content: 引用 4 楼 Intel0011的回复:char *p = "world";改为char p[] = "world"; char *p = "world";这样定义后p指向常量区，不能修改 char p[] = "world";这样定义后p指向栈区，可以修改 你看看这个图片呢，，，，，，，，，

user: user-3
content: char *p = "world";改为char p[] = "world"; char *p = "world";这样定义后p指向常量区，不能修改 char p[] = "world";这样定义后p指向栈区，可以修改

user: user-4
content: 引用 1 楼 user-4的回复:p指向的是常亮区，不能改变里面的值 常量区，打错字了。。。

user: user-4
content: 反过来就可以拷贝了，你试试

user: user-4
content: p指向的是常亮区，不能改变里面的值
user-0 提问: 新人求问

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

user: user-2
content: 输入格式太过严格了吧，还有就是提示什么样的错误请明示。

user: user-3
content: 将float改为double 双精度就可以

user: user-4
content: scanf("%.2f\n",&amount);中的\n会导致scanf挂起，原因是"%f\n"或"%f "使scanf函数跳过空白符，读取一个浮点数数，然后跳到下一个非空白符处才返回

user: user-5
content: scanf不支持按照精度输入，所以直接用%f格式输入，输出是可以格式化printf

user: user-6
content: float有效数字很短,当有小数位的时候丢失精度基本很常见..有的小数的二进制表示是很长很长的.................... 但是float变量的存储空间又是很小很小的........................ 所以就截断了很多,所以很容易近似................... 你要是输入一个100,它肯定没误差，因为小数位的二进制全是0(应该是0吧..). 所以,尽量让变量的内存空间大一点.........有效数字多一点........... 就可以多表示点小数位的二进制,就精确了很多..........可能截断那么一点都怎样,通过输出的.精度控制一下，就是你想要的了.  #include <stdio.h>  int main(int argc, char *argv[]) {     double num;     scanf("%lf",&num);     printf("\n%.2lf",num);//注意.控制四舍五入保留2位小数      getchar(); //吃回车     getchar(); //等待输入退出     return 0; }   摘自http://bbs.csdn.net/topics/340072804 7楼  main函数返回值为void，return (0) 没报错？

user: user-5
content: #include <stdio.h>  void  main() {     float amount,sum;      printf("Enter an amount:");     scanf("%f",&amount);      sum = amount +0.05*amount;     printf("with tax added:$%.2f\n",sum);      return(0); } 对printf可以%.2f输出，对于输入不建议使用。

user: user-7
content: 结果差了多少？ 浮点数的计算结果可能跟你的预期不是精确一致的。如果你要很精确的结果，可以转成整数计算，比如以分为单位进行。

user: user-0
content: [quote=引用 3 楼 hefashion0190 的回复:] float有效数字很短,当有小数位的时候丢失精度基本很常见..有的小数的二进制表示是很长很长的.................... 但是float变量的存储空间又是很小很小的........................ 所以就截断了很多,所以很容易近似................... 你要是输入一个100,它肯定没误差，因为小数位的二进制全是0(应该是0吧..). 所以,尽量让变量的内存空间大一点.........有效数字多一点........... 就可以多表示点小数位的二进制,就精确了很多..........可能截断那么一点都怎样,通过输出的.精度控制一下，就是你想要的了.  #include <stdio.h>  int main(int argc, char *argv[]) {     double num;     scanf("%lf",&num);     printf("\n%.2lf",num);//注意.控制四舍五入保留2位小数      getchar(); //吃回车     getchar(); //等待输入退出     return 0; }   摘自http://bbs.csdn.net/topics/340072804 7楼  main函数返回值为void，return (0) 没报错？  [/quo  没有任何报错，就是结果不对。应该是scanf 这个函数用错了。

user: user-0
content: 引用 2 楼 cfjtaishan 的回复:#include <stdio.h>  void  main() {     float amount,sum;      printf("Enter an amount:");     scanf("%f",&amount);      sum = amount +0.05*amount;     printf("with tax added:$%.2f\n",sum);      return(0); } 对printf可以%.2f输出，对于输入不建议使用。  参考你的已经解决了，非常感谢，书上写的scanf函数是可以有%.2f的输出的，我还是慢慢学，谢谢！

user: user-0
content: [quote=引用 1 楼 hzy_76 的回复:] 结果差了多少？ 浮点数的计算结果可能跟你的预期不是精确一致的。如果你要很精确的结果，可以转成整数计算，比如以分为单位进行。[/quote   结果是个随机的数 吧，反正相差很多，参考楼下的，已经解决了，谢谢谢谢！
user-0 提问: 新手请教一个socket问题

回复:
user: user-0
content: 问题已经解决了：　原来recv还需要循环接收  引用 楼主 user-0 的回复:问题：客户端发送一次数据后，第二次服务端接收不了啦，只能接收一次是为什么      服务端代码： #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <arpa/inet.h> #include <netinet/in.h> #include <string.h>   int main() { 	int sfd, cfd; 	struct sockaddr_in server_addr; 	char buff[10];  	//创建套接字 	if( (sfd=socket(AF_INET, SOCK_STREAM, 0))<0 ){ 		perror("create socket error!"); 		exit(0); 	} 	 	memset(&server_addr, 0, sizeof(server_addr)); 	server_addr.sin_family = AF_INET; 	server_addr.sin_port = htons(8888); 	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);		//通配符地址  	//防止服务器关闭后需要等待TIME_WAIT状态才能才继续使用address 	int on=1; 	if ( setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on))<0 ){ 		perror("set socket opt fail!\n"); 		exit(0); 	} 	//绑定套接字 	if( bind(sfd, (struct sockaddr *)&server_addr, sizeof(server_addr))==-1 ){ 		perror("bind has error!\n"); 		exit(0); 	} 	 	//监听套接字 	if( listen(sfd, 10)==-1 ) { 		perror("listen has error!\n"); 		exit(0); 	} 	 	//接收客户端 	while(1){ 		puts("waitting for client on 888"); 		if( (cfd = accept(sfd,  (struct sockaddr *)NULL, NULL)) > -1 ) { 			printf("new socket fd:%d\n", cfd); 		} 		 		int n; 		if( (n = recv(cfd, buff, strlen(buff), 0)) < 0 ) { 			puts("recv data fail\n"); 			exit(0); 		} 	    buff[n] = '\0';     	printf("recv msg from client: %s\n", buff); 		puts(buff); 		close(cfd); 	} 	 	//关闭close(); 	close(sfd); 	 	return 0; }  客户端代码： #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <arpa/inet.h> #include <netinet/in.h> #include <string.h>  int main() { 	int cfd; 	struct sockaddr_in server_addr; 	char buff[10]; 	 	//创建socket 	server_addr.sin_family = AF_INET; 	server_addr.sin_port = htons(8888); 	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); 	 	cfd = socket(AF_INET, SOCK_STREAM, 0); 	if( cfd<0 ) { 		perror("create socket error\n!"); 		exit(0); 	} 	 	//连接 	if( connect(cfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) ==-1 ){ 		perror("connect has error!\n"); 		exit(1); 	} 	printf("connect with destination host...\n");   	 	while(1){ 		memset(buff, 0, strlen(buff)); 		scanf("%s", buff); 		send(cfd, buff, strlen(buff), 0); 	} 	 	 	//关闭close(); 	close(cfd); }
user-0 提问: c语言 二维数组数组名问题

回复:
user: user-0
content: 引用 13 楼 qq_33194620 的回复:[quote=引用 10 楼 chenqi123_ 的回复:] 除了优先级以外,下标引用和间接访问完全相同,对于C选项来说: (*(a+1)[1])等价于(a[1])[1],即a[1][1] 那为什么我运行出来，输出的不是a[1][1]的地址呢，好纠结。[/quote] 谢谢，也就是说这道题目却是存在问题对吧。

user: user-1
content: 不好意思我那个看错了,C应该是括号括错了

user: user-0
content: 引用 10 楼 chenqi123_ 的回复:除了优先级以外,下标引用和间接访问完全相同,对于C选项来说: (*(a+1)[1])等价于(a[1])[1],即a[1][1] 那为什么我运行出来，输出的不是a[1][1]的地址呢，好纠结。

user: user-2
content: 不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！

user: user-2
content: http://edu.csdn.net/course/detail/2516 C语言指针与汇编内存地址-三.数组和二维数组

user: user-3
content: 《C++二维数组》 http://blog.csdn.net/hou09tian/article/details/78421982 《C++数组地址偏移》 http://blog.csdn.net/hou09tian/article/details/75332577 《C++中的指针数组与数组指针》 http://blog.csdn.net/hou09tian/article/details/77426750 希望能帮到你

user: user-3
content: 个人觉得应该选C和D。 A和B都可以表示a[1][1]，原因我觉得你分析的很到位。 假设 int a[3][4] = { 0,1,2,3,4,5,6,7,8,9,10,11}; a+1则指向{4,5,6,7}需要注意的是，此时a+1的类型仍然是3×4的多维数组，所以，此时的(a+1)[1]应该指向的是{8， 9， 10， 11}，如图所示  而方括号[]的优先级高于星号*，所以选项C，*(a+1)[1]的值应该是8。 对于选项D，*(a+5)的类型是数组的地址，而不是数组的一个具体元素值。

user: user-4
content: 选项C的括号是不必要的，间接说明括号位置错了。应该是 (*(a + 1))[1] 正确答案是D，同时选项C括号位置应该改正

user: user-0
content: 意思是这题答案不唯一？ 可这是研究生考题啊，怎么会出现这种错误

user: user-1
content: 除了优先级以外,下标引用和间接访问完全相同,对于C选项来说: (*(a+1)[1])等价于(a[1])[1],即a[1][1]

user: user-5
content: 111111111111

user: user-6
content: C和D都不能表示a[1][1]  D如楼主所说。 说 一下C，(*(a+1)[1])，首先a的类型相当于一个指向有4个整数的数组的指针，与 int (*b)[4]中的b指针类型是一样的，那 a+1就指向了下一行，也就是&a[1][0]，但a的类型不变，我们让 b=a+1，然后(a+1)[1]也就是b[1]，这又指向了下一行，也就是&a[2][0]，解引用之后就得到了a[2][0].

user: user-7
content: 引用 2 楼 qq_33194620 的回复:那这题答案是什么 答案就是你说的AB呢  *(a+1)[1]就是相当于a[2][0]呢

user: user-0
content: 那这题答案是什么

user: user-7
content: 注意[]的优先级高于*所以(a+1)[1]为一体，即等价于*((a+1)[1])。  (a+1)[1]就相当于*((a+1)+1)，所以*(a+2)即a[2]为第三行的首地址； 然后在加上前面的*，所以取得的就是第三行的第一个元素的值；   可以参考一下如下的链接： http://bbs.csdn.net/topics/320177279
user-0 提问: 新手编斐波那契数列，程序有些问题

回复:
user: user-1
content: 每次在循环里面都给a 和 b 赋值1，所以结果是2。应该把赋值语句放循环前面。

user: user-2
content: 可以用数值储存计算好的值后，以后再调用

user: user-3
content: #include <stdio.h> int main() {    int f1=1,f2=1,f3;    int i;    printf("%12d\n%12d\n",f1,f2);    for(i=1;i<=38;i++)    //40个    { 	   f3=f1+f2; 	   printf("%12d\n",f3); 	   f1=f2; 	   f2=f3;    }    return 0; }

user: user-4
content: a, b放在循环里定义，其作用域是for循环体内。每次循环体执行一遍，就会释放，然后重新定义，并初始化为1，所以，a ,b的值在每次循环开始时都是固定的1

user: user-5
content: #include <stdio.h>  int main(void) {    int i, a, b, c, num;     printf("请输入第num位数:");    scanf("%d", &num);     a = b = 1;    for (i = 0;  i < num - 2; ++i)    {       c = a + b;       a = b;       b = c;    }     printf("%d\n", c);    return 0; }

user: user-6
content: #include <stdio.h>  int main() {     int i, a, b, c, num;     printf("请输入第num位数:");     scanf("%d",&num);     a = b = 1;     if(1==num)     {         printf("%d\n",a);     }     else if(2==num)     {         printf("%d\n%d\n",a,b);     }     else if(num >2)     {         printf("%d\n%d\n",a,b);         for(i=3;i<=num;i++)         {             c = a+b;             a = b;             b = c;             printf("%d\n",b);         }     }     else     {         printf("num error!\n");         return -1;     }     return 0; }

user: user-7
content: 每次都初始化a b 为1 这结果绝对不会变
user-0 提问: 菜鸟提一个关于数组指针的问题，求大神解答

回复:
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-0
content: 引用 4 楼 tecsai的回复:可以看做类型定义，其实也是强制转换。 好的谢谢大神，十分感谢

user: user-0
content: 引用 2 楼 自信男孩的回复:int (*p)[2]是指向一个二维数组的指针，并且该二维数组是一个列数为2的（行数不固定）。这样的指针叫做数组指针，即指向数组的指针；和它比较混的就是指针数组 int *q[2];这是一个定义了2个指针元素的数组，即数组中的元素都是int *指针；int (*p)[2]指向的数组元素都是int类型的数值。  int []的写法是强制类型转换，因为{1, 2}的类型可以理解为一维数组，比如int arr[2] = {1, 2}; int (*p)[2]上面已经讲了是数组指针，指向二维数组，所以类型是不匹配的。 但是这种强制类型转换是否有效我是持怀疑态度的；  以下是int (*p)[2]的使用。 int (*p)[2]; int arr[5][2] = { {1, 2} }; p = arr; 好的谢谢大神，十分感谢

user: user-0
content: 引用 1 楼 user-5的回复:int(*p)[2] = (int[]) { 1, 2 };应该写成int *p = (int[]) { 1, 2 }; 这是C99中的复合赋值，C89不支持 C89的写法是 int b[2] = { 1,2 }; int(*p1)[2] = &b; //不是int(*p1)[2] = b; 好的谢谢大神，十分感谢

user: user-2
content: 可以看做类型定义，其实也是强制转换。

user: user-3
content: C99中，复合赋值中，可以指定对象类型的数组、结构或联合表达式。当使用复合赋值时，应在括弧内指定类型，后跟由花括号围起来的初始化列表；若类型为数组，则不能指定数组的大小。建成的对象是未命名的。 　　例： double *fp = (double[]) {1.1, 2.2, 3.3}; 　　该语句用于建立一个指向double的指针fp，且该指针指向这个3元素数组的第一个元素。 在文件域内建立的复合赋值只在程序的整个生存期内有效。在模块内建立的复合赋值是局部对象，在退出模块后不再存在。

user: user-3
content: C89或者C++都不支持这种用法

user: user-4
content: int b[2] = { 1,2 }; int(*p1)[2] = b; 这种写法是不对的，类型不匹配；  int b[2] = {1, 2}; int *p = b;

user: user-4
content: int (*p)[2]是指向一个二维数组的指针，并且该二维数组是一个列数为2的（行数不固定）。这样的指针叫做数组指针，即指向数组的指针；和它比较混的就是指针数组 int *q[2];这是一个定义了2个指针元素的数组，即数组中的元素都是int *指针；int (*p)[2]指向的数组元素都是int类型的数值。  int []的写法是强制类型转换，因为{1, 2}的类型可以理解为一维数组，比如int arr[2] = {1, 2}; int (*p)[2]上面已经讲了是数组指针，指向二维数组，所以类型是不匹配的。 但是这种强制类型转换是否有效我是持怀疑态度的；  以下是int (*p)[2]的使用。 int (*p)[2]; int arr[5][2] = { {1, 2} }; p = arr;

user: user-5
content: int(*p)[2] = (int[]) { 1, 2 };应该写成int *p = (int[]) { 1, 2 }; 这是C99中的复合赋值，C89不支持 C89的写法是 int b[2] = { 1,2 }; int(*p1)[2] = &b; //不是int(*p1)[2] = b;
user-0 提问: 请问编写同一程序，用有参函数编写快还是无参函数编写快

回复:
user: user-1
content: 当然是直接把函数展开更快啦，根本就没有函数调用的开销了。 不过你要清楚你到底想做什么，而不是纠结于这一点点的压栈的开销

user: user-2
content: 参数的有无不是根据这个来决定了，参数的有无是接口设计决定的。可以根据自己需求设计来确定是否需要参数； 比如，求一个数组里的最大元素；若无参数定义求最大值的函数，那么该数组就要定义成全局的。这样做是没问题的，定义成全局的可能要考虑维护全局变量；若该数组长度较大（占用空间几K设置是几M），那么可以考虑定义成全局变量，若此时在栈上申请，就会得不偿失；若数组长度较小，可以考虑定义形参，通过参数传递到求最大值的自定义函数； 总之，参数是函数与外界交互的一个窗口，对于参数有无和定义多少要根据需求设计来定，需要权衡一些条件。

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

user: user-4
content: 参数是调用函数和被调用函数，交互用的 有参的肯定要比无参多几个指令， 但是你不能为了节省这点性能，就不要参数。 就好比为了省钱就不吃饭了。

user: user-4
content: 最根本的问题是“函数是干什么用的？” 如果能狗回答这个问题，其余一切自然会恍然大悟

user: user-5
content: 函数不用参数就要用全局变量，不可取。 这点性能影响微不足道。 如果你原意的话，可以不用函数，每个调用函数的地方用完整代码替代，这比调用函数不用参数还快。

user: user-6
content: 不用参数只能用全局变量，这不是一个好的选择。

user: user-2
content: 参数个数不宜过多（控制在<= 5)，参数多了会影响函数调用效率；
user-0 提问: 请教，关于scanf格式问题！

回复:
user: user-1
content: 很少见过这样使用scanf的，因为scanf是格式化输入，一般只会将数组格式放在第一个参数里，其他比如提示内容，建议用printf输出。 比如  printf("a = "); scanf("%d", &a); printf("b = "); scanf("%f", &b);

user: user-2
content: 你的scanf用法不太正确 [code=c][/#include <stdio.h>  int main(void) {    int a;    float b;     printf("a = ");    scanf("%d", &a);     printf("b = ");    scanf("%f", &b);     printf("%d, %f\n", a, b);    return 0; } code]

user: user-3
content: scanf第一个参数最好不要加提示符，会导致函数无法结束。可以使用ctrl+d或者ctrl+z结束，不过不推荐。 提示符最好用printf()
user-0 提问: c快排求助请看代码最后

回复:
user: user-1
content: 会变化，因为递归传进去的虽然是begin，end，但是这两个值是变化的（i, 和j 分别取代了end和start，i,j是变化的变量）。建议详细了解一下递归的原理。

user: user-2
content: 递归的时候，参数传递过程中，begin和end的值不断变化的 自己做个简单的模拟就了解了。 1、quicksort(array, maxlen, begin, i);  //这时候begin不变，但是end的值是i了，变化了 2、quicksort(array, maxlen, j, end);   //同理，begin的值是j，变了 不断递归下去，只有最左边的一个组，begin永远不变，最右边的组，end永远不变，中间的组，begin和end都变了。
user-0 提问: 奇怪的出错 VC里死循环 但是代码应该没错 普通简单的for循环

回复:
user: user-1
content: #include<stdio.h> int main() {     int day=0,t,a,b;     int aa[366];     scanf("%d%d",&a,&b);     printf("a=%d b=%d\n\n",a,b);     for(day=0;day<366-7;day=day+7)     {         /*      aa[day]=1;                 aa[day+1]=2;                 aa[day+2]=3;                 aa[day+3]=4;                 aa[day+4]=5;                 aa[day+5]=6;                 aa[day+6]=7;*/         for(int j=0;j<7;j++)             aa[day+j]=j+1;         printf("day=%d  %d\n\n",day,aa[day]);     }     day=0;     printf("a=%d b=%d\n\n",a,b);     switch(a)     {         case 12: day+=30;         case 11:day+=31;         case 10: day+=30;         case 9: day+=31;         case 8: day+=31;         case 7: day+=30;         case 6: day+=31;         case 5: day+=30;         case 4: day=day+31;         case 3: day=day+28;         case 2: day=day+31;         case 1: day=day+b;     }     printf("%d\n", day);    /*这儿的day远大于366-1*/     printf("day=%d %d\n\n",day,aa[day]);     return 0; } 楼主的问题主要体现在数组越界，第一个for循环已经会导致aa越界，所以循环退出条件应该为day < 366 - 7;另外，该循环语法也有问题，for的第三个表达式后没有分号  下面的第二个循环后，day已经远大于366-1，下标最大为365，所以也会导致越界； 建议重新梳理一下逻辑，另外注意数组的边界。

user: user-2
content: for(int j=0;j<7;j++)          aa[day+j]=j+1; ---->当day=364 j>=2时数组越界了 需要加个条件判断 [code=c][/for(int j=0;j<7;j++)          {             if ((day+j)<366)                aa[day+j]=j+1;          } code]
user-0 提问: 最后一句一直在报错！

回复:
user: user-1
content: C语言不支持&运算符，只有C++的编译器才支持。建议使用C++的编译器或者将参数定义成指针；这两种方法其实都是传地址到initList中，通过调用都能将初始化的list带回。

user: user-2
content: Status initList(SqList &L, int initSize) 中的&时C++中的引用，C语言中时没有的 你需要改为C语言的方式 Status initList(SqList L, int initSize)  或 Status initList(SqList *L, int initSize)  --》程序中的L需要改为(*L)
user-0 提问: 求个算法，用c或vb，拜托了

回复:
user: user-1
content: Dijkstra算法求无向图的最短距离，如果自己没有思路，可以从网上看一下别人的算法和实现，或改一改别人的算法；

user: user-2
content: 首先要设计输入数据格式，可以是这样的一个结构体：  struct direct_path { 	char start; 	char end; 	int length; }  用这个结构来定义一个表（数组），这样你就可以定义任意两点的直接距离，注意是直接路径，只有两点之间可以直达才能出现在这个表里。 问题是以A为起点 ，求给出的另一个点的最短距离，那么应该在这个表里找到所有包含A的成员，记录下一个点，然后从下一个点开始，又找下一个点，这个过程中已走过的点不要重复。直到出现目标，或遍历结束。 最后你会得到多个结果，取最小的即可。  我有实现此算法的代码，若需要可发给你。

user: user-3
content: https://zh.wikipedia.org/wiki/%E6%88%B4%E5%85%8B%E6%96%AF%E7%89%B9%E6%8B%89%E7%AE%97%E6%B3%95

user: user-4
content: 数学问题问数学老师啊！
user-0 提问: 求大佬指點，有關輸出的問題

回复:
user: user-1
content: static double b[36],c[36],d1[36],d2[36],M1[36],M2[36],x[361],h[36]; static double u[36],v[36],y1[36],y2[36]; 在占用内存空间较大的局部数组声明的前面加static将其从堆栈数据段挪到全局数据段即可避开因局部数组大小超过默认堆栈大小1MB造成程序不能正常运行的问题。

user: user-2
content: 调试也是IT必备的技能

user: user-3
content: 浮点数值溢出了就会有这样的结果

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

user: user-4
content: 楼主的需求是什么？代码定义的变量太多，代码可读性很差呢。如果可以，个人建议没必要定义那么多变量，变量多了会使代码变得乱，可读性降低；
user-0 提问: c语言链表水题纠错

回复:
user: user-1
content: 楼主能分享下正确的代码嘛

user: user-1
content: 约瑟夫环的变式吧

user: user-2
content: 分析需求，可以得到的问题的分类，就是一个约瑟夫环变相问题。

user: user-3
content: 咋就那么多0粉贴呢

user: user-4
content: visio画图工具，画图理解
user-0 提问: 关于同步互斥问题

回复:
user: user-1
content: s=1;//垫子资源 m=1;//计数器访问资源数,防止多进程同时改变计数器 a=0;//计数器，判断a方向前面有几个小朋友 b=0;//计数器，判断b方向前面有几个小朋友  p1() {    while(1)    {       p(m);       a++;       if(a==1)          p(s);       v(m);       a方向上桥;       p(m);       a--;       if(a==0)          v(s);       v(m);    } }   p2() {    while(1)    {       p(m);       b++;       if(b==1)          p(s);       v(m);       b方向上桥;       p(m);       b--;       if(b==0)          v(s);       v(m);    } }  你看下喽

user: user-0
content: 求大神！谢谢，没搜到答案
user-0 提问: 关于code blocks的使用问题

回复:
user: user-0
content: 过了这么久才想起发过这个帖子，我最后是删除了360就好了，嘻嘻

user: user-1
content: https://github.com/hongwenjun/CodeBlocks

user: user-2
content: 路径或者程序名中有中文的问题吧。

user: user-0
content: 求大神帮我解答一下T^T

user: user-3
content: 关闭UAC、防火墙、杀毒软件、…… 以管理员身份运行  程序员的常识之一：不要将程序源代码或项目或exe放在桌面这种复杂（多半带空格和汉字且在防火墙或杀毒软件严密控制的C盘上）的目录下。
user-0 提问: 求大神解答

回复:
user: user-1
content: 栈中的变量通常包括函数参数和函数里声明的临时变量。 栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。 而栈中的类变量退出其作用域时，会自动执行其析构函数，……  其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。
user-0 提问: 【求助】子函数定义一个字符串变量，返回指针。由数组和指针定义而出现的不同现象，挺有趣的！！

回复:
user: user-1
content: 栈中的变量通常包括函数参数和函数里声明的临时变量。 栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。 而栈中的类变量退出其作用域时，会自动执行其析构函数，……  其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。  http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

user: user-2
content: 返回局部变量数组是未定义行为，如果能够得到正确的值，那么说明释放的函数空间没有被申请，数据自然没有被覆盖。

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

user: user-3
content: char *s="abcde"; 这种方式定义的字符串"abcde"在常量区，即s指向常量区，所以返回的是常量区的地址，常量区的内容是不会变化的

user: user-0
user-0 提问: 新手遇到点小问题，求大神解答

回复:
user: user-1
content: 引用 1 楼 qq_21193563 的回复:程序运行到puts时，数组a的内存生命周期结束了，内部内存被释放，指针乱指 指针没有乱指哦，只是指向的那部分内存区域不能使用了（被释放了），若被其他函数栈占用，就会把arr的数组覆盖掉；

user: user-2
content: 你定义的函数返回了一个局部变量arr[]的地址，会在函数返回后销毁，值就是随机的了

user: user-3
content: 栈中的变量通常包括函数参数和函数里声明的临时变量。 栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。 而栈中的类变量退出其作用域时，会自动执行其析构函数，……

user: user-1
content: 返回局部变量是未定义行为，建议将数组arr定义成static变量，改变数组的生命周期；  int* decimaltobinary(int x) {     int i;     static int arr[32]={0};     int * p;      for(i=0;i<32;i++)     {         //printf("%d ",x%2);         arr[i]=x%2;         if(x==1)             break;         x/=2;     }     p=arr;     return p; }

user: user-4
content: 还是不要返回指针了，直接在参数里传入指针不是更好？

user: user-5
content: 程序运行到puts时，数组a的内存生命周期结束了，内部内存被释放，指针乱指
user-0 提问: error: missing binary operator before token "("

回复:
user: user-1
content: #elif define 改为 #elif defined

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

user: user-3
content: 咋就那么多0粉贴呢

user: user-4
content: 这种宏的错误 , 很可能是前面的东西导致的.
user-0 提问: 关于线性表的链式存储结构

回复:
user: user-1
content: 创建那个元素的时候当然知道其地址（比如用new创建的话，返回的就是对应指针），然后把它存储到前一个元素里就可以了。

user: user-2
content: 对于c语言里的结构体数据内存存储，会按照不同机器采用不同的对齐方式。所以，要了解结构体的元素地址先了解一下这个结构体里数据内存存储的对齐方式。 比如 struct {      int  a；     char  b；     int  c； }temp； 假设 a地址是1000；b的地址是1004；c的地址是1008；而不是1006；

user: user-3
content: typedef struct List{ 	struct List *start; 	int num; 	struct List *end; }list;

user: user-4
content: 通过这个后继元素的地址找到后继，地址值，就像门牌号，知道了门牌号还不容易找到对应的后继吗？如果你要了解，怎么找到的，这个过程那就不是链表知识能解答了。建议看一下内存管理机制

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

user: user-6
content: 比如  struct node_info { 	int data; 	struct node_info *next; }  这里的next就用来存储下一个元素的地址，这样组成了一个任意长度的链表。

user: user-6
content: 记录后一个元素的内存地址呀
user-0 提问: 初始化问题

回复:
user: user-0
content: 谢谢你们，我懂了，还请以后多多帮忙

user: user-1
content: 要用就初始化 不用就无需初始化  好的习惯是 先初始化

user: user-2
content: 不初始化，在大多数系统中就是一个随机值，程序是否能正常运行，取决于你如何使用变量。 第一个程序其实没有任何初始值被使用，因此不初始化并没有影响。第二个程序直接把x和A等变量做对比，若无初始化，对比结果是未知的，这不代表程序运行不下去，只是结果是你无法预期的而已。

user: user-3
content: 上面的代码中，虽然定义并初始化了A B C D E变量，但代码中并未使用，所以可以去掉 下面的代码中则不一样，if语句是根据x变量与A B C D E变量的值进行比较来做判断而显示的，所以必须初始化
user-0 提问: 求问二维数组怎样写入二进制文件。。。。

回复:
user: user-1
content: 引用 3 楼 losercat 的回复:[quote=引用 2 楼 zhao4zhong1 的回复:] 搜“序列化 反序列化” www.json.org 谢谢！！刚刚我又在网上查了一下，原来是fread和fwrite里的参数写错了。。。。。现在解决了  这位老师。。。。。第一次看到你头像的时候就觉得是不是初中的数学老师在回答别人问题。。。。。你们长得简直一毛一样  还有就是我第一次发帖，不知道要给分的。。。。。抱歉啊[/quote] 没准你遇到了我失散多年的孪生兄弟。

user: user-1
content: 搜“序列化 反序列化” www.json.org

user: user-2
content: FILE 文件操作

user: user-0
content: 引用 2 楼 zhao4zhong1 的回复:搜“序列化 反序列化” www.json.org 谢谢！！刚刚我又在网上查了一下，原来是fread和fwrite里的参数写错了。。。。。现在解决了  这位老师。。。。。第一次看到你头像的时候就觉得是不是初中的数学老师在回答别人问题。。。。。你们长得简直一毛一样  还有就是我第一次发帖，不知道要给分的。。。。。抱歉啊
user-0 提问: c语言

回复:
user: user-1
content: 咋就那么多0粉贴呢

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

user: user-3
content: 前面是输出、后面等你输入
user-0 提问: 关于释放结点的问题

回复:
user: user-1
content: 必须先释放指针域指向的空间，然后才释放本节点。

user: user-2
content: 释放某个节点，只是释放的该节点的占用空间（由使用状态变为未使用状态），该空间里的数据域和指针域都会释放，但是指针域指向的内存空间不会释放，但是指针域指向的地址有可能找不到了。因为释放之后指针域不可用了。

user: user-3
content: 数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633
user-0 提问: Push函数出错Program received signal SIGSEGV, Segmentation fault

回复:
user: user-1
content: 看这个函数：  81 Tree create_Tree(void)  82 {  83     Stack S;  84     Tree T, R;  85     char s[50], E;  86     int i = 0;  87     gets(s);  88     puts(s);  89     for (i = 0; s[i] != '\0'; i++) {  90         if (s[i] >= '0' && s[i] <= '9') {  91             T = (Tree) malloc(sizeof(Tree));  92             T->data = s[i];  93             T->left = NULL;  94             T->right = NULL;  95             Push(T, S);  96             printf("aaaaaaa");  97         } else  98             if (s[i] == '+' || s[i] == '-' || s[i] == '*'  99             || s[i] == '/') { 100             T = (Tree) malloc(sizeof(Tree)); 101             T->data = s[i]; 102             E = s[i]; 103             T->left = Top(S); 104             Pop(S); 105             T->right = Top(S); 106             Pop(S); 107             Push(T, S); 108         } 109     } 110     printf("bbbbbbb"); 111     return R; 112 }  Stack S; 这一行，S只是一个指针，并没有分配空间，此时S指向的地址是随机的，很可能是不能访问的，特别是写操作，后面第一次调用Push()函数的时修，第一次访问S就是楼主所说的那一行： tmp->next = S->next; 如果S是空，或其它不可访问的地址，这句就错了。 楼主应该先给S分配空间。

user: user-2
content: 程序的若干问题： 第一个，=与==的区别；建议注意下； void MakeEmpty(Stack S) {     if(S==NULL) /* = 与 == */         printf("Must create first!");     else         while(!IsEmpty(S))             Pop(S); }  第二个，Tree create_Tree(void)函数的返回值R是一个随机值的指针，该函数中并没有对R做赋值或者修改操作； 返回一直随机值应该是无意义的；同时该函数里有push操作，但是S一样是为初始化的，我想这个栈应该通过参数传进来。 第三个，Levelorder函数里， void Levelorder(Tree X) {     Tree Q[50];     Q[0]=X;     int front=0,rear=1;     while(front<rear)     {         printf("%c ",Q[front]->data);         if(Q[front]->left)             Q[rear++]=Q[front]->left;         if(Q[front]->right)             Q[rear++]->right;    /*无意义的表达式*/         ++front;     } }

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

user: user-4
content: s为空么？  设置断点调试一下
user-0 提问: While 语句 问题

回复:
user: user-1
content: 对楼上进行指正： （2）while(!(x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0))  x++;  X对2取余为1，对3取余为2，对5取余为4，对6取余为5和能被7整除。当这些条件不满足其一的时候，X才会++。

user: user-2
content: （1）while(x%2!=1 && x%3!=2 && x%5!=4 && x%6!=5 && x%7!=0) x++; X对2取余不为1，对3取余不为2，对5取余不为4，对6取余不为5和不能被7整除。当这些条件都满足的时候，X才会++。  （2）while(!(x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0)) x++; X对2取余为1，对3取余为2，对5取余为4，对6取余为5和能被7整除。当这些条件都不满足的时候，X才会++。  而与的逻辑是，当第一个条件为假时，结果为假，后面的条件不进行运算，就算后面的条件为真也不进行运算。只有第一个为真时，按照从左到右的规则，继续判断。 所以，在（1）中，当X为2时，"x % 2 != 1"的运算结果为0，所以while将跳出循环。此时X的值为1（如果X的初值是1） 而在（2）中，当X为2时，“x %2 == 1”的运算结果也为0，但是有一个“！”在前面，所以while会继续循环，直到不满足while条件时才会退出循环。  以上是我的理解，不正确之处请指正。

user: user-3
content: 首先要知道运算符的优先级和不同编译器的编译原理才能做，因为你的各个表达式都没加括号，不同的编译器出来结果可能不一样

user: user-4
content: while(x%2!=1 && x%3!=2 && x%5!=4 && x%6!=5 && x%7!=0)  while(!(x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0))  这两个是不一样的，比如 一旦 x%2!=1 为0，那0根谁&&都是0 ，所以就不会往下执行（也就是说不会去判断  x%3!=2 && x%5!=4 && x%6!=5 && x%7!=0 这些东西），

user: user-5
content: 与或区别， 逻辑问题

user: user-0
content: 感谢大佬们的回答

user: user-6
content: 引用 2 楼 zhao4zhong1 的回复:!(A && B)等价于(!A || !B) !(A || B)等价于(!A && !B) 赞同

user: user-7
content: !(A && B)等价于(!A || !B) !(A || B)等价于(!A && !B)

user: user-8
content: 与非   逻辑 我记得数电有公式  上面的必须全部不满足才可以 全部不等于才可以  下面的只要不满足一个就可以 只要有一个不等于就为0 取反为1
user-0 提问: 这段代码出了什么问题呢

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

user: user-2
content: n和10有什么关系，为什么用一个10来作为实参呢，不是n吗？

user: user-0
content: 因为实参实际上是10 我这里是错了，应该是n的 但是这个好像不影响，问题依然存在
user-0 提问: while 语句

回复:
user: user-1
content: 两个中，如果把其中一个里面的“&&”改成“||”，就是一样的了

user: user-2
content: 对于第一种，当x等于3时：先计算x%2!=1，该表达式为假，后面的 x%3!=2等都不会再计算了。整个表达式为假（0） 对于第二种，当x等于3时：先计算x%2==1，该表达式为真，于是再计算 x%3==2，该表达式为假，后面的x%5==4等都不会再计算了。 整个括号中的表达式为假，再套上个！，结果为真（1） 所以第一种和第二种并不等价，代入一个数字算算就知道了

user: user-3
content: while(!(x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0)) x++  等价于 while((x%2!=1 || x%3!=2 || x%5！=4 || x%6!=5 || x%7!=0)) x++   对于这么唱的多个判断不容易判断，建议可以利用一个简单的例子对比学习：  while (!(x == 1 && x == 2)) 等价与 while (x != 1 || x != 2)

user: user-4
content: while(x%2!=1 || x%3!=2 || x%5!=4 || x%6!=5 || x%7!=0) x++ 与 while(!(x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0)) x++ 等价

user: user-5
content: !(A && B)等价于(!A || !B) !(A || B)等价于(!A && !B)

user: user-6
content: 上面的必须全部不满足才可以 全部不等于才可以  下面的只要不满足一个就可以 只要有一个不等于就为0 取反为1
user-0 提问: 简单代码-字符转换 运行无限输出 求解

回复:
user: user-1
content: 循环的最后加上ch = getchar();，否则下一次循环开始时，ch还是之前输入的值，永远不为\n

user: user-2
content: 因为你的第一个字符若不是换行符'\n'，那么就会进入while循环，然后在while循环体内并没有修改ch为'\n'，所以ch就一直不会是换行符，就会是死循环；  加一句ch = getchar();就会解决死循环

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

user: user-4
content: 只要不输入换行符就会进入循环，若在A-Z中间，执行一次if后，就>Z不在里面了，此后就不会执行if语句，只是一直输出；若最开始不在里面直接无限输出。

user: user-5
content: 或者这样 #include <stdio.h>  int main(void) {     char ch;       while((ch = getchar()) != '\n')     {         if (ch >= 'A' && ch <= 'Z')             ch = ch + 32;         putchar(ch);      }      return 0; }

user: user-6
content: ch没变过 所以一直循环

user: user-7
content: 把getchar放在while里面
user-0 提问: 求助大佬：

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

user: user-2
content: 引用 3 楼 qq_40470949 的回复:那直接b[N] = {a}本质是什么？为什么可以这样做？ 把a的值（一个地址）当做字符（一般要截断变短），存入 b[0]

user: user-0
content: 那直接b[N] = {a}本质是什么？为什么可以这样做？

user: user-2
content: 至少应该这样吧 char b[N] = {a[0], a[1]};

user: user-3
content: 赋值改一下memcpy（b，a，N）；
user-0 提问: 从控制台向变量输入值出现的问题

回复:
user: user-1
content: 第15行多余，删掉。

user: user-1
content: float a,b; char c; while (1) {  rewind(stdin);  if (3!=scanf("%f%c%f", &a, &c, &b)) break;  switch (c) {   case '*':    printf("%g*%g=%g\n",a,b,a*b);   break;   case '/':    printf("%g/%g=%g\n",a,b,a/b);   break;   default:   break;  }  } }

user: user-2
content: scanf只是按%s的说明识别输入项。 如果你想输入 0,3.14/2，应该用 scanf("%f,%f/%f", &a, &b, &c)，结果abc分别为0、3.14、2

user: user-3
content: 你得自己按字符去接收运算符，然后判断这个字符是什么运算符，然后采取不同的操作

user: user-4
content: 控制台能接收 但是无法识别  那只是一个符号 不是运算符

user: user-5
content: 你就输入两个运算符然后监控程序中变量的值……你就明白了

user: user-0
content: 抱歉，乘号计算也是错的
user-0 提问: c++ debug assertion failed 新人求教！！！

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

回复:
user: user-0
content: 引用 2 楼 自信男孩的回复:变量定义一般是要求初始化的，不初始化会导致变量时随机值，若直接使用（一般是读）没有初始化的变量，则结果是未定义（随机值）；所以，初始化能保证数据是固定的； 比如，指针不初始化，那么指针是野指针，使用野指针可能会导致段错误；  具体楼主的问题，建议贴出相关代码，然后根据代码来确定具体是什么问题 一个是必须初始化，一个可以初始化也可以省略

user: user-0
content: 引用 1 楼 user-2的回复:变量尽量都初始化。避免没有处理这个变量造成bug。 比如成绩是0-100分， 变量就初始化为0.  加入有人没参加考试， 不用单独赋值就是0分了。如果没初始化， 后续又忘记给这个变量赋值， 那么发成绩单的时候。。。。。。 谢谢了，还是有点不明白。

user: user-0
content: 引用 2 楼 自信男孩的回复:变量定义一般是要求初始化的，不初始化会导致变量时随机值，若直接使用（一般是读）没有初始化的变量，则结果是未定义（随机值）；所以，初始化能保证数据是固定的； 比如，指针不初始化，那么指针是野指针，使用野指针可能会导致段错误；  具体楼主的问题，建议贴出相关代码，然后根据代码来确定具体是什么问题 我是初学C语言，没有学过指针

user: user-1
content: 变量定义一般是要求初始化的，不初始化会导致变量时随机值，若直接使用（一般是读）没有初始化的变量，则结果是未定义（随机值）；所以，初始化能保证数据是固定的； 比如，指针不初始化，那么指针是野指针，使用野指针可能会导致段错误；  具体楼主的问题，建议贴出相关代码，然后根据代码来确定具体是什么问题

user: user-2
content: 变量尽量都初始化。避免没有处理这个变量造成bug。 比如成绩是0-100分， 变量就初始化为0.  加入有人没参加考试， 不用单独赋值就是0分了。如果没初始化， 后续又忘记给这个变量赋值， 那么发成绩单的时候。。。。。。
user-0 提问: 求大佬看一看这串代码的warning是怎么回事

回复:
user: user-1
content: char reverse(char s[]); 函数reverse的参数类型是字符数组，本质上是一个指针 而返回值的类型是字符，本质上是一个整数值 两者是不一样的 你把那几个函数的返回类型改为char *即可

user: user-2
content: 都是类型不匹配的警告；首先reverse函数的返回值定义的是char类型，但是你返回的是一个地址（指针），所以接收用指针也是不可以的。因为reverse返回的是char类型，不是指针。itoa一样，定义的返回值是char，返回的是地址

user: user-3
content: 把前两个函数的返回类型改为char* 应该能解决问题

user: user-4
content: s[] 不是char  建议看看函数的值传递和引用传递 传数组引用传递就好了
user-0 提问: 数字常量真就没办法取地址吗？

回复:
user: user-1
content: 引用 4 楼 大尾巴猫 的回复:const常量可以取地址 const int i = 6; int* pi = &i; 应该用指向int常量的指针来指常量啊 const int i=6; const int *p=&i;

user: user-2
content: 常量有可能直接使用，不需要占用内存（比如立即数），因此取地址没意义； 字符串常量，字符串本身就是地址，因此也无需再取地址。

user: user-3
content: 获得一个数字常量的地址的目的是什么？ 如果是为了限制代码的膨胀，你直接写成const int变量形式就行了 如果是为了单纯的看看地址，我认为编译器是直接在编译过程中将常量数字写进了汇编代码里，而没有用符号解析，所以，没有意义

user: user-4
content: 数字是一个临时变量，生命周期未知，假如你取到了它的地址，下一时刻地址里边的值可能就改变了。

user: user-5
content: 楼主的直接定义指针好吧-

user: user-6
content: 咋个取地址啊  把整数当地址用? 那就把整数强制转换成指针  然后指向指针的指针  大概是这样 比如说st标准库里对寄存器地址的访问都是这么定义的

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

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

user: user-8
content: 立即数本身可能就没地址，已经直接被编入了指令中

user: user-9
content: const常量可以取地址 const int i = 6; int* pi = &i;
user-0 提问: 如何有选择的对数组进行操作

回复:
user: user-1
content: 引用 2 楼 Wezty 的回复:能具体写下思路吗？ 根据你说的，我突然想到可以给每个数组再加一个（数字）标识，这样就可以解决 我问个比较笨的问题，数组a【3】最前面的是存放它的地址，可以用标识a得到其地址，然后传入函数进行运算，这样可以实现吗？ #include <stdio.h>  int a[3] = {1,2,3}; int b[3] = {2,3,4}; int c[3] = {4,5,6}; int arr[3][3];  //addArr加的数组序号，addedArr被加的数组需要,用指针传递结果 void fun(int addArr, int addedArr,int *result) {     for(int i=0;i<3;++i)        //组成一个二维数组     {         arr[0][i] = a[i];         arr[1][i] = b[i];         arr[2][i] = c[i];     }      for(int i=0;i<3;++i)    //对应数组相加     {         result[i] = arr[addArr][i] + arr[addedArr][i];     }      return; }  int main() {     unsigned int add1,add2;     int ret[3];     scanf("%d %d", &add1, &add2);     if(add1<3 && add2<3)     {         fun(add1, add2, ret);          for(int i=0;i<3;++i)             printf("result[%d] = %d\n", i, ret[i]);     }     else         printf("input error.\n");      return 0; }

user: user-0
content: 能具体写下思路吗？ 根据你说的，我突然想到可以给每个数组再加一个（数字）标识，这样就可以解决 我问个比较笨的问题，数组a【3】最前面的是存放它的地址，可以用标识a得到其地址，然后传入函数进行运算，这样可以实现吗？

user: user-1
content: 用二维数组？输入的话就可以是int了，返回一个新的一维数组。怎么样？

user: user-2
content: 函数参数 求和的函数 void f(int* arr, int num); 根据用户输入，调用f的时候给不同的数组做参数
user-0 提问: 关于删除结构体变量的数据的问题

回复:
user: user-1
content: 这样的问题，解决起来方法不止一种。统计数组的有效长度是一种方法，也有一种方法就是s[4], s[5]赋值非法值，使用s[4], s[5]时增加判断，若是非法值则不用

user: user-2
content: 程序中再增加一个变量，用于记录数组元素的长度，访问时不访问超出范围的元素
user-0 提问: 冒泡排序法。各位前辈，我检查过很多遍 可是结果输出来就是不对 帮忙看看 

回复:
user: user-0
content: 引用 2楼Arlen22 的回复:我觉得应该是里面的for循环，改成for i，j小于9，j++。抱歉手机上写的.:-)没事 谢谢噢

user: user-0
content: 引用 3楼wang0635 的回复:for (j=0;j<9-i;j++);  <-------!!!!! 后面多了一个分号谢谢。现在完成了

user: user-1
content: #include <stdio.h>  int main () {     int a[10];     int i,j,t;     printf("please input num：");     for(i=0;i<10;i++)         scanf("%d",&a[i]);      for (i=0;i<9;i++)     {         for (j=0;j<9-i;j++) /* delete ;*/         {             if(a[j]>a[j+1])             {                 t=a[j];                 a[j]=a[j+1];                 a[j+1]=t;             }         }     }     for (i=0;i<10;i++)     {         printf("%d",a[i]);     }      //getch();     return 0; }

user: user-2
content: getch（）是conio.h的函数，无回显。让他等待用两个getchar()吧。第一个消掉scanf剩余的\n第二个让它等待

user: user-3
content: for循环有问题-应该条件都是小于10；另一个条件是10-i

user: user-4
content: for (j=0;j<9-i;j++);  <-------!!!!! 后面多了一个分号

user: user-5
content: 我觉得应该是里面的for循环，改成for i，j小于9，j++。抱歉手机上写的.:-)
user-0 提问: 怎么通过数组标记找到前几个不重复的最小值？

回复:
user: user-1
content: #include<iostream> #include <cmath> using namespace std;  int a[6] = { 6,3,2,5,4,1 };  int get_min(int *arr, int len);  int main(void) {     int min = 100, tmp, MIN[3];     int i, j;      MIN[0] = get_min(a, 6);     for (i = 0; i < 2; i++) {         for (j = 0; j < 6; j++) {             tmp = a[j] - MIN[i];             if (tmp > 0 && tmp < min) {                 min = tmp;                 MIN[i+1] = a[j];             }         }         min = 100;     }      for (i = 0; i < 3; i++)         cout<<MIN[i]<<endl;     return 0;  }   int get_min(int *arr, int len) {     int i, min;      min = arr[0];     for (i = 1; i < len; i++)         if (arr[i] < min)             min = arr[i];      return min; }

user: user-2
content: 是因为变量min在第一次循环中就是最小的了，而你却没有清楚标记，造成了三次循环找到的都是一个数。 int i=0,j,middle ,min = 100, aa[6] = { 0 }, MIN[3];   //aa[6]是一个标记数组，分配好了就让其自增为1                for (j = 0;j < 3;j++)     { 	min=100;         for (i = 0;i < 6;i++)         if (aa[i]==0)                 if (a[i] < min)                 {                     min = a[i];                     middle = i;                 }         MIN[j] = middle;         aa[middle] = 1;     }  增加一句min=100，就OK了，位置如代码所示。

user: user-0
content: /* 找最小的前3个不重复的数字*/ #include<stdio.h> #include<iostream> using namespace std; int a[6] = { 6,3,2,5,4,1 }; int main() {     int i=0,j,middle ,min = 100, aa[6] = { 0 }, MIN[3];   //aa[6]是一个标记数组，分配好了就让其自增为1                for (j = 0;j < 3;j++)     {         for (i = 0;i < 6;i++)         if (aa[i]==0)                 if (a[i] < min)                 {                     min = a[i];                     middle = i;                 }         MIN[j] = middle;         aa[middle] = 1;     }   }  这个为什么选出来的是都是几个重复的数字
user-0 提问: const限定符失效的疑问

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

user: user-2
content: const限定符是供编译器使用的，实际上，只要在系统允许修改的空间内取得地址，你就可以修改，编译后，根本没有const限定符的语义，那是编译前的语义

user: user-3
content: const 是本来就是伪常量，不管在C还是在CPP
user-0 提问: while（E）中的(E)不等价的表达式是

回复:
user: user-1
content: 这个题 选B 呀

user: user-2
content: 真假不仅仅局限于bool类型，对于其他类型，只要不为0即为真，为0即为假。

user: user-3
content: 就是当E不为0时，就会执行循环。所以E就相当于非零。不理解就直接把A,B,C,D四个选项直接代进while（）里，看看哪个结果与while（E）不同。

user: user-4
content: 非0为真  0为家

user: user-5
content: while(E)的意思是当E为真时，进行循环。 A：E大于0或者E小于0，为真； C：非E等于0，就是E不等于0 ，为真； D：E不等于0 ，为真。  而B选项：E等于0 ，为假，所以错

user: user-6
content: 就是 B 呀
user-0 提问: 链接时出现问题，大神帮忙看一下，一直没找到问题，谢谢！

回复:
user: user-1
content: 你的代码中有#include<iostream>，这是C++的头文件，C编译器是不支持的 可能你用的是C的编译器编译你的程序，所以出错 你将#include<iostream>这句删除即可

user: user-2
content: #include<stdio.h> #include<iostream>      void exchange(int *q1,int *q2,int *q3); void swap(int **pt1,int **pt2);  int main() {     int a=9;     int b=0;     int c=10;     int *p1,*p2,*p3;     p1=&a;     p2=&b;     p3=&c;     exchange(p1,p2,p3);     printf("\n%d,%d,%d\n",a,b,c);      return 0; }  void exchange(int *q1,int *q2,int *q3) {     if(*q1<*q2) swap(&q1, &q2);     if(*q1<*q3) swap(&q1, &q3);     if(*q2<*q3) swap(&q2, &q3); }  void swap(int **pt1,int **pt2) {     int temp;     temp = **pt1;     **pt1 = **pt2;     **pt2 = temp; } 建议了解一下一重指针和二重指针

user: user-3
content: swap没有在前面声明吧

user: user-4
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-5
content: #include<stdio.h> #include<iostream>  void exchange(int *q1, int *q2, int *q3); //使用该函数前必须声明 void swap(int *pt1, int *pt2);  void main() { 	int a = 9; 	int b = 0; 	int c = 10; 	int *p1, *p2, *p3; 	p1 = &a; 	p2 = &b; 	p3 = &c; 	exchange(p1, p2, p3); 	printf("\n%d,%d,%d\n", a, b, c); 	system("pause"); }  void exchange(int *q1, int *q2, int *q3)  //该函数用来交换q1,q2,q3的值，使得三者的值由大到小的顺序排序 { 	if (*q1<*q2) swap(q1, q2); 	if (*q1<*q3) swap(q1, q3); 	if (*q2<*q3) swap(q2, q3); }  void swap(int *pt1, int *pt2)           //该函数用来交换pt1和pt2的值 { 	int temp; 	temp = *pt1; 	*pt1 = *pt2; 	*pt2 = temp; }

user: user-5
content: 前向声明不是写在函数里面，是写在外面的。
user-0 提问: 如何取4x4数组中不同行不同列的元素的全部排列

回复:
user: user-1
content: http://www.cnblogs.com/wanxiao/p/3607216.html

user: user-2
content: 如何拓展至n*n呢

user: user-3
content: #include <stdio.h> int isright(int i,int j, int x,int y) { 	int a[4]={0,0,0,0}; 	a[i]+=1;a[j]+=1;a[x]+=1;a[y]+=1; 	if(a[0]*a[1]*a[2]*a[3]==0) 	    return 0; 	printf("%d,%d,%d,%d>>",i,j,x,y); 	return 1; } int main() {          int i,j,x,y;          for(i=1;i<=4;i++)             for(j=5;j<=8;j++)                for(x=9;x<=12;x++)                    for(y=13;y<=16;y++)                    {                    	if(isright(i%4,j%4,x%4,y%4))        	           printf("%d,%d,%d,%d\n",i,j,x,y);                    } 	     return 0;    }

user: user-4
content: http://blog.csdn.net/wangshengfeng1986211/article/details/38366709
user-0 提问: 求c语言 1000的阶乘 详细教学

回复:
user: user-1
content: #include <stdio.h> #include <stdlib.h> #include <string.h>  #define MAX_NUM_LEN 2048  int cal_factorial(unsigned char *num_list, int num_size, int n);  int cal_val(unsigned char *num_list, int num_size, int base, int num) {     int i = 0, j;     int len = 1, tmp, carry_bit;      num_list[1] = 1;      while (i < num) {         carry_bit = 0;         for (j = 1; j <= len; j++) {             tmp = num_list[j] * base + carry_bit;             num_list[j] = tmp % 10;             carry_bit = tmp / 10;             if (j >= len && carry_bit != 0)                 len++;             if (num_size-1 < len) {/* overflow */                 printf("Overflow!\n");                 return num_size-1;             }         }         i++;     }      return len; }   int main(void) {     unsigned char num_list[MAX_NUM_LEN];     int num_len, i;     int base, power;      memset(num_list, 0, sizeof(num_list));     printf("Please input two numbers: ");     scanf("%d%d", &base, &power);      if (base < 0 && power % 2)         num_list[0] = 1; /* negative number */     else         num_list[0] = 0;     base = abs(base);      num_len = cal_val(num_list, MAX_NUM_LEN, base, power);     printf("len = %d\n", num_len);     if (num_list[0])         putchar('-');     for (i = num_len; i >= 1; i--)         printf("%d", num_list[i]);     printf("\n");     return 0; }   int cal_factorial(unsigned char *num_list, int num_size, int n) {     int carry_bit, i, j, len = 1;     int tmp;      num_list[1] = 1;     for (i = 2; i <= n; i++)     {         carry_bit = 0;         for (j = 1; j <= len; j++) {             tmp = num_list[j] * i + carry_bit;             num_list[j] = tmp % 10;             carry_bit = tmp / 10;             if (j >= len && carry_bit != 0)                 len++;             if (num_size -1 < len) { /* overflow */                 printf("Overflow!\n");                 return num_size-1;             }         }      }      /*     for (i = len; i >= 1; i--)//逆序输出数组就是结果         printf("%d", a[i]);     printf("\n");     */     return len; } 参考一下吧

user: user-2
content: http://blog.csdn.net/zhagoodwell/article/details/53511996

user: user-3
content: #include<stdio.h> #define N 1000    //要计算的N long s[N]={1,1},n=N,t=2,a=1,b=0; int main()//雨中飞燕之作 {     for(;a<=*s||(++t<=n?(b=0,a=1):0);(*s==a++&&b)?(*s)++:0)         s[a]=(b+=s[a]*t)%10000,b/=10000;     for(printf("%d",s[*s]);--*s>0;) printf("%04d",s[*s]);     return 0; }  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。
user-0 提问: 简单的代码，一看就懂。结果却不对，为什么

回复:
user: user-1

user: user-2
content: scanf格式的问题，注意格式匹配问题就可以。

user: user-3
content: 根据你的代码，输入应该是4,2中间的逗号少不了，格式匹配问题

user: user-4
content: 仅供参考：#include <stdio.h> int main() {     int a,b,n,v,r,k;     char buf[80];     char *p;      k=0;     r=EOF;     while (1) {         if (EOF==r) {             fgets(buf,80,stdin);             p=buf;         }         while (1) {             r=sscanf(p,"%d%n",&v,&n);             if (1==r) {k++;break;}             if (EOF==r) break;             p++;         }         if (EOF==r) continue;         p+=n;         if (1==k) a=v;         if (2==k) {             b=v;             break;         }     }     printf("%d,%d\n",a,b);     return 0; }

user: user-5
content: scanf("%lf,%lf\n", &a, &b); 改成 scanf("%lf%lf\n", &a, &b);  或者输入的时候用逗号分隔，而不是空格

user: user-6
content: scanf("%lf,%lf\n", &a, &b);这一句代码中多了一个逗号 改成scanf("%lf %lf\n", &a, &b);

user: user-7
content: printf输出double的时候，最好不用%lf，不是每个编译器都支持的，直接用%f

user: user-8
content: 浮点数不能判断精确的相等

user: user-9
content: double a, b, c,d;     printf("请输入两个数：A和B\n");     scanf("%lf%lf", &a, &b);     assert(b != 0);     c = a / b;     printf("%lf\n", c);  	getchar(); 	getchar(); 		getchar(); 	getchar();         return 0;

user: user-10
content: 你的第八行代码，是我的vc6的12行

user: user-10
content: #include <stdio.h> #include <assert.h>  int main() { 	double a, b, c,d; 	printf("请输入两个数：A和B\n"); 	scanf("%lf%lf", &a, &b); 	assert(b != 0); 	c = a / b; 	printf("%lf\n", c);         return 0; }  把第12行的逗号和\n符号去掉就正常了

user: user-11
content: 输入的时候少个逗号； 或者直接将代码里的逗号去掉，重新编译然后按照你现在的格式输入也是可行的。

user: user-0
content: 是不是初始化的问题？
user-0 提问: 成绩等级转为百分制

回复:
user: user-0
content: 引用 1 楼 自信男孩的回复:if 判断表达式都是赋值表达式；注意=和==是不一样的。一个是赋值符，一个是判断相等的表达式； 谢谢，我懂了，以后还请多多关照

user: user-0
content: 引用 2 楼 abc_18217053753的回复:你的程序有比较大的问题，逻辑都不是很清晰，针对上面两张图片和你提出的问题，我的说明如下： 针对第一张图片： #include<stdio.h> int main() {  char A,B,C,D,x;            //  A,B,C,D只定义了变量，没有初始化，所以他们的值是随机的。 scanf("%c",&x); if(A) printf();                  //  if,else if 和else 在做判断时是判断括号内的表达式是否成立或者括号内的值为0还是不为0（不为0就是成立，无论值是正还是负），而此时A,B,C,D的值都是随机值，若A的值不为0，就直接执行if（A）这个条件，然后程序结束。所以走哪个条件都是在碰运气。 else if(B) printf(); else if(C) printf();  else if(D) printf(); return 0; }  针对第二张图： 虽然你的变量A，B,C,D都有初始化，但是你每个if条件都是并列的（程序会依次判断每一个if），并且你括号内的条件是个赋值语句（等号）而并不是判断是否相等（判等语句，判等语句是==，两个等号），所以在判断if的时候每次赋值给x的值都不为0（,字符类型对应ASCII码，A,B,C,D的ASCII码都大于0），因此每一条if语句都会执行。 谢谢我懂了，初学C语言还有很多问题请多多指教

user: user-1
content: 你的程序有比较大的问题，逻辑都不是很清晰，针对上面两张图片和你提出的问题，我的说明如下： 针对第一张图片： #include<stdio.h> int main() {  char A,B,C,D,x;            //  A,B,C,D只定义了变量，没有初始化，所以他们的值是随机的。 scanf("%c",&x); if(A) printf();                  //  if,else if 和else 在做判断时是判断括号内的表达式是否成立或者括号内的值为0还是不为0（不为0就是成立，无论值是正还是负），而此时A,B,C,D的值都是随机值，若A的值不为0，就直接执行if（A）这个条件，然后程序结束。所以走哪个条件都是在碰运气。 else if(B) printf(); else if(C) printf();  else if(D) printf(); return 0; }  针对第二张图： 虽然你的变量A，B,C,D都有初始化，但是你每个if条件都是并列的（程序会依次判断每一个if），并且你括号内的条件是个赋值语句（等号）而并不是判断是否相等（判等语句，判等语句是==，两个等号），所以在判断if的时候每次赋值给x的值都不为0（,字符类型对应ASCII码，A,B,C,D的ASCII码都大于0），因此每一条if语句都会执行。

user: user-2
content: if 判断表达式都是赋值表达式；注意=和==是不一样的。一个是赋值符，一个是判断相等的表达式；
user-0 提问: 用codeblocks向main函数传递参数，控制台输出乱码

回复:
user: user-1
content: #include <stdio.h>  // int main(int argc, char* argv[]) int main()  {     char* s[] = {"myexe", "abc", "123"};     int argc = 3;      char** argv = s;      while (argc > 1) {         ++argv;   // 指向 s[1];         printf("%s\n", *argv); //用*argv         --argc;  //(3-1)     }      return 0; }  实际是这样的

user: user-0
content: 引用 9 楼 zhao4zhong1 的回复:http://bbs.csdn.net/topics/390469280 多谢赵老师

user: user-2
content: http://bbs.csdn.net/topics/390469280

user: user-0
content: 引用 6 楼 hongwenjun 的回复:#include <stdio.h>  int main(int argc, char* argv[]) {     while (argc-- > 1) {         printf("%s\n", *++argv);     }     return 0; }  更加挖坑的写法，这个运行是正确的 对于指针数组，例如char *s[]={"abc","123"};，既然s[0  引用 6 楼 hongwenjun 的回复:#include <stdio.h>  int main(int argc, char* argv[]) {     while (argc-- > 1) {         printf("%s\n", *++argv);     }     return 0; }  更加挖坑的写法，这个运行是正确的 您好，“挖坑的写法”是指使用指针变量吗？

user: user-0
content: 引用 3 楼 hongwenjun 的回复: 命令行参数  如图中所示  *argv 这个指针，实际 指向 argv[0] .  ++ argv后就指向了  argv[1]  楼主的代码 正确的写法应该如下面 ，不过这样写，感觉在给自己挖坑  #include <stdio.h>  int main(int argc, char* argv[]) {     while (argc > 1) {         ++argv;         printf("%s\n", *argv);         --argc;     }     return 0; }  非常感谢。 现在被谭书的指针绕的云里雾里的

user: user-1
content: #include <stdio.h>  int main(int argc, char* argv[]) {     while (argc-- > 1) {         printf("%s\n", *++argv);     }     return 0; }  更加挖坑的写法，这个运行是正确的

user: user-1
content: 下载了电子版  教程 确实是错了， 少了  *

user: user-3
content: #include <stdio.h>  int main(int argc,char *argv[]) {     while(argc>1)     {         ++argv;         printf("%s\n", *argv); //用*argv         --argc;     }     return 0; } 用*argv，注意argv的类型是char **是字符类型的的指针数组

user: user-1
content: 命令行参数  如图中所示  *argv 这个指针，实际 指向 argv[0] .  ++ argv后就指向了  argv[1]  楼主的代码 正确的写法应该如下面 ，不过这样写，感觉在给自己挖坑  #include <stdio.h>  int main(int argc, char* argv[]) {     while (argc > 1) {         ++argv;         printf("%s\n", *argv);         --argc;     }     return 0; }

user: user-1
content: #include<stdio.h> int main(int argc, char* argv[]) {      printf("You have inputed total %d argments\n", argc);     for (int  i = 0 ; i < argc ; i++) {         printf("arg%d : %s\n", i, argv[i]);     }      return 0; }   你学的教材不行，学参数 应该要这样的代码，这样才好理解

user: user-1
content: printf("%s\n", argv[0]);
user-0 提问: 为什么下面的程序错误

回复:
user: user-0
content: 明白了，谢谢了诸位

user: user-1
content: #include<stdio.h>  int main() {     int year,month,day,what_day = 0;     //   int a[130],b[130];     int a[13]={0,31,29,31,30,31,30,31,31,30,31,30,31};     int b[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};     scanf("%d,%d,%d", &year, &month, &day);     if(year%400 ==0 || (year % 4 == 0 && year % 100 != 0))     {         for(month = month-1;month>0;month--)             what_day+=a[month];         printf("\n%d",what_day);     }     else     {         for(month = month-1;month>0;month--)             what_day+=b[month];         printf("\n%d",what_day);     }     what_day+=day;     //  printf("\n第%d天",what_day);     return 0; } 四个问题： 1. 输入格式不正确，年月日变量缺少& 2. 闰年判断不对； 3. what_day没有初始化；  4. a的下标month应从month - 1开始

user: user-1
content: 引用 4 楼 zjq9931 的回复:来晚了，上面已经有正解了。 还有问题呢，what_day没有初始化，闰年的判断是否正确？

user: user-2
content: 来晚了，上面已经有正解了。

user: user-3
content: for(;month>0;month--)改成 for(;month>1;month--) what_day+=a[month];改成what_day+=a[month-1] 看看;

user: user-4
content: 还有scanf  里面&year ...  以及闰年判断方法

user: user-5
content: 多算了一个月吧 假如是五月二十日 你这算了12345月的总和+20 应该是1234+20