Question: 计算指数级数

多谢各位大神了！其实小弟当时写这个程序有问题只以为是哪的逻辑可能不对 ，但自己检查好几遍感觉没什么问题就想来发个贴问问。没想到还挺复杂，关键是大神们讨论的东西自己都不太懂，说实话我连级数是什么都不清楚。看来想编好程序数学也确实很重要啊！

引用 23 楼 lm_whales 的回复:e这个常数，应该自己求出来，如果直接获得，就有些突然了。 嗯，是应该自己算出来才能达到指定精度

这里主要利用公式 e^x = 1 + x + x^2/2! + x^3/3! + ....................x^n/n! 来计算 e^x

引用 20 楼 dianyancao 的回复:e^(floor(x))能用O(log(x))次迭代求出 e这个常数，应该自己求出来，如果直接获得，就有些突然了。

引用 20 楼 dianyancao 的回复:e^(floor(x))能用O(log(x))次迭代求出这个也可以这么快？？

引用 17 楼 dianyancao 的回复:计算e^x，由于e是常数，不知道一般的做法是不是用足够的二进制位储存e 然后只计算e^r,  (0<=r<1),r=x-floor(x) 那么e^r * e^(floor(x))即是计算结果  按这样计算e^r,有 0<=item(n)<1 1-item(n)>0 所以当fabs(sum*item /(1-item)) >= 1e-6时精度可以满足要求  引用 16 楼 lm_whales 的回复:R(n) =f(x) *item(n)=(sum(n) +R(n) )*item(n) 这个法子不错 e 可以用  e^1 =e^x = 1 + x + x^2/2! + x^3/3! + ....................x^n/n!+......... | x=1 求出来 e^1 =1+1 +1/2!+1/3!+1/4!+1/5!+....1/n! e^r 可以用公式e^x = 1 + x + x^2/2! + x^3/3! + ....................x^n/n!+......... | x=r 求出来

总不至于上GMP库吧。

e^(floor(x))能用O(log(x))次迭代求出

引用 18 楼 lm_whales 的回复:[quote=引用 17 楼 dianyancao 的回复:] e^r 可以用公式e^x = 1 + x + x^2/2! + x^3/3! + ....................x^n/n!+......... | x=r 求出来 这里的r就是整数啦，所以直接O(log(r))次迭代就能求得e^r的结果

计算e^x，由于e是常数，不知道一般的做法是不是用足够的二进制位储存e 然后只计算e^r,  (0<=r<1),r=x-floor(x) 那么e^r * e^(floor(x))即是计算结果  按这样计算e^r,有 0<=item(n)<1 1-item(n)>0 所以当fabs(sum*item /(1-item)) >= 1e-6时精度可以满足要求  引用 16 楼 lm_whales 的回复:R(n) =f(x) *item(n)=(sum(n) +R(n) )*item(n) 这个式子应该是|R(n)|<=|(sum(n) +R(n) )*item(n)|，即 R(n)*(1-item(n))<=sum(n)*item(n) 当1-item(n)<0时，得到 R(n)>=sum*item /(1-item) 用来估计误差上界似乎不合适，不过测试了多个例子精度都满足要求

f(x) =sum(n) +R(n) R(n) =f(x) *item(n)=(sum(n) +R(n) )*item(n) R(n) = sum(n) *item(n) /(1 -item(n) ) 这样看来，应该改成 sum(n) *item(n) /(1 -item(n) ) 即判断 sum *item /(1 -item )   #include <iostream>  double e( int x );  int main( void ) { 	int x; 	printf( "please input x :" ); 	scanf( "%d" , &x );  	printf( "\nThe result of e^%d is %-10.6f\n" , x , e( x ) );  	return 0; }  double e( double x ) { 	double item = 1.0 ; 	double sum = 0; 	int i = 1;         int plus = x > 0;//当x 为负数的时候，e^-x =1/e^x ,负数计算的精度不够，所以改为求正数的幂。 	do 	{ 		sum += item; 		item = item * x / i; 		i++; 	}while( fabs( sum *item /(1 -item )  ) >= 1e-6 );	  	return sign? sum: 1/ sum ; } 这样，在不计算，浮点数表示，精度损失的情况下，是不是算可以了。

R(n)| <=|f(sum,item,n,x)|

引用 13 楼 dianyancao 的回复:好像不行，这样要求|sum|>=e^|x|才行，但是|sum|<e^|x|  ++ 试了一下，起码对于负数结果是不正确的 不知道有什么办法，让某个已经计算出来的 数据，替换 e^r   或者从已经计算出来的结果中,得到一个式子， f(sum,item,i,x) 使得|R(n)| <=|f(sum,item,i,x)|

引用 3 楼 user-5 的回复:问题就在于当x^n/n!小于10^-6时，后面的其它数的和，还有可能进位。  没懂您的意思 当x^n/n!小于10^-6时不就只有一项吗?

引用 10 楼 lm_whales 的回复:[quote=引用 9 楼 dianyancao 的回复:] 这里是错了，该幂级数的拉格朗日型余项是|R(n)|=|(e^r*x^(n+1))/(n+1)!|<|e^|x|*x^(n+1))/(n+1)!| 这个|R(n)|就是用前n+1项近似产生的误差值上界 ++ 既然如此，这里，可以近似的让 f(x) = e^x  =  sum(n) 这样,R(n) =f(x) *x^(n+1))/(n+1)! ~=sum(n) *x^(n+1)/(n+1)!  sum += item;         item = item * x / i; 此时，item = x^(i+1)/(i+1)! R(i) = sum(i) *x^(i+1)/(i+1)!  = sum *item; 只要 fabs(sum *item) < 10^-6 即可 编程,果然还是要数学好 这应该差不多了 如果还不够严格，各位大牛继续讨论  [/quote] 好像不行，这样要求|sum|>=e^|x|才行，但是|sum|<e^|x|

更高精度，要用到高精度浮点数或者定点数表示， 64Bits浮点数，计算exp(50) ，甚至exp(30) 已经很不精确了。

另外，这个改进，对于精度为 1e-3 效果明显，对于 1e-6，及更高精度， 效果不大。   引用 1 楼 FancyMouse 的回复:e^5不是应该148.41么 ++ 确实是148.41 Windows 计算器的结果大约是，148.41315910257660342111558004055 楼主149.372018 和138.307168的两个结果都是错误的，精度误差也太大了。

引用 9 楼 dianyancao 的回复:这里是错了，该幂级数的拉格朗日型余项是|R(n)|=|(e^r*x^(n+1))/(n+1)!|<|e^|x|*x^(n+1))/(n+1)!| 这个|R(n)|就是用前n+1项近似产生的误差值上界 ++ 既然如此，这里，可以近似的让 f(x) = e^x  =  sum(n) 这样,R(n) =f(x) *x^(n+1))/(n+1)! ~=sum(n) *x^(n+1)/(n+1)!  sum += item;         item = item * x / i; 此时，item = x^(i+1)/(i+1)! R(i) = sum(i) *x^(i+1)/(i+1)!  = sum *item; 只要 fabs(sum *item) < 10^-6 即可 编程,果然还是要数学好 这应该差不多了 如果还不够严格，各位大牛继续讨论

数学分析中要作“误差分析“，算得再多也是作无用功！

问题就在于当x^n/n!小于10^-6时，后面的其它数的和，还有可能进位。


Question: VS中的profiler

vtunes 很不错。 但 license太贵了

还是一头雾水 是想看一下一个程序中函数调用的次数以及时间，好优化程序，有没有更好的建议啊？

我想1L误解了LZ的问题，LZ问的应该时profiler，而不是1L所说的.filter  而最直接的答案就是MSDN

查看MSDN联机帮助中相关内容。

引用 2 楼 u013220057 的回复:但是这个文件是怎么生成的啊？求指点  你理解错了，我说的这个文件就是你说的.filters文件，这个.filters文件是管理工程内的文件结构的。  你可以关闭工程把这个文件删掉再打开工程试试效果。

但是这个文件是怎么生成的啊？求指点

那个文件是用来给源文件分类管理的，有这个文件才有这种效果：   否则的话全部的文件会在一个filter下面。  它只是VS文件视图结构关系，没有你说的函数结构关系！


Question: union问题

仅供参考http://bbs.csdn.net/topics/390676437

union { int i; char x[2]; } a;  就类似于这样. int i = 0; char *buf = (char*)&i; buf[0] = 10;  //0x0A buf[1] = 1 ;   //0x01  这时. i = 0x0000010A = 266

由于union的地址是重合的，所以： i = (x[1] << 8) | x[0]  = x[1] * 256 + x[0]  = 1 *256 + 10  = 266  引用 楼主 remember_tody 的回复:rt,  union { 	int i; 	char x[2]; } a; a.x[0]=10; a.x[1]=1; printf("%d\n",a.i); 输出结果是266, 小弟不懂这个结果是怎样算出来的, 希望大家指导!

(1<<8)+10 查查union就明白了

这和你电脑的存储结构有关，你可以直接调试看看i和x[0],x[1]的地址关系，由你给的结果，存储是这样的

这说明你的机器是小端模式。a.x[0]占一个字节，a.x[1]占一个字节，这两个字节在内存中是相邻的；一般情况下a.x[0]在低地址，a.x[1]在高地址；由于a是union型的，所以a.i的值直接取决于a.x[0]和a.x[1]；在内存中a.x[0]、a.x[1]所在地址上存储的值是客观存在的，但是在将这两个字节的数据解读为整形数a.i时，又有两种方式，有的机器将a.x[0]看做是高位，a.x[1]是低位，称之为大端模式；有的机器将a.x[0]看做是低位，a.x[1]是高位，称之为小端模式，a.i的值即为266；所以说明你的机器是小端模式；


Question: 关于内存泄漏的问题，大神求解，在线等哈~~！

很简单，用mallocstat打印堆信息，你语句不多，暴力点就每句下面打一下，就知道内存是怎么分配释放了。

那个cpytmp = StrString(strtmp, i, str1) ——malloc分配来等着free的内存怎么半道上被重新赋值？那重新赋值后，free的地址还是malloc当初返回的地址么？  另外有点好奇的是，那个if和else分支的语句怎么是一模一样的？


Question: C语言 一道题目 求助

所以上课要认真听讲，课后还要复习实践，完了还要反思总结。  这一行不是那么容易的。

题目看不懂==

引用 6 楼 a515360208 的回复:[quote=引用 5 楼 u014485390 的回复:] 楼主，，，，，，很不好意思，可以把原题发上吗？没看懂 应该是这样的意思： 假如输入4个字符串：s1[20] = "hello"; s2[20] = "world"; s3[20] = "hey"; s4[20] = "man";  输出1：nam yeh dlrow olleh 输出2：olleh dlrow yeh nam 输出3：man hey world hello [/quote] 如果是这样，就把每一种情况单独分开写出来就好了呀

为什么就找不到几个编程风格漂亮的.

#include <iostream>  using namespace std;  #define SIZE 10 #define NUM 4  int main() { 	char strall[NUM][SIZE];  	for (int i = 0;i<4;++ i) 	{ 		cin.getline(strall[i],' '); 	} 	cout << endl; 	for (int i=3;i>=0;-- i) 	{ 		for (int j = strlen(strall[i])-1; j >= 0 ;-- j) 		{ 			cout << strall[i][j]; 		}cout << "\t"; 	} 	cout << endl; 	for (int i=0;i<4;++ i) 	{ 		for (int j=strlen(strall[i])-1;j >=0 ;-- j) 		{ 			cout << strall[i ][j]; 		} 		cout << "\t"; 	} 	cout << endl;  	for (int i=3;i >=0 ;-- i ) 	{ 		cout << strall[i ]<<"\t"; 	}cout << endl;   	return 0; }  请多多指教！

int main() { 	int i; 	char c; 	char a[4]={'d','g','q','n'}; 	printf("初始顺序\n"); 	for(i=0;i<4;i++) 		printf("%c",a[i]); 	printf("逆输出\n"); 	for(i=3;i>0;i--) 		printf("%c,",a[i]); 	for(i=0;i<3/2;i++){ 		c=a[i]; 		a[i]=a[3-i]; 		a[3-i]=a[i]; 	} 	return 1; }

基本一个问题 例如 1、逆着输出for（i = n；n >= 0 ;  n --）

引用 5 楼 u014485390 的回复:楼主，，，，，，很不好意思，可以把原题发上吗？没看懂 应该是这样的意思： 假如输入4个字符串：s1[20] = "hello"; s2[20] = "world"; s3[20] = "hey"; s4[20] = "man";  输出1：nam yeh dlrow olleh 输出2：olleh dlrow yeh nam 输出3：man hey world hello

楼主，，，，，，很不好意思，可以把原题发上吗？没看懂

