Question: execv函数参数构建

引用 3 楼 赵4老师的回复:别忘了还有realloc 多谢赵4.....er老师提醒

别忘了还有realloc

多谢您的回复，man手册我读过没有提到过execv系列函数的argv数组指针的构建。您给的这个是execl系列函数的参数介绍，这个其实比较简单我觉得....。 如果使用我的不断malloc的想法的话，释放内存肯定是个问题。感觉这样做太机械化了。

楼主：linux man page说明的参数如下： The const char *arg and subsequent ellipses in the execl(), execlp(), and execle() functions can be thought of as arg0, arg1, ..., argn. Together they describe a list of one or more pointers to null-terminated strings that represent the argument list available to the executed program. The first argument, by convention, should point to the filename associated with the file being executed. The list of arguments must be terminated by a NULL pointer, and, since these are variadic functions, this pointer must be cast (char *) NULL.   按照你说的，你的方法应该可以的，尝试实践才知道结果。


Question: c语言猜数字

引用 8 楼 colinfang2006 的回复:我的意思是维护一个数组，保存每次猜测后还有可能是答案的数。 初始数组里面有10 * 9 * 8 * 7=5040个数。 每次猜测后，都需要在数组中划掉一部分不符合要求的数字。 例如你猜测1234，结果是0A0B，那么数组中所有含有1、2、3、4的数组都不符合要求。 哦有点明白的 感觉好难，我努力试试吧 谢谢啦

引用 6 楼 colinfang2006 的回复:提供个思路： 计算机猜测的数字尽可能带来的信息量较大，比如可以猜每次留下的数中，每一位出现最多的数字    大神能在详细的说一下吗....萌新实在是不太懂

引用 1 楼 yfqvip 的回复:http://bbs.bccn.net/viewthread.php?tid=474692&extra=&page=1 自己输入我会就是不太懂如何写 给上一次的A B 程序猜下一个数 求帮助

引用 2 楼 hou09tian 的回复:guess()函数的作用就是提示玩家输入一个数字，并把这个数字作为返回值吧？  就是让程序自己猜不用输入数

引用 2 楼 hou09tian 的回复:guess()函数的作用就是提示玩家输入一个数字，并把这个数字作为返回值吧？不是 是给上一次 A B 的值 然后返回你猜的数

guess()函数的作用就是提示玩家输入一个数字，并把这个数字作为返回值吧？


Question: C语言文件打开失败

我用cocoa编程出现同样问题，命令行没问题。

使用strerror(errno);输出文件打开失败的原因。

沒問題吧？“its fail”都沒見打印出來。


Question: 动态库链接静态库的问题

看上去没啥好方法，结贴吧。。。

引用 1 楼 boise 的回复:保持能正常调用的Bin方式， 让你的动态库去调用执行Bin文件，想办法解决传递数据的问题吧。 这是个思路，只是现在用到的函数是性能关键路径，如果通过bin文件的方式去访问，性能损耗比较大


Question: 求大神解c语言中数组与指针的问题

A[B] *(A+B) *(B+A) B[A] //以上四行等价  "abc"[1] *("abc"+1) *(1+"abc") 1["abc"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价

a可以理解为指针常量。数组名本身就是地址，可以把a当做指针来用，但需要注意它是指针常量

a[b] 就是 *(a + b) 的缩写，其中a、b一个是地址，一个是整数，顺序无所谓

尽量不要问这种问题，非常基础。而且答案 c/c++的基础书籍中，都可以轻易找到

VS2015输出是0啊。 &a和a都是指向数组a的第一个元素的地址，即&a[0]  但是两者也是有区别的。 请参考 《C++中对数组名的运算》 《C++中指针的数组和数组的指针》 希望能够帮到你

数组名作为参数传递给函数时,数组名会退化为指针

数组和指针关系了解一下。

在仔细看看数组那块的知识吧。。  数组名是可以直接代表数组首单元的地址的。。。


Question: C# 窗体程序中，连接数据库的工具类怎么写？

顶！！！

自顶


Question: 关于C语言中malloc函数的疑问

当实际用户输入的数据量 > malloc分配时设定的字节大小 越界操作属于高危操作

malloc所分配的内存是一块连续的空间（逻辑上连续，物理上不一定）。同时，malloc实际分配的内存空间可能会比你请求的多一点，但是这个行为只是由编译器定义的。malloc不知道用户所请求的内存需要存储的数据类型，所以malloc返回一个void *的指针，它可以转换为其它任何类型的指针。

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

不一定连续，但是我们不需要关注连续不连续。我们使用的内存地址是虚拟地址，内存由MMU来管理，MMU是会处理虚拟地址与物理地址的映射关系； 内存分配会比malloc参数指定的要大，因为要存储一些内存管理信息（用于管理申请的内存），这部分多出的内存是有系统决定的（malloc是程序运行时申请的，所以跟编译器没关系）。

MSDN关于malloc()函数的描述 The malloc function allocates a memory block of at least size bytes. The block may be larger than size bytes because of the space that's required for alignment and maintenance information. malloc()函数分配的内存空间至少是函数参数指定的字节数，而实际分配的内存空间比指定的要大一些，因为分配的内存空间中还要包含内存空间的排列信息和维护信息。


Question: 大神们这如何操作

DosBox是个好东东！

引用 7 楼 u010165006 的回复:[quote=引用 6 楼 goldenhawking 的回复:] 各种老掉牙的软件： https://winworldpc.com/library/operating-systems 再用Oracle VirtualBox安装。   层主经历旺盛~[/quote] 老了，把以前写的程序全攒到虚拟机里留着。

引用 6 楼 goldenhawking 的回复:各种老掉牙的软件： https://winworldpc.com/library/operating-systems 再用Oracle VirtualBox安装。   层主经历旺盛~

如果是非要在TC2下输入汉字，只有虚拟机DOS6.22+UCDOS 7.0 +TC2了。老掉牙的东西。 否则，建议参考3楼。

感觉楼上的做法应该可以

TC（Turbo C）老代码（比如小游戏）最好看懂了以后，理解了算法和过程，用VC改写成Windows平台的。  楼主如果想用C玩玩图形、小游戏编程，可以了解一下EasyX，EasyX是Windows平台最简单的绘图函数库（名副其实），兼容BC和TC的绘图函数，在VC下用EasyX来编程跟在TC下编程绘图差不多是完全一样的。EasyX既可以绘图，也支持图像显示和处理。  下载一个EasyX包，里面有完整的函数手册EasyX_Help.chm，有示例。EasyX官网有很多网友上传的实例，包括游戏。  仅供参考： 用绘图语句画机器猫（初学C语言的同学必看） http://blog.163.com/tab_98/blog/static/1192409720150316223680/

挖了个坟，类似主题，不过结果貌似不行。。。 https://bbs.csdn.net/topics/60045726

百度 怎样在TC2.0中输入汉字输出汉字


Question: 有关 SDK listview 分组的问题？？（再次发帖，寻求大神解答！）

没有人回答吗？

我没在VC里测试过，不过我想知道在winGW里编译通过，该怎么处理？？

在vs中编译没什么大问题。 #pragma comment(linker, ... 这句估计你的没起作用。


Question: CentOS64, 一个函数内static指针的值竟然不知怎么就变了——已解决，来接分了

自己找出問題，成就感滿滿的。

学会使用数据断点：#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; }     GDB有watch命令

来接分， 越界操作危害大呀

这个问题就是数组越界的原因，有段代码使用一个数组，数组的索引越来越大，慢慢的就覆盖了它后面的内容，导致它后面的内容被覆盖成了相应的值。 用objdump -x 查找被修改的变量前面的变量，再看检查操作那些变量的代码有没有问题


Question: 在将汉字存入文件时，遇到了乱码问题，新手求大佬帮助

楼主，在我本地测试发现如下： 1)“但是如果文件为空的情况，并且第一个存储的汉字是“猫”或者“猫猫”这种连续的以猫为内容的字符串存入的文件就会出现乱码” -->这种情况，内容保存在txt文件中是已utf-8的格式保存的，所以你使用记事本打开时，会显示乱码。如果你使用notepad++使用ANSI编码打开时，显示的就是猫或者猫猫。 2) "如果文件不为空，且第一个存储的汉字不是“猫”，都不会出现乱码" -->这种情况，例如第一个字是狗字，那么保存到文件中的内容的编码是ANSI编码的，所以你使用记事本打开的时候，显示没有乱码。 3)"如果在“猫”字乱码的基础上，再次存入一个其他汉字，猫的乱码就会恢复" -->这种情况例如第一个字是猫字，这是保存的内容的编码是utf-8的编码格式，但输入第二个字，例如为狗字时，保存的内容“猫狗”的编码确实ANSI编码格式了，所以使用记事本打开时，显示没有乱码。  猜测原因：应该是系统会根据你写入文件的内容而动态的改变内容的编码格式，来寻求存储方面的最优化。

谢谢你们，大致了解了

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

我估计，当后一种情况的时候，实际上文件头已经标明了UTF编码，比如是EF BB。


Question: 二进制字符问题

修改成  str3 = int_to_bin((n1 & n2), str3); 	show_bin(str3);  也可以正常显示。原因是:       char * int_to_bin(int n, char *ps)       这个函数看着是传递了一个指针，其实本质还是形参的值传递形式，ps实际是实参的一个拷备，只不过ps和实参指向的是同一个地址，然后你在函数内部执行       ps = (char*)malloc(sizeof(char) * size + 1); 后，其实就改变了ps所指向的地址，但是不会改变实参的地址，所以你在此后所做的操作都是针对改变指向后的ps的操作，没有影响到实参，因此在函数执行后实参还是调用前的状态。

谢谢各位，总算是用最开始的方法，写完整了。 #include "stdafx.h" #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h> #include <limits.h> #include <ctype.h> #define Length 9  void show_bin(const char *); char * int_to_bin(int); char * int_to_bin111(int, char *); int bin_to_int(char *); int _tmain(int argc, char * argv[]) { 	char str1[Length] = ""; 	char str2[Length] = ""; 	const static int size = CHAR_BIT * sizeof(int); 	//char bin_str[CHAR_BIT * sizeof(int) + 1]; 	//char * str3 = (char*)malloc(sizeof(char) * Length + 1); 	char * bin_str22 = (char*)malloc(sizeof(char) * size + 1);  	int n1 = 0,  n2 = 0; 	printf("Please enter str1:"); 	scanf("%s", str1); 	while (getchar() != '\n') 		continue; 	printf("Please enter str2:"); 	scanf("%s", str2); 	while (getchar() != '\n') 		continue; 	n1 = bin_to_int(str1); 	n2 = bin_to_int(str2); 	printf("n1 is %d. n2 is %d.\n", n1, n2); 	printf("Operation & result is "); 	//str3 = int_to_bin((n1 & n2));//int_to_bin((n1 & n2), str3); 	int_to_bin111((n1 & n2), bin_str22); 	//show_bin(str3); 	//printf("********* & result is "); 	show_bin(bin_str22); 	printf("\n");  	printf("Operation | result is "); 	//str3 = int_to_bin((n1 | n2)); 	int_to_bin111((n1 | n2), bin_str22); 	//show_bin(str3); 	//printf("********* | result is "); 	show_bin(bin_str22); 	printf("\n");  	printf("Operation ^ result is "); 	//str3 = int_to_bin((n1 ^ n2)); 	int_to_bin111((n1 ^ n2), bin_str22); 	//show_bin(str3); 	//printf("********* ^ result is "); 	show_bin(bin_str22); 	printf("\n");  	//free(str3); 	free(bin_str22);  	system("PAUSE"); 	return 0; } char * int_to_bin(int n)//char * int_to_bin(int n, char *) { 	int i = 0; 	const static int size = CHAR_BIT * sizeof(int); 	char * ps = (char*)malloc(sizeof(char) * size + 1);	 	for (i = size - 1; i >= 0; i--, n >>= 1) 	{ 		ps[i] = (char)((01 & n) + '0'); 	} 	ps[size] = '\0'; 	return ps; } char * int_to_bin111(int n,  char * ps)//char * int_to_bin(int n, char *) { 	int i = 0; 	const static int size = CHAR_BIT * sizeof(int); 	//char * ps = (char*)malloc(sizeof(char) * size + 1); 	for (i = size - 1; i >= 0; i--, n >>= 1) 	{ 		ps[i] = (char)((01 & n) + '0'); 	} 	ps[size] = '\0'; 	return ps; } int bin_to_int(char *ps) { 	size_t length = 0; 	length = strlen(ps); 	int value = 0, cheng2 = 1; 	for (size_t i = 0; i < length; i++) 	{ 		cheng2 = 1; 		for (size_t j = 0; j < i; j++) 		{ 			cheng2 *= 2; 		} 		value += cheng2 * (int)(ps[length - i - 1] - '0'); 	} 	return value; } void show_bin(const char * str) { 	int i = 0; 	while (str[i]) 	{ 		putchar(str[i]); 		if (++i % 4 == 0 && str[i]) 		{ 			putchar(' '); 		} 	} 	printf("\n"); }

整个代码只需要两处改动即可： ①在main函数中 str3 = (char*)malloc(sizeof(int) * Length + 1);//修改char为int memset(str3, 0, sizeof(int) * Length+1);//添加这一行  改动的意义是int_to_bin会返回一个32长度的char数组，而你str3只分配8字节长度，去接收肯定是不对的，其次分配内存空间后最好能初始化为0 ②int_to_bin函数中 屏蔽代码ps = (char*)malloc(sizeof(char) * size + 1);  改动的意义是我在①中添加的代码已经保证此时的ps集成了str3的初始化，重新初始化会产生错误  这些错误都是我加断点一步步找出来的，希望程序错误时，多用断点

重新看了下书上写的。改了一下，char * int_to_bin(int, char *);这个函数的定义还是加上了char *试的，就是在主函数调用的时候，把之前的指针改成了字符串数组的模式。就可以了。但是不明白用指针的形式怎么就不行了。。。 #include "stdafx.h" #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h> #include <limits.h> #include <ctype.h> #define Length 9  void show_bin(const char *); char * int_to_bin(int); char * int_to_bin111(int, char *);  int bin_to_int(char *); int _tmain(int argc, char * argv[]) { 	char str1[Length] = ""; 	char str2[Length] = ""; 	//const static int size = CHAR_BIT * sizeof(int); 	char * str3; 	char bin_str[CHAR_BIT * sizeof(int) + 1]; 	str3 = (char*)malloc(sizeof(char) * Length + 1); 	int n1 = 0,  n2 = 0; 	printf("Please enter str1:"); 	scanf("%s", str1); 	while (getchar() != '\n') 		continue; 	printf("Please enter str2:"); 	scanf("%s", str2); 	while (getchar() != '\n') 		continue; 	n1 = bin_to_int(str1); 	n2 = bin_to_int(str2); 	printf("n1 is %d. n2 is %d.\n", n1, n2); 	printf("Operation & result is "); 	str3 = int_to_bin((n1 & n2)); 	int_to_bin111((n1 & n2), bin_str); 	show_bin(str3); 	printf("********* & result is "); 	show_bin(bin_str); 	printf("\n");  	printf("Operation | result is "); 	str3 = int_to_bin((n1 | n2)); 	int_to_bin111((n1 | n2), bin_str); 	show_bin(str3); 	printf("********* | result is "); 	show_bin(bin_str); 	printf("\n");  	printf("Operation ^ result is "); 	str3 = int_to_bin((n1 ^ n2)); 	int_to_bin111((n1 ^ n2), bin_str); 	show_bin(str3); 	printf("********* ^ result is "); 	show_bin(bin_str); 	printf("\n");  	free(str3);  	system("PAUSE"); 	return 0; } char * int_to_bin(int n)//char * int_to_bin(int n, char *) { 	int i = 0; 	const static int size = CHAR_BIT * sizeof(int); 	char * ps = (char*)malloc(sizeof(char) * size + 1);	 	for (i = size - 1; i >= 0; i--, n >>= 1) 	{ 		ps[i] = (char)((01 & n) + '0'); 	} 	ps[size] = '\0'; 	return ps; } char * int_to_bin111(int n,  char * ps) { 	int i = 0; 	const static int size = CHAR_BIT * sizeof(int); 	//char * ps = (char*)malloc(sizeof(char) * size + 1); 	for (i = size - 1; i >= 0; i--, n >>= 1) 	{ 		ps[i] = (char)((01 & n) + '0'); 	} 	ps[size] = '\0'; 	return ps; } int bin_to_int(char *ps) { 	size_t length = 0; 	length = strlen(ps); 	int value = 0, cheng2 = 1; 	for (size_t i = 0; i < length; i++) 	{ 		cheng2 = 1; 		for (size_t j = 0; j < i; j++) 		{ 			cheng2 *= 2; 		} 		value += cheng2 * (int)(ps[length - i - 1] - '0'); 	} 	return value; } void show_bin(const char * str) { 	int i = 0; 	while (str[i]) 	{ 		putchar(str[i]); 		if (++i % 4 == 0 && str[i]) 		{ 			putchar(' '); 		} 	} 	printf("\n"); }