[code=c#include <stdio.h> #include <string.h>  #define MAX 	200 #define SIZE	  3  void str_revrs(char (*) [], int);  //用以反转字符串 void chr_revrs(char (*) [], int);  //用以反转字符串里的字符 void str_disp(char (*) [], int);   //用以显示字符串  int main(void) { 	char str[SIZE][MAX]; 	char (* pstr)[MAX] = str;     int count = 0;  	puts("Input strings (empty line to quit):"); 	while(count < SIZE &&  gets(str[count]) != NULL && str[count][0] != '\0') 		count++; 	puts("Round one:"); 	chr_revrs(pstr, count);  //第一轮字符串内字符顺序 	str_revrs(pstr, count);  //以及字符串顺序全都反转成逆序 	str_disp(pstr, count); 	puts("Round tow:");     //第二轮留着第一轮已反转成逆序的字符串内字符顺序不动 	str_revrs(pstr, count);  //将在第一轮时反转的字符串顺序再次反转 	str_disp(pstr, count);   //结果就会是字符串内字符顺序依然是逆序，而字符串顺序则回归正序 	puts("Round three:"); 	chr_revrs(pstr, count);  //第三轮将第一轮反转成逆序的字符串内字母再反转回正序 	str_revrs(pstr, count);  //将第二轮回归正序的字符串顺序又反转成逆序 	str_disp(pstr, count); 	puts("Done!");  	return 0; }  void str_revrs(char (* ar)[MAX], int n) { 	int i, j; 	char temp[MAX];      //将字符串前后顺序调换 	for(i = 0, j = n -1; i < n/2, j > n/2; i++, j--) 	{ 		strcpy(temp, ar[i]); 		strcpy(ar[i], ar[j]);   //用strcpy是为了确保字符串 		strcpy(ar[j], temp);    //本身换了位置，而非指针换位 	}                           //这是为了下次反转时做准备 }  void chr_revrs(char (* ar)[MAX], int n) { 	int i, j, k; 	char temp;      for(i = 0; i < n; i++)         for(j = 0, k = strlen(ar[i]) - 1; j < strlen(ar[i])/2, k > strlen(ar[i])/2; j++, k--)         {             temp = ar[i][j];        //道理同上             ar[i][j] = ar[i][k];             ar[i][k] = temp;         } }  void str_disp(char (* ar)[MAX], int n) { 	int i;  	for(i = 0; i < n; i++) 		puts(ar[i]); } [/code]

楼主要表达的是4个字符串吧？！以后好好上课吧 #include<stdio.h>  #define SIZE 20    //字符串最大长度 #define NUM 3      //字符串数量 int main(){ 	char c[NUM][SIZE]; 	int i, j;  	for (i = 0; i < NUM; ++i) 		gets(c[i]);  	for (i = NUM-1; i >= 0; --i){    //1 		for (j = 0; c[i][j] != '\0'; ++j); 		for (--j; j >= 0; --j) 			putchar(c[i][j]); 		putchar('\n'); 	} 	puts("");  	for (i = 0; i < NUM; ++i){    //2 		for (j = 0; c[i][j] != '\0'; ++j); 		for (--j; j >= 0; --j) 			putchar(c[i][j]); 		putchar('\n'); 	} 	puts("");  	for (i = NUM - 1; i >= 0; --i)    //3 		puts(c[i]); }


Question: 输出的数不符合自己的要求（由于本人是初学者，请不要见怪啊）

这个符号 ^  在c语言中不是平方关系，是或运算~

我想LZ是把C的运算符和MATLAB的搞混了。。

程序执行到sq=toes^2;这行时， toes = 10; 即 sq = 10^2 10的二进制 ：1010 2  的二进制 ： 0010 异或后：          1000 转换成十进制，即为8

toes^2 这个不是平方，这个是异或1010(10) ^ 10(2) = 1000(8)  平方用power函数


Question: 新手请教

引用 1 楼 user-1 的回复:楼主的意思是不知道那个循环中的具体含义吗？        p是定义的一个指针，p=a1是指p取的a1的储存地址;             s=*p++是指s取的是a2的地址；         至于n>0和n--就是控制循环的次数的。         ++p的含义之p指针指向a1+1的地址，即a2;         以你的第二个例子来解释：         s=3.5*2.0+2.5(第一次循环）         s=4.5*2.0+3.5（第二次循环） ps:以上解释可能有错误，楼主仅供楼主参考，如果有错，还望指出 引用 1 楼 user-1 的回复:楼主的意思是不知道那个循环中的具体含义吗？        p是定义的一个指针，p=a1是指p取的a1的储存地址;             s=*p++是指s取的是a2的地址；         至于n>0和n--就是控制循环的次数的。         ++p的含义之p指针指向a1+1的地址，即a2;         以你的第二个例子来解释：         s=3.5*2.0+2.5(第一次循环）         s=4.5*2.0+3.5（第二次循环） ps:以上解释可能有错误，楼主仅供楼主参考，如果有错，还望指出 哦，这样说我就明白点了，谢谢啦


Question: 【求助】关于C语言中动态申请数组空间的问题

引用 1 楼 turingo 的回复:例如： char* str = (char*)malloc(sizeof(char)*length);  引用 楼主 QQ2543514322 的回复:C语言新手，拜托论坛里朋友指点一下。我有这么一个main()函数，调用一个子函数，传递给它一个参数unsigned char *ptr，然后在子函数里面定义length =strlen(ptr)。然后，比如我想在子函数内部申请一个unsigned int data[length]的数组，请问我该如何实现。 恩 已经行了 谢谢你！

# include <stdio.h> # include <string.h> # include <stdlib.h>  void fun(char *ptr);  int main() { 	char *s = "hello world";  	fun(s);  	return 0; }  void fun(char *ptr) { 	int length = strlen(ptr); 	int *data = (int *)malloc(length * sizeof(int));  	printf("input %d numbers:", length); 	for (int i = 0; i < length; i++) 		scanf("%d", data + i);  	printf("arr data[]:\n"); 	for (int i = 0; i < length; i++) 		printf("%d ", data[i]);  	free(data); }


Question: C。同时接收2个键的信息

这种就不能用getch这个API， 你要区别不用的事件

想达成什么效果？给个示意图？


Question: 小弟新学C，有问题请教

C语言我一节课都没去过，都是自学的，重要的是掌握基本的规则，然后多运用这些规则写程序。所谓编程，就是遵守现有的种种语法规则，实现任何要实现的效果。

引用 7 楼 Falleyes 的回复:[quote=引用 5 楼 x000000xd 的回复:] [quote=引用 4 楼 Falleyes 的回复:] #include<stdio.h>  void main() { 	void daozhi(char a[], char b[]); 	char a[10], b[10]; 	int i;  	for (i = 0; i <= 9; i++) 		scanf("%c", &a[i]); 	daozhi(a, b); 	for (i = 0; i <= 9; i++) 		printf("%c", b[i]); }  void daozhi(char a[], char b[]) { 	int x, y = 9; 	for (x = 0; x <= 9; x++) 	{ 		b[y] = a[x]; 		y--; 	} } 我明白了！ 感谢前辈！[/quote]哈哈哈，前辈谈不上，我今年秋天才大三！[/quote] 我就比你小一年级，能力跟你差这么多，您能说说你对学c语言的心得体会吗？  启发小学弟

引用 5 楼 x000000xd 的回复:[quote=引用 4 楼 Falleyes 的回复:] #include<stdio.h>  void main() { 	void daozhi(char a[], char b[]); 	char a[10], b[10]; 	int i;  	for (i = 0; i <= 9; i++) 		scanf("%c", &a[i]); 	daozhi(a, b); 	for (i = 0; i <= 9; i++) 		printf("%c", b[i]); }  void daozhi(char a[], char b[]) { 	int x, y = 9; 	for (x = 0; x <= 9; x++) 	{ 		b[y] = a[x]; 		y--; 	} } 我明白了！ 感谢前辈！[/quote]哈哈哈，前辈谈不上，我今年秋天才大三！

单步调试，看内存。自己掌握的比别人说的强一万倍。

引用 4 楼 Falleyes 的回复:#include<stdio.h>  void main() { 	void daozhi(char a[], char b[]); 	char a[10], b[10]; 	int i;  	for (i = 0; i <= 9; i++) 		scanf("%c", &a[i]); 	daozhi(a, b); 	for (i = 0; i <= 9; i++) 		printf("%c", b[i]); }  void daozhi(char a[], char b[]) { 	int x, y = 9; 	for (x = 0; x <= 9; x++) 	{ 		b[y] = a[x]; 		y--; 	} } 我明白了！ 感谢前辈！

对数组进行初始化 char a[10] = {'\0'}; char b[10] = {'\0'};

引用 1 楼 Falleyes 的回复:字符串数组是以'\0'作为结束的，那么你倒置复制就会把b的第一个字符赋值为'\0'抱歉，看错了，你在主函数中并没有执行daozhi函数啊


Question: c语言写的程序，关于printf和时间函数问题

引用 3 楼 jerry_dqh 的回复:程序关闭后，重新打开，开始还是一样吗？     是一样的。  全部重新编译也是一样的。  我用的是dev-c

程序关闭后，重新打开，开始还是一样吗？

唔，完整的太长了，我贴其中一个循环			                                              			case(IDLE):                        //空闲状态  			while(ele->headp->nextPtr->theReq==Zero){ 				cache(ele,fp); 				timeCount=clock(); 				if((timeCount-starttime)%(CLOCKS_PER_SEC/2)==0&& (timeCountstarttime)/(0.5*CLOCKS_PER_SEC)>num){ 					printf("%10d,%10d,%10.2f\n",timeCount-starttime,ele->theST,ele->theFloor); 					num+=1; 					}  				}  //timeCount和starttime是clock_t类型的全局变量。 其中cache函数是用来判断是否读入新请求并排序的。新请求是从文件中读取的。 void cache(struct ElevatorRec *ele,FILE *fp){  	static struct LIST Req; 	static int g=0; 		if(g==0){ 			fscanf(fp,"%10d,%10d,%10d",&Req.eventTime,&Req.theReq,&Req.reqFloor); 			getc(fp); 			g++; 			} 		 timeCount=clock(); 		 if(( timeCount-starttime)>=Req.eventTime){ 			buildnewReq(ele,Req); 			if(!feof(fp)) {      				fscanf(fp,"%10d,%10d,%10d",&Req.eventTime,&Req.theReq,&Req.reqFloor); 				getc(fp); 				} 			else return; 			} 		return;	 } 我在同学电脑上运行也是同样的，刚开机的时候正常。。。。

帖代码...


Question: fseek(fp, -1, SEEK_CUR); 遇到一个问题。

额~，原来我在后面的代码中写错了，把SEEK_CUR 写成SEEK_SET 了，所以跑到前面去了。 多谢3楼的提示，才让我想到用FTELL 去调试。

不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,fread,fwrite,fgetc,fclose  //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了  // szStringReaded 是已经从fp 中读取出来的一个字符串，chFind 是查找szStringReaded 中是否有该字符。 // 该函数的意思是：查找读取出来的字符中是否有字符chFind ，如果有则将文件指针移动回该字符位置。 void MOVE_BACK(FILE *fp, char *szStringReaded, char chFind) {         char *pPosition = strchr(szStringReaded, chFind);         if (pPosition != NULL)         {                 long nOffset = -abs((long)(strlen(szStringReaded) - (pPosition - szStringReaded)));                 printf("before fseek: nOffset==%d,ftell(fp)==%d\n",nOffset,ftell(fp)):                 fseek(fp, nOffset, SEEK_CUR);                 printf("after fseek: ftell(fp)==%d\n",ftell(fp)):         } }

引用 1 楼 user-2 的回复:文件映射，操作映射出来的指针 没明白。

文件映射，操作映射出来的指针


Question: 求买一个来电显示程序【或2FSK解调】！！！！！急！！软件就好！！！

这里有一个，不知是否合用。 http://download.csdn.net/detail/vipsms/2376288


Question: Makefile交叉编译问题

CC=arm-linux-gcc 然后把Makefile 中的gcc GCC神马的都换成$(CC)

什么是automake啊

要cross compiling，最好使用automake, configure来自动生成makefile  ./configure --prefix=/ CC=my-cross-compiler

能再说的具体点儿吗？

prefix


Question: 简单C语言问题

引用 60 楼 hadues 的回复:正好我看C primer plus正好看到strlen（）这个函数在string.h头文件不是stdio.h头文件[/quote] 那为什么 #include <string.h> void main() {                   char s[]  = "abc";                   printf("数组的长度为：%d\n", strlen(s)); } 可以正常运行呢？[/quote]VC中也可以这么干，不知道为什么

是你的strlen函数字符结尾判断条件的问题。

$ cat a.c # include <stdio.h>  int mystrlen(char s[]) // 标准库里有个strlen，为了避嫌，换个名字 {     int n;     for (n = 0; *s != '\0'; s++) {         n++;         printf("%d ", n); // 每数一个字符，都把当前字符总数打印一次     }     return n; }  int main() {     char s[] = "abc";     printf("数组的长度为：%d\n", mystrlen(s));     return 0; }  $ ./a  1 2 3 数组的长度为：3

[/quote]正好我看C primer plus正好看到strlen（）这个函数在string.h头文件不是stdio.h头文件[/quote] 那为什么 #include <string.h> void main() {                   char s[]  = "abc";                   printf("数组的长度为：%d\n", strlen(s)); } 可以正常运行呢？

引用 28 楼 u010980545 的回复:[quote=引用 23 楼 u014485390 的回复:] [quote=引用 16 楼 hadues 的回复:] 引用stdio.h中有strlen()函数？ 应该有，虽然我不能十分确定，但是如果不这么理解？ 如何解释这两个代码编译链接运行都没有问题，都可以正确输出数组长度为3？ 方法一： #include <stdio.h> void main() {                  char s[]  = "abc";                   printf("数组的长度为：%d\n", strlen(s)); } 方法二：  #include <string.h> void main() {                   char s[]  = "abc";                   printf("数组的长度为：%d\n", strlen(s)); }   没有使用<stdio.h>也能使用printf?????[/quote]我在VC中试了一下，是可以的，但是不知道为什么，不知道其他的IDE行不行[/quote]好无奈，我没试过

引用 57 楼 zhangshichuan972 的回复:中国的软件教育.o(︶︿︶)o 唉新手上路，有什么不对的还请阁下明示

引用 51 楼 lin5161678 的回复:1 strlen 和库函数重名了 换一个名字 不要用这个名字  2 你的strlen 内的 变量n 没有初始化在for循环中初始化了的

中国的软件教育.o(︶︿︶)o 唉

Rebuild All

你为什么不单步调试？我这有单步时看到问题，他在}之后还在找跳

引用 16 楼 hadues 的回复:引用stdio.h中有strlen()函数？ 应该有，虽然我不能十分确定，但是如果不这么理解？ 如何解释这两个代码编译链接运行都没有问题，都可以正确输出数组长度为3？ 方法一： #include <stdio.h> void main() {                  char s[]  = "abc";                   printf("数组的长度为：%d\n", strlen(s)); } 方法二：  #include <string.h> void main() {                   char s[]  = "abc";                   printf("数组的长度为：%d\n", strlen(s)); }  正好我看C primer plus正好看到strlen（）这个函数在string.h头文件不是stdio.h头文件

不错 学习了

引用 30 楼 u010408449 的回复:引用 21 楼 u012843100 的回复:你重写了strlen函数，在你的strlen函数里面，for循环中每次循环都打印出n的值。*s实际上是数组s的第一个元素a，ASCII码61，接着for循环的递增语句s++，是对地址的自增，这里得到的值是不可预料的。由于你的程序中没有包含头文件<string.h>，所以你的主程序中调用strlen，调用了你自己写的strlen函数，在for循环中不断的打印n的值，至于这个值就因每次调用时候内存的状态不同而不同数组在内存中占用的是一段连续的内存单元吧，地址自增就指向下一个内存单元中的元素，数组中的元素在初始化的时候就已经知道了，所以指针每次指向的下一个内存单元中的值都是可以预知的吧，直到指针指向'\0'就结束循环，而且我打印的是n的值，也不是数组中的元素啊，你说n的值跟每次调用的内存状态有关，但是实际上我每次运行结果都是一样的。从VC中的云翔结果来看，貌似strlen函数被调用了很多次。之前是我太轻薄，没仔细看过代码，还请见谅。还是等大神吧

引用 26 楼 hadues 的回复:[quote=引用 21 楼 u012843100 的回复:] 你重写了strlen函数，在你的strlen函数里面，for循环中每次循环都打印出n的值。*s实际上是数组s的第一个元素a，ASCII码61，接着for循环的递增语句s++，是对地址的自增，这里得到的值是不可预料的。由于你的程序中没有包含头文件<string.h>，所以你的主程序中调用strlen，调用了你自己写的strlen函数，在for循环中不断的打印n的值，至于这个值就因每次调用时候内存的状态不同而不同           看了您的评论，感觉很有道理。确实如果按照您这么理解，假设是楼主重写了strlen函数，打印出那种结果按您这么理解倒也行得通。           可是当调用完毕楼主自己写的strlen函数后，程序还会再次调用系统#include <stdio.h>库函数中的strlen函数？这就不是很理解啦。          还有这重写和编译器不知有什么关系，vc++6.0运行该代码会出错，而codeblocks编译器运行相同代码却没有报错？[/quote]确实我只是看了下代码就乱说了，多谢提醒。刚开始还以为最后的结果是巧合，刚刚运行了下，发现确实没那么简单，每次都会输出”数组长度为：3“。还是坐等大神吧

路过学习，继续加分

反汇编看看发生了什么

引用 47 楼 u011584079 的回复:引用 20 楼 u010980545 的回复:[quote=引用 17 楼 u011584079 的回复:] [quote=引用 10 楼 u010980545 的回复:] [quote=引用 9 楼 u013697891 的回复:] 我的输出123，数组长度是3现在可以确信是我的机器或者软件的问题了，但是这不科学啊 我用vc跑了，结果还是对的啊，你是不是后缀名。你是怎么建的工程[/quote]new 一个32位的控制台程序啊，看前面几位大哥的回复，貌似只有使用VC的时候运行结果才不对[/quote] 为何我的vc跑出的结果跟你的不一样，[/quote]估计用的是不同版本的吧，这个问题有点纠结，决定不用VC，用VS

引用 20 楼 u010980545 的回复:引用 17 楼 u011584079 的回复:[quote=引用 10 楼 u010980545 的回复:] [quote=引用 9 楼 u013697891 的回复:] 我的输出123，数组长度是3现在可以确信是我的机器或者软件的问题了，但是这不科学啊 我用vc跑了，结果还是对的啊，你是不是后缀名。你是怎么建的工程[/quote]new 一个32位的控制台程序啊，看前面几位大哥的回复，貌似只有使用VC的时候运行结果才不对[/quote] 为何我的vc跑出的结果跟你的不一样，

引用 16 楼 hadues 的回复:引用stdio.h中有strlen()函数？ 应该有，虽然我不能十分确定，但是如果不这么理解？ 如何解释这两个代码编译链接运行都没有问题，都可以正确输出数组长度为3？ 方法一： #include <stdio.h> void main() {                  char s[]  = "abc";                   printf("数组的长度为：%d\n", strlen(s)); } 方法二：  #include <string.h> void main() {                   char s[]  = "abc";                   printf("数组的长度为：%d\n", strlen(s)); }   建议你去翻一下msdn


Question: strcpy怎么啦

++，不理解的人容易钻牛角尖。  引用 2 楼 lin5161678 的回复:数组越界 未定义行为  什么结果都有可能   数组越界是可能会出错 不是一定会出错  之所以不允许数组越界是对错误零容忍 不许可能出错的情况  开车闯红灯是可能会撞到人  不是开车闯红灯 一定会撞到人 这么简单的道理 为什么会有人一直不理解  难以置信

str长度太短了。。。


Question: 在Linux下用C语言写打砖块

不做图形界面吗？

用控制台实现还是要自绘界面？ 如果自绘界面的话我记得好像有一个C的库可以实现名字好像是Allegro

引用 3 楼 FENGQIYUNRAN 的回复:Lua由标准C编写而成，代码简洁优美，几乎在所有操作系统和平台上都可以编译，运行。 This is ~我不是说了要用C写吗。。。

引用 1 楼 user-4 的回复:Linux下面，QT?用Qt不是C++吗？我们这里是C

Linux下面，QT?


Question: ATTINY2313如何用C语言编写,如何调用里面内置的晶振,求各位大神指教!

Windows下读写硬件端口使用WinIO.sys

内置晶体是由编程熔丝决定的。


Question: 关于出圈问题

引用 9 楼 wander0001 的回复:[quote=引用 8 楼 zxh707wk 的回复:] [quote=引用 6 楼 wander0001 的回复:] [quote=引用 3 楼 zxh707wk 的回复:] 代码： #include <stdio.h> #include <malloc.h>  int fun(int sum,int n) { 	int* num=(int*)malloc(sizeof(int)*sum); 	int i; 	int j=sum; 	int m=0; 	for(i=0;j>1;i++) 	{ 		if(i>=sum)i=0; 		if(num[i]==0)m++; 		if(m==n) 		{ 			num[i]=1; 			m=0; 			j--; 		} 	} 	for(i=0;i<sum;i++) 	{ 		if(num[i]==0) 		{ 			free(num); 			return i+1; 		} 	} 	free(num); 	return -1; }  int main() { 	printf("%d\n",fun(5,3)); 	return 0; } 你的窝运行得不出结果。。你测试了吗？我想问问为什么我的代码得不到结果。。。[/quote] 哪没结果了？  没加getchar();而已[/quote]我用的是VS2008确实是没结果的[/quote] 他没赋初值，楼主看不出来么？

仅供参考//假设有n个人团团围做，从第1个人开始数数，数到第m个人时候，第m个人出列， //然后继续从1开始数数，数到第m个人退出 #include <stdio.h> #include <conio.h> int i,k,t; int n,m; static char f[1001];//0该座位未出圈,1该座位已出圈 void main() {     while (1) {         printf("Input n m(1000>=n>=m>=1):");         fflush(stdout);         rewind(stdin);         if (2==scanf("%d%d",&n,&m)) {             if (1000>=n && n>=m && m>=1) break;         }     }     t=0;//已出圈总人数     i=1;//座位编号     k=1;//当前要数的数     while (1) {         if (0==f[i]) {             if (m==k) {                 t++;                 f[i]=1;                 printf("%3d ",i);                 if (0==t%10) printf("\n");                 if (t>=n) break;             }             k++;if (k>m) k=1;         }         i++;if (i>n) i=1;     }     cprintf("Press any key ...");     getch(); }

我用linux gcc编译的。。。

引用 8 楼 zxh707wk 的回复:[quote=引用 6 楼 wander0001 的回复:] [quote=引用 3 楼 zxh707wk 的回复:] 代码： #include <stdio.h> #include <malloc.h>  int fun(int sum,int n) { 	int* num=(int*)malloc(sizeof(int)*sum); 	int i; 	int j=sum; 	int m=0; 	for(i=0;j>1;i++) 	{ 		if(i>=sum)i=0; 		if(num[i]==0)m++; 		if(m==n) 		{ 			num[i]=1; 			m=0; 			j--; 		} 	} 	for(i=0;i<sum;i++) 	{ 		if(num[i]==0) 		{ 			free(num); 			return i+1; 		} 	} 	free(num); 	return -1; }  int main() { 	printf("%d\n",fun(5,3)); 	return 0; } 你的窝运行得不出结果。。你测试了吗？我想问问为什么我的代码得不到结果。。。[/quote] 哪没结果了？  没加getchar();而已[/quote]我用的是VS2008确实是没结果的

引用 5 楼 qiang81020 的回复: #include <stdio.h>  #define area 2000  typedef struct pnode {     int mynum;     struct pnode *next; }node;  void printfnode(node *p) {     node *p0 = p;     while(p0->next != p)     {         printf ("%d ", p0->mynum);         p0 = p0->next;     }     printf ("%d ", p0->mynum); }  int foo(int m, int n, int *num) {     int i = 0, j = 0;     char strnum[5 + 1] = {0};     node *p, *phead;     node *ppre, *pnow;      if ((n < 1) || (n > 10))         return -1;     if (NULL == (p = (node *)malloc(sizeof(node) * m)))         return -1;      phead = p;     /*init*/     for (i = 0; i < m - 1; i++)     {         (p + i)->mynum = i + 1;         (p + i)->next  = p + i + 1;         printf ("(%d - 0x%08x)", (p + i)->mynum, p + i);     }     (p + m - 1)->mynum = m;     (p + m - 1)->next = p;     printf ("\n\n");      /*begin*/     ppre = p + m - 1;     pnow = p;     i = j = 1;     while (1)     {         if (i % n == 0)         {             printf ("REMOVE %d, i = %d\n", pnow->mynum, i);             pnow = pnow->next;             ppre->next = pnow;             if (pnow == ppre)                 break;             i++;             continue;         }          strnum[0] = '\0';         sprintf (strnum, "%05d", i);         if (n == strnum[4] - 0x30)         {             printf ("REMOVE %d, i = %d\n", pnow->mynum, i);             pnow = pnow->next;             ppre->next = pnow;             if (pnow == ppre)                 break;             i++;             continue;         }          ppre = ppre->next;         pnow = pnow->next;          if (2000 == i)             i = 1;         else             i++;     }     printf ("pnow->mynum = %d\n", pnow->mynum);     *num = pnow->mynum;      free (p);     return 0; }  int main(int argc, char **argv) {     int xx = 0;      if (0 != foo(1000, 7, &xx))         printf ("error!\n");     printf ("xx = %d\n", xx);      return 0; }  M = 10, N = 3; REMOVE 3, i = 3 REMOVE 6, i = 6 REMOVE 9, i = 9 REMOVE 2, i = 12 REMOVE 4, i = 13 REMOVE 7, i = 15 REMOVE 1, i = 18 REMOVE 10, i = 21 REMOVE 8, i = 23 xx = 5  M = 10, N = 7; REMOVE 7, i = 7 REMOVE 4, i = 14 REMOVE 8, i = 17 REMOVE 2, i = 21 REMOVE 1, i = 27 REMOVE 3, i = 28 REMOVE 9, i = 35 REMOVE 5, i = 37 REMOVE 6, i = 42 xx = 10  M = 20, N = 7; REMOVE 7, i = 7 REMOVE 14, i = 14 REMOVE 17, i = 17 REMOVE 1, i = 21 REMOVE 8, i = 27 REMOVE 9, i = 28 REMOVE 18, i = 35 REMOVE 20, i = 37 REMOVE 6, i = 42 REMOVE 15, i = 47 REMOVE 19, i = 49 REMOVE 12, i = 56 REMOVE 13, i = 57 REMOVE 10, i = 63 REMOVE 3, i = 67 REMOVE 11, i = 70 REMOVE 4, i = 77 REMOVE 5, i = 84 REMOVE 16, i = 87 xx = 2  用了个环链，顺序思路。  学习更好的方法留着慢慢看

引用 3 楼 zxh707wk 的回复:代码： #include <stdio.h> #include <malloc.h>  int fun(int sum,int n) { 	int* num=(int*)malloc(sizeof(int)*sum); 	int i; 	int j=sum; 	int m=0; 	for(i=0;j>1;i++) 	{ 		if(i>=sum)i=0; 		if(num[i]==0)m++; 		if(m==n) 		{ 			num[i]=1; 			m=0; 			j--; 		} 	} 	for(i=0;i<sum;i++) 	{ 		if(num[i]==0) 		{ 			free(num); 			return i+1; 		} 	} 	free(num); 	return -1; }  int main() { 	printf("%d\n",fun(5,3)); 	return 0; } 你的窝运行得不出结果。。你测试了吗？我想问问为什么我的代码得不到结果。。。

引用 6 楼 wander0001 的回复:[quote=引用 3 楼 zxh707wk 的回复:] 代码： #include <stdio.h> #include <malloc.h>  int fun(int sum,int n) { 	int* num=(int*)malloc(sizeof(int)*sum); 	int i; 	int j=sum; 	int m=0; 	for(i=0;j>1;i++) 	{ 		if(i>=sum)i=0; 		if(num[i]==0)m++; 		if(m==n) 		{ 			num[i]=1; 			m=0; 			j--; 		} 	} 	for(i=0;i<sum;i++) 	{ 		if(num[i]==0) 		{ 			free(num); 			return i+1; 		} 	} 	free(num); 	return -1; }  int main() { 	printf("%d\n",fun(5,3)); 	return 0; } 你的窝运行得不出结果。。你测试了吗？我想问问为什么我的代码得不到结果。。。[/quote] 哪没结果了？  没加getchar();而已

有一种简单做法： # include <iostream> using namespace std;  int main() { 	int i, s = 0; 	int M, N;  	cout << "input the number M and N:" << endl; 	cin >> M >> N;  	for (i = 2; i <= M; i++) 	{ 		s = (s + N) % i; 	}  	cout << "the number is:" << s + 1 << endl; } 数学推导的过程就不在这里写了

简单的问题要这么复杂吗。。。

题目如下 M 个人围成一圈报数，数到 N （ 1<N<10 ）的倍数或包含 N 这个数字时出圈，问剩下的最后 一个人在原来的位置是多少？   报数规则：    1 、从第一个人开始报数为 1 ，下一个人报数为上一个人报数加 1   2 、报数的最大值为 2000 ，如果报数超过 2000 ，则下一个人重新从 1 开始报数   要求实现函数    int OutFunc (unsigned int iTotalNum, unsigned int iKey)   【输入】 iTotalNum ：   开始报数前的总人数 , 0<iTotalNum<65535                  iKey ：             题目中要求的数目 N  【输出】无    【返回】剩下的人的原来的位置   示例    输入： iTotalNum =5,    iKey =3  返回： 4     输入： iTotalNum =15,    iKey =3  返回： 10


Question: [SWU]关于文件打包程序的疑惑

为什么不用winrar生成自解压文件呢？


Question: 再次向大家请教全局变量的问题

定义成类吧. 对修改的函数设置保护以上的权限 而读取函数则是公有函数.  这样的话, 只需要把你指定的模块设置成 友元类,  (友元类是可以访问保护或者私有类型的)  这样就可以达到指定类可读写,   其它类只读

回复于： 2014-05-09 22:55:27  其他模块通过函数接口读取，不允许直接访问。    我也试过用函数接口的形式来读取，可是其他地方用的实在太多，都用函数的话会很繁琐

当然是封装读写函数啊。 可以说，永远别搞出非static的全局变量啊。

其他模块通过函数接口读取，不允许直接访问。

除非重新设计，没有必要这么做

引用 2 楼 zhao4zhong1 的回复:只要多用grep或findstr管理源代码即可。  Windows下的grep http://download.csdn.net/detail/zhao4zhong1/4381913  C:\>findstr /? 在文件中寻找字符串。  FINDSTR [/B] [/E] [/L] [/R] [/S] [/I] [/X] [/V] [/N] [/M] [/O] [/F:file]         [/C:string] [/G:file] [/D:dir list] [/A:color attributes] [/OFF[LINE]]         strings [[drive:][path]filename[ ...]]    /B         在一行的开始配对模式。   /E         在一行的结尾配对模式。   /L         按字使用搜索字符串。   /R         将搜索字符串作为一般表达式使用。   /S         在当前目录和所有子目录中搜索匹配文件。   /I         指定搜索不分大小写。   /X         打印完全匹配的行。   /V         只打印不包含匹配的行。   /N         在匹配的每行前打印行数。   /M         如果文件含有匹配项，只打印其文件名。   /O         在每个匹配行前打印字符偏移量。   /P         忽略有不可打印字符的文件。   /OFF[LINE] 不跳过带有脱机属性集的文件。   /A:attr    指定有十六进位数字的颜色属性。请见 "color /?"   /F:file    从指定文件读文件列表 (/ 代表控制台)。   /C:string  使用指定字符串作为文字搜索字符串。   /G:file    从指定的文件获得搜索字符串。 (/ 代表控制台)。   /D:dir     查找以分号为分隔符的目录列表   strings    要查找的文字。   [drive:][path]filename              指定要查找的文件。  除非参数有 /C 前缀，请使用空格隔开搜索字符串。 例如: 'FINDSTR "hello there" x.y' 在文件 x.y 中寻找 "hello" 或 "there"。'FINDSTR /C:"hello there" x.y' 文件 x.y  寻找 "hello there"。  一般表达式的快速参考:   .        通配符: 任何字符   *        重复: 以前字符或类别出现零或零以上次数   ^        行位置: 行的开始   $        行位置: 行的终点   [class]  字符类别: 任何在字符集中的字符   [^class] 补字符类别: 任何不在字符集中的字符   [x-y]    范围: 在指定范围内的任何字符   \x       Escape: 元字符 x 的文字用法   \<xyz    字位置: 字的开始   xyz\>    字位置: 字的结束  有关 FINDSTR 常见表达法的详细情况，请见联机命令参考。  请牢记：源代码本身的书写是否结构化或面向对象或符合设计模式或敏捷…并不重要，重要的是你是否使用结构化或面向对象或符合设计模式或敏捷…的方法命名标识符、阅读、修改、检查、测试源代码。

说明设计有问题。

C++似乎没这种语法

只要多用grep或findstr管理源代码即可。

读写锁可以试试


Question: 菜鸟求助

赋值前内存： 0x003EF77C  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................ 0x003EF78C  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................ 0x003EF79C  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................ 0x003EF7AC  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................ 0x003EF7BC  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................ 0x003EF7CC  cc cc cc cc 7f ee 0f 80 20 f8 3e 00 cb d0 0f 01  ????.?.€ ?>.??..  复制后内存： 0x003EF77C  31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31  1111111111111111 0x003EF78C  31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31  1111111111111111 0x003EF79C  31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31  1111111111111111 0x003EF7AC  31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31  1111111111111111 0x003EF7BC  31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31  1111111111111111 0x003EF7CC  00 cc cc cc 7f ee 0f 80 20 f8 3e 00 cb d0 0f 01  .???.?.€ ?>.??..  越界将0x003EF7CC修改了，而0x003EF7CC不属于data的内存

首先我调试时，如下图  已经跳出循环  其次，你这段代码越界了 如： memset时 0x0036FB24  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................................ 0x0036FB44  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................................ 0x0036FB64  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 cc cc cc cc 05 5b e8 e8 c8 fb 36 00 cb d0 20 01  ................????.[????6.?? .

原来是这样！脑子糊涂了。 谢谢！  引用 1 楼 turingo 的回复:原因在于字符串需要多存储一个结束符'\0'，所以5位数字的话，实际上需要6个字符空间，应该改为： char data[16][6];  [quote=引用 楼主 u013892219 的回复:]  main() {     char data[16][5];     memset(data,0,sizeof(data));     int a = 11111,i;     for(i=0;i<16;i++)         sprintf(data[i],"%d",a);     printf("%s\n",data); }  这段代码为什么跳不出循环，求高手帮助！[/quote]

至于为什么跳不出循环，参考下面：  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步对应汇编一行！  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）

char data[16][5+1];

原因在于字符串需要多存储一个结束符'\0'，所以5位数字的话，实际上需要6个字符空间，应该改为： char data[16][6];  引用 楼主 u013892219 的回复: main() {     char data[16][5];     memset(data,0,sizeof(data));     int a = 11111,i;     for(i=0;i<16;i++)         sprintf(data[i],"%d",a);     printf("%s\n",data); }  这段代码为什么跳不出循环，求高手帮助！


Question: 请问为何声明数组后，函数调用时未初始化的变量为0，而不是一个不确定数了

我再更正一下，我认为定义一个大的数组，是为了把局部变量给分配到更后面的空间，应该说是挤到，我猜测后面空间里都被默认成了0，于是乎变量i就被不确定成0了。

我更换了一台笔记本 debian7的系统，上面两个源程序测试的结果有点儿差别，第一个程序的第一个i仍然是不确定数，只不过无论执行多少次，这个数不变，说明每次执行都在读取一个块；第二个加入数组的程序，数组的长度要加大，我测试了一下test[100]的时候，i就等于0了，所以我认为i仍然是不确定数，但是由于它每次运行的时候都划定了一个相对固定的范围，且这个范围在数组的区间里，而定义数组的结果就是将一个大范围都给初始成0了，导致i成为了一个“确定数”。  上面的兄弟提供的源码我测试了一下，两次i的结果相同，故判断，第一个函数释放以后，第二个函数重新占用了这个空间的相同位置，导致两次结果相同，不知以上这些想法对不对，大家拍砖！！

同意7楼，赶巧的事。你换台机器试试  你再试试下面的代码  void func1() {     int i = 0;     printf("%d",i); } void func2() {     int i;     printf("%d",i); } int main() {     func1();     func2();     return 0; }

赶巧的事情，遇到一块值为0的内存块

原因就是没初始化 值是不确定 而不是 没初始化 值确定不为0  这区别能分清楚吗?

[quote=引用 4 楼 turingo 的回复:] 对局部数组没有初始化的元素的值,多数编译器都将其设置为0.但是如果不对数组进行初始化,即在定义的同时没有用列表初始化,那么局部数组的值就取决于编译器而对程序员来说就是不可预料的了.所以对局部数组的初始化要特别小心.但是全局的数组和静态数组还是会被正确的赋于0值的.  实际上我的确也只是仅仅定义了一个数组而已，结果函数中的变量变成了一个确定的0；而不是像您说的还要初始化数组才行；而如果源代码中没有数组，则函数中未初始化的变量又变成了不确定的值。 我使用的是gcc编译

对局部数组没有初始化的元素的值,多数编译器都将其设置为0.但是如果不对数组进行初始化,即在定义的同时没有用列表初始化,那么局部数组的值就取决于编译器而对程序员来说就是不可预料的了.所以对局部数组的初始化要特别小心.但是全局的数组和静态数组还是会被正确的赋于0值的.  引用 3 楼 wtwhs1985 的回复:[quote=引用 2 楼 turingo 的回复:] 初始化值不能寄希望于编译器，最好自己手动去初始化。  上面的兄弟可能不知道我问这个的目的，我想问的是C规定未初始化的变量会赋予一个不确定的值。但是为什么定义了一个数组后，那个不确定的值却恒定为0了，这个才是我疑惑的问题。

初始化值不能寄希望于编译器，最好自己手动去初始化。  引用 楼主 wtwhs1985 的回复:为了测试，我自己单独写了一段，结果发现i 的确是一个不确定的值,这个我能理解因为变量没有初始化。 1 #include <stdio.h> 2  3 void print_i(void) 4 { 5 int i; 6 printf("i = %d\n", i); 7 i = 777; 8 } 9  10 int main(void) 11 { 12 print_i(); 13 print_i(); 14  15 return 0; 16 }  但是修改加入了数组的声明后，却没有初始化的变量却为0了： 修改后的源码： 1 #include <stdio.h> 2  3 void print_i(void) 4 { 5 int i; 6 printf("i = %d\n", i); 7 i = 777; 8 } 9  10 int main(void) 11 { 12 int test[9]; 13 print_i(); 14 print_i(); 15  16 return 0; 17 }   运行后的结果 [root@studylinux studyC]# ./a.out  i = 0 i = 777 如果没有定义数组，或者定义的数组长度小于9，那么第一个i将是一个不确定数。

生成Release版再试试。


Question: C语言新手，时间显示问题

楼上的全是一家的吧，统一的头像！不闹了...

楼主 完全自high啊 打印格式自己定嘛

全角－可以上一点，但是比半角的要长了点，还是不行

引用 2 楼 aa573915483 的回复:还有个问题怎么把 - 显示上一点  我的怎么显示下面了 这还要美观？那用图片吧

还有个问题怎么把 - 显示上一点  我的怎么显示下面了

{"%04d-%02d-%02d  %02d:%02d","系 统 时 间"},  网上找了一下，OK 搞定

楼主这是在自娱自乐么。。。。

#include <stdio.h> #include <string.h> #include <time.h> #include <sys/timeb.h>  struct tm st; time_t tt; char mon[4]; char mn[12][4]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"}; int i; char timstr[27]; char tmpbuf[128]; struct _timeb tb; int tz; char c;  void main() {     strcpy(timstr,"08/Dec/2011:15:25:03 +0800");     sscanf(timstr,"%2d/%3s/%4d:%2d:%2d:%2d",&st.tm_mday,mon,&st.tm_year,&st.tm_hour,&st.tm_min,&st.tm_sec);     for (i=0;i<12;i++) if (0==stricmp(mn[i],mon)) {st.tm_mon=i; break;}     st.tm_year-=1900;     tt=mktime(&st);     if (-1!=tt) {         strftime(tmpbuf,128,"%Y-%m-%d %H:%M:%S\n",localtime(&tt));         printf(tmpbuf);//2011-12-08 15:25:03     } else {         printf("[%s] is Invalid time string!\n",timstr);     }      _ftime(&tb);     strftime(tmpbuf,128,"%m/%b/%Y:%H:%M:%S",localtime(&tb.time));     tz=-tb.timezone;     c=(tz>0)?'+':'-';     tz=(tz>0)?tz:-tz;     sprintf(tmpbuf,"%s %c%02d%02d\n",tmpbuf,c,tz/60,tz%60);     printf(tmpbuf);//12/Dec/2011:17:36:41 +0800 }


Question: c语言动态内存分配 请大神指点啊

引用 14 楼 sadadi 的回复:[quote=引用 10 楼 a515360208 的回复:] [quote=引用 7 楼 sadadi 的回复:] NOED 是变量 Node 才是类型 呵呵，没看见typedef吗，NODE已经是一个类型了，Node是结构标记[/quote] 失误 [/quote] 用错表情了

引用 10 楼 a515360208 的回复:[quote=引用 7 楼 sadadi 的回复:] NOED 是变量 Node 才是类型 呵呵，没看见typedef吗，NODE已经是一个类型了，Node是结构标记[/quote] 失误

#include<stdio.h> #include<malloc.h> #include<stdlib.h> typedef struct Node { int data;// 数据域 struct Node*pNext;//指针域 }NODE ,*PNODE; void main() { PNODE  create_list(); void traverse_list(PNODE phead); PNODE phead=NULL; phead =create_list();//create_list()功能：创建一个非循环单链表，并将该链表的头结点的地址付给phead traverse_list(phead );//遍历数组 getchar (); } PNODE  create_list() { int len; int i; int val;//用来临时放用户结点的值 PNODE phead=(PNODE )malloc (sizeof (NODE));//分配了一个头指针 if(phead =NULL) { printf("内存分配失败，程序终止：\n"); exit(-1);  } PNODE ptail=phead ; ptail ->pNext=NULL ; printf("请输入你要生成的链表结点个数：len="); scanf ("%d",&len ); for (i=0;i<len;i++) { printf("请输入第%d个结点的值：",i-1); scanf ("%d",&val); PNODE pnew=(PNODE )malloc (sizeof (NODE )); if( pnew=NULL )  ////这不是判断是赋值 { printf ("分配失败，程序终止！\n"); exit (-1); } pnew ->data =val; ptail ->pNext =pnew ; pnew ->pNext =NULL ; ptail =pnew ; } return phead ; }

#include<stdio.h> #include<malloc.h> #include<stdlib.h> typedef struct Node { int data;// 数据域 struct Node*pNext;//指针域 }NODE ,*PNODE; void main() { PNODE  create_list(); void traverse_list(PNODE phead); PNODE phead=NULL; phead =create_list();//create_list()功能：创建一个非循环单链表，并将该链表的头结点的地址付给phead traverse_list(phead );//遍历数组 getchar (); } PNODE  create_list() { int len; int i; int val;//用来临时放用户结点的值 PNODE phead=(PNODE )malloc (sizeof (NODE));//分配了一个头指针 if(phead =NULL)  ///这不是判断是赋值 { printf("内存分配失败，程序终止：\n"); exit(-1);  } PNODE ptail=phead ; ptail ->pNext=NULL ; printf("请输入你要生成的链表结点个数：len="); scanf ("%d",&len ); for (i=0;i<len;i++) { printf("请输入第%d个结点的值：",i-1); scanf ("%d",&val); PNODE pnew=(PNODE )malloc (sizeof (NODE )); if( pnew=NULL ) { printf ("分配失败，程序终止！\n"); exit (-1); } pnew ->data =val; ptail ->pNext =pnew ; pnew ->pNext =NULL ; ptail =pnew ; } return phead ; }

谢谢各位啊，已经找到错误了

#include <stdio.h> #include<malloc.h>  typedef struct Node { 	int data;// 数据域 	struct Node*pNext;//指针域 }NODE ,*PNODE; int main() { 	PNODE phead=(PNODE )malloc (sizeof (NODE));//分配了一个头指针 	return 0; }

没问题啊 程序没问题

int main() { PNODE phead=(PNODE )malloc (sizeof (NODE));//分配了一个头指针 return 0; } 你写在主函数里面了没？

引用 7 楼 sadadi 的回复:NOED 是变量 Node 才是类型 呵呵，没看见typedef吗，NODE已经是一个类型了，Node是结构标记

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

去掉<malloc.h>试试

NOED 是变量 Node 才是类型

#include<stdio.h> #include<malloc.h> #include<stdlib.h> typedef struct Node { 	int data;// 数据域 	struct Node*pNext;//指针域 }NODE ,*PNODE; void main() { 	PNODE  create_list(); 	void traverse_list(PNODE phead); 	PNODE phead=NULL; 	phead =create_list();//create_list()功能：创建一个非循环单链表，并将该链表的头结点的地址付给phead 	traverse_list(phead );//遍历数组 	getchar (); } PNODE  create_list() { 	int len; 	int i; 	int val;//用来临时放用户结点的值 	PNODE phead=(PNODE )malloc (sizeof (NODE));//分配了一个头指针 	if(phead =NULL) 	{ 		printf("内存分配失败，程序终止：\n"); 		exit(-1);  	} 	PNODE ptail=phead ; 	ptail ->pNext=NULL ; 	printf("请输入你要生成的链表结点个数：len="); 	scanf ("%d",&len ); 	for (i=0;i<len;i++) 	{ 		printf("请输入第%d个结点的值：",i-1); 		scanf ("%d",&val); 		PNODE pnew=(PNODE )malloc (sizeof (NODE )); 		if( pnew=NULL ) 		{ 			printf ("分配失败，程序终止！\n"); 			exit (-1); 		} 		pnew ->data =val; 		ptail ->pNext =pnew ; 		pnew ->pNext =NULL ; 		ptail =pnew ; 	} 	return phead ; } 这是程序的代码，程序运行到“ptail ->pNext=NULL ”这里就终止了，显“0x01011473 处有未经处理的异常(在 ConsoleApplication1.exe 中): 0xC0000005: 写入位置 0x00000004 时发生访问冲突。”

我是用vs2012写的程序代码

在主函数里写了


Question: 字符串查找，在某字符串中查找指定字符串。如：有字符串:this is c program!  查找is。找到与否给出相应提示。至少使用一个自定义函数来实现。

C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\strstr.c /*** *strstr.c - search for one string inside another * *       Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *       defines strstr() - search for one string inside another * *******************************************************************************/  #include <cruntime.h> #include <string.h>  /*** *char *strstr(string1, string2) - search for string2 in string1 * *Purpose: *       finds the first occurrence of string2 in string1 * *Entry: *       char *string1 - string to search in *       char *string2 - string to search for * *Exit: *       returns a pointer to the first occurrence of string2 in *       string1, or NULL if string2 does not occur in string1 * *Uses: * *Exceptions: * *******************************************************************************/  char * __cdecl strstr (         const char * str1,         const char * str2         ) {         char *cp = (char *) str1;         char *s1, *s2;          if ( !*str2 )             return((char *)str1);          while (*cp)         {                 s1 = cp;                 s2 = (char *) str2;                  while ( *s1 && *s2 && !(*s1-*s2) )                         s1++, s2++;                  if (!*s2)                         return(cp);                  cp++;         }          return(NULL);  }

函数返回类型换成 char *

方法1  int search(char str1[],char str2[]) {      return strstr(str1, str2); }  方法2  int search(char str1[],char str2[]) {     int i;     for(i=0; i<strlen(str1); i++)     {         if(0==memcmp(&str1[i], str2, strlen(str2)))         {                 break;         }     }     return &str1[i]; }


Question: #define问题

问题解决了，谢谢大家！ 参考：http://www.cnblogs.com/morewindows/archive/2011/08/18/2144112.html 重点：宏遇#和##不会展开嵌套的宏，嵌套使用需中间转换。 fun.h文件 #define _fun1(name) fun1_##name #define _fun2(name) fun2_##name #define _fun3(name) fun3_##name #define fun1(name) _fun1(name) #define fun2(name) _fun2(name) #define fun3(name) _fun3(name) a.c文件 #define name a void fun1(name)() {}   =>   void fun1_a() {} void fun2(name)() {}   =>   void fun1_a() {} void fun3(name)() {}   =>   void fun1_a() {} b.c文件 #define name b void fun1(name)() {}   =>   void fun1_b() {} void fun2(name)() {}   =>   void fun1_b() {} void fun3(name)() {}   =>   void fun1_b() {}  当你的工程中有多个形同以上的文件，如此定义，增加类似文件时只需修改 #define name xxx 显然很方便简洁，而且不容易出错。

引用 12 楼 jerry_dqh 的回复:在一个头文件中 pre.h中定义好 #define fun1 fun_pre##_fun1 #define fun2 fun_pre##_fun2 #define fun3 fun_pre##_fun3  =============== main.cpp中如下使用  #define fun_pre  a  #include "pre.h"  void fun1() {} void fun2() {} void fun3() {}  这个是我要的想法，可惜依然行不通，fun_pre##_fun1的fun_pre并未作替换，所以 void fun1() {} void fun2() {} 展开是： void fun_pre_fun1() {} void fun_pre_fun1() {} 而非： void a_fun1() {} void a_fun1() {}

之前没见过这样定义的

进来学习学习~

定义常变量 如： int const a = 10;

#include <stdio.h> #define A1 \ enum {a1 = 1};  #define A2 \ enum {\ 	a1 = 1,\ 	a2 = 2\ };  #define A3 \ enum {\ 	a1 = 1,\ 	a2 = 2,\ 	a3 = 3\ };    #define A4 \ enum {\ 	a1 = 1,\ 	a2 = 2,\ 	a3 = 3,\ 	a4 = 4\ };  #define A5 \ enum {\ 	a1 = 1,\ 	a2 = 2,\ 	a3 = 3,\ 	a4 = 4,\ 	a5 = 5\ }; //.... 直到AXXX， 你满意为止  A4; int main(void) { 	printf("%u %u %u %u\n", a1, a2, a3, a4); 	return 0; }

代码生成器？试试Visual Assistant的定制功能。

可以使用##运算符，但比较少 # define a(n) i##n  int a(1), a(2), a(3); //相当于int i1, i2, i3;  # define fun(n) a_fun##n fun(1)();	//调用a_fun1 fun(2)();	//调用a_fun2 fun(3)();	//调用a_fun3 但你两个c文件都用同样的函数名，放一起会有问题的吧

进来学习学习~

可以用 ## 预编译运算符  不过重复定义，确实比较难、不如直接生成代码

引用 8 楼 bEst_02 的回复:void fun1() {     printf("2222222"); } #define AA(X) fun##X  void _tmain(int argc, _TCHAR* argv[]) {     AA(1)(); }   打印2222222 ++

头文件里加个ifdef不就行了


Question: 绝对值最小问题  求助！！！

1)先排序，顺便去重复。 2)找到最大负数，0，最小正数； 3.分别处理 3.1)有0 返回0； 3.2)无正数返回最大负数的绝对值的二倍 3.3)无负数返回最小正数的二倍 3.4)有正负数，无0，先求出正和最小，负和绝对值最小，作为当前最小        根据正负数个数，       用数量少的集合，去逐个元素，二分查找绝对值相近的数据。       找到后，相邻两个数中，和的绝对值最小值。      逐个比较，求和比较，      比当前最小小的，的作为新前最小，大的扔掉。

含有0，结果是0

纯粹正数最小值的二倍，就是最小的 纯粹负数绝对值最小的绝对值的二倍，就是最小的 有正有负 分割成正数集合，负数集合 正数最小的二倍， 负数绝对值最小的的绝对值的二倍， 以及正负数和绝对值最小值，三者的最小值就是最小的。 这可以多次用二分查找找到。

那个链接。。。挑战一直点不进去。。。

引用 17 楼 u013037061 的回复:[quote=引用 16 楼 Falleyes 的回复:] 感觉你的算法复杂度较高，是n^2，我这个用了sort函数，先排序，然后对每两个数之间进行相加比较，最后再和最小元素的2倍比较。楼主的代码结果错误，可能是某些细节没有处理好。 刚开始没有看清题意，非常抱歉。以下代码满足现有的测试数据测试。 #include<iostream> #include<climits> #include<cstdlib> #include<algorithm> using namespace std;  int compare(const int& a, const int& b){ 	int x = abs(a), y = abs(b); 	return x < y ? 1 : 0; }  int main(){ 	int n; 	while (cin >> n){ 		if (n == 0){ 			cout << '0' << endl; 			continue; 		} 		if (n == 1){ 			cin >> n; 			cout << n + n << endl; 			continue; 		}  		int result = INT_MAX; 		int* num = new int[n];  		for (int i = 0; i < n; ++i) 			cin >> num[i];  		sort(num, num + n, compare); 		for (int i = 0; i < n - 1; ++i){ 			if (abs(num[i] + num[i + 1]) < abs(result)) 				result = num[i] + num[i + 1]; 		}  		if (result>2 * num[0]) 			result = 2 * num[0]; 		cout << abs(result) << endl; 		delete[] num; 	} } 楼主可以拿这个代码先测试下。 这个代码是不行的啊，http://student.csdn.net/mcs/programming_challenges  这是链接，层主可以去试试，1   2   3结果应该是2啊，，[/quote] 是吗？！我在vs上面尝试，确实1 2 3是2啊！