引用 2 楼 user-4 的回复:供参考： int_to_bin声明改成 char * int_to_bin(int); str1和str2改成      char str1[Length+1] = "";     char str2[Length+1] = ""; int_to_bin函数改成： char * int_to_bin(int n) {     int i = 0;     const static int size = CHAR_BIT * sizeof(int);     char* ps = (char*)malloc(sizeof(char) * size + 1);     //memset(ps,0,sizeof(char)*(size+1));     for (i = size - 1; i >= 0; i--, n >>= 1)     {         ps[i] = ((01 & n)+'0');     }     ps[size] = '\0';     return ps; } 结果如下：   你的书上代码这么写，然后也没解释为什么这么写么？为什么数组形式就可以，指针形式就不行？想不明白。

仅供参考：#include <stdio.h> #include <stdlib.h> #include <string.h> #include <locale.h> int main() {     int i,v;     char bs[33];     char b[33];     char hs[9];     char h[9];     char s[4];     char *e;  // 十进制整数转二进制串；     i=1024;     ltoa(i,b,2);     sprintf(bs,"%032s",b);     printf("i=%d,bs=%s\n",i,bs); // 十进制整数转十六进制串；     i=1024;     ltoa(i,h,16);     sprintf(hs,"%08s",h);     printf("i=%d,hs=%s\n",i,hs); // 十六进制字符串转成十进制数     strcpy(hs,"00000400");     sscanf(hs,"%x",&i);     printf("hs=%s,i=%d\n",hs,i); // 二进制字符串转化为十六进制字符串；     strcpy(bs,"00000000000000000000010000000000");     i=strtol(bs,&e,2);     ltoa(i,h,16);     sprintf(hs,"%08s",h);     printf("bs=%s,hs=%s\n",bs,hs); // 二进制字符串转化为十进制数；     strcpy(bs,"00000000000000000000010000000000");     i=strtol(bs,&e,2);     printf("bs=%s,i=%d\n",bs,i); // 十六进制字符串转成二进制串     strcpy(hs,"00000400");     sscanf(hs,"%x",&i);     ltoa(i,b,2);     sprintf(bs,"%032s",b);     printf("hs=%s,bs=%s\n",hs,bs); // ASC\GBK字符串转十六进制串     strcpy(s,"a汉");     i=0;     while (1) {         if (0==s[i]) break;         sprintf(hs+i*2,"%02X",(unsigned char)s[i]);         i++;     }     setlocale(LC_ALL,"chs");     printf("s=%s,hs=%s\n",s,hs); // 十六进制字符串转成汉字（GBK）及字符(ASC)     strcpy(hs,"61BABA");     i=0;     while (1) {         if (1!=sscanf(hs+i*2,"%2x",&v)) break;         s[i]=(char)v;         i++;     }     s[i]=0;     printf("hs=%s,s=%s\n",hs,s);      return 0;  } //i=1024,bs=00000000000000000000010000000000 //i=1024,hs=00000400 //hs=00000400,i=1024 //bs=00000000000000000000010000000000,hs=00000400 //bs=00000000000000000000010000000000,i=1024 //hs=00000400,bs=00000000000000000000010000000000 //s=a汉,hs=61BABA //hs=61BABA,s=a汉

为什么输出的结果是这样乱码的？ int_to_bin这个函数哪儿写的有问题？这个是照着书上写的啊。


Question: 指针变量问题

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

印象中这段代码是谭浩强书上的经典错误

引用 1 楼 user-5 的回复:楼主先看下面一段话： 一个由C/C++编译的程序占用的内存分为以下几个部分  1、栈区（stack）： 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。  2、堆区（heap） ： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。  3、全局区（静态区）（static）：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域， 程序结束后有系统释放 。 4、文字常量区：常量字符串就是放在这里的， 程序结束后由系统释放 。 5、程序代码区：存放函数体的二进制代码。  好了，你的代码的问题是，你尝试修改文字常量区的内容。为什么换成数组没问题呢，是因为，数组是被放在栈区，是可以访问并修改的。而文字常量区是不可以修改的。 我曾经修改常量地址的地址骗过了编译器的眼睛

int main() { 	void copy_string(char * from, char * to); 	char * a = "I am a teacher."; 	char * b = "You are a student."; 	//char * p;  	printf("string a=%s\nstring b=%s\n", a, b); 	printf("\ncopy string a to string b:\n"); 	b = (char*)malloc(sizeof(char) * strlen(a) + 1); //这里给指针分配了一个内存就可以正常运行了。 	copy_string(a, b); 	printf("string a=%s\nstring b=%s\n", a, b);  	free(b);//释放 	system("PAUSE"); 	return 0; }  void copy_string(char * from, char * to) { 	for (; *from != '\0'; from++, to++) 	{ 		*to = *from; 	} 	*to = '\0'; }


Question: C语言求教：如何在一个坐标轴内用C语言统计表达出点位最集中的小片区域对应的Y轴区域范围的函数？

生成了100个时间随机数在0-70之间，按照上述算法出来的结果，大于14的  就是比较集中的区间了。你不要看我这些数据分散的比较平均，因为用了时间随机数。。

写简单点  比如说你有一个数组num[100]存的是这些点的y坐标。  根据你图中y大小定义一些变量：y10,y20,y30,y40,y50,y60,y70  for循环100次依次提取num数组中的数并除以10，switch case一下，相应的y大小计数加1。例：循环执行到50次，num[50]中的数为56，除以10后变为5，switch case一下，判断为5后y50自加1。  按上述步骤统计完后100/7=14，计算出平均每组的计数个数，大于等于这个数字的区间准予输出，例： y10=2,y20=10,y30=19,y40=23,y50=29,y60=13,y70=4,其中，y30,y40,y50满足条件，准予输出，即30-40，40-50，50-60，即30-60。输出再自己编写一下就ok。这是一种非常简单的算法，，你可以根据你那边的具体要求再加一点东西进去

百度搜“四叉树”？


Question: C语言写的一个公交管理系统，不能正确新增和查询数据，好像是结构体内数组输入的时候出了问题，求教怎么办

char type; char name; 这两个输入有错，自己检查下。 你本意要想输入字符串就要用数组，如果字长不确定就用动态分配，但注意用完要释放。

char type; char name; 这两个输入有错，自己检查下。

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

scanf("%s",&LineInfo[n].type);     printf("请输入线路名称\n");     scanf("%s",&LineInfo[n].name);     printf("请输入公交站名称\n"); type和name都是char类型，不是char类型的数组。因此，不用用%s，要么将type和name定义成数组，就可以了。

请检查scanf的返回值。

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


Question: 用C怎么把png图片数据转换成二进制数据

你的意思是不是想把图片保存到内存里面，再加载出来？

引用 2 楼 cfjtaishan 的回复:直接打开图片文件，fread读取到char *的缓存里即可。因为图片本身就是二进制存储的    @自信男孩，png文件存到Char * 中，并且能够转回png文件，fread我这边只能读出一部分，能给代码看下吗

回复 oblivi ，用C语言来实现，这个有点看不懂

所有文件都是二进制的，你的意思是不是这个BOOL MusicResolve::GetMusicJpgIndirect(LPCTSTR lpszFileName,IStream **pStream) { 	CFile file; 	BOOL flag = file.Open(lpszFileName, CFile::modeRead | CFile::typeBinary); 	if (!flag) 		return FALSE; 	 	int nCount=file.GetLength(); 	BYTE *jpg = new BYTE[nCount]; 	file.Read(jpg, nCount); 	HGLOBAL glb = GlobalAlloc(GHND, nCount); 	LPVOID data = GlobalLock(glb); 	memcpy(data, jpg, nCount); 	delete[]jpg; 	if (FAILED(CreateStreamOnHGlobal(glb, TRUE, pStream))) 		return FALSE; 	return TRUE; }

电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。  不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了

https://blog.csdn.net/qq_21334991/article/details/79035222 使用libpng就可以省很多事，参考一下上面的文章

引用 5 楼 u014608536 的回复:[quote=引用 2 楼 cfjtaishan 的回复:] 直接打开图片文件，fread读取到char *的缓存里即可。因为图片本身就是二进制存储的    @自信男孩，png文件存到Char * 中，并且能够转回png文件，fread我这边只能读出一部分，能给代码看下吗[/quote] 你的png文件多大呢，你读取放到char *缓存里做什么用？ 这个问题就是一个文件操作呢，fopen，fclose, fread/fwrite就能实现


Question: 指向含有10个函数指针的数组的指针的初始化

好比  int *a; &a的返回值你打算用什么类型去接收，只能用 int **b;  b=&a;

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

p是指向含有10个函数指针的数组的指针变量 也就是说，p是数组的指针。 所以应该为p赋数组A的地址，即 p = &A; 数组的一个特性是：在很多用到数组名字的地方，编译器都会自动地将其替换为一个指向数组首元素的指针； 所以 p = A; 时，A的含义是指向int*的指针，而p是指向int*数组的指针，所以会报错！

基本搞清楚了，数组名和数组名取地址虽然值是一样的，都是指向数组首元素的地址，但是类型不一样，可以通过下面的代码来理解  下面的代码中， int arr[10] = { 0,1,2,3,4,5,6,7,8,9 }; arr的类型是 int* 而 &arr的类型是 int(*)[10] 所以如果定义一个变量int(*p)[10]，赋值的时候必须 p=&arr，如果p=arr，那么编译器会报类型不匹配的错误。    #include "stdafx.h" #include "stdlib.h" void test_sizeof_addr(char *a) {     printf("%d\n", sizeof(a)); } void test_sizeof_array(char a[]) {     printf("%d\n", sizeof(a)); }  int main() {     int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };     int *p = arr;     //int *q = &arr; //非法，类型不匹配  cannot convert from 'int (*)[10]' to 'int *'      int b = sizeof(arr);     int a = sizeof(&arr);     //int *q = &arr;     printf("&arr=0x%x\r\n",(int)&arr);     printf("arr=0x%x\r\n", (int)arr);     printf("&arr[0]=0x%x\r\n", (int)&arr[0]);      char d[30];     printf("%d\n", sizeof(d));     printf("%d\n", sizeof(&d));     printf("%x  %x\n", d, &d);     test_sizeof_addr(d);     test_sizeof_array(d);     system("pause");     return 0; }

指针变量和数组名是不同的，数组名取地址和数组名是一样的值，


Question: 有多个相同字符串的情况下，如何定位到某个指定字符串？

楼主，可以参考一下下面的代码，原理应该差不多的。 void main() { 	FILE* pFile = NULL; 	fopen_s(&pFile, "2.txt", "r"); 	if (pFile == NULL) 	{ 		return ; 	}  	fseek(pFile, 0, SEEK_END); 	long lFileSize = ftell(pFile); 	if (lFileSize == 0) 	{ 		fclose(pFile); 		return ; 	} 	fseek(pFile, 0, SEEK_SET);  	char* pFileInfo = (char*)malloc(lFileSize + 1); 	if (pFile == NULL) 	{ 		fclose(pFile); 		return; 	} 	memset(pFileInfo, 0, lFileSize + 1);  	int nSpaceIndex = 0; 	while (fgets(pFileInfo, lFileSize, pFile) != NULL) 	{ 		while (pFileInfo[nSpaceIndex] == ' ') 		{ 			++nSpaceIndex; 			continue; 		}  		if (pFileInfo[nSpaceIndex] == '/') 		{ 			nSpaceIndex = 0; 			memset(pFileInfo, 0, lFileSize + 1); 			continue; 		} 		else 		{ 			if (pFileInfo[nSpaceIndex] == '&') 			{ 				int nLen = strlen(pFileInfo); 				if (nLen >= 5) 				{ 					if (pFileInfo[1] == '0' && pFileInfo[2] == '0' && pFileInfo[3] == '0' && pFileInfo[4] == '1') 					{ 						break; 					} 				} 			} 			nSpaceIndex = 0; 			memset(pFileInfo, 0, lFileSize + 1); 			continue; 		} 	} 	fclose(pFile);  	printf("%s", pFileInfo); 	free(pFileInfo);  	getchar(); 	return ; }

建议研究一下正则表达式

https://www.cnblogs.com/274914765qq/p/4574367.html 参考下这篇文章使用正则表达式， 定义两个正则表达式："&0001.*"，"//&0001.*"判断包含"&0001.*"但不包含"//&0001.*"的就是你需要的


Question: 网络编程select模型设置超时时间无效

cpu内部的时钟周期并不是无限小，仅仅只是一个比较小的值，再加上操作系统的封装，程序内能表示的最小时间间隔很可能更大。如果你设置的超时时间太小，当然出来的超时结果就不准确了。当然我想这并不是你代码超时不准确的原因。。。 最主要的原因应该是操作系统时间分片机制。如果你对操作系统的线程运作稍微有所了解，就应该知道操作系统的线程并不是真实并行运行的，而是快速交替运行（当然现在的cpu拥有多核多线程可以实现真实并行，但是这种分时机制依然起着主要作用）。假设只有两线程，线程切换周期为10ms,那么如果当前线程只运行了9ms就进行了线程切换，那么设置的超时时间不会在第10ms起作用，因为此时定时器所在的线程已经没有执行权了。只有等到线程再次拿到执行权后，定时器才会起作用，即第19ms。考虑到代码运行也需要时间，定时器将在>19ms的时候超时。 所以，一般来讲，涉及到超时时间，这是超时时间只是一个大概值。并且不能太小，否则会非常非常“大概”。。。

1微妙太短了吧，建议用1秒试试


Question: 头文件

楼上2位是正解，getnights()函数的声明后面要加分号

函数的声明是一条语句，因此需要加上分号;

extern int getnights(void)后面缺少分号，写代码仔细点

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


Question: 请教一条代码的含义

就是1到10，每个数字都和1到10相加的总和

如果你不知道怎么调试的话，  在sum+=i*j;后面加一句printf("i=%d,j=%d,sum=%d",i,j,sum);来观察3个数的值是如何变化的

你可以对sum+=i*j ;这句加个断点，然后单步调试，观察i、j、sum三个值的变化；  执行的逻辑是进入外圈for i=1时 进入内圈for，从j=1开始到j=9，执行9次 sum=sum+i*j，就是0+1*1+1*2+...+1*9，然后跳出内圈for，此时i=2，同理进行九次45+2*1+2*2+...+2*9，同理执行到i=9，外圈for也执行了9次，内外一共9*9次，sum就是累加和

sum=0+1*1+1*2+...+1*9             +2*1+2*2+...+2*9             +...+             +9*1+9*2+...+9*9

两层循环，外层循环i = 1时， sum  = 1 * 1 + 1 * 2 + 1 * 3...+1*9;此时j就是从1~9； 当i = 2时，sum += 2 * 1 + 2 * 2 + 2 * 3...+ 2 * 9; 此时j是从1~9 ... 当i = 9时，sum += 9 * 1 + 9 * 2 + 9 * 3...+9 * 9;

这个在学习了循环语句后很容易理解的，你可以在调试模式下载循环入口处打断点一步一步看，应该就很清楚了


Question: 二叉树的动态查找

問題出在把數組ch的地址傳給兩個函數了。 這是一個固定地址，但它的内容隨著scanf的執行而發生變化。 InsertBiTree函數中，data僅僅是指向傳遞進來的字符串地址，所以它指向的其實是ch這個數組。換句話說，執行多次InsertBiTree函數之後，生成的這個樹，每一個data數據項其實都指向同一個地方，這是問題之一。 而在BiTreeSearch函數中，又在這個樹中查找ch這個字符串，既然都指向了ch，再跟ch做比較，豈不是必然相等？  所以解決辦法是： 樹結搆体中的data改用字符數組而不是指針，或者在InsertBiTree中給它動態分配地址。 並且在InsertBiTree中必須用strcpy拷貝字符串内容。

楼上说的正确，楼主可以参考一下下面代码，逻辑差不多的。注意需要添加动态分配的内存释放操作。  #include <stdio.h> #include <string.h> #include <stdlib.h>  typedef struct node{ 	char *data; 	struct node *lchild, *rchild; }Btree;  typedef Btree *BiTree;  int InsertBiTree(Btree **root, char *x) { 	Btree *current = NULL, *parent = NULL, *p = NULL; 	current = *root; 	while (current != NULL) 	{ 		if (strcmp(current->data, x) == 0) 			return 0;  		parent = current; 		if (strcmp(current->data, x) < 0) 			current = current->rchild; 		else 			current = current->lchild; 	}  	p = (Btree*)malloc(sizeof(Btree)); 	if (p == NULL) 	{ 		printf("空间不够\n"); 		exit(1); 	}  	int nLen = strlen(x); 	if (nLen > 9) 	{ 		printf("输入的字符数不对\n"); 		exit(1); 	}  	char* px = (char*)malloc(nLen + 1); 	if (px == NULL) 	{ 		printf("空间不够\n"); 		exit(1); 	} 	memset(px, 0, nLen + 1); 	memcpy(px, x, nLen);  	p->data = px; 	p->lchild = NULL; 	p->rchild = NULL; 	if (parent == NULL) 		*root = p; 	else if (strcmp(x, parent->data) < 0) 		parent->lchild = p; 	else 		parent->rchild = p; 	return 1; }  int BiTreeSearch(Btree *root, char *x){ 	Btree *current; 	if (root != NULL){ 		current = root; 		while (current != NULL){ 			if (strcmp(current->data, x) == 0) 				return 1; 			if (strcmp(current->data, x)<0) 				current = current->rchild; 			else 				current = current->lchild; 		} 	} 	return -1; }   int main(void) { 	Btree *s = NULL; 	char ch[10] = { 0 }; 	printf("请输入最多9个元素:\n"); 	for (int i = 0; i<12; i++){ 		scanf_s("%s", ch, 10); 		InsertBiTree(&s, ch); 		memset(ch, 0, 10); 	}  	printf("请输入要查找的最多9个元素:"); 	scanf_s("%s", ch, 10); 	if (BiTreeSearch(s, ch) == -1) 		printf("无此元素"); 	else  		printf("查找成功");  	getchar(); 	return 0; }


Question: linux 终端后台执行程序发送udp包，插着usb线就能发送，拔了usb就停止发送了。

还有一个现象，我把终端插到充电器上，服务端也会收到client的包，但是就会收到几个包，收到几个包后也就收不到了，拔掉充电器也会收到几个包，然后就收不到了。很奇怪，不理解为什么。

linux 终端，一个测试软件，软件主要功能向服务端发送udp包，通过adb进入到终端shell，把测试软件后台运行，然后把usb线拔掉，服务端就会收不到client发过来的数据包，但是当我把usb线重新插到终端，不进入adb shell，服务端就会重新收到client发过来的udp包。

用usb做加密，权限，还是说读取了usb中的内容？不清楚，瞎猜的。。。

发送包跟插拔usb有什么关系？建议详细介绍一下你的测试环境


Question: 大佬们快帮我改一下

#include<stdio.h> #include<malloc.h>  typedef int KeyType;  typedef struct {     KeyType key; }ElemType;  typedef struct {     ElemType *elem; }SSTable;  typedef struct {     int low,high,mid;     ElemType *elem; }STable;  int Search_seq(SSTable ST, int n, KeyType key) {     int i=n-1,count=0;     ST.elem[0].key=key;     while(ST.elem[i].key!=ST.elem[0].key)     {         i--;         count++;     }     if(ST.elem[i].key==ST.elem[0].key&& i!=0)     {         printf("一共有%d次",count);         return i;         //printf("一共有%d次",count);     }     else         return 0; }   int Search_Bin(STable QT, int n,KeyType key) {     int low=0,high=n-1,mid;     while(low<=high)     {         mid=(low+high)/2;         if(key==QT.elem[mid].key)             return mid;         else if(key<QT.elem[mid].key)             high = mid-1;         else             low = mid+1;     }      return 0; }  //void main() int main() {     int a[10],i,j,k;     KeyType key=5;     SSTable ST;     STable QT;     ST.elem = (ElemType *)malloc(100*sizeof(ElemType));     QT.elem = (ElemType *)malloc(100*sizeof(ElemType));     for(i=0;i<10;i++)     {         //scanf("%d",&a);         scanf("%d", &a[i]);         ST.elem[i+1].key=a[i];     }     printf("顺序查找法:\n");      if ((j=Search_seq(ST, 10, key))!=0)         printf("元素%d的位置是%d\n",key,j);     else         printf("该表中无此元素%d\n", key);      printf("折半查找法:\n");     for(i=0;i<10;i++)         QT.elem[i].key = a[i];      if((k=Search_Bin(QT,10,key))!=0)         printf("元素%d的位置是%d\n",key,k);     else         printf("未找到该元素%d\n",key); } 参考一下吧  建议对比上面的代码，找到自己的问题所在。


strcpy

已经找到问题了，调用标准库，但是strcpy写错了

strcopy是你這個庫提供的嗎？


Question: 为什么59行会警报

定义StartProgram()函数为 void StartProgram() { }

你这写子函数，不说明类型吗，如果没有返回值，用 void StartProgram() { } void getnumber() { } 如果需要返回值，把void改成int，同时在子函数末尾return一个对应类型的值

函数类型未定义啊。

因为这个函数没有定义返回值类型，若未定义，编译器默认认为是int类型。因此，需要函数返回一个int类型的数据。


Question: cpp(12) :  error C2065: 'ReadRecord' : undeclared identifier  错在哪里了呢

ReadRecord()这个函数没有定义

你这代码哪下的，子函数全都不写类型

没找到这个函数的定义，该函数需要声明在前，或者定义在前都是可以的。

ReadRecord 没有定义，或者定义了，没有声明


Question: C语言菜鸟提问

2楼的解释是对的，但初学者可能理解起来很难，以这个例子给你说=和==的区别 void main() { 	int a=0,b=1,c=2;  	if(c==a+b) 		printf("A %d\n",c); 	if(c=a+b) 		printf("B %d\n",c);  	getch();//暂停以显示  }//执行后输出为B 1 if其实是两句话，先执行括号里的代码，然后拿括号里的结果去执行if判断； 第一个if 先判断c是否等于a+b，现在是不等的，所以c==a+b这句话就等于是个false，所以第一个if等效于if(0)，后面的一句不会执行； 第二个if先执行将a+b的值赋值给c，一般没什么内存问题的话，c=a+b这句话就执行成功了，现在c=1了，而且执行成功的话返回一个true，所以第二个if等效于if(1)，会执行后面的一句。

sum==a+b; 这句有问题，==是判断符，不是赋值符。

sum=a+b       //a+b赋值给sum sum ==a+b   //a+b于sum相比较为等于，然而sum在赋值之前没有任何值

楼主主学的Javascript的吧，哈哈，=，==，===

二楼的理解例子很到位


Question: malloc问题

越界访问是未定义行为，即有出错的可能，程序不一定会出问题。但这终归是一个bug。  越界访问可能是越界的内存未被使用，越界的内存正好也是可读可写的。 还有可能，虽然申请sizeof(float)个字节，内存管理会申请比sizeof(float)更多的内存（这是必然，因为需要记录申请的信息）

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


Question: 菜鸟请指教~

下面是这个函数的完整代码：      能否更能帮助你们理解下？

个人感觉应该有两组按键，一组是主按键序列，其状态是ui8CurrentSeq，另外一组是8个按键。 switch...case语句执行的前提就是如果8个按键中某个按键短按、长按1秒和长按2秒；之后再来判断当前的状态ui8CurrentSeq，第一个case中的MAIN_BUTTON_SEQ_NOT_PRESSED，从字面理解就是主按键序列没有被按下，也就是说，如果8个按键中的某个按键短按、长按1秒和长按2秒，但是主按键序列没有被按下，则将主按键序列的对应状态进行设置

程序都不完整 怎么看

可能不同的按鍵對於處理時間長短的邏輯不同，所以case裏面又是根據按鍵進行的。至於一個case之後執行另一個case，這段代碼看不出來，你貼的代碼也不完整。 不同結搆体中的同名數組，含義有可能完全不同的。 賦值可能在另一個進程？ 邏輯技巧嘛，懂業務咯。對業務越熟，越容易看懂。

个人感觉:从代码中，先判断GPIODrv中的按钮状态，如果存在按键,或者按键1秒或者按键2秒情况就执行switch语句的判断, 否则没有按键操作就重新设置按钮的状态。其中aMainButtonStatus数组变量中每个值表示着GPIO按钮的当前状态值。 还是需要根据工程上下文代码好判断，最好能打断点一步一步调试，这样才好弄清楚。


Question: %.2lf 小数点问题帮忙看看

你应该先熟悉一下%打印的使用，比如%.是截断而非四舍五入，0.1怎么让他显示成0.100，左对齐，右对齐什么的，%功能很多的；  其次对float和double来说，要注意的是表示范围和精度，比如float，小数点第七位和以后的基本是不准的，为什么不准这些都是要熟知的。

MSDN上的说明 The precision value specifies the number of digits after the decimal point. If a decimal point appears, at least one digit appears before it. The value is rounded to the appropriate number of digits. 大概的意思是“对于浮点数来说，printf()函数的精度参数指定了小数点后面的数字个数，即小数位数。如果要输出小数点，则小数点后面至少要有一个数字，即小数位数至少是1。根据输出的小数位数，要输出的值被四舍五入到一个合适的数字” 也就是说printf()函数也可以四舍五入的。那么接下来我们看看d1的值到底是多少  实际上可以看到，d1的值不是37.975000，而是37.974999999999994。 默认情况下，printf()函数输出的浮点数小数位数是6，d1的第7位小数值是9，根据四舍五入，会向前进1位，以此类推，最终当 printf("%lf\n", d1); 时，输出的值是37.975 而printf("%.2lf\n", d1); 时，d1的第3位小数值是4，根据四舍五入，不进位，所以输出的值是37.97 请参考《C++浮点型变量的存储方式》 希望能够帮到你

你只要记住，C语言编程不存在四舍五入。  例如：实际上9/5=1.8    C语言中 9/5=1…4，然后9/5就等于1了，余数直接被吃了。

浮点数格式 http://bbs.csdn.net/topics/390676437

%.2lf只显示小数点后两位，不会自动给你四舍五入


Question: linux编译报错

不是看出來，只是根據經驗。不同版本通常有不一樣的實現，會不兼容的。

我傾向於不同版本造成的衝突，仔細看看版本要求吧。

引用 1 楼 hzy_76 的回复:庫文件的問題，是不是缺文件？還是版本不一致？  我怀疑是引用的头文件问题造成的，我用的是linux  /user/include下的头文件

引用 3 楼 hzy_76 的回复:我傾向於不同版本造成的衝突，仔細看看版本要求吧。  你是如何看出来的？

庫文件的問題，是不是缺文件？還是版本不一致？


Question: 光线跟踪 代码 求帮忙看一下问题

没有光源 ？

摄像头方向不对？ 左右手坐标系搞混了？ 坐标值没换算到0,1或-1,1范围内？ 我猜。

最后出来的图像一片黑……我也不知道哪儿有错orz

int main(int argc,char** argv) {     unsigned char head[54]; 	int size = w*h*3;     FILE *fp1,*fp2=NULL;     fp1 = fopen("white.bmp","rb+");      if(fp1==NULL) 	{ 		printf("文件未找到\n"); 	}     fread(head,sizeof(char),54,fp1);  	for(int i =0;i<h;i++) 	{//初始化帧缓存 		for(int j=0;j<w;j++){             zbuffer[i][j] = 100000;             buffer[i][j][0] = 0;             buffer[i][j][1] = 0;             buffer[i][j][2] = 0;         }     }  	//球1设置     sphere_1.centerpos[0] = 50;     sphere_1.centerpos[1] = 0;     sphere_1.centerpos[2] = 140;     sphere_1.radius = 90;     sphere_1.B = 139;     sphere_1.G = 236;     sphere_1.R = 255;     sphere_1.n = 10;     sphere_1.ks = 0.6;     sphere_1.kt = 0.6; 	sphere_1.ka[0]=0.1; 	sphere_1.ka[1]=0.1; 	sphere_1.ka[2]=0.1; 	sphere_1.kd[0]=0; 	sphere_1.kd[1]=0; 	sphere_1.kd[2]=0.8;      //球2设置 	sphere_2.centerpos[0] = -90;     sphere_2.centerpos[1] = 0;     sphere_2.centerpos[2] = 200;     sphere_2.radius = 100;     sphere_2.B = 8;     sphere_2.G = 101;     sphere_2.R = 139;     sphere_2.n = 10;     sphere_2.ks = 0.6;     sphere_2.kt = 0.6;     sphere_2.ka[0]=0.1; 	sphere_2.ka[1]=0.1; 	sphere_2.ka[2]=0.1; 	sphere_2.kd[0]=0; 	sphere_2.kd[1]=0; 	sphere_2.kd[2]=0.8;      //平面设置     plane_1.a = 0;     plane_1.b = 0;     plane_1.c = 1;     plane_1.d = -180;     plane_1.n = 40;     plane_1.R = 0;     plane_1.G = 0;     plane_1.B = 255;     plane_1.ks = 0.9;     plane_1.kt = 0.6; 	plane_1.ka[0]=0.1; 	plane_1.ka[1]=0.1; 	plane_1.ka[2]=0.1; 	plane_1.kd[0]=0; 	plane_1.kd[1]=0; 	plane_1.kd[2]=0.8;  	//通过视点V和像素pixel的光线R，R[0]R[1]R[2]存储方向，R[3]R[4]R[5]存储发射点 	float D[3]={0,0,0};//设置视线方向 	float t1,t2,t3; 	float z;  	float* color;  	for(i = 0; i<h; i++){         for(int j = 0; j<w; j++){             D[0] = (-w/2+j-eye[0])/sqrt((float)(pow((-w/2+j-eye[0]),2)+pow((h/2-i-eye[1]),2)+pow((zv-eye[2]),2)));             D[1] = (h/2-i-eye[1])/sqrt((float)(pow((-w/2+j-eye[0]),2)+pow((h/2-i-eye[1]),2)+pow((zv-eye[2]),2)));;             D[2] = (zv-eye[2])/sqrt((float)(pow((-w/2+j-eye[0]),2)+pow((h/2-i-eye[1]),2)+pow((zv-eye[2]),2)));;             Ray.start[0] = D[0];             Ray.start[1] = D[1];             Ray.start[2] = D[2];             Ray.direction[0] = eye[0];             Ray.direction[1] = eye[1];             Ray.direction[2] = eye[2];  			t1 = intersection_sphere(sphere_1, Ray);             t2 = intersection_sphere(sphere_2,Ray);             t3 = intersection_plane(plane_1,Ray);  			if(t1!=0){                 z = eye[2]+D[2]*t1;                 if(z<zbuffer[i][j]){ 					color=RayTrace(Ray,1,1);                     buffer[i][j][0] = color[0]; 					printf("%f",color[0]);                     buffer[i][j][1] = color[1];                     buffer[i][j][2] = color[2];                     zbuffer[i][j] = z;                 }              }              if(t2!=0){                 z = eye[2]+D[2]*t2;                 if(z<zbuffer[i][j]){ 					color=RayTrace(Ray,1,1);                     buffer[i][j][0] = color[0];                     buffer[i][j][1] = color[1];                     buffer[i][j][2] = color[2];                     zbuffer[i][j] = z;                 }              }             if(t3!=0){                 z = eye[2]+D[2]*t3;                 if(z<zbuffer[i][j]){                     color=RayTrace(Ray,1,1);                     buffer[i][j][0] = color[0];                     buffer[i][j][1] = color[1];                     buffer[i][j][2] = color[2];                     zbuffer[i][j] = z;                 }             } 		} 	}  	fp2=fopen("result.bmp","wb+");     fwrite(head, sizeof(char), 54, fp2);     fseek(fp2,54,0);     fwrite(buffer,sizeof(char),size,fp2);     return 0; }


Question: C语言课设 从文件读取时遇到的问题

int read(struct tele *read) {     int i=0;     FILE *fp;     if((fp=fopen("通讯录.txt" , "rb" ))==NULL)     {         printf("error when opening");         exit(0);     }     //fscanf(fp,"%d",cur);     fscanf(fp,"%d", &cur);     fread(read,sizeof(struct tele),cur,fp);     /*     for(i=0;i<cur;i++)     {         fread(read,sizeof(struct tele),cur,fp);     }     */     press();     return 0; }  read函数有问题，另外，函数名最好不要和变量（参数）名相同，否则有些编译器不是别和代码也不好阅读。 建议对比代码找一下原因


Question: KMP 算法的next函数匹配值如何得到的，只说明原理就行

有几种方法，有一种方法是对于模式串中的某一字符，提取它前面的字符串，分别从字符串的两端查看连续相同的字符串的个数，在其基础上 +1 ，结果就是该字符对应的值。  https://blog.csdn.net/yzy1103203312/article/details/80836272


Question: 为什么执行函数read（m）后无法返回主函数继续执行

不知道你用的什么编译器，我用vs2013编译了一下，就报一个错，未初始化变量fp1，然后我改成FILE *fp1=NULL； 界面正常弹出来啊，并没有卡在read

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

int read(zggz a[]) {     zggz A;     FILE *fp;     if((fp=fopen("gx.dat","r"))==NULL) //文件打开失败     {         printf("文件打开失败！\n");          return 0;     }      else     {         do         {             //fscanf(fp, "%s\n", &A.id);             fscanf(fp, "%s\n", A.id);             //fscanf(fp, "%s\n", &A.name);             fscanf(fp, "%s\n", A.name);             //fscanf(fp, "%lf\n", &A.post_wage);             fscanf(fp, "%f\n", &A.post_wage);             //fscanf(fp, "%lf\n", &A.pay_wages);             fscanf(fp, "%f\n", &A.pay_wages);             //fscanf(fp, "%lf\n", &A.post_allowance);             fscanf(fp, "%f\n", &A.post_allowance);             //fscanf(fp, "%lf\n", &A.merit_pay);             fscanf(fp, "%f\n", &A.merit_pay);             //fscanf(fp, "%lf\n", &A.salary);             fscanf(fp, "%f\n", &A.salary);             //fscanf(fp, "%lf\n", &A.income_tax);             fscanf(fp, "%f\n", &A.income_tax);             //fscanf(fp, "%lf\n", &A.take_home_pay);             fscanf(fp, "%f\n", &A.take_home_pay);             a[n]=A;             n=n+1;         }while(!feof(fp));     }     printf("\t\t\t\t\t\t共读取到%d个员工信息\n",n+1);     fclose(fp);     return n;  }  read函数有点问题。对比一下找一下自己的问题。  int write(zggz a[])    //保存 {     FILE *fp1;     if(n<1)     {         if((fp1=fopen("gx.dat","w"))==NULL) //文件打开失败         {             printf("文件打开失败！\n");         }         else         {             printf("未读取到员工数据！\n");         }     }      else     {         for(i;i<n;i++)         {             fprintf(fp1, "%s\n", a[i].id);             fprintf(fp1, "%s\n", a[i].name);             //fprintf(fp1, "%lf\n", a[i].post_wage);             fprintf(fp1, "%f\n", a[i].post_wage);             //fprintf(fp1, "%lf\n", a[i].pay_wages);             fprintf(fp1, "%f\n", a[i].pay_wages);             //fprintf(fp1, "%lf\n", a[i].post_allowance);             fprintf(fp1, "%f\n", a[i].post_allowance);             //fprintf(fp1, "%lf\n", a[i].merit_pay);             fprintf(fp1, "%f\n", a[i].merit_pay);             //fprintf(fp1, "%lf\n", a[i].salary);             fprintf(fp1, "%f\n", a[i].salary);             //fprintf(fp1, "%lf\n", a[i].income_tax);             fprintf(fp1, "%f\n", a[i].income_tax);             //fprintf(fp1, "%lf\n", a[i].take_home_pay);             fprintf(fp1, "%f\n", a[i].take_home_pay);         }         fclose(fp1);     }     return 0; }


Question: 如何将几个文件合并成一个bin文件

copy  tp.jpg /b+ yjh.jpg /b wocao.bin 漏了个b

copy  tp.jpg /b+ yjh.jpg wocao.bin

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

参考这个：#include <stdio.h> #include <string.h> FILE *f; char buffer[4096]; int r,a; void HexDump(char *buf,int len,int addr) { 	int	i,j,k; 	char binstr[80];  	for	(i=0;i<len;i++)	{ 		if (0==(i%16)) { 			sprintf(binstr,"%08x -",i+addr); 			sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]); 		} else if (15==(i%16)) { 			sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]); 			sprintf(binstr,"%s  ",binstr); 			for	(j=i-15;j<=i;j++) { 				sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.'); 			} 			printf("%s\n",binstr); 		} else { 			sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]); 		} 	} 	if (0!=(i%16)) { 		k=16-(i%16); 		for	(j=0;j<k;j++) { 			sprintf(binstr,"%s   ",binstr); 		} 		sprintf(binstr,"%s  ",binstr); 		k=16-k; 		for	(j=i-k;j<i;j++)	{ 			sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.'); 		} 		printf("%s\n",binstr); 	} } int main(int argc,char **argv) { 	if (argc<2)	{ 		fprintf(stderr,"Usage: %s filename.ext\n",argv[0]); 		return 2; 	} 	f=fopen(argv[1],"rb"); 	if (NULL==f) { 		fprintf(stderr,"Can not open file [%s]!\n",argv[1]); 		return 1; 	} 	a=0; 	while (1) { 		r=fread(buffer,1,4096,f); 		HexDump(buffer,r,a); 		a+=r; 		if (r<4096)	break; 	} 	fclose(f); 	return 0; }

引用 6 楼 zhao4zhong1 的回复:引用 4 楼 qq_36794790 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] file12.bin那这个文件就是二进制文件了吗 电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。 [/quote]再问一个问题，fopen打开一个文件后怎么具体输出文件内容的第一个的地址

直接用文件指针读取目标文件，再合并一起？

WinExec("cmd /c copy /b file1.bmp+file2.bmp file12.bmp >NUL 2>NUL",SW_HIDE);

可以尝试用压缩包的形式


Question: 不能printf扩展ASCII字符码（C code on FreeBSD），请问是什么原因？

又或者： Windows：使用cprintf Linux：使用CURSES库。

chcp命令了解一下。

没有正确设置locale

linux不支持扩展ascii码表


Question: C语言填空题

讲道理，写作业这种事，一道50分都不一定有人做

服了，这种题请好好自学

额！论坛的资源不是解决这些问题的。作为学生，还是要仔细认真的付出，才能学到自己肚子里。

伸手党。。。


Question: 大佬帮忙看一下哪里有错谢谢

问题就在后面的 long int fracsum(int n) { if(/**/ n==0 /**/) return(n);   return(n*/**/ fracsum(n) /**/); }  当前的状态是如果n=0返回0，如果n!=0返回n*fracsum(n)，在新的fracsum里，n的值没变，这导致你的这个函数等效为 long int fracsum(int n) {   return(n*fracsum(n)); } 陷入死循环；  改变在于，每一次调用fracsum这个函数，得让他里面的n减一，所以第二句改成return(n*/**/ fracsum(n-1) /**/); 其次阶乘是从n乘到1，也就是说这个函数调用的终点是n=1的时候，所以第一句改成 if(/**/ n==1 /**/) return(n);  以4为例子，整个递归的逻辑即为： sum=fracsum(4)           =4*fracsum(3)                  =3*fracsum(2)                        =2*fracsum(1)                              =1        =   4*    3*  2*   1

#include<stdio.h> #include<conio.h>      long int fracsum(int n); int main() {     int n;     long int sum;     do     { printf("Input n (n =1 to 9) :");         scanf("%d",&n);     }while(n>=10 || n<0);     //sum=fracsum(/**/int n/**/);     sum=fracsum(n);     printf("fracsum(n)  = %ld\n", sum);     getch();     return 0; }  long int fracsum(int n) {     //if(/**/ n==0 /**/)     if(n==0)         return 1;     return(n * fracsum(n-1)); } 参考一下吧 建议去掉无用的注释格式，代码中有一些问题（编译和逻辑），建议对比找一下。

ong  int fracsum(int n) { if(/**/ n==0 /**/) return(n);    // n==1   return(n*/**/ fracsum(n) /**/); }

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


Question: 运算符优先级问题

引用 7 楼 wang0635 的回复:[quote=引用 4 楼 ai977313677 的回复:] [quote=引用 3 楼 weixin_38470851 的回复:] [quote=引用 1 楼 wang0635 的回复:] --比&&和||的优先级高，而&&和||有短路性质，所以 先计算--x，若为0，则表达式的值为假，结束 否则，再计算--y，若非0，则表达式的值为真，结束 否则，计算--z，若为0，则表达式值为假，若非0，则表达式值为真  执行--后，为什么不是先执行 （）呢，而是直接被&&短路了，不是应该先执行（），然后再执行&& [/quote] 在逻辑表达式中，如果&&之前的--x已经为负数（C++中int<0都可以表示为false），那么整个表达式就已经是false，就不会继续向后执行了。 而逻辑或||之前为正数，那么整个表达式就已经是true，不会继续向后执行。 这个原理牵扯的比较底层。[/quote] 目的也很简单，就是避免不必要的运算。就像我们计算 0*1*2*3*...*100一样，可以直接得到结果0，不用算到最后。[/quote] 但是，问他的具体实现的话，涉及到编译层面的优化操作，而目前回答的都是比较高层，就是面向语言的的设计内容。

引用 4 楼 ai977313677 的回复:[quote=引用 3 楼 weixin_38470851 的回复:] [quote=引用 1 楼 wang0635 的回复:] --比&&和||的优先级高，而&&和||有短路性质，所以 先计算--x，若为0，则表达式的值为假，结束 否则，再计算--y，若非0，则表达式的值为真，结束 否则，计算--z，若为0，则表达式值为假，若非0，则表达式值为真  执行--后，为什么不是先执行 （）呢，而是直接被&&短路了，不是应该先执行（），然后再执行&& [/quote] 在逻辑表达式中，如果&&之前的--x已经为负数（C++中int<0都可以表示为false），那么整个表达式就已经是false，就不会继续向后执行了。 而逻辑或||之前为正数，那么整个表达式就已经是true，不会继续向后执行。 这个原理牵扯的比较底层。[/quote] 目的也很简单，就是避免不必要的运算。就像我们计算 0*1*2*3*...*100一样，可以直接得到结果0，不用算到最后。

对照这张图可以清楚知道运算符优先级

如果你想知道是怎么一步一步判断的，你可以把表达式写成几行，然后设断点调试跟踪

引用 3 楼 weixin_38470851 的回复:[quote=引用 1 楼 wang0635 的回复:] --比&&和||的优先级高，而&&和||有短路性质，所以 先计算--x，若为0，则表达式的值为假，结束 否则，再计算--y，若非0，则表达式的值为真，结束 否则，计算--z，若为0，则表达式值为假，若非0，则表达式值为真  执行--后，为什么不是先执行 （）呢，而是直接被&&短路了，不是应该先执行（），然后再执行&& [/quote] 在逻辑表达式中，如果&&之前的--x已经为负数（C++中int<0都可以表示为false），那么整个表达式就已经是false，就不会继续向后执行了。 而逻辑或||之前为正数，那么整个表达式就已经是true，不会继续向后执行。 这个原理牵扯的比较底层。

引用 1 楼 wang0635 的回复:--比&&和||的优先级高，而&&和||有短路性质，所以 先计算--x，若为0，则表达式的值为假，结束 否则，再计算--y，若非0，则表达式的值为真，结束 否则，计算--z，若为0，则表达式值为假，若非0，则表达式值为真  执行--后，为什么不是先执行 （）呢，而是直接被&&短路了，不是应该先执行（），然后再执行&&


Question: 【C语言】一个函数的返回值类型为指向自己的指针

先定义成返回void * 然后在使用时强转为所需类型。


Question: linux下应用数组溢出的影响，麻烦看看

引用 8 楼 zhao4zhong1 的回复:最严重能造成入侵者拿到root权限。  这个 倒不存在

引用 6 楼 hzy_76 的回复:要看這些代碼出現在哪裏，如果是用戶層，可能導致其他應用異常，某些應用在啓動階段會調用的話，還可能導致啓動異常。 但是如果出現在内核代碼中，就嚴重得多，基本就無法啓動了。  無論如何，不會導致flash損壞的，更換flash解決可能只是一個誤解，巧合。也許剛好溢出到的位置是那片flash本來有問題的位置？我猜測而已。  我认为应用也不会导致F损坏，  但有没可能 应用 数组越界，会改写嵌入式linux什么系统文件导致无法启动

引用 4 楼 cfjtaishan 的回复:[quote=引用 3 楼 u011609112 的回复:] [quote=引用 1 楼 cfjtaishan 的回复:] 数组越界是未定义行为，主要看越界的内容会不会被覆盖或者把其他数据内容覆盖。数组越界很有可能导致程序异常。因此，应处理掉数组越界的问题  没错，我想你写的在烂的app，也不知道导致flash芯片出问题吧？[/quote] 我不写app，程序出问题不要找芯片的问题。当你保证了自己写的程序没问题了，再去找别人的问题，比如flash芯片。数组都越界访问，自己本身就有问题，再去怀疑别人的问题，比如芯片，这是说不过去的 [/quote]  我意思是前同事写的接口代码确实错误不少，尤其操作文件这块，但应该不至于导致flash芯片出问题吧、

引用 3 楼 u011609112 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 数组越界是未定义行为，主要看越界的内容会不会被覆盖或者把其他数据内容覆盖。数组越界很有可能导致程序异常。因此，应处理掉数组越界的问题  没错，我想你写的在烂的app，也不知道导致flash芯片出问题吧？[/quote] 我不写app，程序出问题不要找芯片的问题。当你保证了自己写的程序没问题了，再去找别人的问题，比如flash芯片。数组都越界访问，自己本身就有问题，再去怀疑别人的问题，比如芯片，这是说不过去的

引用 1 楼 cfjtaishan 的回复:数组越界是未定义行为，主要看越界的内容会不会被覆盖或者把其他数据内容覆盖。数组越界很有可能导致程序异常。因此，应处理掉数组越界的问题  没错，我想你写的在烂的app，也不知道导致flash芯片出问题吧？

flash芯片是  NANDFlash ， 现在就是不知道到底无法启动的原因是什么？

最严重能造成入侵者拿到root权限。

1 可能是由于越界导致了某些代码补擦除了，导致启动不了。 2 可能是由于越界导致flash在程序中被多次擦除，烧写，导致了flash坏了。如这样的代码： while(1) {      擦除();      写Flash（） }  不一定是while,但是是这样的一个循环结构。


Question: c语言程序

#include "stdafx.h" #include "stdio.h" #include <iostream>  #define INIT 20 #define  increment  2  typedef struct{     char name[20];     float china;     float math;     float English;     int num; //学号     int Class;    //年级     float average;     float All; }Stu; typedef struct{     Stu *elem;     int length;     int initsize; }link; link L; //定义全局线性表变量L void Init(link &l)   //初始化线性表 {     l.elem = (Stu*)malloc(sizeof(Stu)*INIT);     l.length = 0;     l.initsize = INIT; } void entry()  //信息录入 { int i;     for (i = 0; i<10; i++)  //录入十个学生信息     {         printf("姓名：");         //scanf_s("%s", L.elem[i].name);         scanf_s("%s", L.elem[i].name, 20);         printf("语文成绩：");         scanf_s("%f",&(L.elem[i].china));         printf("数学成绩：\n");         scanf_s("%f",&(L.elem[i].math));         printf("英语成绩：\n");         //scanf_s("%f",(L.elem[i].English));         scanf_s("%f", &(L.elem[i].English));         printf("学号：");         scanf_s("%d",&(L.elem[i].num));         printf("年级：");         scanf_s("%s",&(L.elem[i].Class));         L.elem[i].All = L.elem[i].china + L.elem[i].math + L.elem[i].English;         printf("总成绩：%f", L.elem[i].All);         L.elem[i].average = L.elem[i].All/3;         printf("平均成绩:%f", L.elem[i].average);         L.length=L.length+1;     }     //L.length=L.length+1;     return; } 发现三处错误，建议对比一下找到自己的问题

楼主，上面代码在vs2013中是能编译通过的，编译没有错误。


Question: 字符串的二叉树动态查找

怎么输入不同的字符串就不给进行输入要查找的字符串的

因为我的系统是英文版，请无视乱码。最后输出修改为no suc是为了让你看清楚。

// T392406882.cpp : Defines the entry point for the console application. //  #include "stdafx.h"   #include <stdio.h> #include <string.h> #include <stdlib.h> typedef struct node{ char *data; struct node *lchild,*rchild; }Btree;  typedef Btree *BiTree; int InsertBiTree(Btree **root,char *x){ Btree *current,*parent=NULL ,*p; current=*root; while(current!=NULL){ if(strcmp(current->data,x)==0)  return 0;  parent=current;  if(strcmp(current->data,x)<0)  current=current->rchild;  else   current=current->lchild; } p=(Btree*)malloc(sizeof(Btree)); if(p==NULL){ printf("空间不够\n"); exit(1); } p->data = (char *)(malloc(sizeof(char) * 100)); //修改这里 strcpy(p->data,x); //修改这里 p->lchild=NULL; p->rchild=NULL; if(parent==NULL)     *root=p; else if(strcmp(x,current->data)<0)     parent->lchild=p; else      parent->rchild=p; return 1; } int BiTreeSearch(Btree *root ,char *x){ Btree *current; if(root!=NULL){ current=root; while(current!=NULL){ if(strcmp(current->data,x)==0) return 1; if(strcmp(current->data,x)<0)  current=current->rchild; else current=current->lchild; } } return -1; } int main(void){ Btree *s=NULL; int i; char ch[5]; printf("请输入字符串:\n"); for(i=0;i<2;i++){ scanf("%s",ch); InsertBiTree(&s,ch);     } printf("请输入要查找的字符串:"); scanf("%s",ch); if(BiTreeSearch(s,ch)==-1) printf("no"); else printf("suc");  return 0; }

百度搜相关关键字。


Question: 无报错警告的程序在VC上不能完全运行完，在Dev C++上不能运行

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


Question: c语言求txt中的单词数 最后一个单词无法计入数 求大神

在while循环中的引用if(((ch >= 'a' && ch <= 'z')||(ch >= 'A' && ch <= 'Z')||(ch =='\'')) && (flag == 1))再加一个||ch == EOF应该就满足楼主的要求了吧，其他都不动。 完整代码如下： #include <stdio.h> #include <string.h> #include <stdlib.h> #define N 200 #define M 20 void change(char &a)                        //大写字母转换成小写字母函数 {     if((a >= 'A') && (a <= 'Z'))         a+=32; } int main() {     FILE *in, *out;     int i = 0, j = 0, k = 0,x = 1, l = 0, y = 0, flag = 0, flag1 = 1, d[N];     char b[N][M], ch, z;     if((in = fopen("in.txt","r")) == NULL)	//打开输入和输出文件     {         printf("cannot open the file\n");         exit (0);     }     if((out = fopen("out.txt","w")) == NULL)     {         printf("cannot open the file\n");         exit (0);     }     printf("原文：\n");	//输出原文到屏幕和输出文件     fprintf(out,"原文：\n");     z = fgetc(in);     while (z != EOF)     {         putchar(z);         fprintf(out,"%c",z);         z = fgetc(in);     }     printf("\n");     fclose(in);     if((in = fopen("in.txt","r")) == NULL)     {         printf("cannot open the file\n");         exit (0);     }     ch = fgetc(in);	//将单词输入到二维数组中     while (ch != EOF)     {         flag = 0;         if((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')||(ch =='\''))         {             change(ch);             b[i][j++] = ch;         }         else         {             flag = 1;         }         ch = fgetc(in);         if((((ch >= 'a' && ch <= 'z')||(ch >= 'A' && ch <= 'Z')||(ch =='\'')) && (flag == 1))||ch == EOF)         {             flag1 = 0;         }         if(!flag1)         {             d[l++] = j-1;             i++;             j = 0;             flag1 = 1;         }     }      printf("\n");     printf("所有单词：\n");	//输出所有单词到屏幕和输出文件     fprintf(out,"\n");     fprintf(out,"\n");     fprintf(out,"所有单词：\n");     for(j = 0; j < i; j++)     {         if(d[j] != -1)         {             y++;             for(l = 0; l <= d[j]; l++)             {                 printf("%c",b[j][l]);                 fprintf(out,"%c",b[j][l]);             }         }         printf(" ");         fprintf(out," ");     }       printf("\n");     printf("\n");     printf("词数统计：\n");	//计算和输出词数统计到屏幕和输出文件     fprintf(out,"\n");     fprintf(out,"\n");     fprintf(out,"词数统计：\n");     for(j = 0; j <= y-2; j++)     {         x = 1;         for(i = j + 1; i <= y-1; i++)         {              if((d[j] != -1) && (d[j] == d[i]))             {                 for(l = 0; l <= d[j]; l++)                 {                     if(b[j][l] != b[i][l] )                         break;                 }                 if(l == d[j]+1)                 {                     d[i] = -1;                     x++;                 }             }         }         if(i == y && d[j] != -1)         {             for(l = 0; l <= d[j]; l++)             {                 printf("%c",b[j][l]);                 fprintf(out,"%c",b[j][l]);             }             printf(" ");             fprintf(out," ");             printf("%d\n",x);             fprintf(out,"%d\n",x);         }     }     if(d[y-1] != -1)     {         for(i = 0; i <= d[y-1]; i++)         {             printf("%c",b[y-1][i]);             fprintf(out,"%c",b[y-1][i]);         }         printf(" ");         fprintf(out," ");         printf("%d\n",x);         fprintf(out,"%d\n",x);     }      fclose(in);	//关闭输入输出文件     fclose(out);     return 0; }

仅供参考：#include <stdio.h> #include <string.h> #define MAXLEN 1000 char ln[MAXLEN]; FILE *f; int i,z; int b,n,L; int main(int argc,char **argv) {     if (argc<2) {         printf("Usage:%s fullpathfilename.ext\nget total blank/non-blank/total linenumbers.\n",argv[0]);         return 1;     }     f=fopen(argv[1],"r");     if (NULL==f) {         printf("Can not open file [%s]!\n",argv[1]);         return 2;     }     z=0;     b=0;     n=0;     L=0;     while (1) {         if (NULL==fgets(ln,MAXLEN,f)) break;         L=strlen(ln);         if ('\n'==ln[L-1]) {             if (0==z) {                 for (i=0;i<L-1;i++) {                     if (!(' '==ln[i] || '\t'==ln[i])) break;                 }                 if (i<L-1) z=1;//当前行不是空行             }             if (0==z) b++; else n++;             z=0;         } else {             if (0==z) {                 for (i=0;i<L;i++) {                     if (!(' '==ln[i] || '\t'==ln[i])) break;                 }                 if (i<L) z=1;//当前行不是空行             }         }     }     fclose(f);     if (L>0 && '\n'!=ln[L-1]) {         if (0==z) b++; else n++;//最后一行末尾无'\n'也计算     }     printf("File:[%s] total blank/non-blank/total linenumbers is %d/%d/%d\n",argv[1],b,n,b+n);     return 0; }

刚刚看了下，你后面的单词个数统计好像是没啥问题。解雇破显示数据统计是对的。

前面所有单词输出的部分给你找出问题了，你是每次处理完一个单词，遇到空格或换行符之类的，才把单词字符个数写入数组。可是，最后一个单词遇到EOF，所以没有执行最后一个单词的数据传输。最后加上一个就可以。然后就是你的输出循环里。单词个数是从0开始算起的，所以，j<=i就可以。后面的词数统计，是在是有些乱，看不下去，变量太多，而且解释不明确。你自己找找吧。 while (ch != EOF) 	{ 		flag = 0; 		if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch == '\'')) 		{ 			change(ch); 			b[i][j++] = ch; 		} 		else 		{ 			flag = 1; 		} 		ch = fgetc(in); 		if (((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch == '\'')) && (flag == 1)) 		{ 			flag1 = 0; 		} 		if (!flag1) //ADD:这里是每次前面一个单词处理完了，遇到空格或者换行才把每个单词的数据传给d[l]的；		 		{			//所以遇到最后一个EOF时，数据还没有传给数据，while循环已经退出；	 			d[l++] = j - 1; 			i++; 			j = 0; 			flag1 = 1; 		} 	} 	d[l++] = j - 1; //ADD:把你最后一个没处理完的数据加上了； 	printf("\n"); 	printf("所有单词：\n");	//输出所有单词到屏幕和输出文件 	fprintf(out, "\n"); 	fprintf(out, "\n"); 	fprintf(out, "所有单词：\n"); 	for (j = 0; j <= i; j++) // ADD:i是从0开始算起的。 	{ 		if (d[j] != -1) 		{ 			y++; 			for (l = 0; l <= d[j]; l++) 			{ 				printf("%c", b[j][l]); 				fprintf(out, "%c", b[j][l]); 			} 		} 		printf(" "); 		fprintf(out, " "); 	}


Question: c语言有没有类似boost这样的库?libc太简陋了

引用 5 楼 zyx6680599 的回复:[quote=引用 2 楼 u010165006 的回复:] 可以C++当C用，加上boost。 我指的是lz[/quote]  指针不要乱指，会绕晕

c没有直接的boost库，只能间接调用

引用 2 楼 u010165006 的回复:可以C++当C用，加上boost。 我指的是lz

你前两天还说C++不好  引用 3 楼 mLee79 的回复:libc 过于庞大了, 大部分都没啥用 ...

libc 过于庞大了, 大部分都没啥用 ...

不能说没有, 但是必须用c的环境一定是嵌入式, 有库你也没空间用. 不然你为啥不用c++呢, 就算是普通的嵌入式也可能用c++

可以C++当C用，加上boost。


Question: 删除航班信息的函数  跪求！！！！

百度搜相关关键字。

就是再加一个 删除航班信息的函数       谢谢！！！

#include<stdio.h> #include<windows.h> struct feiji { 	int dpbh;   //订票编号 	char dingchu[10];  // 是否定出 	char xm[10];  //姓名 	char sfz[20];  //身份证 	char zk[10];    //折扣 	int hxbh;     //航线编号 	char hbrq[30]; //航班日期 	char cfcs[10];//出发城市 	char ddcs[10];//到达城市 	char cwlx[10];//舱位类型 	char jpjg[10];//机票价格 }plane[1000]; int jllen; void mulu(); void shuru(); void liulan(); void chaxun(); void dingpiao(); void xiugai();  void main() { 	printf("************************************************************************\n");  	printf("************************************************************************\n"); 	printf("*         ********欢迎使用某航空公司订票信息管理系统********           *\n"); 	printf("*         *                                                *           *\n"); 	printf("*         *                                                *           *\n"); 	printf("*         *                                                *           *\n"); 	printf("*         *           设计人员：赵国威                     *           *\n"); 	printf("*         *      专业班级：计算机网络工程二班              *           *\n"); 	printf("*         *           学号：20170306039                    *           *\n"); 	printf("*         *                                                *           *\n"); 	printf("*         *                                                *           *\n"); 	printf("*         *                                                *           *\n"); 	printf("*         **************************************************           *\n"); 	printf("************************************************************************\n");  	printf("************************************************************************\n");  	system("pause"); 	system("cls"); 	mulu(); }  void mulu() { 	int a;  	do 	{ 	printf("************************************************************************\n"); 	printf("*         ********欢迎使用某航空公司订票信息管理系统********           * \n"); 	printf("*         *1.增加航班信息                                  *           * \n"); 	printf("*         *2.浏览航班信息                                  *           * \n"); 	printf("*         *3.订票                                          *           * \n"); 	printf("*         *4.修改航班信息                                  *           * \n"); 	printf("*         *5.查询航班信息                                  *           * \n"); 	printf("*         *6.安全退出                                      *           * \n"); 	printf("*         *                                                *           * \n"); 	printf("*         **************************************************           * \n"); 	printf("************************************************************************\n"); 	printf("请在1-6中选择以回车键结束\n"); 	scanf("%d",&a); 	switch(a) 	{  	case 1:shuru(); 			   break; 	case 2:liulan(); 			   break ; 	case 3:dingpiao(); 			   break; 	case 4:xiugai(); 			   break; 	case 5:chaxun(); 		break; 	case 6: 		break; 	}  	}while(a!=6); 	printf("~~~~~~~~~~谢谢使用，祝你生活愉快，再见~~~~~~~~~\n"); } 	void shuru()  //信息输入 	{ 		int zqmima=2018;//正确的密码 		int mima;     //输入密码 		int c; 	printf("请输入密码："); 	scanf("%d",&mima); 	if(zqmima!=mima) 	{ 		printf("输入密码错误,请按任意键返回\n"); 		getchar(); 		getchar(); 		mulu(); 	} 	else 	{ 	system("cls");   //空白 		printf("请问输入几个航班信息："); 		scanf("%d",&jllen); 		for(c=0;c<jllen;c++) 	{ 		printf("请输入订票编号：\n"); 		scanf("%d",&plane[c].dpbh); 		printf("请输入是否定出：\n"); 		scanf("%s",plane[c].dingchu); 		printf("请输入客户姓名：\n"); 		scanf("%s",plane[c].xm); 		printf("请输入客户身份证号码：\n"); 		scanf("%s",plane[c].sfz); 		printf("请输入折扣情况：\n"); 		scanf("%s",plane[c].zk); 		printf("请输入航线编号：\n"); 		scanf("%d",&plane[c].hxbh); 		printf("请输入航班日期：\n"); 		scanf("%s",plane[c].hbrq); 		printf("请输入出发城市：\n"); 		scanf("%s",plane[c].cfcs); 		printf("请输入到达城市：\n"); 		scanf("%s",plane[c].ddcs); 		printf("请输入舱位类型：\n"); 		scanf("%s",plane[c].cwlx); 		printf("请输入机票价格：\n"); 		scanf("%s",plane[c].jpjg);  		} 		getchar(); 		mulu(); 	} 	} void liulan()  //信息浏览 { 	int c; 	printf("\n\n订票编号\t是否定出\t客户姓名\t客户身份证号\t折扣比例\t航线编号\t航班日期\t出发城市\t到达城市\t舱位类型\t机票价格\n\n"); 	for(c=0;c<jllen;c++) 	{ 		printf("\n\n%-8d\t%-12s\t%-11s\t%-10s\t%-6s\t%-8d\t%-8s\t%-8s\t%-8s\t%-8s\t%-8s\t\n\n",plane[c].dpbh,plane[c].dingchu,plane[c].xm,plane[c].sfz,plane[c].zk,plane[c].hxbh,plane[c].hbrq,plane[c].cfcs,plane[c].ddcs,plane[c].cwlx,plane[c].jpjg); 	} 	getchar(); 	mulu(); } void dingpiao() //订票模板 { 	int c=0,d; 	struct feiji p; 	system("cls");    //空白 	do 	{ 		chaxun(); 		printf("请输入你需要的航线编号："); 		scanf("%d",&p.hxbh); 		for(c=0;c<jllen;c++) 		{ 			if(plane[c].hxbh==p.hxbh) 			printf("恭喜您订票成功！祝您旅行愉快~\n"); 			continue; 			if(plane[c].hxbh!=p.hxbh) 				printf("亲，该飞机票已定出~"); 			continue; 		} 	printf("\n\n继续订票请选择1；退出请选择0\n\n"); 	scanf("%d",&d); 	}while(d==1); } void xiugai()//修改机票 { 	int c,hxbh1,hxbh2,m; 	system("cls"); 	do 	{ 		liulan(); 		printf("请输入你购买过的航线编号："); 		scanf("%d",&hxbh1); 		printf("请输入你需要的航线编号："); 		scanf("%d",&hxbh2); 		for(c=0;c<jllen;c++) 			if(plane[c].hxbh==hxbh2) 				printf("恭喜您，改签成功！"); 			break; 			if("hxbh2!=plane[c].hxbh"); 			printf("sorry!亲，该航班已订出~~"); 				break; 	printf("\n\n继续改签请输入1，退出请输入0\n\n"); 	scanf("%d",&m); 	}while(m=1); } void chaxun() { 	int c,k=0,flag=-1; 	struct feiji y; 	system("cls"); 	printf("请输入航线编号："); 	scanf("%d",&y.hxbh); 	printf("请输入出发城市："); 	scanf("%s",y.cfcs); 	printf("请输入到达城市："); 	scanf("%s",y.ddcs);  	for(c=0;c<jllen;c++)  		if(plane[c].hxbh==y.hxbh&&strcmp(plane[c].cfcs,y.cfcs)==0&&strcmp(plane[c].ddcs,y.ddcs)==0) 		{flag=c;break;}  	if(flag!=-1) 	{ 		printf("为您查询的航班信息："); 		printf("\n\n订票编号\t是否定出\t客户姓名\t客户身份证号\t折扣比例\t航线编号\t航班日期\t出发城市\t到达城市\t舱位类型\t机票价格\n\n"); 		printf("\n\n%-8d\t%-12s\t%-11s\t%-10s\t%-6s\t%-8d\t%-8s\t%-8s\t%-8s\t%-8s\t%-8s\t\n\n",plane[c].dpbh,plane[c].dingchu,plane[c].xm,plane[c].sfz,plane[c].zk,plane[c].hxbh,plane[c].hbrq,plane[c].cfcs,plane[c].ddcs,plane[c].cwlx,plane[c].jpjg); 	} 	else 	printf("对不起，没有找到航班信息！\n"); }


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

qiuzhu a

笔误, g2u((char *)cust_name,strlen((char *)cust_nm),name_out,100);  这句我上面打错了,cust_nm是cust_name,笔误.


Question: c语言大佬路过看一下 自己写的带界面转换器 有点小问题但是不怎么怎么回事

因为学校要求vc 所以用的vc 编译没有错误但是界面显示数字有点问题 输入123只显示23 然后转换后的结果也不正确

void o2() {    int n;    int N;    char A[10];    char B[5];    char C[100];    SqStack s;     SElemType E;    InitStack(&s);      scanf("%d",&n);    itoa(n,A,10);    outtextxy(180,80,A);      scanf("%d",&N);    itoa(N,B,10);    outtextxy(200,140,B);     while(n)     {      Push(&s,n%N);       n=n/N;    }    while(!StackEmpty(s))     {      Pop(&s,&E); 	 if(E<10) 	 { 	 itoa(E,C,10);  	 outtextxy(10,240,C); 	 } 	 else  	 {  		 char C=' '; 		 switch(E){ 		    case 10:C='a';break;             case 11:C='b';break;   	        case 12:C='c';break; 	        case 13:C='d';break;             case 14:C='e';break;             case 15:C='f';break;}           outtextxy(10,240,C);  	 }  getch();	     } }  int main() { 	lead();  }

#include <stdio.h> #include <stdlib.h> #include <time.h> #include <conio.h> #include <string.h> #include <graphics.h>   typedef int SElemType;  #include"C1.H" #include"C3-1.H"  #include"BO3-1.C"  #define WIDTH 400 #define HEIGHT 500  void o1(); void o2(); void lead();  void lead() { 	initgraph(WIDTH,HEIGHT); 	setbkcolor(RGB(135,206,250)); 	settextcolor(RGB(0,0,0)); 	o1(); 	o2();  }  void o1() { 	cleardevice();  	setfont(40,0," 微软雅黑");  	RECT r1={0,20,400,60}; 	drawtext("进制转换器:",&r1,DT_CENTER|DT_VCENTER|DT_SINGLELINE);  	RECT r2={0,80,400,120}; 	drawtext("输入的数字:",&r2,DT_LEFT|DT_SINGLELINE);  	RECT r3={0,140,400,180}; 	drawtext("输入转换进制:",&r3,DT_LEFT|DT_SINGLELINE);  	RECT r4={0,200,400,240}; 	drawtext("转换后的数字:",&r4,DT_LEFT|DT_SINGLELINE);    	setfillcolor(RGB(255,255,255)); 	solidrectangle(180,80,390,120); 	solidrectangle(200,140,390,180); 	solidrectangle(10,240,390,490);  	setfont(30,0," 微软雅黑"); 	settextcolor(RGB(0,0,0)); 	setbkcolor(RGB(255,255,255));  	getch();  }


Question: 宏使用的疑问

宏相当于源文件的文本替换。 第一个直接用1替换对应的代码 第二个是个变量，能替换吗？

这宏属于预编译，比编译更早。不能这样用吧，还是得用数组。

求助，谢谢！

//codegen.c // 输入一组字符串，比如 // aa ss ddd dd 33 dd // 然后自动生成一个函数 int A(const char*); // 实现A("aa")返回0  A("ss")返回1 依次类推 #include <stdio.h> int main(int argc,char **argv) {     int i;     if (argc<2) {         printf("%s p1 [p2 ...] [>result.c]\nGenerate code int A(const char *a); 0==A(\"p1\") 1==A(\"p2\") ...",argv[0]);         return 1;     }     //printf("#include <string.h>\n");     printf("int A(const char *a) {\n");     for (i=0;i<argc-1;i++) {         printf("    if (0==strcmp(a,\"%s\")) return %d;\n",argv[i+1],i);     }     printf("    return -1;\n");     printf("}\n");     return 0; } //C:\test\Debug>codegen.exe //codegen.exe p1 [p2 ...] [>result.c] //Generate code int A(const char *a); 0==A("p1") 1==A("p2") ... //C:\test\Debug>codegen.exe aa ss ddd dd 33 dd //int A(const char *a) { //    if (0==strcmp(a,"aa")) return 0; //    if (0==strcmp(a,"ss")) return 1; //    if (0==strcmp(a,"ddd")) return 2; //    if (0==strcmp(a,"dd")) return 3; //    if (0==strcmp(a,"33")) return 4; //    if (0==strcmp(a,"dd")) return 5; //    return -1; //} // //c:\test\Debug>codegen.exe aa ss ddd dd 33 dd >result.c // //c:\test\Debug>type result.c //int A(const char *a) { //    if (0==strcmp(a,"aa")) return 0; //    if (0==strcmp(a,"ss")) return 1; //    if (0==strcmp(a,"ddd")) return 2; //    if (0==strcmp(a,"dd")) return 3; //    if (0==strcmp(a,"33")) return 4; //    if (0==strcmp(a,"dd")) return 5; //    return -1; //} //

了解一下代码生成技术。

引用 楼主 yangyunzhao 的回复: #define random_reslev(_ResType) random(Res##_ResType##Levs[0], Res##_ResType##Levs[1])    // 代码1 int lev = random_reslev(1);  // 正确  // 代码2 int type = 1; int lev = random_reslev(type); // 编译失败   请改如何使用才可以实现代码2的目标？谢谢  // 变量定义类似这样 int Res0Levs[2]={10,20}; int Res1Levs[2]={20,35}; int Res2Levs[2]={40,80};


Question: 为什么要使用 malloc（）是动态内存分配函数？

举个例子说，我让你给我读取一个文件，这个文件有可能只有几个字节，也可能是有几个GB这么大。 只有到运行时候才知道它的实际大小。 数组是用不了的，因为数组必须是用常量确定它的大小。也就是说编译时必须确定数组的大小。 如果你用一个运行时才能确定其值的变量去定义数组的大小是编译报错的，比如下面这样就写代码就是错的。  int fileSize = size; //size是已经确定的文件大小 unsigned char fileBuff[fileSize] = { 0 }; //错了，数组必须是用常量定义大小。    如果想要实现之前说的功能，就必须使用malloc动态内存分配，像下面这样：  int fileSize = size; //size是已经确定的文件大小 unsigned char* pFileBuff = (unsigned char*)::malloc(fileSize); //文件处理操作代码略 ::free(pFileBuff); //千万记着，动态分配的内存必须手动释放，否则会引发内存泄漏

（1）如果int X[100] 是全局变量，那么他的生存周期可与malloc类似；如果int x 是临时变量，则该程序结束后，int x则消失，malloc需要使用free函数释放内存； （2）个人感觉使用malloc的原因，如'caozhy'版主和‘自信男孩’所述，是为了动态分配内容，合理使用内存容量。

容量大小从小到大：栈≤全局数据≤堆≤文件≤硬盘≤磁盘阵列≤云存储

如果你不知道你需要多少内存，比如说用数组存储学生的信息，那么你不知道你程序要输入多少个学生的信息。 你不动态分配只能估计个值，估计大了，在程序运行的大部分时候，都浪费了存储。估计小了，在程序少部分情况下就无法满足需要。 这就是静态指定数组大小的弊端。

引用 楼主 MM_man 的回复:1、相对于自动分配内存，malloc（）函数申请分配的内存地址有什么不同：  比如：  int x[100]   int * x = (int *)malloc(100 *sizeof(int))  二者之间的内存地址有什么区别？  求教，谢谢  2、C语言什么情况下需要用malloc来申请内存？求教，谢谢  说的简单通俗一点，malloc分配指的是堆内存，也就是说除了malloc分配的变量，其他的都在栈里面，假如在一个函数里面定义的一个整型变量， int a;那么这个a就会在这个函数里面的最后一行结束｝被释放掉了，如果另外一个函数想调用这个函数int a时已经不可能了,因为他已经被释放了，所以要定义一个堆内存malloc,当这个函数}结束时，a不会被释放，就是这么理解

容量大小从小到大：栈≤全局数据≤堆≤文件≤硬盘≤磁盘阵列≤云存储

1.自动分配的是在栈上，动态申请的是在堆上申请的。内存的申请的位置不同 2. 作用域不同，自动分配的，作用域是在函数内，从申请申请开始到函数结束，它的生命周期也就结束了，所以栈上的空间是系统分配和系统回收，不需要程序员手动去做什么；动态分配的作用域是从申请开始到调用free释放结束；所以，不限于函数内，但是释放需要程序员参与，否则会出现内存泄露。  什么时候使用malloc，那就是需要动态改变大小的时候，通过realloc变更内存的大小（可变大可变小）；

1. 自动分配的内存函数结束就不能使用了 malloc 分配的内存可以一直使用直到你调用了 free  2.   (1). 内存大小需要等到运行的时候才能确定.  (2). 内存的大小超过了栈的大小  (3). 内存的使用范围


Question: C语言银行排队，求改错

自己编译或执行，或什么有没有问题？提出自己的改错需求。 大家工作都挺忙的，别闹。


Question: C语言一级指针字符串去空格程序求挑错

又重新研究了一下。 #include<stdlib.h> #include<stdio.h> #include<string.h> #include<stdbool.h>  //去掉字符串中的空格并输出 void qukongge(char *instr, char *outstr, int *num) { char *intemp = instr; int count = 0; while (*intemp!='\0') { if (*intemp==' ') { intemp++; count++; } else { *outstr = *intemp; outstr=outstr+sizeof(*instr); intemp=intemp+sizeof(*instr);//新增 } } *outstr = '\0'; *num = count; }  void main() { char *instr = "   daffdfa dsf dff saf    "; char *outstr=(char*)malloc(100); int num = 0; qukongge(instr, outstr, &num); printf("空格数为%d\n去空格后为%s\n", num, outstr);//修改*outstr为outstr，因为*outstr对应的是一个字符。 system("pause"); }

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

求挑错。。 提示的是内存错误 0x0039154C 处的第一机会异常(在 2018.06.24.exe 中): 0xC0000005: 写入位置 0x01509000 时发生访问冲突。 如有适用于此异常的处理程序，该程序便可安全地继续运行。

#include<stdlib.h> #include<stdio.h> #include<string.h> #include<stdbool.h>  //去掉字符串中的空格并输出 void qukongge(char *instr, char *outstr, int *num) { int count=0; int j=0; int i=0; for(i=0;(*(instr+i)!='\0');i++)  {   if (*(instr+i)==' ')    {      count++;     continue;     } else    {     *(outstr+j) = *(instr+i);     j++;    }  } *(outstr+j) = '\0'; *num = count; }  int main(void) { char instr[32]= "   daffdfa dsf dff saf    "; char *outstr=(char*)malloc(sizeof(instr)); int num = 0; qukongge(instr, outstr, &num); printf("空格前为%s\\0\n", instr);  printf("空格数为%d\n", num); printf("去空格后为%s", outstr); return 0; }


Question: win32 SDK LISTVIEW控件分组问题？

有大神方便帮我看看吗？

有大神方便帮我看看吗？

有人知道吗？ 我是新手，想了很久，还是不行啊！ 为什么我的commctrl.h里都没有这些LISTVIEW分组需要的定义？？ 我是用MinGW编译的。它里面commctrl.h不全吗？？


Question: ACM基础题Peg（跳棋）求助

正确的写法是把两段分开： for(i = 0; i < 5; i++){     for(j = 0; j < 7; j++){         if(board[i][j] == 'o' && board[i+1][j] == 'o' && board[i+2][j] == '.')         counter ++;         else if(board[i][j] == '.' && board[i+1][j] == 'o' && board[i+2][j] == 'o')         counter ++;         }     }  for(i = 0; i < 7; i++){     for(j = 0; j < 5; j++){         if(board[i][j] == 'o' && board[i][j+1] == 'o' && board[i][j+2] == '.')         counter ++;         else if(board[i][j] == '.' && board[i][j+1] == 'o' && board[i][j+2] == 'o')         counter ++;         }     }

你的算法只遍历了2个5*7的区域，遗漏了7*7右下角2*2的区域 例如：board[5][4]='.' board[5][5]='o' board[5][6]='o'

代码贴错了，应该是这个：//1 2 3 //4 5 6 求一笔划过所有9个键的所有方法 //7 8 9 #include <stdio.h> int g[10][9]={     {0,0,0,0,0,0,0,0,0},     {2,4,5,0,0,0,0,0,0},//1     {1,3,4,5,6,0,0,0,0},//2     {2,5,6,0,0,0,0,0,0},//3     {1,2,5,7,8,0,0,0,0},//4     {1,2,3,4,6,7,8,9,0},//5     {2,3,5,8,9,0,0,0,0},//6     {4,5,8,0,0,0,0,0,0},//7     {4,5,6,7,9,0,0,0,0},//8     {5,6,8,0,0,0,0,0,0},//9 }; int k,i,n; int h[10];//记录是否划过h[1..9],history int p[10];//记录划的顺序p[1..9],path void go(int f,int L) {     int j;      if (L==9) {         p[L]=f;         n++;         printf("%08d:",n);         for (i=1;i<=9;i++) printf(" %d",p[i]);         printf("\n");     } else {         p[L]=f;         h[f]=1;         j=0;         while (1) {             if (g[f][j]==0) break;             if (h[g[f][j]]==0) {                 go(g[f][j],L+1);                 h[g[f][j]]=0;             }             j++;         }     } } int main() {     n=0;     for (k=1;k<=9;k++) {         for (i=1;i<=9;i++) h[i]=0;         go(k,1);     }     return 0; } //00000001: 1 2 3 5 4 7 8 6 9 //00000002: 1 2 3 5 4 7 8 9 6 //00000003: 1 2 3 5 6 9 8 4 7 //00000004: 1 2 3 5 6 9 8 7 4 //00000005: 1 2 3 5 7 4 8 6 9 //00000006: 1 2 3 5 7 4 8 9 6 //00000007: 1 2 3 5 9 6 8 4 7 //00000008: 1 2 3 5 9 6 8 7 4 //00000009: 1 2 3 6 5 4 7 8 9 //00000010: 1 2 3 6 5 7 4 8 9 //00000011: 1 2 3 6 5 9 8 4 7 //00000012: 1 2 3 6 5 9 8 7 4 //00000013: 1 2 3 6 8 4 7 5 9 //00000014: 1 2 3 6 8 7 4 5 9 //00000015: 1 2 3 6 8 9 5 4 7 //00000016: 1 2 3 6 8 9 5 7 4 //00000017: 1 2 3 6 9 5 4 7 8 //00000018: 1 2 3 6 9 5 4 8 7 //00000019: 1 2 3 6 9 5 7 4 8 //00000020: 1 2 3 6 9 5 7 8 4 //00000021: 1 2 3 6 9 5 8 4 7 //00000022: 1 2 3 6 9 5 8 7 4 //00000023: 1 2 3 6 9 8 4 5 7 //00000024: 1 2 3 6 9 8 4 7 5 //00000025: 1 2 3 6 9 8 5 4 7 //00000026: 1 2 3 6 9 8 5 7 4 //00000027: 1 2 3 6 9 8 7 4 5 //00000028: 1 2 3 6 9 8 7 5 4 //00000029: 1 2 4 5 3 6 9 8 7 //00000030: 1 2 4 5 7 8 9 6 3 //00000031: 1 2 4 7 5 3 6 8 9 //00000032: 1 2 4 7 5 3 6 9 8 //00000033: 1 2 4 7 5 8 9 6 3 //00000034: 1 2 4 7 5 9 8 6 3 //00000035: 1 2 4 7 8 5 3 6 9 //00000036: 1 2 4 7 8 5 9 6 3 //00000037: 1 2 4 7 8 6 3 5 9 //00000038: 1 2 4 7 8 6 9 5 3 //00000039: 1 2 4 7 8 9 5 3 6 //00000040: 1 2 4 7 8 9 5 6 3 //00000041: 1 2 4 7 8 9 6 3 5 //00000042: 1 2 4 7 8 9 6 5 3 //00000043: 1 2 4 8 7 5 3 6 9 //00000044: 1 2 4 8 7 5 9 6 3 //00000045: 1 2 4 8 9 6 3 5 7 //00000046: 1 2 5 3 6 9 8 4 7 //00000047: 1 2 5 3 6 9 8 7 4 //00000048: 1 2 5 4 7 8 9 6 3 //00000049: 1 2 5 7 4 8 9 6 3 //00000050: 1 2 6 3 5 4 7 8 9 //00000051: 1 2 6 3 5 7 4 8 9 //00000052: 1 2 6 3 5 9 8 4 7 //00000053: 1 2 6 3 5 9 8 7 4 //00000054: 1 2 6 9 8 4 7 5 3 //00000055: 1 2 6 9 8 7 4 5 3 //00000056: 1 4 2 3 5 6 9 8 7 //... ... //00000776: 9 8 7 4 5 6 3 2 1 //00000777: 9 8 7 5 1 4 2 3 6 //00000778: 9 8 7 5 1 4 2 6 3 //00000779: 9 8 7 5 3 6 2 1 4 //00000780: 9 8 7 5 3 6 2 4 1 //00000781: 9 8 7 5 4 1 2 3 6 //00000782: 9 8 7 5 4 1 2 6 3 //00000783: 9 8 7 5 6 3 2 1 4 //00000784: 9 8 7 5 6 3 2 4 1

思路应该有可参考的地方吧。我觉得。

@赵4老师  老师，回复错地方了吧

仅供参考：//手机的键盘是这样的： // 1      2 abc  3 def // 4 ghi  5 jkl  6 mno // 7 pqrs 8 tuv  9 wxyz // *      0      # //要按出英文字母就必须要按数字键多下。例如要按出x就得按9两下，第一下会出w，而第二下会把w变成x。0键按一下会出一个空格。 //读取若干句只包含英文小写字母和空格的句子，求出要在手机上打出这个句子至少需要按多少下键盘。 #include <stdio.h> #include <string.h> char n[127]; char s[]="i have a dream"; char c; int L,i,k; int main() {     n[' ']=1;     n['a']=1;     n['b']=2;     n['c']=3;     n['d']=1;     n['e']=2;     n['f']=3;     n['g']=1;     n['h']=2;     n['i']=3;     n['j']=1;     n['k']=2;     n['l']=3;     n['m']=1;     n['n']=2;     n['o']=3;     n['p']=1;     n['q']=2;     n['r']=3;     n['s']=4;     n['t']=1;     n['u']=2;     n['v']=3;     n['w']=1;     n['x']=2;     n['y']=3;     n['z']=4;     k=0;     L=strlen(s);     for (i=0;i<L;i++) {         printf("%2d %c  %d\n",i,s[i],n[s[i]]);         k+=n[s[i]];     }     printf("Total %d\n",k);     return 0; } // 0 i  3 // 1    1 // 2 h  2 // 3 a  1 // 4 v  3 // 5 e  2 // 6    1 // 7 a  1 // 8    1 // 9 d  1 //10 r  3


Question: vc6.0运行一直说0x00401221指令引用的0xccccccd8内存，该内存不能为read

windows里常见的内存填充数据含义  * 0xABABABAB : Used by Microsoft's HeapAlloc() to mark "no man's land" guard bytes after allocated heap memory 漱 * 0xABADCAFE : A startup to this value to initialize all free memory to catch errant pointers 涵?  * 0xBAADF00D : Used by Microsoft's LocalAlloc(LMEM_FIXED) to mark uninitialised allocated heap memory 很?  * 0xBADCAB1E : Error Code returned to the Microsoft eVC debugger when connection is severed to the debugger 撅饰 * 0xBEEFCACE : Used by Microsoft .NET as a magic number in resource files 烫烫 * 0xCCCCCCCC : Used by Microsoft's C++ debugging runtime library to mark uninitialised stack memory 屯屯 * 0xCDCDCDCD : Used by Microsoft's C++ debugging runtime library to mark uninitialised heap memory 葺葺 * 0xDDDDDDDD : Used by Microsoft's free() or delete to mark freed heap memory 蕲蕲 * 0xDEADDEAD : A Microsoft Windows STOP Error code used when the user manually initiates the crash  * 0xFDFDFDFD : Used by Microsoft's C++ debugging heap to mark "no man's land" guard

没发完 void PreThreading(BiThrTree p) { 	if(p) 	{ 		if(p->lchild) 		{ 			p->lchild=pre;p->Ltag=1; 		} 		if(pre->rchild) 		{ 			pre->rchild=p;pre->Rtag=1; 		} 		pre=p; 		if(p->Ltag==0)PreThreading(p->lchild); 		if(p->Rtag==0)PreThreading(p->rchild); 	} }   void PreOrderTraverse_Thr(BiThrTree Thrt) {       BiThrTree p; 	p=Thrt->lchild; 	while(p!=Thrt) 	{ 		printf("%c->",p->data); 		while(p->Ltag==0) 		{ 			p=p->lchild;printf("%c->",p->data); 		} 			while((p->Rtag==1)&&(p->rchild!=Thrt)) 			{ 				p=p->rchild; printf("%c->",p->data); 			} 			if(p->Ltag==0)  p=p->lchild; 			else p=p->rchild; 	} }   void main() { 	BiThrTree T,Thrt; 	printf("请输入树的结点（#表示结点为空）：\n");   	PreOrderThreading(Thrt,T); 	PreOrderTraverse_Thr(Thrt); 	printf("先序遍历结果：\n"); 	printf("\n");  }


cout << "请选择要进行的操作：\n1.请求分配内存 \n2.请求回收内存 \n3.退出\n"; 		cin >> choice; 		if(choice == 1) 		{ 			cout << "请求分配内存\n"; 			cout << "请输入要分配的内存的长度："; 			cin >> len; 			Distribute(len); 		} 		else if (choice == 2) 		{ 			cout << "请求回收内存\n"; 			cout << "请输入要回收的内存的ID："; 			cin >> ID; 			recover(ID); 		} 		else if (choice == 3) 		{ 			break; 		} 		else 		{ 			cout << "输入有误！请重新输入!\n"; 			continue; 		} 	} 	return 1; }

//若回收的分区有上邻空闲分区和（或）下邻空闲分区，要求合并为一个空闲分区登记在空闲分区表的一个表项里   				temp->next->next = temp->next->next->next; 				temp->next->state = 0;        //分区状态改为空闲   			} 		} 		cout << "回收内存后的内存状态：" << endl;  		display(); 	} } int main()        //主函数   { 	int choice; 	int len; 	int ID; 	//初始化内存分区状态   	fstream file; 	file.open("start.txt", ios_base::in | ios_base::out | ios_base::app);   //读写input.txt文件，读入最初的内存分配状态   	string s0; 	getline(file, s0);                //从输入流读取一行到s0   	istringstream sin(s0);          //从s0中读取单个字符   	sin >> FQCount;                    //将sin向右位移6位   	FQ *temp = (FQ*)malloc(sizeof(FQ));     //定义当前指针   	temp = First; 	for (string s; getline(file, s);)        //将文件中的分区起始地址，分区长度及分区状态读入程序   	{ 		FQ *fq = (FQ*)malloc(sizeof(FQ)); 		istringstream sin(s); 		sin >> fq->beginAddress; 		sin >> fq->length; 		sin >> fq->state; 		fq->ID = ++maxID; 		fq->next = NULL; 		temp->next = fq; 		temp = fq; 	} 	cout << "最初的内存分配状态：" << endl; 	display(); 	while(1) 	{

while (!(temp->next->state == 0 && temp->next->length >= len))     //此分区的状态为占用状态或者分区长度小于需要的长度   	{ 		temp = temp->next;                    //考虑下一个分区   	} 	temp = temp->next; 	//  修改分区表   	FQ *fq1 = (FQ*)malloc(sizeof(FQ)); 	fq1->ID = ++maxID; 	fq1->next = temp->next; 	fq1->beginAddress = temp->beginAddress + len; 	fq1->length = temp->length - len; 	fq1->state = 0; 	temp->next = fq1; 	temp->length = len; 	temp->state = 1; 	cout << "分配内存后的内存状态：" << endl; 	display(); } void recover(int id)               //回收内存函数   { 	if (id>maxID)                      //判断想要回收的分区是否合理   	{ 		cout << "输入的id过大，没有与之匹配的分区" << endl;  	} 	else{ 		FQ *temp = (FQ*)malloc(sizeof(FQ)); 		temp = First;                          //当前指针指向头指针   		while (!(temp->next->ID == id))        //寻找要回收的分区的id   		{ 			temp = temp->next; 		} 		if (temp->state == 0)                //分区状态为空闲时   		{ 			if (temp->next->next == NULL) 			{ 				temp->next = NULL; 				temp->length = temp->length + temp->next->length; 				//若回收的分区有上邻空闲分区和（或）


Question: int值保存初始化

#include "stdafx.h" #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h> #include <ctype.h> #define Length 10 #define Amount 5 int _tmain(int argc, char * argv[]) { 	struct three_name{ 		char last_name[Length]; 		char mid_name[Length]; 		char first_name[Length]; 	}; 	struct member{ 		char account[Length]; 		struct three_name name; 	};  	struct member m_member[Amount] = { { "101", { "aaa", "bb2", "dccc" } }, { "202", { "abb", .mid_name = "fccc" } }, { "303", { "acc", "bb4", "hccc" } }, { "404", { "add", "bb5", "fccc" } }, { "505", { "aee", "bb6", "ccc" } } };  	system("PAUSE"); 	return 0; }

不会吧，程序第二次运行。count应该还是从1开始的，你可以输出count看一下变量值

fseek函数一般用于二进制文件，也可以用于文本文件。用于文本文件操作时，需特别注意回车换行的情况：因为在一般浏览工具如UltraEdit中，回车换行视为两个字符0x0D和0x0A，但真实的文件读写和定位时却按照一个字符0x0A进行处理，因此碰到此类问题时，可以考虑将文件整个读入内存，然后在内存中手工插入0x0D的方法，这样可以达到较好的处理效果。

第二次运行结果

第一次运行结果

0 1 2 3 4 5 6 7 8 9 1 8 7 6 5 4 3 2 1 0 2 0 0 0 2 2 2 0 0 0 3 1 2 4 5 6 7 8 6 5 4 5 4 5 4 5 4 5 4 5 5 7 7 7 7 9 9 9 9 9 6 3 3 3 4 4 4 1 1 1

#include "stdafx.h" #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> #define Length 20 int _tmain(int argc, char * argv[]) { 	char name[Length]; 	char ch; 	int data_n[7][10] = {}; 	char data_i[8][10] = {}; 	FILE * fp; 	char image_n[10] = { ' ', '.', '/', '-', '+', '*', '&', '^', '#', '@' }; 	int num = 0, value = 0; 	printf("Please enter the file's name:"); 	scanf("%s",name); 	if ((fp = fopen(name, "r")) == NULL) 	{ 		printf("Cna't open %s file.", name); 		exit(EXIT_FAILURE); 	} 	for (size_t i = 0; i < 7; i++) 	{ 		for (size_t j = 0; j < 10; j++) 		{ 			//fseek(fp, fp_n, SEEK_SET); 			ch = fgetc(fp); 			//ch = getc(fp); 			value = (int)(ch - '0'); 			data_n[i][j] = value; 			fgetc(fp); 			//fp_n = fp_n +  2; 		} 		//fp_n = fp_n - 1; 	} 	for (size_t i = 0; i < 7; i++) 	{ 		for (size_t j = 0; j < 10; j++) 		{ 			num = data_n[i][j]; 			data_i[i][j] = image_n[num]; 		} 	} 	for (size_t i = 0; i < 10; i++) 	{ 		data_i[7][i] = image_n[1]; 	} 	for (si

打印出来的count，是读出文件中的单词的计数。第二次运行时，文件中追加了一句话后，却又从头开始读出，当然要有前面的东西了

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


Question: VC 连接 MySQL数据库时，如何实现条件查询，条件由用户输入

搓→矬

res = mysql_query(&my_connection, "SELECT childno, fname,                                            age FROM children WHERE age > 5"); 这一句后面改成你输入的sql语句

代码都贴不全，是我浏览器问题？？csdn现在做的越来越搓了

#include <stdlib.h>       #include <stdio.h>       #include "mysql.h"       MYSQL my_connection;       MYSQL_RES *res_ptr;       MYSQL_ROW sqlrow;       int main(int argc, char *argv[]) {          int res;          mysql_init(&my_connection);           if (mysql_real_connect(&my_connection, "localhost", "rick",                                                   "bar", "rick", 0, NULL, 0)) {          printf("Connection success\n");          res = mysql_query(&my_connection, "SELECT childno, fname,                                            age FROM children WHERE age > 5");          if (res) {            printf("SELECT error: %s\n", mysql_error(&my_connection));          } else {             res_ptr = mysql_store_result(&my_connection);            if (res_ptr) {            printf("Retrieved %luows\n",(unsignedlong)mysql_num_rows(res_ptr));              while ((sqlrow = mysql_fetch_row(res_ptr))) {                printf("Fetched data...\n");              }             if (m


Question: 程序有个很难理解的bug,求助！请教各位大神，注释的那句//printf("%d",array[i]);为什么一定要加，不加程序就会停止运行，不应该啊。加

明显的内存溢出

C++ 本身并没有对内存做什么保护, 你访问越界了, 直接就覆盖掉后面部分的内存, 如果后面部分的内存刚好没有其他人使用, 没有覆盖到关键数据, 就会出现看起来正常的现象.

申请的内存是 num 个:  malloc(num*sizeof(int)); 访问却是 2 * num 个: for(i=0;i<2*num;i++) 这不是赤裸裸的越界吗!

引用 2 楼 zhanshen112 的回复:嗯嗯，发完就注意到了，array=(int*)malloc(2*num*sizeof(int));，申请内存空间不够。 但是我在测试的时候发现即使申请的内存不够，有时也是可以用的，例如，申请3个int空间，可以存6个；但是申请5 个，不能存10个。虽然应该用多少，申请多少，但是看来申请的时候，内存机制也不一定会完全按照你申请的来，是这样吗？ 只是你没有遇到更难受的结果。不能正常运行，这不就是问题吗？至于加了之后可以了，也只能说错误的效果相互抵消了而已

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


Question: C语言里的Struct里使用错鋘

性别和班级要用字符串存储，"男"实际上是个字符串，由两个字符组成

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

引用 2 楼 weixin_38495478 的回复:谢谢！你的指点，其实我想做的是这个程序的，想通过上面的那个小程序进行的测试，最后那个到了输入班级的时候就出了问题：   #   include<stdio.h> #   include<stdlib.h> #   include<time.h>   struct information { 	char name[300];//姓名； 	char sex[50];//性别	 	int age;//年龄；	 	char class1[250];//班级	 };  int main(void) { 	struct information st; 	int i,j;  	printf("输入学生数量"); 	scanf("%d",&j);  	for(i=1;i<=j;++i) 	{ 		printf("第%d位学生的信息：\n",i);  		printf("姓名:"); 		scanf("%s",st.name);  		printf("性别:"); 		scanf("%s",st.sex);   		printf("年龄:"); scanf("%d",&st.age);    		printf("班级:"); 		scanf("%s",st.class1); 	}  	system("pause"); 	return 0; }  代码没有大问题，只是年龄那里应该是scanf("%d",&st.age); //scanf %d对应的是整形地址，所以要加个地址符&

printf("年龄:"); scanf("%d",st.age);  那个st.age前加上&

name 是字符串，定义的时候双引号“张三”，而班级你定义的是字符，定义的时候单引号里面必须是单个字符，高二三班就是字符串了，   1 #include<stdio.h>   2    3 struct student{   4         char name[100];   5         char sex;   6         int age;   7         char class[100];   8 };   9   10 int main(){  11           12         struct student stu={"张三",'M',20,"高三二班"};//M代表男，Ｆ代表女     13         printf("%s,%c,%d,%s\n",stu.name,stu.sex,stu.age,stu.class);  14           15           16         return 0;  17 } ~

谢谢！你的指点，其实我想做的是这个程序的，想通过上面的那个小程序进行的测试，最后那个到了输入班级的时候就出了问题：   #   include<stdio.h> #   include<stdlib.h> #   include<time.h>   struct information { 	char name[300];//姓名； 	char sex[50];//性别	 	int age;//年龄；	 	char class1[250];//班级	 };  int main(void) { 	struct information st; 	int i,j;  	printf("输入学生数量"); 	scanf("%d",&j);  	for(i=1;i<=j;++i) 	{ 		printf("第%d位学生的信息：\n",i);  		printf("姓名:"); 		scanf("%s",st.name);  		printf("性别:"); 		scanf("%s",st.sex);   		printf("年龄:"); 		scanf("%d",st.age);    		printf("班级:"); 		scanf("%s",st.class1); 	}  	system("pause"); 	return 0; }


Question: 二维数组指针操作 求助大神！！

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

首先，既然你声明的是 unsigned char a[2][3]={{10,5,6},{1,2,3}};和unsigned char (*m)[3]那么在你的e函数中的for循环中i的取值范围就应该是0到2，否则就越界了。因为你这么声明，其实m[i][j]就是a[i][j]，相当于给a取了个别名叫做m for(i=0;i<2;i++) {          if(memcmp(m[i],l,3)==0) {return i;}  } 其次，起步向前走也已经提到了，你的e函数仅仅在for循环中有返回值，return的是i；但是如果都不符合你的if条件的话，我这边测试的时候程序默认返回的是0，那岂不是达不到你的目的。所以对于e函数最终还是需要设定一个返回值，用来表示什么条件都不满足条件的情况，并且能够与符合条件时的返回值区分开来。鉴于你的函数返回值类型是unsigned char，弄个255已经是最大了。 参考代码如下，我加了两处printf可供你参考#include <stdio.h> #include <string.h> unsigned char e(unsigned char (*m)[3],unsigned char *l) {     unsigned char i;     for(i=0;i<2;i++)     {         printf("m[%d]=%d,%d,%d\n",i, m[i][0],m[i][1],m[i][2]);         if(memcmp(m[i],l,3)==0) {return i;}     }     return 255; } int main() {    unsigned char a[2][3]={{10,5,6},{2,2,3}};    unsigned char b[]={1,2,3,5,6,9,6};      for(int i=0;i<2;i++)     {         printf("a[%d]=%d,%d,%d\n",i, a[i][0],a[i][1],a[i][2]);     }     int q=0;     q=e(a,b);     printf("%d",q);     return 0; }

引用 6 楼 weixin_42518655 的回复:[quote=引用 5 楼 qq_42523402 的回复:] 各位大神 看看还有问题吗  if(memcmp(m[i],l,3)==0) {return i;}//这一句需要优化一下，如果没有相等的字符，那么你怎么控制该子程序有反馈值。[/quote] 不是很明白 ？？

引用 5 楼 qq_42523402 的回复:各位大神 看看还有问题吗  if(memcmp(m[i],l,3)==0) {return i;}//这一句需要优化一下，如果没有相等的字符，那么你怎么控制该子程序有反馈值。

不是哦 找到问题了   #include <stdio.h> #include <string.h> unsigned char e(unsigned char (*m)[3],unsigned char *l) {     unsigned char i;     for(i=0;i<3;i++)     {          if(memcmp(m[i],l,3)==0) {return i;}     }  } int main() {     unsigned char a[2][3]={{10,5,6},{1,2,3}};    unsigned char b[]={1,2,3,5,6,9,6};     int q=0;     q=e(a,b);     printf("%d",q);     return 0; }

在你眼中int和int[]是同一个东西么？

引用 1 楼 SHIGUANGTUJING 的回复:兄弟,你闹呢,e函数参数是指针型整数变量,你用的时候给他传的是数组, 他没报错?  一维数组可以用 二维的怎么改 谢谢 了

各位大神 看看还有问题吗


Question: 为什么最后生成TXT文件中stu.id 为乱码 如何修改

printf("%d*%d=",a,b);                     ques[i][0]=a;                     ques[i][1]='*';                     ques[i][2]=b;                     ques[i][3]=a*b;                     break;                 }             }             scanf("%d",&ans[i]);             break;             case 3:             while(1)             {                 a=(int)rand()%100;                 b=(int)rand()%100;                                       if(b!=0&&a%b==0)                 {                      printf("%d/%d=",a,b);                     ques[i][0]=a;                     ques[i][1]='/';                     ques[i][2]=b;                     ques[i][3]=a/b;                     break;                 }             }             scanf("%d",&ans[i]);             break;             }     } time(&end); stu.time=difftime(end,start); //����ɼ� stu.score=0; if(ans[i]==ques[i][3]) { stu.score =stu.score + 10; printf("Score:%d Time:%d seconds\n",stu.score,stu.time); } infile=fopen("d:\\record.text","a");