引用 16 楼 Falleyes 的回复:感觉你的算法复杂度较高，是n^2，我这个用了sort函数，先排序，然后对每两个数之间进行相加比较，最后再和最小元素的2倍比较。楼主的代码结果错误，可能是某些细节没有处理好。 刚开始没有看清题意，非常抱歉。以下代码满足现有的测试数据测试。 #include<iostream> #include<climits> #include<cstdlib> #include<algorithm> using namespace std;  int compare(const int& a, const int& b){ 	int x = abs(a), y = abs(b); 	return x < y ? 1 : 0; }  int main(){ 	int n; 	while (cin >> n){ 		if (n == 0){ 			cout << '0' << endl; 			continue; 		} 		if (n == 1){ 			cin >> n; 			cout << n + n << endl; 			continue; 		}  		int result = INT_MAX; 		int* num = new int[n];  		for (int i = 0; i < n; ++i) 			cin >> num[i];  		sort(num, num + n, compare); 		for (int i = 0; i < n - 1; ++i){ 			if (abs(num[i] + num[i + 1]) < abs(result)) 				result = num[i] + num[i + 1]; 		}  		if (result>2 * num[0]) 			result = 2 * num[0]; 		cout << abs(result) << endl; 		delete[] num; 	} } 楼主可以拿这个代码先测试下。 这个代码是不行的啊，http://student.csdn.net/mcs/programming_challenges  这是链接，层主可以去试试，1   2   3结果应该是2啊，，