{                     printf("%d+%d=",a,b);                     ques[i][0]=a;                     ques[i][1]='+';                     ques[i][2]=b;                     ques[i][3]=a+b;                     break;                 }             }             scanf("%d",&ans[i]);             break;             case 1:             while(1)             {                 a=(int)rand()%100;                 b=(int)rand()%100;                 if(a-b>=0)                     {                         printf("%d-%d=",a,b);                         ques[i][0]=a;                         ques[i][1]='-';                         ques[i][2]=b;                         ques[i][3]=a-b;                         break;                     }             }             scanf("%d",&ans[i]);             break;             case 2:             while(1)             {                 a=(int)rand()%100;                 b=(int)rand()%100;                                       if(a*b<100)                 {

{        int i,num1=0,num2=0;//num1��ʾǰ������ĸ��num2��ʾ���ĸ�����        for(i=0;i<2;i++)       {          if((id[i]>=97&&id[i]<=122)||(id[i]>=65&&id[i]<=90))          {           num1++;             }        }        for(i=2;i<6;i++)        {        if(id[i]>=48&&id[i]<=57) num2++;         }        if(num1==2&&num2==4) break;          { 		   printf("The id is invalid,please put in again\n"); 		   gets(id);            } 	} }  void Startext(char id[]) { struct STU stu; FILE *infile; time_t start,end; time(&start); srand(time(NULL)); char ques[10][4]; FILE  *fptr; int a,b,op,i;//op��ʾ�㷨���� i��ʾ10������ĵڼ��� char ans[10]; for(i=0;i<10;i++) { srand(time(NULL)); op=(int)(rand()%4); a=(int)(rand()%100); b=(int)(rand()%100);     for(i=0;i<10;i++)     {         srand(time(NULL));         op=(int)rand()%4;         switch(op)         {             case 0:             while(1)             {                 a=(int)rand()%100;                 b=(int)rand()%100;                 if(a+b<100)

代码不全呢，建议贴全代码。CSDN的论坛界面做的越来越烂了

代码缺失了,是不是被截断了


Question: C语言文件，疑惑不解，请求支援

引用 2 楼 JutuQishui 的回复:谢谢你的帮助，我感觉自己总是犯同样的错误，if后面总加分号，也查找不出来，下次一定会多注意的。 （1）但理论上有分号是不会继续执行语句的，为何此处又执行了了呢？ （2）我认为此处与源文件的关系并不大，若源文件第五行有回车键，应该也会影响第一程序的执行结果的，你认为呢？ 回复（1）：有分号表示执行空语句，执行完之后，会继续向下进行。 回复（2）：如果原文件的下一行无空格之类的，那么应该检索到了文件结尾，也不会有多余的输出了。

我是菜鸟，第一次回答问题。呵呵。 原因有两个： （1）第二个程序中的fscanf()后面多了一个分号； （2）估计原文件中的第五行有个回车键。 所以最后一次扫描时，虽然“if（fscanf（)不等于3”，但依然可以执行下面的语句，所以又使用原数据输出了一行。 你再检查一下源文件是否像我说的。


Question: 为什么BinTree tree无输出，而BinTree = NULL就有输出？

在main函数的第一行是BinTree tree；的时候就无法正常输出， 改为BinTree tree = NULL；是就可以正常输出。 这是为什么？

void DelTree(BinTree tree)					//删除一个树得节点  { 	if(tree){								//非空才能free  		free(tree->Left);					//先free左节点，再free右节点，最后free根节点  		free(tree->Right); 		free(tree);  	} }   void PreOrderTraversal(BinTree tree) { 	if(tree){								//如果这个树不为空，则对他进行先序遍历  		printf("%d ",tree->Data); 		PreOrderTraversal(tree->Left); 		PreOrderTraversal(tree->Right);  	}  }

引用 3 楼 cfjtaishan 的回复:因为，你注意看一下insert函数，若不是定义tree = NULL;那么传入insert中的tree就是随机值，就可能无法执行这个分支的逻辑：  if(!(*tree)){                            //如果树不为空          Temp = (BinTree)malloc(sizeof(struct TreeNode));    //为零时节点申请一个空间，并初始化          Temp->Data = val;         Temp->Left = NULL;         Temp->Right = NULL;         *tree = Temp;                        //将临时节点挂到树上      }  谢谢，明白了


Question: 求助怎么把c++的程序改成C语言，老师布置的作业，原来的程序是个火柴人

请牢记：源代码本身的书写是否结构化或面向对象或符合设计模式或敏捷…并不重要，重要的是你是否使用结构化或面向对象或符合设计模式或敏捷…的方法命名标识符、阅读、修改、检查、测试源代码。  意思是你程序结构看上去再合理，再简洁，也不一定比看上去一团乱麻的程序结构在运行或修改时更不易出错，更方便修改，出错了更容易找到哪里出错和具体出错的原因，更容易改正错误。  试对比 图书馆（对图书的分类够结构化了吧） 和 搜索引擎（可看作是扁平化任何结构数据，仅支持全文检索） 哪个处理信息更方便、更高效。  所以 与其费劲去重构代码让其看上去更简洁、更合理 不如费劲学习grep、sed、awk、……这类全文搜索和批处理编辑的工具。  结构越复杂，越难修改，越难除错。 有时（甚至大多数时候），看上去越合理、越简洁的代码，运行起来性能越差，出错时查找原因越难，找到出错原因后改正越费劲。  程序员要做的不是尽力避免错误，而是聚焦在快速发现并改正错误。真正以快速方式轻易解决错误，“快速的失败”远胜过“预防错误”。Fred George  前微软C#编辑器的开发主管Jay Bazuzi列出的一些有助于找到正确方向的问题；他觉得前同事们应该用这些问题来问自己；实际上不管在哪里工作的开发者们都应该经常问问自己这些问题： ◆“要保证这个问题不会再出现，我该怎么做？” ◆“要想少出些Bug，我该怎么做？” ◆“要保证Bug容易被修复，我该怎么做？” ◆“要保持对变化的快速响应，我该怎么做？” ◆“要保证我的软件的运行速度，我该怎么做？” 如果大多数团队都能不时问一下自己，必定会从中得益，因为这些都是真正强而有力的问题。

代码都是半截子

还不如学点C++，能阅读更多代码。

#include <stdio.h> #include <graphics.h> #include <conio.h> #include <time.h>  /******全局变量******/ #define	STEPDISTANCE	6	// 一步的距离。数值越大，移动速度越快 #define	JUMPSPEED	10	// 数值越小，跳得越远 #define	ROLLDISTANCE	30	// 滚动的总步数。数值越大，滚得越远  /******全局变量******/ int s_v = STEPDISTANCE; //障碍物和人物移动速度 int	p_v	= JUMPSPEED;	//人物跳跃速度 int	score	= 0;	//分数 int	max_s	= 0; char keydown;	//按键值  /********************/ void move(); void Login();  /*************************************障碍物类****************************************/ // 障碍物 struct zhangai {     int left;     int top;     int right;     int bottom;     int r; } s1, s2, s3;  // 障碍物类型 void zhangai_style(struct *ps) {     int a;     srand((unsigned int) time(NULL));     a = rand() % 5 + 1;     switch(a) {     case 0:     case 1:     case 2:     case 3:     case 4:         ps->top = 330;         ps->bottom = 361;         break;     case 5:         ps->top = 260;         ps->bottom = 291;         break;     }

你们老师真是个笨蛋哟，出这些莫名其妙的踢呀！

引用 6 楼 user-5 的回复:[quote=引用 5 楼 u010165006 的回复:] [quote=引用 4 楼 user-5 的回复:] [quote=引用 3 楼 u010165006 的回复:] 还不如学点C++，能阅读更多代码。 那是你不懂C的奥妙[/quote]  面向过程，组织以函数，代码随意写的奥妙？[/quote] of course 但你没说出C操作DOS Windows时多顺手（想当初我刚学时背cmd命令背了三天）[/quote]  引用 6 楼 user-5 的回复:[quote=引用 5 楼 u010165006 的回复:] [quote=引用 4 楼 user-5 的回复:] [quote=引用 3 楼 u010165006 的回复:] 还不如学点C++，能阅读更多代码。 那是你不懂C的奥妙[/quote]  面向过程，组织以函数，代码随意写的奥妙？[/quote] of course 但你没说出C操作DOS Windows时多顺手（想当初我刚学时背cmd命令背了三天）[/quote]  操作DOS Windows？调用系统API？C++一样简单。

引用 5 楼 u010165006 的回复:[quote=引用 4 楼 user-5 的回复:] [quote=引用 3 楼 u010165006 的回复:] 还不如学点C++，能阅读更多代码。 那是你不懂C的奥妙[/quote]  面向过程，组织以函数，代码随意写的奥妙？[/quote] of course 但你没说出C操作DOS Windows时多顺手（想当初我刚学时背cmd命令背了三天）

引用 4 楼 user-5 的回复:[quote=引用 3 楼 u010165006 的回复:] 还不如学点C++，能阅读更多代码。 那是你不懂C的奥妙[/quote]  面向过程，组织以函数，代码随意写的奥妙？

引用 3 楼 u010165006 的回复:还不如学点C++，能阅读更多代码。  引用 3 楼 u010165006 的回复:还不如学点C++，能阅读更多代码。 那是你不懂C的奥妙


Question: 关于扫雷中递归的问题

“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出

引用 1 楼 user-2 的回复:static void open_board(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)   {       int i, j;       if ((x >= 1 && x <= ROW) && (y >= 1 && y <= COL))  //坐标合法       {           if (CountMine(mine, x, y) == 0)                //坐标周围没有雷           {               show[x][y] = '0';                                        for (i = x - 1; i <= x + 1; i++)               {                   for (j = y - 1; j <= y + 1; j++)                   {                       if (show[i][j] == '*')             //如果这个地方没有展开，则递归展开                           open_board(mine, show, i, j);                   }               }           }           else               show[x][y] = CountMine(mine, x, y) + '0';       }   } 感谢大佬的提示，问题已解决。顺带问一下堆栈段溢出是怎么回事

·感谢大佬的提示，问题已解决。顺带问一下堆栈段溢出是怎么回事？


Question: 用fprintf输入增加文本数据时，输入值结果为数字

提供的信息不足，问题也不清晰呢。 建议贴出更多代码

fprintf向流中写入数据 fscanf从流中读取数据

printf("请输入要增加候选人的信息：序号 姓名 票数（请输入序号为%d）",j); //使用scanf()函数，添加从键盘输入的代码 //将输入保存在worker中 //接下来再使用fprintf()函数将worker的数组写入到文件中     fprintf(fin,"%4d\t%s\t %d\n",worker[j].num,worker[j].name,worker[j].vote); fprintf()函数的作用是将数据写入到文件中

fprintf已經是往文件中寫了，之前你應該從其他地方得到值，比如用scanf從標準輸入中取得。


Question: clang速度比gcc快主要体现在什么地方？

我只知道写编译器的时候用了表达式模板的呀

百度搜相关关键字。


Question: 求问，2字节的short为什么输出了4个字节？

我就想问问新版限制一次贴更少的代码，是出于什么考虑？

printf("%s\n",binstr);     } }

void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%08x -",i+addr);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             printf("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }

short是2个字节，但是%d是输出整型数（32位或64位）的格式。 对于short，建议用%hd格式输出。 同理%x也是输出的整型数(32位或64位）。


Question: c语言用fscanf 和fprintf来复制并修改数据出现问题。

加上process.h也不行

#include <stdio.h> #include <stdlib.h> struct Data { 	int num; 	char name[20]; 	int vote; }worker[40];    void xiugai() {     FILE *fin,*ftp;     int i=0,j;     printf("请输入要修改的人员的序号"); 	scanf("%d",&j);      fin=fopen("1.data","r");     ftp=fopen("2.data","w");     if(fin==NULL || ftp==NULL){         printf("打开失败...\n");         exit(0);     }     	while(!feof(fin)) 	{    	    if(i!=j)         fscanf(fin,"%d  %s  %d",&worker[i].num,worker[i].name,&worker[i].vote),         fprintf(ftp,"%d  %s  %d",worker[i].num,worker[i].name,worker[i].vote);         i++;         i++;     }     fclose(fin);     fclose(ftp);     remove("1.data");     rename("2.data","1.data");     FILE *fin2;     fin2=fopen("1.data","a+");     printf("请输入修改的信息 "); 	fprintf(fin2,"%d  %s  %d",&worker[j].num,worker[j].name,&worker[j].vote); 	fclose(fin2); 	printf("修改完成");  }     这是代码，而且发现运行时并没有过滤那个特定的行，最后输入的值也是数字

加上process.h再试一次


Question: 新手求助 printf没有输出

#include <stdio.h>  int main() { #if 1     int cnt = 0;     char t;      while (scanf("%c", &t) == 1 && t != '.') {         cnt++;         if (t == ' ') {             printf("%d\n", cnt);             cnt = 0;         }     }     printf("%d\n", cnt); #else     char t=' ';     while(t != '.'){         int cnt=0;         while(t != ' '){             cnt++;             scanf("%c", &t);             if(t=='.'){                 printf("%d\n",cnt);                 goto out;             }         }         printf("++%d\n",cnt);         scanf("%c", &t);     } out: #endif     return 0; } 参考一下吧

上面笔误，将 scanf("%s",&t); 改为 scanf("%c",&t);

确实，正如楼上几位所说的那样，感觉问题主要处在对scanf()这个函数的使用上。这个函数的格式之一为 int scanf(const char* format, argument); 其中，第一个参数format是格式化控制字符串，指定了以什么样的格式读取输入的数据，格式化字符串的基本格式为“%type”，其中type是单个的字母，%s表示以字符串的方式读取数据，%c表示以字符的方式读取数据。由于t的类型是char，所以在读取t时需要将格式化字符串设置为%c而不是%s。 所以，需要修改的代码为 scanf("%s",&t); 改为 scanf("%c",&t); 因为scanf()函数的第二个参数必须是指针，所以还需要修改的代码为 scanf("%s",t); 改为 scanf("%s",&t);

两个scanf改为  scanf("%c", &t);

給t的定義只是一個char，卻以字符串進行輸入，這裏就溢出了。 起碼要定義成一個字符數組，比如   char t[32] = '0';   另外前後兩個scanf的寫法也不一樣，要糾正一下。


Question: 关于base64 编解码的一点疑惑？

[quote=引用 6 楼 jha334201553 的回复:] 二进制数据是同样的道理呀。假设经过base64编码的就是一个长度为6的字符串(去掉 = )， 同样是6 * 6 bit数据。 经过移位处理，得到4 *8bit + 4bit 数据，我们按照标准算法，就是丢掉那4bit的数据。 这4bit是 36 %8 算出来的，跟二进制数据有00结尾的有什么关系呢？

引用 4 楼 weixin_40810615 的回复:赵四老师，能不能谈谈你的理解，不要一言不和就贴代码！我认为“1234” 和“12345”base64的编码，加不加等号，都可以把原始数据解出来。 “MTIzNA” 这个（去掉 =的）base64编码， 一共有6 * 6bit数据， 我们经过移位处理后，会得到 4B （4 * 8bit）数据。 还有剩余4bit,我们直接扔掉。就会把原始数据解出来。 “MTIzNDU”也是类似。那还加什么等号呢？因为你编码的是字符串，如果编码二进制数据呢，里面有00结尾数据，解码出来全删掉吗？

不用补也能用，一般也支持的。 补了对齐呗

=是补0的字节数，比如“1234”（4+2）*8 = 48 = 6*8 ，也就是"1234\0\0" 补充2字节的\0，等这个编码完成在最后 加 == ，以表示最后的两个\0是对齐补充的，解码的时候根据=个数再去掉末尾的\0

就像你说的每3个字节变成4个字节。字符串末尾不足3个字节的就按照约定补上去。


Question: 求解一个程序问题

问题应该是return 0;导致，因为最后一个for循环里有一个return 0;即只会执行一次，执行一次之后就直接return 0;退出程序了，其他的循环不会继续执行了。


Question: VS2017C语言编程，写入位置时发生访问冲突

引用 2 楼 cfjtaishan 的回复:  //if (j == 13)     if (j >= 13)         return 1; 这个条件改一下，把j == 13改成j >= 13;否则，你会发现j的值会大于13，最终会导致 nt coordinate1[13] = { 0 }; //横坐标 int coordinate2[13] = { 0 }; //纵坐标 数组越界，导致内存溢出而程序异常退出。  可以试一下，不改成j >= 13;在mov函数里加一句打印j的值。 printf("j = %d\n", j); 看看是不是j的值大于13了，我测试的结果是j= 967，然后程序异常退出（段错误）  回复一下2楼的前辈，包含原点在内，移动12步，数组的长度是13，因为之前使用matlab，角标是1~13，但是C应该是0~12，所以经过你的提示那部分代码应该改为，   //if (j == 13)     if (j >11)         return 1; j>11，j的最小值是12，coordinate[12]就是第13个单元，不需要也不能产生第14个坐标，所以我认为应该这么修改。 将j==13改为j>11之后，的确解决了出现的问题，但是结果仍然不对。需要继续修改。

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

程序里用到了j+1, 所以判断要改成 if (j>=12)

我用单步执行，每一步之后的变量值的确符合我的预期。


Question: 在linux中调用XML文件

引用 4 楼 super828 的回复:主要目的就是实现一些参数的存储与读取，使用libxml2有点太大了 So，#3正解。

主要目的就是实现一些参数的存储与读取，使用libxml2有点太大了

fopen fscanf fprintf fclose

应该说是操作，有没有比较简便的操作方法

调用? 还是解析?  解析的话看看tinyxml,Expat-XML之类的开源库


Question: C语言  输入三边判断三角形的类型（直角 锐角  钝角）

1.  a、b、c一定是某个三角形的三边长吗？ 2.  A=cos(b*b+c*c-a*a/2*b*c) 什么意思？余弦定理是 cosA = (b*b + c*c - a*a）/（2*b*c）啊

#include<stdio.h> #include<math.h>  int main() {     int a,b,c,t;     double A;     printf("三角形的三边是：");     scanf("%d,%d,%d",&a,&b,&c);      if(a>=b)     {         if(a>=c) {             t = a;             a = c;             c = t;         } else{             t = c;             b = a;             a = t;         }     }     else     {         if(b>=c) {             t = b;             b = a;             a = t;         }         if(b<c) {             t = c;             c = a;             a = t;         }     }     A = cos(b*b+c*c-a*a/2*b*c);     if(A > 0 && fabs(A) >= 1e-16)         printf("此三角形为钝角三角形");     else if(A < 0 && fabs(A) >= 1e-16)         printf("此三角形我锐角三角形");     else if (fabs(A) < 1e-16)         printf("此三角形为直角三角形");      return 0; } 参考一下吧

if(b>=c)    t=b;b=a,a=t;   if(b<c)    t=c,c=a,a=t; 中间有个分号，还是加个括号吧。


Question: 求解，文件联合查询的问题

联合查询，建议将文件内容都先加载到内存，对内存里的数据进行查找效率较高；即使是文件联合查询也需要将文件信息读到内存再查找


Question: 问个动态内存分配数组的问题，执行程序后段错误，求解。。。

//#include "/home/coy/coyhead/myhead.h"  void coyArr_Type(int **pArr,int *len); void coyArr_Type2(int *pArr, int *len);  int main() {     if((system("clear")) == 0)     {         ;     }      int len = 0;      puts("请输入数组长度");      if((scanf("%d", &len)) == 1)     {         ;     }       int *Arr = (int*)malloc(sizeof(int) * len);     if (!Arr)         exit(0);      coyArr_Type(&Arr, &len);     coyArr_Type2(Arr, &len);      return 0; }  void coyArr_Type(int **pArr, int *len) {     printf("请输入不超过%d个数的数组元素\n", *len);      for(int i = 0; i < *len; i++)     {         //if((scanf("%d", pArr[i])) == 1)         if((scanf("%d", &(*pArr)[i])) == 1)         {             ;         }     }      return; }  void coyArr_Type2(int *pArr, int *len) {     printf("请输入不超过%d个数的数组元素\n", *len);      for(int i = 0; i < *len; i++)     {         //if((scanf("%d", pArr[i])) == 1)         if((scanf("%d", &pArr[i])) == 1)         {             ;         }     }      return; } 若是传递二重指针，那么就需要用&(*pArr)[i]作为scanf的参数。若直接用pArr[i],第一个元素即i= 0时还没问题，但是若是i>0则是内存越界了。 建议了解一下一重指针和二重指针的关系


Question: 求大佬修改一下C语言啊啊啊，不会写带有数组的子函数

数组子函数用指针啊 int *arry（int *in，int length） {      int *out；     //中间把你要干的事弄到out里     return out; }

请参考《C++函数的数组形参》 希望能够帮到你

2楼正解啊，，为什么不采纳？你直接把#if 1 #else 和你自己写的内容去掉   就好了啊，不去掉程序也能实现

#include<stdio.h> #include <stdlib.h> #include<time.h>    void init_array(int *parr, int len); void sort_array(int *parr, int len); void show_array(const int *parr, int len); int get_pass_nums(int *parr, int len, int key);  int main(void) { #if 1     int K[30], count;      init_array(K, 30);     printf("升序前：\n");     show_array(K, 30);     printf("\n升序后：\n");     sort_array(K, 30);     show_array(K, 30);      count = get_pass_nums(K, 30, 60);     printf("\n[60,100]的数目：%d\n", count);  #else     int i,K[30],temp,count,j;     srand((unsigned int)time(NULL));     printf("升序前：\n");     for (i=0; i<30; i++)     {         K[i]=rand()%101;//生成[0,100] 的数         printf(" %d",K[i]);     }     printf("\n升序后：\n");     for(i=0;i<29;i++)     {         for(j=i+1;j<30;j++)         {              if(K[i]>K[j])             {                 temp=K[i];                 K[i]=K[j];                 K[j]=temp;             }         }     }     for(i=0;i<30;i++)     {         printf(" %d",K[i]);     }     printf("\n[60,100]的数：");     for(i=0;i<30;i++)     {         if(K[i]>60)             printf(" %d",K[i]);      }     for(i=0;i<30;i++)     {         if(K[i]>60)             count++;     }     printf("\n[60,100]的数目：%d",count-1); #endif  }  void init_array(int *parr, int len) {     int i;      srand((unsigned int)time(NULL));     for (i=0; i< len; i++)         parr[i] = rand() % 101;//生成[0,100] 的数 }  void show_array(const int *parr, int len) {     int i;      for (i = 0; i < len; i++)         printf(" %d", parr[i]);     putchar(10); }  void sort_array(int *parr, int len) {     int i, j;     int temp;      for(i=0;i< len-1;i++)     {         for(j=i+1;j < len;j++)         {              if(parr[i]> parr[j])             {                 temp = parr[i];                 parr[i] = parr[j];                 parr[j]=temp;             }         }     } }  int get_pass_nums(int *parr, int len, int key) {     int i, cnt = 0;      for(i=0;i<len;i++)     {         if(parr[i] > key)             cnt++;     }      return cnt; } 供参考

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