引用 10 楼 Falleyes 的回复:1.你的程序执行顺序是先输入一个元素个数的整形，然后输入n个整形来填充数组。 2.然后如此反复执行1，直到你输入n为Ctrl+Z结束数据输入和处理 3.输出处理后的数组数据  在输入n的时候只要1次Ctrl+Z就可以 这个程序为啥显示是挑战失败啊！！！

引用 11 楼 Falleyes 的回复:这是我测试的一组数据截图：  题目详情: 给你一个数组A[n],请你计算出ans=min(|A[i]+A[j]|)(0<=i,j<n). 例如：A={1， 4， -3}， 则： |A[0] + A[0]| = |1 + 1| = 2. |A[0] + A[1]| = |1 + 4| = 5. |A[0] + A[2]| = |1 + (-3)| = 2. |A[1] + A[1]| = |4 + 4| = 8. |A[1] + A[2]| = |4 + (-3)| = 1. |A[2] + A[2]| = |(-3) + (-3)| = 6. 所以ans=1. 输入描述： 有多组测数数据，每组数据有两行，第一行包含一个正整数n(0<n<=100000),第二行包含n个整数，分别表示A[0],A[1]，A[2],....,A[n-1]，（|A[i]|<2^30）。 输入以文件结束。 输出描述： 对于每组数据，输出相应的答案。   答题说明: 输入样例： 3 1 4 -3 1 2 3 -1 -2 -5 3 1 2 3 2 0 5 输出样例： 1 4 2 2 0

我给你写一个。。。

这个其实就是求最小两个元素的和的绝对值最小，你没必要对所有元素两两相加比较，你只要找出离0最近的两个元素就可以了。 就你的代码来说，根本没有达到题目要求啊，比如我测试截图上的，1，2，3，那么得出结果应该是3，你却得出2.

不贴代码版规何在？哈哈，只在在大牛心中！

这是我测试的一组数据截图：

引用 2 楼 boxmanstan 的回复:你是在死循环里做的，sleep（500）；试试 代码楼下，求指导！！！

引用 1 楼 Falleyes 的回复:是不是你机子慢，才导致Ctrl+Z无效？新手可以贴代码的 在楼下贴了代码，求指导！！

#include <iostream> #include <cmath> using namespace std; int main() { 	int a[100000],n,i,b,j,min,l=0; 	int c[1000]; 	while(cin>>n) 	{ 		for(i=0;i<n;i++) 			cin>>a[i];	 		min=abs(a[0]+a[0]); 		for(i=0;i<n;i++) 			for(j=i;j<n;j++) 			{ 				b=abs(a[i]+a[j]); 				if(min>b) 					min=b; 			} 		c[l++]=min; 	} 	for(i=0;i<l;i++) 	{ 		cout<<c[i]<<endl; 	} 	return 0; }

代码？  其实可以贴的

引用 楼主 u013037061 的回复:开始我先编了一个当只输入一组数据时可以正确输出的程序，之后加入了while循环直到输入ctrl+z时停止循环，但是在dos下输入ctrl+z时，总得重复输入几次ctrl+z，才能得到几次答案，新手看版规，貌似不准贴代码，求高手指导，ctrl+z的用法，一直很纠结这个问题，网上貌似类似问题很少啊  贴代码是程序员的基本权利，任何版规都不能剥夺

你是在死循环里做的，sleep（500）；试试


Question: 动态数列排序怎么输出不了结果？

引用 12 楼 ForestDB 的回复:对于这种问题，自己用debugger跟踪一遍最是有益。 好吧

对于这种问题，自己用debugger跟踪一遍最是有益。

大神来。。。啊

要不要改的这么销魂，我的问题你们都木有回答啊！？等等我缩进下。 #include <string.h> #include <stdio.h> #include <malloc.h> typedef int ElemType;  typedef struct node{ 	ElemType data; 	struct node *next; }LNode,*LinkList;   void insertList(LinkList *list,LinkList q,ElemType e) { 	LinkList p; 	p = (LinkList)malloc(sizeof(LNode)); 	p->data = e; 	if(!*list) { 		*list = p; 		p->next = NULL; 	} }  void Sort(LinkList q) { 	LNode *p = q; 	int t,i,j,k = 0; 	while(p) {k++;p=p->next;} 	p = q; 	for(i = 0 ; i<k-1 ; i++) 	{ 		for(j = 0 ; j<k-i-1 ; j++) 		{ 			if(p->data>p->next->data) 			{ 				t = p->data; 				p->data = p->next->data; 				p->next->data = t; 			} 			p = p->next; 		} 		p = q; 	} }  void Print(LinkList q) { 	while(q) 	{ 		printf("%d ",q->data); 		q = q->next; 	} } main() { 	ElemType e; 	LinkList l,q; 	l = NULL; 	q = NULL; 	scanf("%d",&e); 	insertList(&l,q,e); 	q = l;     scanf("%d",&e); 	while(e) 	{ 		insertList(&l,q,e); 		q = q->next; 		scanf("%d",&e); 	} 	Sort(l); 	Print(l); 	getchar(); }

艹蛋的代码。。。 改了一下： #include <string.h> #include <stdio.h> #include <malloc.h>  typedef struct node { 	int data; 	struct node *next; }LNode;  void Sort(LNode *q) { 	LNode *p = q; 	int t,i,j,k = 0; 	while(p)  	{ 		k++; 		p=p->next; 	} 	p = q; 	for(i = 0 ; i<k-1 ; i++) 	{ 		for(j = 0 ; j<k-i-1 ; j++) 		{ 			if(p->data>p->next->data) 			{ 				t = p->data; 				p->data = p->next->data; 				p->next->data = t; 			} 			p = p->next; 		} 		p = q; 	} }  void Print(LNode *head) { 	while(head!=NULL) 	{ 		printf("%d",head->data); 		head = head->next; 	} }  int main() { 	int e; 	LNode* head; 	LNode* p; 	LNode* q; 	head=p=(LNode*)malloc(sizeof(LNode)); 	scanf("%d",&e); 	p->data=e; 	while(e) 	{ 		scanf("%d",&e); 		if(e) 		{ 			q=p; 			p=(LNode*)malloc(sizeof(LNode)); 			p->data=e; 			q->next=p; 			p->next=NULL; 		} 	} 	Sort(head); 	Print(head); 	return 0; }  删除了插入函数 取消了int的宏定义

引用 6 楼 Symfund 的回复:你们解决问题的人，怎么能把人家的代码全盘替换掉了呢？这叫帮人家吗？ +1 这个很正常 lz贴的代码格式太乱，没有缩进 而且这么长的代码没多少人喜欢看的

看错了。。。。p和q太像了

p = (LinkList)malloc(sizeof(LNode));动态申请了，所以形参中应该用void insertList(LinkList *list,LinkList  *q,ElemType e)

引用 6 楼 Symfund 的回复:你们解决问题的人，怎么能把人家的代码全盘替换掉了呢？这叫帮人家吗？  赞一个~

你们解决问题的人，怎么能把人家的代码全盘替换掉了呢？这叫帮人家吗？

仅供参考： //假设带表头结点的单向链表头指针为head，试编写一个算法将值为5的结点插入到连接表的第k个结点前，删除第k个节点，并对该链表进行排序。 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> struct NODE {     int          data;     struct NODE *next; } H,*head,*p,*q,*s1,*s2,*s3,*s4,*s; int i,j,k,n,t,m; int main() {     srand(time(NULL));      //填写头节点数据     H.data=-1;     H.next=NULL;     head=&H;      //创建10个节点的单链表     p=head;     for (i=0;i<10;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) return 1;         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         p->next=q;         p=q;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将值为5的结点插入到单链表的第k个结点前     k=3;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) return 1;             q->data=5;             q->next=p->next;             p->next=q;             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //删除第k个节点     k=5;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=p->next;             if (q) {                 p->next=q->next;                 free(q);             }             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //从小到大排序     for (p=head;p!=NULL && p->next!=NULL;p=p->next) {         for (q=p->next;q!=NULL && q->next!=NULL;q=q->next) {             if (p->next->data > q->next->data) {                  //交换data //              printf("swap %02d %02d\n",p->next->data,q->next->data); //              t=p->next->data;p->next->data=q->next->data;q->next->data=t;                  //或者                  //交换next //              printf("swap %02d %02d\n",p->next->data,q->next->data);                 s1=p->next;                 s2=p->next->next;                 s3=q->next;                 s4=q->next->next;                  if (s2!=s3) {                      p->next=s3;                     s3->next=s2;                      q->next=s1;                     s1->next=s4;                 } else {                      p->next=s3;                     s3->next=s1;                            q=s3;                     s1->next=s4;                 }                  //输出整个单链表 //              s=head->next; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d->",s->data); //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将单链表中前 m 个结点和后 n 个结点进行互换,m+n为链表总长10     m=4;     n=6;     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m+1==k) {             q=p;         }         s=p;         p=p->next;     }     s1=head->next;     head->next=q->next;     s->next=s1;     q->next=NULL;      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //释放所有节点     p=head->next;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //18->94->58->17->27->20->43->57->75->78-> //18->94->05->58->17->27->20->43->57->75->78-> //18->94->05->58->27->20->43->57->75->78-> //05->18->20->27->43->57->58->75->78->94-> //43->57->58->75->78->94->05->18->20->27-> //

最后的getchar（）

LinkList作为参数的时候用指针吧，在调用的时候，传入这个LinkList的地址，即&LinkList


Question: 求一份将视频用h.264编码再打包成ts流发送的源码

我现在也遇到了，如果已解决，麻烦共享一下哈

我也在找，找到了吗？有的话帮发一份


Question: 新手求指教，为什么编写的红外避障程序只有一侧的轮子转，二另一侧不动。

万一插头或焊点接触不良或步进电机坏了呢？

程序这么长，没人愿意一句一句看啊。自己单步调试看看，用外用表量IO口是否输出，一个模块一个模块的找下去，最后才能发现，有时候但看程序是看不出来的，硬件也有可能有问题啊。

这个我以前玩过类似的。你先一个一个模块的测试。确定的最简单的功能正常


Question: fscanf(fp, "%*[^\"]%*c");   为什么读不走一个字符呢？

引用 3 楼 FancyMouse 的回复:%*[\"]需要至少匹配1个字符，然后才能继续。如果本身就已经没有[\"]的话scanf就直接失败退出了。换句话说这个是正则的+而不是* scanf毕竟是个简易正则，也别期待太多。 额，原来这样，3Q

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

引用 1 楼 user-3 的回复:[quote=引用 楼主 su_787910081 的回复:] fscanf(fp, "%*[^\"]%*c");   为什么读不走一个字符呢？  只能把两个分开，这是为什么呢？ 请大牛赐教！！！！int   fscanf(FILE*stream,  constchar*format,[argument...]); 不是需要3个参数吗？ fscanf(fp,"%d",&a);[/quote] %* 的意思是读取了丢弃。 所以就没有必要给第三个参数的意义了。

引用 楼主 su_787910081 的回复:fscanf(fp, "%*[^\"]%*c");   为什么读不走一个字符呢？  只能把两个分开，这是为什么呢？ 请大牛赐教！！！！int   fscanf(FILE*stream,  constchar*format,[argument...]); 不是需要3个参数吗？ fscanf(fp,"%d",&a);


Question: 求助一道C语言题目

用结构体实现 代码： #include <stdio.h> #define NUM 5  typedef struct node { 	char name[100]; 	int far; }DATA;  int main() { 	DATA head[NUM]; 	int i; 	for(i=0;i<NUM;i++) 	{ 		scanf("%s %d",head[i].name,&head[i].far); 	} 	for(i=0;i<NUM;i++) 	{ 		if(head[i].far<100) 		{ 			printf("%s\t%d\n",head[i].name,head[i].far); 		} 	} 	return 0; }

这个比较简单，楼主多试试总会成功的。

LZ还是自己多动手写代码啊，像这种简单的，LZ自己肯定可以完成的

lz还的好好的锻炼一下思维能力，这样的问题应该是没有任何难度的

#include <stdio.h> #include <string.h> void main(void) { 	char city[5][20]; 	int i,distance,j=0; 	char name[20]; 	for(i=0;i<5;i++) 	{ 		scanf("%d,%s",&distance,name); 		if(distance < 100) 		{ 			strcpy(city[j],name); 			j++; 		} 	} 	for(i=0;i<j;i++) 	{ 		printf("%s\n",city[i]); 	}  }


Question: LIBCD.lib(crt0.obj) : error LNK2001: unresolved external symbol _main

对哦，貌似没有main函数了，我在改改，这个是在网上找的一个程序

你的main函数在哪里？


Question: strcpy()为什么返回指针呢

引用 9 楼 turingo 的回复:你说的没错，链式表达是很重要的一个原因，另外也可以直接判断成功和失败。  [quote=引用 8 楼 jack_leiwin 的回复:] [quote=引用 4 楼 turingo 的回复:]  NAME        strcpy, strncpy - copy a string  SYNOPSIS        #include <string.h>         char *strcpy(char *dest, const char *src);         char *strncpy(char *dest, const char *src, size_t n);  DESCRIPTION        The  strcpy()  function  copies the string pointed to by src, including        the terminating null byte ('\0'), to the buffer  pointed  to  by  dest.        The  strings  may  not overlap, and the destination string dest must be        large enough to receive the copy.         The strncpy() function is similar, except that at most n bytes  of  src        are  copied.  Warning: If there is no null byte among the first n bytes        of src, the string placed in dest will not be null-terminated.         If the length of src is less than n, strncpy() pads  the  remainder  of        dest with null bytes.         A simple implementation of strncpy() might be:             char *            strncpy(char *dest, const char *src, size_t n)            {                size_t i;                 for (i = 0; i < n && src[i] != '\0'; i++)                    dest[i] = src[i];                for ( ; i < n; i++)                    dest[i] = '\0';                 return dest;            }  RETURN VALUE        The  strcpy()  and strncpy() functions return a pointer to the destina‐        tion string dest.  CONFORMING TO        SVr4, 4.3BSD, C89, C99.  NOTES        Some programmers consider strncpy() to be inefficient and error  prone.        If  the  programmer knows (i.e., includes code to test!)  that the size        of dest is greater than the length of src, then strcpy() can be used.         If there is no terminating null byte in the first n characters of  src,        strncpy()  produces  an unterminated string in dest.  Programmers often        prevent this mistake by forcing termination as follows:             strncpy(buf, str, n);            if (n > 0)                buf[n - 1]= '\0';  BUGS        If the destination string of a strcpy() is not large enough, then  any‐        thing  might  happen.   Overflowing  fixed-length  string  buffers is a        favorite cracker technique for taking complete control of the  machine.        Any  time  a  program  reads  or copies data into a buffer, the program        first needs to check that there's enough space.  This may  be  unneces‐        sary  if you can show that overflow is impossible, but be careful: pro‐        grams can get changed over time, in ways that may make  the  impossible        possible.   [quote=引用 楼主 hou1056105902 的回复:] strcpy函数原型为char *strcpy(char *strDest, const char *strSrc); 为什么返回指针呢？还有我们平常用时像： strcpy(s1,s2); 根本也没返回值啊？？求解[/quote]   前辈，您好，strcpy这个返回值是面试过程中面试官问的一个问题，我自己在用这个函数的时候 也不会用这个函数的返回值，在网上查了一下说是为了链式表达，比如：int length = strlen( strcpy( strDest, “hello world”) )， 我想了想，这个理由有点强迁，前辈您觉得呢？[/quote][/quote]多谢！

你说的没错，链式表达是很重要的一个原因，另外也可以直接判断成功和失败。  引用 8 楼 jack_leiwin 的回复:[quote=引用 4 楼 turingo 的回复:]  NAME        strcpy, strncpy - copy a string  SYNOPSIS        #include <string.h>         char *strcpy(char *dest, const char *src);         char *strncpy(char *dest, const char *src, size_t n);  DESCRIPTION        The  strcpy()  function  copies the string pointed to by src, including        the terminating null byte ('\0'), to the buffer  pointed  to  by  dest.        The  strings  may  not overlap, and the destination string dest must be        large enough to receive the copy.         The strncpy() function is similar, except that at most n bytes  of  src        are  copied.  Warning: If there is no null byte among the first n bytes        of src, the string placed in dest will not be null-terminated.         If the length of src is less than n, strncpy() pads  the  remainder  of        dest with null bytes.         A simple implementation of strncpy() might be:             char *            strncpy(char *dest, const char *src, size_t n)            {                size_t i;                 for (i = 0; i < n && src[i] != '\0'; i++)                    dest[i] = src[i];                for ( ; i < n; i++)                    dest[i] = '\0';                 return dest;            }  RETURN VALUE        The  strcpy()  and strncpy() functions return a pointer to the destina‐        tion string dest.  CONFORMING TO        SVr4, 4.3BSD, C89, C99.  NOTES        Some programmers consider strncpy() to be inefficient and error  prone.        If  the  programmer knows (i.e., includes code to test!)  that the size        of dest is greater than the length of src, then strcpy() can be used.         If there is no terminating null byte in the first n characters of  src,        strncpy()  produces  an unterminated string in dest.  Programmers often        prevent this mistake by forcing termination as follows:             strncpy(buf, str, n);            if (n > 0)                buf[n - 1]= '\0';  BUGS        If the destination string of a strcpy() is not large enough, then  any‐        thing  might  happen.   Overflowing  fixed-length  string  buffers is a        favorite cracker technique for taking complete control of the  machine.        Any  time  a  program  reads  or copies data into a buffer, the program        first needs to check that there's enough space.  This may  be  unneces‐        sary  if you can show that overflow is impossible, but be careful: pro‐        grams can get changed over time, in ways that may make  the  impossible        possible.   [quote=引用 楼主 hou1056105902 的回复:] strcpy函数原型为char *strcpy(char *strDest, const char *strSrc); 为什么返回指针呢？还有我们平常用时像： strcpy(s1,s2); 根本也没返回值啊？？求解[/quote]   前辈，您好，strcpy这个返回值是面试过程中面试官问的一个问题，我自己在用这个函数的时候 也不会用这个函数的返回值，在网上查了一下说是为了链式表达，比如：int length = strlen( strcpy( strDest, “hello world”) )， 我想了想，这个理由有点强迁，前辈您觉得呢？[/quote]

引用 4 楼 turingo 的回复: NAME        strcpy, strncpy - copy a string  SYNOPSIS        #include <string.h>         char *strcpy(char *dest, const char *src);         char *strncpy(char *dest, const char *src, size_t n);  DESCRIPTION        The  strcpy()  function  copies the string pointed to by src, including        the terminating null byte ('\0'), to the buffer  pointed  to  by  dest.        The  strings  may  not overlap, and the destination string dest must be        large enough to receive the copy.         The strncpy() function is similar, except that at most n bytes  of  src        are  copied.  Warning: If there is no null byte among the first n bytes        of src, the string placed in dest will not be null-terminated.         If the length of src is less than n, strncpy() pads  the  remainder  of        dest with null bytes.         A simple implementation of strncpy() might be:             char *            strncpy(char *dest, const char *src, size_t n)            {                size_t i;                 for (i = 0; i < n && src[i] != '\0'; i++)                    dest[i] = src[i];                for ( ; i < n; i++)                    dest[i] = '\0';                 return dest;            }  RETURN VALUE        The  strcpy()  and strncpy() functions return a pointer to the destina‐        tion string dest.  CONFORMING TO        SVr4, 4.3BSD, C89, C99.  NOTES        Some programmers consider strncpy() to be inefficient and error  prone.        If  the  programmer knows (i.e., includes code to test!)  that the size        of dest is greater than the length of src, then strcpy() can be used.         If there is no terminating null byte in the first n characters of  src,        strncpy()  produces  an unterminated string in dest.  Programmers often        prevent this mistake by forcing termination as follows:             strncpy(buf, str, n);            if (n > 0)                buf[n - 1]= '\0';  BUGS        If the destination string of a strcpy() is not large enough, then  any‐        thing  might  happen.   Overflowing  fixed-length  string  buffers is a        favorite cracker technique for taking complete control of the  machine.        Any  time  a  program  reads  or copies data into a buffer, the program        first needs to check that there's enough space.  This may  be  unneces‐        sary  if you can show that overflow is impossible, but be careful: pro‐        grams can get changed over time, in ways that may make  the  impossible        possible.   [quote=引用 楼主 hou1056105902 的回复:] strcpy函数原型为char *strcpy(char *strDest, const char *strSrc); 为什么返回指针呢？还有我们平常用时像： strcpy(s1,s2); 根本也没返回值啊？？求解[/quote]   前辈，您好，strcpy这个返回值是面试过程中面试官问的一个问题，我自己在用这个函数的时候 也不会用这个函数的返回值，在网上查了一下说是为了链式表达，比如：int length = strlen( strcpy( strDest, “hello world”) )， 我想了想，这个理由有点强迁，前辈您觉得呢？

说实在的，要想学好编程，英语至少要看得懂的。  引用 6 楼 hou1056105902 的回复:[quote=引用 4 楼 turingo 的回复:]  NAME        strcpy, strncpy - copy a string  SYNOPSIS        #include <string.h>         char *strcpy(char *dest, const char *src);         char *strncpy(char *dest, const char *src, size_t n);  DESCRIPTION        The  strcpy()  function  copies the string pointed to by src, including        the terminating null byte ('\0'), to the buffer  pointed  to  by  dest.        The  strings  may  not overlap, and the destination string dest must be        large enough to receive the copy.         The strncpy() function is similar, except that at most n bytes  of  src        are  copied.  Warning: If there is no null byte among the first n bytes        of src, the string placed in dest will not be null-terminated.         If the length of src is less than n, strncpy() pads  the  remainder  of        dest with null bytes.         A simple implementation of strncpy() might be:             char *            strncpy(char *dest, const char *src, size_t n)            {                size_t i;                 for (i = 0; i < n && src[i] != '\0'; i++)                    dest[i] = src[i];                for ( ; i < n; i++)                    dest[i] = '\0';                 return dest;            }  RETURN VALUE        The  strcpy()  and strncpy() functions return a pointer to the destina‐        tion string dest.  CONFORMING TO        SVr4, 4.3BSD, C89, C99.  NOTES        Some programmers consider strncpy() to be inefficient and error  prone.        If  the  programmer knows (i.e., includes code to test!)  that the size        of dest is greater than the length of src, then strcpy() can be used.         If there is no terminating null byte in the first n characters of  src,        strncpy()  produces  an unterminated string in dest.  Programmers often        prevent this mistake by forcing termination as follows:             strncpy(buf, str, n);            if (n > 0)                buf[n - 1]= '\0';  BUGS        If the destination string of a strcpy() is not large enough, then  any‐        thing  might  happen.   Overflowing  fixed-length  string  buffers is a        favorite cracker technique for taking complete control of the  machine.        Any  time  a  program  reads  or copies data into a buffer, the program        first needs to check that there's enough space.  This may  be  unneces‐        sary  if you can show that overflow is impossible, but be careful: pro‐        grams can get changed over time, in ways that may make  the  impossible        possible.   [quote=引用 楼主 hou1056105902 的回复:] strcpy函数原型为char *strcpy(char *strDest, const char *strSrc); 为什么返回指针呢？还有我们平常用时像： strcpy(s1,s2); 根本也没返回值啊？？求解[/quote]   4楼的看不懂啊[/quote]

引用 4 楼 turingo 的回复: NAME        strcpy, strncpy - copy a string  SYNOPSIS        #include <string.h>         char *strcpy(char *dest, const char *src);         char *strncpy(char *dest, const char *src, size_t n);  DESCRIPTION        The  strcpy()  function  copies the string pointed to by src, including        the terminating null byte ('\0'), to the buffer  pointed  to  by  dest.        The  strings  may  not overlap, and the destination string dest must be        large enough to receive the copy.         The strncpy() function is similar, except that at most n bytes  of  src        are  copied.  Warning: If there is no null byte among the first n bytes        of src, the string placed in dest will not be null-terminated.         If the length of src is less than n, strncpy() pads  the  remainder  of        dest with null bytes.         A simple implementation of strncpy() might be:             char *            strncpy(char *dest, const char *src, size_t n)            {                size_t i;                 for (i = 0; i < n && src[i] != '\0'; i++)                    dest[i] = src[i];                for ( ; i < n; i++)                    dest[i] = '\0';                 return dest;            }  RETURN VALUE        The  strcpy()  and strncpy() functions return a pointer to the destina‐        tion string dest.  CONFORMING TO        SVr4, 4.3BSD, C89, C99.  NOTES        Some programmers consider strncpy() to be inefficient and error  prone.        If  the  programmer knows (i.e., includes code to test!)  that the size        of dest is greater than the length of src, then strcpy() can be used.         If there is no terminating null byte in the first n characters of  src,        strncpy()  produces  an unterminated string in dest.  Programmers often        prevent this mistake by forcing termination as follows:             strncpy(buf, str, n);            if (n > 0)                buf[n - 1]= '\0';  BUGS        If the destination string of a strcpy() is not large enough, then  any‐        thing  might  happen.   Overflowing  fixed-length  string  buffers is a        favorite cracker technique for taking complete control of the  machine.        Any  time  a  program  reads  or copies data into a buffer, the program        first needs to check that there's enough space.  This may  be  unneces‐        sary  if you can show that overflow is impossible, but be careful: pro‐        grams can get changed over time, in ways that may make  the  impossible        possible.   [quote=引用 楼主 hou1056105902 的回复:] strcpy函数原型为char *strcpy(char *strDest, const char *strSrc); 为什么返回指针呢？还有我们平常用时像： strcpy(s1,s2); 根本也没返回值啊？？求解[/quote]   4楼的看不懂啊

谁说没有返回值。。。。。。。。。 只是你没有用变量去接收而已，strcpy返回拷贝后的目标字符串。

NAME        strcpy, strncpy - copy a string  SYNOPSIS        #include <string.h>         char *strcpy(char *dest, const char *src);         char *strncpy(char *dest, const char *src, size_t n);  DESCRIPTION        The  strcpy()  function  copies the string pointed to by src, including        the terminating null byte ('\0'), to the buffer  pointed  to  by  dest.        The  strings  may  not overlap, and the destination string dest must be        large enough to receive the copy.         The strncpy() function is similar, except that at most n bytes  of  src        are  copied.  Warning: If there is no null byte among the first n bytes        of src, the string placed in dest will not be null-terminated.         If the length of src is less than n, strncpy() pads  the  remainder  of        dest with null bytes.         A simple implementation of strncpy() might be:             char *            strncpy(char *dest, const char *src, size_t n)            {                size_t i;                 for (i = 0; i < n && src[i] != '\0'; i++)                    dest[i] = src[i];                for ( ; i < n; i++)                    dest[i] = '\0';                 return dest;            }  RETURN VALUE        The  strcpy()  and strncpy() functions return a pointer to the destina‐        tion string dest.  CONFORMING TO        SVr4, 4.3BSD, C89, C99.  NOTES        Some programmers consider strncpy() to be inefficient and error  prone.        If  the  programmer knows (i.e., includes code to test!)  that the size        of dest is greater than the length of src, then strcpy() can be used.         If there is no terminating null byte in the first n characters of  src,        strncpy()  produces  an unterminated string in dest.  Programmers often        prevent this mistake by forcing termination as follows:             strncpy(buf, str, n);            if (n > 0)                buf[n - 1]= '\0';  BUGS        If the destination string of a strcpy() is not large enough, then  any‐        thing  might  happen.   Overflowing  fixed-length  string  buffers is a        favorite cracker technique for taking complete control of the  machine.        Any  time  a  program  reads  or copies data into a buffer, the program        first needs to check that there's enough space.  This may  be  unneces‐        sary  if you can show that overflow is impossible, but be careful: pro‐        grams can get changed over time, in ways that may make  the  impossible        possible.  引用 楼主 hou1056105902 的回复:strcpy函数原型为char *strcpy(char *strDest, const char *strSrc); 为什么返回指针呢？还有我们平常用时像： strcpy(s1,s2); 根本也没返回值啊？？求解

还有一点，不是没有返回值，只是你没有用对应的变量去接受罢了， 一个函数有没有返回值，你都可以去调用它，但需不需要返回值就要看你自己怎么操作了， 对于strcpy的返回值就是你传进去给strDest的地址，你不去接受完全没有问题

有返回值就可以一次复制任意个字符串，看你怎么用了， # include <stdio.h> # include <stdlib.h> # include <string.h>  int main() { 	char str[] = "hello";  	char str1[10], str2[10];  	strcpy(str1, strcpy(str2, str));  	return 0; }

这样你就可以 strcpy(s3,strcpy(s1,s2)); 貌似我举得例子不太恰当，但就是这个意思


Question: 函数指针问题

#include <stdio.h> #include <string.h> #include <stdlib.h>  int add(int, int); int red(int, int); int mult(int, int); int divi(int, int); void linecut(void);   int usefunc(int (*ops)(int,int), int, int);  //声明调用函数指针的主调函数  int main(void) { 	int a, b, res; 	char ch; 	int (* ops)(int, int);   //声明函数指针，包括类型，参数 	 	puts("Enter one of the following:"); 	printf("%4c%4c%4c%4c%4c\n", '+', '-', '*', '/', 'q'); 	while((ch = getchar()) != 'q') 	{ 		switch(ch) 		{ 			case '+': 				ops = add;         //将函数地址（函数名代表其地址）赋给函数指针 				break; 			case '-': 				ops = red; 				break; 			case '*': 				ops = mult; 				break; 			case '/': 				ops = divi; 				break; 			default: 				puts("No such operation. Enter again:"); 				linecut(); 				continue; 		} 		linecut(); 		puts("Now enter two integers:"); 		scanf("%d%d", &a, &b); 		res = usefunc(ops, a, b); 		printf("The result of %d %c %d is %d\n",                  a, ch, b, res); 		puts("Enter one of the following:"); 		printf("%4c%4c%4c%4c%4c\n", '+', '-', '*', '/', 'q'); 		linecut(); 	} }  void linecut(void) { 	while(getchar() != '\n')   //去除getchar()和scanf()所留下的回车换行 		continue; }  int add(int x, int y) { 	return (x + y); }  int red(int x, int y) { 	return (x - y); }  int mult(int x, int y) { 	return x * y; }  int divi(int x, int y) { 	if(0 == y) 	{ 		puts("Error: dividing by zero."); 		exit(EXIT_FAILURE); 	} 	else 		return x/y; }  int usefunc(int (*ops)(int, int), int a, int b)   //主调函数定义 { 	return  ops(a, b); }


Question: 遍历文件的算法，有没有大神可以优化一下的

推荐楼主阅读《Unix编程艺术》

system("dir /b /a-d c:\\*.* >d:\\allfiles.txt"); //读文件d:\\allfiles.txt的内容即C:\\下所有文件的名字 system("dir /b /a-d /s c:\\*.* >d:\\allfilesinsub.txt"); //读文件d:\\allfilesinsub.txt的内容即C:\\下所有文件的名字包含子目录 system("dir /b /ad  c:\\*.* >d:\\alldirs.txt"); //读文件d:\\alldirs.txt的内容即C:\\下所有子目录的名字 请记住，能用shell命令获取文件、文件夹信息或者操作文件、文件夹最好用shell命令获取或者操作，而不要用各种API获取或者操作，因为当遇到非法文件夹名或非法文件名或非法文件长度、非法文件日期、压缩文件、链接文件、稀疏文件……等各种意料之外的情况时，API会处理的不全面或陷入死循环，而shell命令不会。  如果嫌system弹出cmd窗口难看的话，改用WinExec("...",SW_HIDE);

引用 5 楼 xy505188 的回复:[quote=引用 2 楼 anonymalias 的回复:]  void  filesearch(char newpath[_MAX_PATH],   vector<ff> &v) { } 多谢大神指点[/quote] 这个问题不能说是大神，，，大神是不可以乱叫的

引用 2 楼 anonymalias 的回复: void  filesearch(char newpath[_MAX_PATH],   vector<ff> &v) { } 多谢大神指点

引用 3 楼 user-3 的回复:  #include <vector> #include <algorithm> #include <stdio.h> #include <io.h> #include <iostream> #include <stdlib.h> using namespace std;  typedef struct { 	char p[_MAX_PATH];  ///完整路径 	char n[_MAX_FNAME];  ///文件名 }ff;   void filesearch(char newpath[_MAX_PATH]/*in*/, vector<ff>& fvec ) { 	struct _finddata_t fd; 	int handle, done = 0; 	char path[_MAX_PATH]; 	strcpy_s(path,_MAX_PATH, newpath); 	strcat_s(path,_MAX_PATH, "\\*.*"); 	if (!(handle = _findfirst(path, &fd))) 	{ 		fvec.clear(); 		return; 	}  	while (!(done = _findnext(handle, &fd))) 	{ 		if (strcmp(fd.name, ".") == 0 || strcmp(fd.name, "..") == 0) 		{ 			continue; 		} 		if (fd.attrib == _A_SUBDIR) 		{ 			char t[_MAX_PATH]; 			strcpy_s(t,_MAX_PATH, newpath); 			strcat_s(t, _MAX_PATH,  "\\"); 			strcat_s(t, _MAX_PATH, fd.name); 			filesearch(t, fvec); 			continue; 		} 		else 		{ 			ff f; 			char t[_MAX_PATH]; 			strcpy_s(t, newpath); 			strcat_s(t, "\\"); 			strcat_s(t, fd.name); 			strcpy_s(f.p, t); 			strcpy_s(f.n, fd.name); 			fvec.push_back(f); 		} 	} 	_findclose(handle); }    int main() { 	vector<ff> fvec; 	FILE *in;  	fopen_s(&in, "1.txt", "w"); 	filesearch("f:\\my_proj", fvec); 	for (vector<ff>::size_type i = 0; i < fvec.size(); i++) 	{ 		fprintf(in, "%s\n", fvec[i].p); 	} 	fclose(in); 	system("start 1.txt");  } 谢谢大神点拨，同时更深入理解了vector的原理

look一下


Question: 大家帮帮忙!!!

谢谢大家,一个是数组字符串赋值问题 一个是大数组问题 都解决了 感谢大家结

strcpy ...

谢谢以上三位大侠,,问题又来了:编译通过了,运行出错,内存不足? #include <stdio.h> #include <string.h> int main() { char a[1000001][7]; int i;   FILE *fp1;      fp1=fopen("c:\\Documents and Settings\\Administrator\\桌面\\ltm_tdx9.txt","w"); //winxp;    for(i=1;i<1000000;i++) {	sprintf(&a[i][0], "%06d", i); 	sprintf(&a[i][6], "%06s", "\0");        fprintf(fp1,"a[%d]=%s\n",i,a[i]);	 }  fclose(fp1); }

int sprintf( char *str, const char * format,.........); sprintf()会根据参数format字符串来转换并格式化数据，然后将结果复制到参数str所指的字符串数组，直到出现字符串结束(\0)为止 	char s[6]; 	int a = 12345; 	sprintf(s, "%d", a);   //s="12345"

1、字符串还需要一个结束符'\0'，因此需要char a[1000000][7]多一个空间； 2、用sprintf(&a[i][0], "%06d", i)进行字符串赋值。  引用 楼主 litaiming 的回复:我想用循环语句给一个数组作为字符串赋值,怎样做?各大侠帮帮忙! char a[1000000][6]; 得到: char a[1][]=000001 char a[2][]=000002 .... char a[999999][]=999999 程序: #include <stdio.h> #include <string.h>  main() {char a[1000000][6]; int i;  for(i=1;i<1000000;i++) { ...	 }  }

sprintf(a[i], "%06d", i);


Question: Borland C++ 31linker error： bad object file record in module C:\bc\lib\cs.lib

没有办法，DOS下用的。。。

求助各位大神，看下什么问题

楼主能不能换个岁数比自己年轻一点的编译器？

求助  怎么回事。。。


Question: free(p)弹出错误的对话框,求高手帮忙

参考一下吧： //将c:\\tmp文件夹下的所有文件的内容全部放到用malloc分配的内存中 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <io.h> struct FB {     char fn[256];     size_t fl;     char *b;     struct FB *next;     struct FB *prev; } *fh,*fb,*ft; char ln[256]; char fpn[256]; FILE *af; FILE *f; int L,n; int main() {     system("dir /b /a-d c:\\tmp\\*.* >c:\\allfn.txt");     af=fopen("c:\\allfn.txt","r");     if (NULL==af) {         printf("Can not open file c:\\allfn.txt!\n");         return 1;     }     fh=NULL;     fb=NULL;     n=0;     while (1) {         if (NULL==fgets(ln,256,af)) break;         L=strlen(ln);         if ('\n'==ln[L-1]) ln[L-1]=0;         printf("read %s\n",ln);         strcpy(fpn,"c:\\tmp\\");         strcat(fpn,ln);         ft=(struct FB *)malloc(sizeof(struct FB));         if (NULL==ft) {             printf("Can not malloc ft!\n");             fclose(af);             return 2;//之前的malloc在main退出后由操作系统自动free         }         printf("ft[%d]==%p\n",n,ft);         strcpy(ft->fn,fpn);         f=fopen(fpn,"rb");         if (NULL==f) {             printf("Can not open file %s!\n",fpn);             fclose(af);             return 3;//之前的malloc在main退出后由操作系统自动free         }         ft->fl=_filelength(fileno(f));         ft->b=malloc(ft->fl);         if (NULL==ft->b) {             printf("Can not malloc ft->b!\n");             fclose(f);             fclose(af);             return 4;//之前的malloc在main退出后由操作系统自动free         }         printf("ft[%d]->b==%p\n",n,ft->b);         if (ft->fl!=fread(ft->b,1,ft->fl,f)) {             printf("fread error!\n");             fclose(f);             fclose(af);             return 5;//之前的malloc在main退出后由操作系统自动free         }         fclose(f);         ft->next=NULL;          if (NULL==fh) {             ft->prev=NULL;             fh=ft;         } else {             fb->next=ft;             ft->prev=fb;         }         fb=ft;         n++;     }     fclose(af);     printf("-----list-----\n");     for (ft=fh;NULL!=ft;ft=ft->next) {         printf("%8d %s\n",ft->fl,ft->fn);         if (NULL!=ft) fb=ft;     }     printf("-----free-----\n");     n--;     if (NULL!=fh) {         for (ft=fb->prev;NULL!=ft;ft=ft->prev) {             if (NULL!=ft->next->b) {                 printf("ft[%d]->b==%p\n",n,ft->next->b);                 free(ft->next->b);             }             if (NULL!=ft->next) {                 printf("ft[%d]==%p\n",n,ft->next);                 free(ft->next);             }             n--;         }         if (NULL!=fh->b) {             printf("ft[0]->b==%p\n",fh->b);             free(fh->b);         }         printf("ft[0]==%p\n",fh);         free(fh);     }     return 0; } //C:\tmp\tmp\Debug>dir /a-d c:\tmp // 驱动器 C 中的卷是 C_HD5_1 // 卷的序列号是 1817-D526 // // c:\tmp 的目录 // //找不到文件 // //C:\tmp\tmp\Debug>tmp //找不到文件 //-----list----- //-----free----- // //C:\tmp\tmp\Debug>dir /a-d c:\tmp // 驱动器 C 中的卷是 C_HD5_1 // 卷的序列号是 1817-D526 // // c:\tmp 的目录 // //2011-06-30  18:04            44,840 my_c.rar //2011-06-30  17:18             1,036 err.frm //2011-06-30  14:32            14,243 出租.txt //2011-06-28  12:08            23,681 MSDN98书签.txt //             4 个文件         83,800 字节 //             0 个目录 17,041,870,848 可用字节 // //C:\tmp\tmp\Debug>tmp //read my_c.rar //ft[0]==00421800 //ft[0]->b==00520068 //read err.frm //ft[1]==00421670 //ft[1]->b==0052AFC0 //read 出租.txt //ft[2]==00421530 //ft[2]->b==00378F28 //read MSDN98书签.txt //ft[3]==004213F0 //ft[3]->b==0052B3F8 //-----list----- // 44840 c:\tmp\my_c.rar //  1036 c:\tmp\err.frm // 14243 c:\tmp\出租.txt // 23681 c:\tmp\MSDN98书签.txt //-----free----- //ft[3]->b==0052B3F8 //ft[3]==004213F0 //ft[2]->b==00378F28 //ft[2]==00421530 //ft[1]->b==0052AFC0 //ft[1]==00421670 //ft[0]->b==00520068 //ft[0]==00421800 // //C:\tmp\tmp\Debug>

自己写的代码只有自己最懂。。。 原来帮同学改代码感觉最头痛，因为不知道他是啥思想才能写出那么蛋疼的代码来的。。。

最怕看这种没有格式化的代码

# include <stdio.h>  # include <malloc.h>  # include <stdlib.h>    typedef struct Node  {  	int data;  	struct Node * pNext; }NODE, *PNODE;  PNODE create_list(void);//生成链表  void traverse(PNODE);//遍历链表  int lenth_list(PNODE);//求链表的长度  bool empty_list(PNODE);//判断链表是否为空  void evacuate_list(PNODE);//清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表  void back_value_list(PNODE, int);//输出单链表中第pos个结点中的元素，若pos超出范围，提示输出值不存在  int * back_pdata_list(PNODE, int); //从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL  bool revise_value_list(PNODE, int, int);//把单链表中第pos个结点的值修改为x的值，若修改成功返回 true，否则返回 false  void insert_list(PNODE, int);//向单链表的表头插入一个元素val  void add_list(PNODE, int);//向单链表的末尾添加一个元素val  bool insert_pos_list(PNODE, int, int);//向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回true，否则返回false  int delpHead(PNODE pHead);//删除表头值,并返回,如果失败,中止程序~!  int main(void)  {  	PNODE pHead = NULL;  	pHead = create_list();  //	traverse(pHead); 	// if ( empty_list(pHead) )  	// printf("链表为空!\n");  	// else   	// printf("非空\n");  	// evacuate_list(pHead);//清空链表  	// printf("链表的长度为:%d\n", lenth_list(pHead) );  	// back_value_list(pHead,4);//输出头指针pHead的线性表中的第4个节点中的值  	//int * s = back_pdata_list(pHead,8);  	// printf("%p \n",s);  	// revise_value_list(pHead, 5, 88); 	//printf("将第5个节点的值改为88\n新的线性表为:\n");  	// insert_list(pHead,99);//表头插入  	// add_list(pHead, 888);//表尾追加  //	traverse(pHead);  	insert_pos_list(pHead, 1,9999);  //	traverse(pHead);  	int val = delpHead(pHead);  	printf("表头值为: %d\n", val);  	traverse(pHead); 	return 0;  }    //初始化链表  PNODE create_list(void)  {  	int len,i,val;  	printf("请输入您要生成的链表的长度:len = "); 	scanf("%d", &len);  	PNODE pHead = (PNODE)malloc(sizeof(NODE));  	if ( NULL == pHead )  	{  		printf("内存分配失败!\n");  		exit(-1);  	}  	PNODE pt = pHead;  	pt->pNext = NULL;   	for (i=0; i<len; i++)  	{  		PNODE pNew = (PNODE)malloc(sizeof(NODE));  		if ( NULL == pNew )  		{  			printf("内存分配失败!\n");  			exit(-1);  		}  		printf("请输入第%d个节点的值!", i+1);  		scanf("%d", &(pNew->data) );    		pt->pNext = pNew;  		pt = pNew;  		pt->pNext = NULL;  	}     	return pHead;  }      void traverse(PNODE pHead)  {  	PNODE p = pHead;  	while (NULL != p->pNext)  	{  		p = p->pNext;  		printf("%d ",p->data); 	}  	printf("\n");  	return;  }    //链表的长度  int lenth_list(PNODE pHead)  {  	int n=0;  	PNODE p = pHead;  	while (NULL != p->pNext) 	{  		p = p->pNext;  		n++;  	}  	return n;  }    //判断链表是否为空  bool empty_list(PNODE pHead) {  	if ( NULL == pHead->pNext)  		return true; 	else 		return false;  }    //清空链表  void evacuate_list(PNODE pHead)  {  	if (NULL == pHead->pNext)  		return;  	else  	{  		PNODE p = pHead->pNext;  		PNODE q;  		printf("%p", p->pNext);  		while (NULL != p->pNext)  		{  			q = p->pNext;  			free(p);  			p = q;  		}  		free(p);  		pHead->pNext = NULL;  	}  	return;  }      //返回单链表中第pos个结点中的元素，若pos超出范围，则返回flase  void back_value_list(PNODE pHead,int pos)  {  	int i = 1;  	PNODE p = pHead; 	while ( p->pNext != NULL && i <= pos )  	{  		p = p->pNext;  		i++;  	}  	if ( p != pHead )  		printf("第%d个值为:%d\n", pos, p->data);  	else 		printf("返回值不存在,中止程序!\n");  }      int * back_pdata_list(PNODE pHead,int val) //从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL  {  	PNODE p = pHead;  	while (p->pNext != NULL && (p->pNext)->data != val)  	{  		p=p->pNext;  	}  	if (NULL == p->pNext) return NULL;  	else 		return &((p->pNext)->data);  }    //把单链表中第pos个结点的值修改为val的值，若修改成功返回 true，否则返回 false  bool revise_value_list(PNODE pHead,int pos,int val)  { 	PNODE p = pHead;  	int i=1;  	while (NULL != p->pNext && i<=pos)  	{  		p = p->pNext;  		i++;  	}   	if ( i-1 == pos)  	{  		p->data = val;  		return true;  	}  	else 		return false;  }    //向单链表的表头插入一个元素val  void insert_list(PNODE pHead,int val)  {  	PNODE pNew = (PNODE)malloc(sizeof(NODE));  	if (NULL == pNew)  	{  		printf("内存分配失败!\n");  		exit(-1);  	}  	pNew->data = val;  	pNew->pNext = NULL;  	if ( empty_list(pHead) )  		pHead->pNext = pNew;  	else 	{  		PNODE q = pHead->pNext;  		pHead->pNext = pNew;  		pNew->pNext = q;  	}  	return;  }    //向单链表的末尾添加一个元素val  void add_list(PNODE pHead, int val)  {  	PNODE p = pHead;  	while (NULL != p->pNext)  	{  		p = p->pNext;  	}  	PNODE pNew = (PNODE)malloc(sizeof(NODE));  	pNew->data = val;  	pNew->pNext = NULL;  	p->pNext = pNew;  }    //向单链表中第pos个结点位置前插入元素为val的结点，若插入成功返回true，否则返回false  bool insert_pos_list(PNODE pHead, int pos, int val)  {  	int i=1;  	PNODE p = pHead;  	while ( NULL != p->pNext && i<pos )  	{  		p = p->pNext;  		i++;  	} 	//将p的指向,移动到pos项的前一项  	if ( NULL == p->pNext || pos <i )  		return false;  	else 	{    //问题出在这了,PNODE pNew = (PNODE)malloc  (sizeof(PNODE));   		PNODE pNew = (PNODE)malloc(sizeof(NODE));  if ( NULL == pNew )  		{  			printf("内存分配失败!\n");  			exit(-1);  		}  		pNew->data = val;  		pNew->pNext = p->pNext;  		p->pNext = pNew;  	}  	return true;  }      //从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行  int delpHead(PNODE pHead)  {  	PNODE p = NULL;  	int val;  	if ( NULL == pHead->pNext )  	{  		exit(-1);  	}  	else 	{  		p = pHead->pNext;  		val = p->data;  		pHead->pNext = p->pNext;  		free(p);//该行不注释就出错!!求解...  		p = NULL;  		return val;  	}   }  我现在想问的是: PNODE pNew = (PNODE)malloc(sizeof(PNODE)); 此语句怎么会不报错误,并且后面的 pNew->data   pNew->pNext都能用    但是  另外一个函数 free(p)才出错...望高手讲解...

引用 15 楼 yiyefangzhou24 的回复:[quote=引用 14 楼 sadadi 的回复:] free(p) p=NULL 改 p=NULL free(p) 这个有问题，p指向空了，还free他干嘛 [/quote] 我想说的是 你没初始化...

指针的问题，自己用debugger跟踪一遍，没有什么比这个更好。

我擦.你这样.幸亏好人多愿意帮你看.  free()报错 . 要么free多次一个地址.  要么你进行了指针运算 如p++导致内存越界.一般就这样.

仅供参考//假设带表头结点的单向链表头指针为head，试编写一个算法将值为5的结点插入到连接表的第k个结点前，删除第k个节点，并对该链表进行排序。 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> struct NODE {     int          data;     struct NODE *next; } H,*head,*p,*q,*s1,*s2,*s3,*s4,*s; int i,j,k,n,t,m; int main() {     srand(time(NULL));      //填写头节点数据     H.data=-1;     H.next=NULL;     head=&H;      //创建10个节点的单链表     p=head;     for (i=0;i<10;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) return 1;         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         p->next=q;         p=q;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将值为5的结点插入到单链表的第k个结点前     k=3;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) return 1;             q->data=5;             q->next=p->next;             p->next=q;             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //删除第k个节点     k=5;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=p->next;             if (q) {                 p->next=q->next;                 free(q);             }             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //从小到大排序     for (p=head;p!=NULL && p->next!=NULL;p=p->next) {         for (q=p->next;q!=NULL && q->next!=NULL;q=q->next) {             if (p->next->data > q->next->data) {                  //交换data //              printf("swap %02d %02d\n",p->next->data,q->next->data); //              t=p->next->data;p->next->data=q->next->data;q->next->data=t;                  //或者                  //交换next //              printf("swap %02d %02d\n",p->next->data,q->next->data);                 s1=p->next;                 s2=p->next->next;                 s3=q->next;                 s4=q->next->next;                  if (s2!=s3) {                      p->next=s3;                     s3->next=s2;                      q->next=s1;                     s1->next=s4;                 } else {                      p->next=s3;                     s3->next=s1;                            q=s3;                     s1->next=s4;                 }                  //输出整个单链表 //              s=head->next; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d->",s->data); //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将单链表中前 m 个结点和后 n 个结点进行互换,m+n为链表总长10     m=4;     n=6;     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m+1==k) {             q=p;         }         s=p;         p=p->next;     }     s1=head->next;     head->next=q->next;     s->next=s1;     q->next=NULL;      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //释放所有节点     p=head->next;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //18->94->58->17->27->20->43->57->75->78-> //18->94->05->58->17->27->20->43->57->75->78-> //18->94->05->58->27->20->43->57->75->78-> //05->18->20->27->43->57->58->75->78->94-> //43->57->58->75->78->94->05->18->20->27-> //

引用 15 楼 yiyefangzhou24 的回复:[quote=引用 14 楼 sadadi 的回复:] free(p) p=NULL 改 p=NULL free(p) 这个有问题，p指向空了，还free他干嘛 [/quote] 你说P的引用越界了,是什么意思,我还是没弄明白.至于14楼,就没必要去深究了..

free(p) p=NULL 改 p=NULL free(p)

//这个是代码  //代码好长啊

这种情况一般是你对p的引用越界了

引用 10 楼 buyong 的回复:[quote=引用 7 楼 qq597955169 的回复:] # include <stdio.h> # include <malloc.h> # include <stdlib.h>  typedef struct Node { int data; struct Node * pNext; }NODE, *PNODE; PNODE create_list(void);//生成链表 void traverse(PNODE);//遍历链表 int lenth_list(PNODE);//求链表的长度 bool empty_list(PNODE);//判断链表是否为空 void evacuate_list(PNODE);//清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表 void back_value_list(PNODE, int);//输出单链表中第pos个结点中的元素，若pos超出范围，提示输出值不存在 int * back_pdata_list(PNODE, int); //从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL bool revise_value_list(PNODE, int, int);//把单链表中第pos个结点的值修改为x的值，若修改成功返回 true，否则返回 false void insert_list(PNODE, int);//向单链表的表头插入一个元素val void add_list(PNODE, int);//向单链表的末尾添加一个元素val bool insert_pos_list(PNODE, int, int);//向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回true，否则返回false int delpHead(PNODE pHead);//删除表头值,并返回,如果失败,中止程序~! int main(void) { PNODE pHead = NULL; pHead = create_list(); traverse(pHead);  // if ( empty_list(pHead) ) // printf("链表为空!\n"); // else  // printf("非空\n"); // evacuate_list(pHead);//清空链表 // printf("链表的长度为:%d\n", lenth_list(pHead) ); // back_value_list(pHead,4);//输出头指针pHead的线性表中的第4个节点中的值 //int * s = back_pdata_list(pHead,8); // printf("%p \n",s); // revise_value_list(pHead, 5, 88);//printf("将第5个节点的值改为88\n新的线性表为:\n"); // insert_list(pHead,99);//表头插入 // add_list(pHead, 888);//表尾追加 traverse(pHead); insert_pos_list(pHead, 1,9999); traverse(pHead); int val = delpHead(pHead); printf("表头值为: %d\n", val); return 0; }  //初始化链表 PNODE create_list(void) { int len,i,val; printf("请输入您要生成的链表的长度:len = "); scanf("%d", &len); PNODE pHead = (PNODE)malloc(sizeof(NODE)); if ( NULL == pHead ) { printf("内存分配失败!\n"); exit(-1); } PNODE pt = pHead; pt->pNext = NULL;  for (i=0; i<len; i++) { PNODE pNew = (PNODE)malloc(sizeof(NODE)); if ( NULL == pNew ) { printf("内存分配失败!\n"); exit(-1); } printf("请输入第%d个节点的值!", i+1); scanf("%d", &(pNew->data) );  pt->pNext = pNew; pt = pNew; pt->pNext = NULL; }   return pHead; }   void traverse(PNODE pHead) { PNODE p = pHead; while (NULL != p->pNext) { p = p->pNext; printf("%d ",p->data);  } printf("\n"); return; }  //链表的长度 int lenth_list(PNODE pHead) { int n=0; PNODE p = pHead; while (NULL != p->pNext) { p = p->pNext; n++; } return n; }  //判断链表是否为空 bool empty_list(PNODE pHead) { if ( NULL == pHead->pNext) return true; else return false; }  //清空链表 void evacuate_list(PNODE pHead) { if (NULL == pHead->pNext) return; else  { PNODE p = pHead->pNext; PNODE q; printf("%p", p->pNext); while (NULL != p->pNext) { q = p->pNext; free(p); p = q; } free(p); pHead->pNext = NULL; } return; }   //返回单链表中第pos个结点中的元素，若pos超出范围，则返回flase void back_value_list(PNODE pHead,int pos) { int i = 1; PNODE p = pHead; while ( p->pNext != NULL && i <= pos ) { p = p->pNext; i++; } if ( p != pHead ) printf("第%d个值为:%d\n", pos, p->data); else printf("返回值不存在,中止程序!\n"); }   int * back_pdata_list(PNODE pHead,int val)//从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL { PNODE p = pHead; while (p->pNext != NULL && (p->pNext)->data != val) { p=p->pNext; } if (NULL == p->pNext) return NULL; else return &((p->pNext)->data); }  //把单链表中第pos个结点的值修改为val的值，若修改成功返回 true，否则返回 false bool revise_value_list(PNODE pHead,int pos,int val) { PNODE p = pHead; int i=1; while (NULL != p->pNext && i<=pos) { p = p->pNext; i++; }  if ( i-1 == pos) { p->data = val; return true; } else return false; }  //向单链表的表头插入一个元素val void insert_list(PNODE pHead,int val) { PNODE pNew = (PNODE)malloc(sizeof(NODE)); if (NULL == pNew) { printf("内存分配失败!\n"); exit(-1); } pNew->data = val; pNew->pNext = NULL; if ( empty_list(pHead) ) pHead->pNext = pNew; else { PNODE q = pHead->pNext; pHead->pNext = pNew; pNew->pNext = q; } return; }  //向单链表的末尾添加一个元素val void add_list(PNODE pHead, int val) { PNODE p = pHead; while (NULL != p->pNext) { p = p->pNext; } PNODE pNew = (PNODE)malloc(sizeof(NODE)); pNew->data = val; pNew->pNext = NULL; p->pNext = pNew; }  //向单链表中第pos个结点位置前插入元素为val的结点，若插入成功返回true，否则返回false bool insert_pos_list(PNODE pHead, int pos, int val) { int i=1; PNODE p = pHead; while ( NULL != p->pNext && i<pos ) { p = p->pNext; i++; }//将p的指向,移动到pos项的前一项 if ( NULL == p->pNext || pos <i ) return false; else {  PNODE pNew = (PNODE)malloc(sizeof(PNODE)); if ( NULL == pNew ) { printf("内存分配失败!\n"); exit(-1); } pNew->data = val; pNew->pNext = p->pNext; p->pNext = pNew; } return true; }   //从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行 int delpHead(PNODE pHead) { PNODE p = NULL; int val; if ( NULL == pHead->pNext ) { exit(-1); } else { p = pHead->pNext; val = p->data; pHead->pNext = p->pNext; free(p);//该行不注释就出错!!求解... p = NULL; return val; }  }   我用gcc测试了，并没有出错[/quote] 我用的是VC测试的,弹出一个对话框出来,不清楚是什么问题...你再试试.

引用 14 楼 sadadi 的回复:free(p) p=NULL 改 p=NULL free(p) 这个有问题，p指向空了，还free他干嘛

请输入您要生成的链表的长度:len = 5 请输入第1个节点的值!1 请输入第2个节点的值!2 请输入第3个节点的值!3 请输入第4个节点的值!4 请输入第5个节点的值!5 1 2 3 4 5 1 2 3 4 5 9999 1 2 3 4 5 表头值为: 9999  Process returned 0 (0x0)   execution time : 7.747 s Press any key to continue.

为什么我编译没错？

引用 4 楼 a515360208 的回复:也不知道旁边的代码插入  想让别人帮忙至少要多做点事情啊不太明白,我才来论坛两天!

引用 7 楼 qq597955169 的回复:# include <stdio.h> # include <malloc.h> # include <stdlib.h>  typedef struct Node { int data; struct Node * pNext; }NODE, *PNODE; PNODE create_list(void);//生成链表 void traverse(PNODE);//遍历链表 int lenth_list(PNODE);//求链表的长度 bool empty_list(PNODE);//判断链表是否为空 void evacuate_list(PNODE);//清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表 void back_value_list(PNODE, int);//输出单链表中第pos个结点中的元素，若pos超出范围，提示输出值不存在 int * back_pdata_list(PNODE, int); //从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL bool revise_value_list(PNODE, int, int);//把单链表中第pos个结点的值修改为x的值，若修改成功返回 true，否则返回 false void insert_list(PNODE, int);//向单链表的表头插入一个元素val void add_list(PNODE, int);//向单链表的末尾添加一个元素val bool insert_pos_list(PNODE, int, int);//向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回true，否则返回false int delpHead(PNODE pHead);//删除表头值,并返回,如果失败,中止程序~! int main(void) { PNODE pHead = NULL; pHead = create_list(); traverse(pHead);  // if ( empty_list(pHead) ) // printf("链表为空!\n"); // else  // printf("非空\n"); // evacuate_list(pHead);//清空链表 // printf("链表的长度为:%d\n", lenth_list(pHead) ); // back_value_list(pHead,4);//输出头指针pHead的线性表中的第4个节点中的值 //int * s = back_pdata_list(pHead,8); // printf("%p \n",s); // revise_value_list(pHead, 5, 88);//printf("将第5个节点的值改为88\n新的线性表为:\n"); // insert_list(pHead,99);//表头插入 // add_list(pHead, 888);//表尾追加 traverse(pHead); insert_pos_list(pHead, 1,9999); traverse(pHead); int val = delpHead(pHead); printf("表头值为: %d\n", val); return 0; }  //初始化链表 PNODE create_list(void) { int len,i,val; printf("请输入您要生成的链表的长度:len = "); scanf("%d", &len); PNODE pHead = (PNODE)malloc(sizeof(NODE)); if ( NULL == pHead ) { printf("内存分配失败!\n"); exit(-1); } PNODE pt = pHead; pt->pNext = NULL;  for (i=0; i<len; i++) { PNODE pNew = (PNODE)malloc(sizeof(NODE)); if ( NULL == pNew ) { printf("内存分配失败!\n"); exit(-1); } printf("请输入第%d个节点的值!", i+1); scanf("%d", &(pNew->data) );  pt->pNext = pNew; pt = pNew; pt->pNext = NULL; }   return pHead; }   void traverse(PNODE pHead) { PNODE p = pHead; while (NULL != p->pNext) { p = p->pNext; printf("%d ",p->data);  } printf("\n"); return; }  //链表的长度 int lenth_list(PNODE pHead) { int n=0; PNODE p = pHead; while (NULL != p->pNext) { p = p->pNext; n++; } return n; }  //判断链表是否为空 bool empty_list(PNODE pHead) { if ( NULL == pHead->pNext) return true; else return false; }  //清空链表 void evacuate_list(PNODE pHead) { if (NULL == pHead->pNext) return; else  { PNODE p = pHead->pNext; PNODE q; printf("%p", p->pNext); while (NULL != p->pNext) { q = p->pNext; free(p); p = q; } free(p); pHead->pNext = NULL; } return; }   //返回单链表中第pos个结点中的元素，若pos超出范围，则返回flase void back_value_list(PNODE pHead,int pos) { int i = 1; PNODE p = pHead; while ( p->pNext != NULL && i <= pos ) { p = p->pNext; i++; } if ( p != pHead ) printf("第%d个值为:%d\n", pos, p->data); else printf("返回值不存在,中止程序!\n"); }   int * back_pdata_list(PNODE pHead,int val)//从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL { PNODE p = pHead; while (p->pNext != NULL && (p->pNext)->data != val) { p=p->pNext; } if (NULL == p->pNext) return NULL; else return &((p->pNext)->data); }  //把单链表中第pos个结点的值修改为val的值，若修改成功返回 true，否则返回 false bool revise_value_list(PNODE pHead,int pos,int val) { PNODE p = pHead; int i=1; while (NULL != p->pNext && i<=pos) { p = p->pNext; i++; }  if ( i-1 == pos) { p->data = val; return true; } else return false; }  //向单链表的表头插入一个元素val void insert_list(PNODE pHead,int val) { PNODE pNew = (PNODE)malloc(sizeof(NODE)); if (NULL == pNew) { printf("内存分配失败!\n"); exit(-1); } pNew->data = val; pNew->pNext = NULL; if ( empty_list(pHead) ) pHead->pNext = pNew; else { PNODE q = pHead->pNext; pHead->pNext = pNew; pNew->pNext = q; } return; }  //向单链表的末尾添加一个元素val void add_list(PNODE pHead, int val) { PNODE p = pHead; while (NULL != p->pNext) { p = p->pNext; } PNODE pNew = (PNODE)malloc(sizeof(NODE)); pNew->data = val; pNew->pNext = NULL; p->pNext = pNew; }  //向单链表中第pos个结点位置前插入元素为val的结点，若插入成功返回true，否则返回false bool insert_pos_list(PNODE pHead, int pos, int val) { int i=1; PNODE p = pHead; while ( NULL != p->pNext && i<pos ) { p = p->pNext; i++; }//将p的指向,移动到pos项的前一项 if ( NULL == p->pNext || pos <i ) return false; else {  PNODE pNew = (PNODE)malloc(sizeof(PNODE)); if ( NULL == pNew ) { printf("内存分配失败!\n"); exit(-1); } pNew->data = val; pNew->pNext = p->pNext; p->pNext = pNew; } return true; }   //从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行 int delpHead(PNODE pHead) { PNODE p = NULL; int val; if ( NULL == pHead->pNext ) { exit(-1); } else { p = pHead->pNext; val = p->data; pHead->pNext = p->pNext; free(p);//该行不注释就出错!!求解... p = NULL; return val; }  }   我用gcc测试了，并没有出错

也许是内存释放错误，你释放的大于你申请的了


Question: 步进电机控制

提醒：小心“空回误差”


Question: 关于图的问题求解答

参考《算法精解（C语言描述）》自带的图相关代码。


Question: 有关数据结构问题【c语言】

求大神回复！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！


Question: 新人求教。

哦，可以了! 谢谢

n前面应该是逗号而不是句号： printf ("n = %d, n2 = %d, n3 = %d \n", n, n2, n3);  引用 楼主 huiaizhilin 的回复:我新学的C语言！ liunx  系统  进入终端 打 vi aaaa.c  #include <stdio.h> int main (void) {    int n, n2, n3;      n = 2;   n2 = n * n;   n3 = n2 * n2; printf ("n = %d, n2 = %d, n3 = %d \n". n, n2, n3); return 0; }  gcc aaaa.c aaaa.c:在函数‘main’中： aaaa.c:8:36:错误：在非结构或联合中请求成员'n'  怎么回事 以前不会这样的，


Question: 关于编程所用的编程软件

编程分多种： 1. 命令行式编程 2. GUI编程, 如Windows, Linux, Android, iOS,  3. 脚本式编程，如 perl, python 4. 汇编编程  你想搞哪种？

linux gcc

看你想做什么事而定

最新的VS。

由于有VS2010+，VC6不得不说是过时了。 gcc忠实的陪着大家的，从Windows到嵌入式。

C++ Builder

vim qtcreator codeblock .....

VC6 用筷子吃饭啥时候过时呀？

肯动手，哪个编译器都是趁手的兵器。

Turbo C 2.01

那就用：习语言 吧。

Objective-C和JAVA  引用 楼主 Minghao_Best 的回复:众所周知，VC++已经过时了。。。那用什么编程软件好呢？求推荐~~~