Question: scanf输入问题

Format Specification Fields: scanf and wscanf Functions A format specification has the following form:  % [width] [{h | l | I64 | L}]type  The format argument specifies the interpretation of the input and can contain one or more of the following:   White-space characters: blank (' '); tab ('\t'); or newline ('\n'). A white-space character causes scanf to read, but not store, all consecutive white-space characters in the input up to the next non–white-space character. One white-space character in the format matches any number (including 0) and combination of white-space characters in the input.   Non–white-space characters, except for the percent sign (%). A non–white-space character causes scanf to read, but not store, a matching non–white-space character. If the next character in stdin does not match, scanf terminates.   Format specifications, introduced by the percent sign (%). A format specification causes scanf to read and convert characters in the input into values of a specified type. The value is assigned to an argument in the argument list.  The format is read from left to right. Characters outside format specifications are expected to match the sequence of characters in stdin; the matching characters in stdin are scanned but not stored. If a character in stdin conflicts with the format specification, scanf terminates, and the character is left in stdin as if it had not been read.  When the first format specification is encountered, the value of the first input field is converted according to this specification and stored in the location that is specified by the first argument. The second format specification causes the second input field to be converted and stored in the second argument, and so on through the end of the format string.  An input field is defined as all characters up to the first white-space character (space, tab, or newline), or up to the first character that cannot be converted according to the format specification, or until the field width (if specified) is reached. If there are too many arguments for the given specifications, the extra arguments are evaluated but ignored. The results are unpredictable if there are not enough arguments for the format specification.  Each field of the format specification is a single character or a number signifying a particular format option. The type character, which appears after the last optional format field, determines whether the input field is interpreted as a character, a string, or a number.   The simplest format specification contains only the percent sign and a type character (for example, %s). If a percent sign (%) is followed by a character that has no meaning as a format-control character, that character and the following characters (up to the next percent sign) are treated as an ordinary sequence of characters, that is, a sequence of characters that must match the input. For example, to specify that a percent-sign character is to be input, use %%.  An asterisk (*) following the percent sign suppresses assignment of the next input field, which is interpreted as a field of the specified type. The field is scanned but not stored. 仅供参考：#include <stdio.h> int main() {     int a,b,n,v,r,k;     char buf[80];     char *p;      k=0;     r=EOF;     while (1) {         if (EOF==r) {             fgets(buf,80,stdin);             p=buf;         }         while (1) {             r=sscanf(p,"%d%n",&v,&n);             if (1==r) {k++;break;}             if (EOF==r) break;             p++;         }         if (EOF==r) continue;         p+=n;         if (1==k) a=v;         if (2==k) {             b=v;             break;         }     }     printf("%d,%d\n",a,b);     return 0; }

引用 5 楼 liu15073458538 的回复:这个应该是输入格式问题，同意楼上。+1,自己写的输入格式却不按格式输入

第一，实际输入的格式应严格按照scanf中定义的格式输入，逗号不能省略，最好采用以空格分割，这样通常不易出错。 第二，fflush，注意Parameters与Notes，c标准要求fflush的参数是输出流，扩展的c标准允许fflush的参数是可seek的输入流。所以，fflush(stdin)的行为是不确定的，在vc下通常是有效的，但在gcc下不起作用。清掉输入缓存最好用fgets。

这个应该是输入格式问题，同意楼上。

你得这样输入才行哦：1,2

很有可能是输入格式的问题，输入的时候没加逗号

你用的是什么编译器


Question: c错误local variable 'string' used without having been initializ，运行不了

区分 字符和字符串

引用 1 楼 mewiteor 的回复:char string; 改成 char string[256/*或其它值*/]; 然后 pstr=&string; 改成 pstr=string;

string没有初始化


Question: 关于自建窗口的移动问题

引用 3 楼 mewiteor 的回复:WM_NCHITTEST message 返回 HTCAPTION 的时候，系统会认为你点了窗口的标题栏，窗口会跟随鼠标移动。如果不想让鼠标点哪都跟随，可以根据鼠标相对于窗口的坐标，来判断何时返回 HTCAPTION ，何时返回 HTCLIENT 。 这个消息可以这样判断么?  我在WM_LBUTTONDOWN消息下 判断鼠标所在坐标,条件成立后发送WM_NCHITTEST 消息,进入拖拽状态.

引用 1 楼 zxhuser-2 的回复:没明白你说的是啥 一般的窗口 可以 实现 鼠标在窗口上按下 然后移动鼠标 实现 改变窗口的位置么. 我就要实现这功能 可是我创建的是无标题 无边框的弹出式窗口.如何实现?

引用 8 楼 mewiteor 的回复:[quote=引用 5 楼 qq_18599547 的回复:] [quote=引用 3 楼 mewiteor 的回复:] WM_NCHITTEST message 返回 HTCAPTION 的时候，系统会认为你点了窗口的标题栏，窗口会跟随鼠标移动。如果不想让鼠标点哪都跟随，可以根据鼠标相对于窗口的坐标，来判断何时返回 HTCAPTION ，何时返回 HTCLIENT 。 我成功一般了,但是有个小问题,我在WM_NCHITTEST 消息下 判断 鼠标指针位置y<=20 返回 HTCAPTION 消息,否则返回HTCLIENT. 但是这个判断好像无效啊 不管在什么位置都可以拖拽 子窗口除外[/quote]用GetWindowRect function获得窗口坐标，lParam是鼠标相对于整个屏幕的坐标，需要自己换算一下。[/quote] 谢谢了 我搞定了  之前是判断条件有问题. 现在好了 万分感谢!

引用 5 楼 qq_18599547 的回复:[quote=引用 3 楼 mewiteor 的回复:] WM_NCHITTEST message 返回 HTCAPTION 的时候，系统会认为你点了窗口的标题栏，窗口会跟随鼠标移动。如果不想让鼠标点哪都跟随，可以根据鼠标相对于窗口的坐标，来判断何时返回 HTCAPTION ，何时返回 HTCLIENT 。 我成功一般了,但是有个小问题,我在WM_NCHITTEST 消息下 判断 鼠标指针位置y<=20 返回 HTCAPTION 消息,否则返回HTCLIENT. 但是这个判断好像无效啊 不管在什么位置都可以拖拽 子窗口除外[/quote]用GetWindowRect function获得窗口坐标，lParam是鼠标相对于整个屏幕的坐标，需要自己换算一下。

引用 6 楼 mewiteor 的回复:[quote=引用 4 楼 qq_18599547 的回复:] [quote=引用 3 楼 mewiteor 的回复:] WM_NCHITTEST message 返回 HTCAPTION 的时候，系统会认为你点了窗口的标题栏，窗口会跟随鼠标移动。如果不想让鼠标点哪都跟随，可以根据鼠标相对于窗口的坐标，来判断何时返回 HTCAPTION ，何时返回 HTCLIENT 。 这个消息可以这样判断么?  我在WM_LBUTTONDOWN消息下 判断鼠标所在坐标,条件成立后发送WM_NCHITTEST 消息,进入拖拽状态.[/quote] 不用WM_LBUTTONDOWN,用GetCursorPos function和ScreenToClient function就可以得到鼠标相对于窗口的坐标了。 并且WM_NCHITTEST是按下鼠标时触发的。[/quote] 可以不用GetCursorPos,lParam就是鼠标相对于屏幕的坐标。

引用 4 楼 qq_18599547 的回复:[quote=引用 3 楼 mewiteor 的回复:] WM_NCHITTEST message 返回 HTCAPTION 的时候，系统会认为你点了窗口的标题栏，窗口会跟随鼠标移动。如果不想让鼠标点哪都跟随，可以根据鼠标相对于窗口的坐标，来判断何时返回 HTCAPTION ，何时返回 HTCLIENT 。 这个消息可以这样判断么?  我在WM_LBUTTONDOWN消息下 判断鼠标所在坐标,条件成立后发送WM_NCHITTEST 消息,进入拖拽状态.[/quote] 不用WM_LBUTTONDOWN,用GetCursorPos function和ScreenToClient function就可以得到鼠标相对于窗口的坐标了。 并且WM_NCHITTEST是按下鼠标时触发的。

引用 3 楼 mewiteor 的回复:WM_NCHITTEST message 返回 HTCAPTION 的时候，系统会认为你点了窗口的标题栏，窗口会跟随鼠标移动。如果不想让鼠标点哪都跟随，可以根据鼠标相对于窗口的坐标，来判断何时返回 HTCAPTION ，何时返回 HTCLIENT 。 我成功一般了,但是有个小问题,我在WM_NCHITTEST 消息下 判断 鼠标指针位置y<=20 返回 HTCAPTION 消息,否则返回HTCLIENT. 但是这个判断好像无效啊 不管在什么位置都可以拖拽 子窗口除外

没明白你说的是啥


Question: C编译问题（使用Code::Blocks和IDEone）

c++有个库函数叫getline，可能是名字冲突了。 改个名字再试试，比如my_getline之类的


Question: 帮我看看下面程序哪里错了？messaga为当前路径下创建的文件

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


Question: 指针数组copy问题，为什么值传不过来？

j的值和i是同步变化的，将j增加移到拷贝时strcpy(buf[i],array2[j++])

我觉得在拷贝array[3]的时候就应该报错了，buf[3]就已经越界了

引用 2 楼 uoksui 的回复:第一次malloc时应该sizeof(char *)，因为存的是指针，指针占四个字节  这个问题，后来我已经发现了，改正之后还是不行，在你的编译器上可以吗？

引用 1 楼 wujunqi11 的回复:问题如：23行到26行，希望各位大神帮帮忙 这个问题，后来我已经发现了，改正之后还是不行，在你的编译器上可以吗？

后来改成这样就可以，但是不知道为什么上面的不行，求大神告知，谢谢 /* 实现两个字符串的合并，并且排序出来，采用的是三种二维指针的内存输入模型 */ #define  _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h>  char ** sortArray2(const char ** array1, int count1, const char(*array2)[30], int count2,int *buflen) { 	char **buf = (char **)malloc((count1 + count2) * sizeof(char*)); 	int i = 0, j = 0; 	char cmp[30] = { 0 }; 	*buflen = count1 + count2; 	for (i = 0; i < count1 + count2; i++) 	{ 		buf[i] = (char *)malloc(32 * sizeof(char)); 		memset(buf[i], 0, 32 * sizeof(char)); 	}  	printf("排序前:\n"); 	for (i = 0; i < count1; i++) 	{ 		strcpy(buf[i], array1[i]); 		printf("%s ", buf[i]); 	}  	for (j = 0; j < count2; j++,i++) 	{ 		strcpy(buf[i], array2[j]); 		printf("%s ", buf[i]); 	}  	for (i = 0; i < count1 + count2; i++) 	{ 		for (j = i + 1; j < count1 + count2; j++) 		{ 			if (strcmp(buf[i], buf[j]) > 0) 			{ 				strcpy(cmp, buf[i]); 				strcpy(buf[i], buf[j]); 				strcpy(buf[j], cmp); 			} 		} 	} 	return buf; }  void main() { 	char *array1[] = { "1111xxx", "ccccc", "jkdsfj", "34343" }; 	int count1 = sizeof(array1) / sizeof(char *); 	int buflen = 0; 	int i = 0; 	char array2[10][30] = { "xxxxxxxxxxxx", "yyyyyy", "zzzzz" }; 	char **buf = NULL;  	buf = sortArray2(array1, count1, array2, 3, &buflen);  	printf("\n排序后：\n"); 	for (i = 0; i < buflen; i++) 	{ 		printf("%s ", buf[i]); 	} 	system("pause"); }

引用 1 楼 wujunqi11 的回复:问题如：23行到26行，希望各位大神帮帮忙  如下修改： char **sortArray(const char **array1, int count1, const char(*array2)[30], int count2) { 	char **buf = (char **)malloc((count1 + count2) * sizeof(char)); 	int i = 0, j = 0; 	for (i = 0, j = 0; j < count2; ) 	{ 		buf[i] = (char *)malloc(32 * sizeof(char)); 		if (i < count1) 		{ 			strcpy(buf[i], array1[i]); 			printf("%s ", buf[i]); 			i++; 		} 		else 		{ 			strcpy(buf[i + j], array2[j]); 			printf("%s ", buf[i + j]); 			j++; 		} 	} 	//排序…… 	return buf; }

最后加一句：free(buf);

这样更好：  /* 实现两个字符串的合并，并且排序出来，采用的是三种二维指针的内存输入模型 */ #define  _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h>  char **sortArray2(const char ** array1, int count1, const char(*array2)[30], int count2, int *buflen) { 	char **buf = (char **)malloc((count1 + count2) * sizeof(char*)); 	int i = 0, j = 0; 	//char cmp[30] = { 0 }; 	*buflen = count1 + count2; 	//for (i = 0; i < count1 + count2; i++) 	//{ 	//	buf[i] = (char *)malloc(32 * sizeof(char)); 	//	memset(buf[i], 0, 32 * sizeof(char)); 	//} 	printf("排序前:\n"); 	for (i = 0; i < count1; i++) 	{ 		//strcpy(buf[i], array1[i]); 		buf[i] = array1[i]; 		printf("%s ", buf[i]); 	}  	for (j = 0; j < count2; j++) 	{ 		//strcpy(buf[i], array2[j]); 		buf[i + j] = array2[j]; 		printf("%s ", buf[i + j]); 	} 	for (i = 0; i < count1 + count2; i++) 	{ 		for (j = i + 1; j < count1 + count2; j++) 		{ 			if (strcmp(buf[i], buf[j]) > 0) 			{ 				//strcpy(cmp, buf[i]); 				//strcpy(buf[i], buf[j]); 				//strcpy(buf[j], cmp); 				char *p = buf[i]; 				buf[i] = buf[j]; 				buf[j] = p; 			} 		} 	} 	return buf; } void main() { 	char *array1[] = { "1111xxx", "ccccc", "jkdsfj", "34343" }; 	int count1 = sizeof(array1) / sizeof(char*); 	int buflen = 0; 	int i = 0; 	char array2[10][30] = { "xxxxxxxxxxxx", "yyyyyy", "zzzzz" }; 	char **buf = NULL; 	buf = sortArray2(array1, count1, array2, 3, &buflen); 	printf("\n排序后：\n"); 	for (i = 0; i < buflen; i++) 	{ 		printf("%s ", buf[i]); 	} 	system("pause"); }

问题如：23行到26行，希望各位大神帮帮忙


Question: fopen函数问题

引用 5 楼 lgbxyz 的回复:文件路径不对,既不是linux的也不是window是的  char * FILENAME = "G:/test/cfg2.txt"; //应该是下面这个吧 char * FILENAME = "G:\\test\\cfg2.txt";  win下双'\'转义,应该是这样的

_chdir, _wchdir Change the current working directory.  int _chdir( const char *dirname );  int _wchdir( const wchar_t *dirname );  Routine Required Header Optional Headers Compatibility  _chdir <direct.h> <errno.h> Win 95, Win NT  _wchdir <direct.h> or <wchar.h> <errno.h> Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  Each of these functions returns a value of 0 if successful. A return value of –1 indicates that the specified path could not be found, in which case errno is set to ENOENT.  Parameter  dirname  Path of new working directory  Remarks  The _chdir function changes the current working directory to the directory specified by dirname. The dirname parameter must refer to an existing directory. This function can change the current working directory on any drive and if a new drive letter is specified in dirname, the default drive letter will be changed as well. For example, if A is the default drive letter and \BIN is the current working directory, the following call changes the current working directory for drive C and establishes C as the new default drive:  _chdir("c:\\temp");  When you use the optional backslash character (\) in paths, you must place two backslashes (\\) in a C string literal to represent a single backslash (\).  _wchdir is a wide-character version of _chdir; the dirname argument to _wchdir is a wide-character string. _wchdir and _chdir behave identically otherwise.  Generic-Text Routine Mapping:  TCHAR.H Routine  _UNICODE & _MBCS Not Defined _MBCS Defined _UNICODE Defined  _tchdir _chdir _chdir _wchdir    Example  /* CHGDIR.C: This program uses the _chdir function to verify  * that a given directory exists.  */  #include <direct.h> #include <stdio.h> #include <stdlib.h>  void main( int argc, char *argv[] ) {    if( _chdir( argv[1] )   )       printf( "Unable to locate the directory: %s\n", argv[1] );    else       system( "dir *.wri"); }   Output   Volume in drive C is CDRIVE  Volume Serial Number is 0E17-1702   Directory of C:\write  04/21/95  01:06p                 3,200 ERRATA.WRI 04/21/95  01:06p                 2,816 README.WRI                2 File(s)          6,016 bytes                              71,432,116 bytes free   Directory Control Routines  See Also   _mkdir, _rmdir, system

引用 2 楼 user-4 的回复:雖然没有一眼看出問題，但建議可以從以下幾個點定位： 1、對於fopen中的filepath， 因為很少在windows下編碼讀取文件，不确信，這裡路径是否写法有問題。 2、從代碼中看，應該是win平臺的。可以参照linux的error code。在打失敗後把error code打出，对應去查看error code的代表含義，這樣可以很快定位出來問题。  // Reset errno to zero before calling fopen().     errno = 0;      // Lets open a file that does not exist        fd = fopen("Linux.txt","r");     if(errno || (NULL == fd))     {         printf("\n fopen() failed， error code =%d\n", errno);     }  对于errno代表含义可以查對應平台的API接口說明。 errno = 0; 	fp = fopen(fileName, "wb"); 	  	if (errno || fp == NULL); 	{  		rv = -2; 		printf("func fopen err: %d\n", rv); 		printf("errn0 = %d", errno); 		goto End; 	}   然后呢？

实现函数的文件：(cfg_op.c)中，36行，fp一直等于空，不知道为什么，希望大神们，帮帮忙，小女感激不尽，实现的是一个配置文件的读，没有实现写，文件在磁盘上都新建好了，并且有数据，谢谢大家了


Question: 来个大神帮忙答疑解惑。

C#？不会


Question: C语言怎么通过操作语句来实现操作

循环+if判断

研究下shell源代码吧


Question: 怎么在一个函数中调用另一个函数中输入的的数据，新手求教

把函数1里数据的地址传给函数2，就可以在函数2里用函数1里的对应数据

引用 1 楼 jerry_dqh 的回复:没有搞明白你说的啥] 就是比如我定义了一个函数sort1，在这个sort1 函数中输入了一个数组a[3]，然后我又定义了一个数组sort2，想在这个sort2函数中将sort1中输入的数据a[3]拿过来用在sort2中使用做一些其他事情比如排序，这个该怎么办

没有搞明白你说的啥


Question: 大神请看过来，如何在c语言中打开视频文件

system("d:\\mv\\abc.avi");

用SDL就可以了，不难

VC播放视频的方法有： MCI activex dShow 如果机器上有播放器，可以直接运行播放。（从注册表里面读取播放器的参数，然后命令行就可以开始播放了。）

就是把视频保存为外部文件（不插入程序文件中），然后调用  这种的


Question: 请教C语言中局部变量的问题

引用 1 楼 user-2 的回复:return a; 返回的是数组地址，也就是指针，局部变量是放在调用堆栈里的，函数退出了，堆栈释放了，但数据还在。看下编译后的汇编就明白了。不过也跟编译器有关系。你可以做个实验，main里调用try两次，对a的赋值两次不同，看第一次数据的还在不在？ 引用 3 楼 gzwgyfgpf 的回复:你这不是局部变量的问题，而是数据在内存中的存储问题，你的代码中try（）函数传递的是数组的地址，所以主函数中仍可以操作数组  谢谢两位的解答

补充一下，C不是严格意义的高级语言，应该算中级语言，对语言的安全性并不进行过多检查，所有C可以干一些很低级的事情，同样也可以做一些别的高级语言做不到的技巧。


Question: 为什么Release版本无法运行？

解决问题了，是小红伞的事情...

只有杀软自己才知道了，先把杀毒软件关了试试呗

引用 19 楼 falloutmx 的回复:只有杀软自己才知道了，先把杀毒软件关了试试呗试过了，还是不行（小红伞与360都关了.）

引用 16 楼 falloutmx 的回复:这么看应该是杀毒软件阻止了这个程序的运行为毛只管release版本，而放纵debug版本呢...

楼上正解，要是自己确认电脑和程序没毒，关闭杀毒软件再运行，看能不能成功

这么看应该是杀毒软件阻止了这个程序的运行

引用 13 楼 zhao4zhong1 的回复:引用 12 楼 idiot_fox 的回复:[quote=引用 9 楼 zhao4zhong1 的回复:] 用depends.exe查看exe依赖的dlldebug可以加载进去，但是release版本的出现错误-“Access to F:\Temporary Folder\First\bin\Release\First.exe was denied” 很可能你的电脑染毒了，用杀毒软件杀杀。 或者 以管理员身份运行 以XP兼容模式运行[/quote]我用360查杀那个文件结果是TR.Drooper.Gen（释放木马病毒）

引用 13 楼 zhao4zhong1 的回复:引用 12 楼 idiot_fox 的回复:[quote=引用 9 楼 zhao4zhong1 的回复:] 用depends.exe查看exe依赖的dlldebug可以加载进去，但是release版本的出现错误-“Access to F:\Temporary Folder\First\bin\Release\First.exe was denied” 很可能你的电脑染毒了，用杀毒软件杀杀。 或者 以管理员身份运行 以XP兼容模式运行[/quote]我用小红伞扫描release版本的exe是病毒，然后再用管理员身份运行得到这个错误：

引用 6 楼 idiot_fox 的回复:引用 5 楼 zhao4zhong1 的回复:程序员的常识之一：不要将程序源代码或项目或exe放在桌面这种复杂（多半带空格和汉字且在防火墙或杀毒软件严密控制的C盘上）的目录下。我的那个文件是在F盘，只是在桌面创建了快捷方式而已....这也会被杀软严格监控？ 带汉字的目录属于复杂目录，弄不好和全英文开发环境或操作系统的文件管理子系统不兼容。

用depends.exe查看exe依赖的dll

引用 6 楼 idiot_fox 的回复:引用 5 楼 zhao4zhong1 的回复:程序员的常识之一：不要将程序源代码或项目或exe放在桌面这种复杂（多半带空格和汉字且在防火墙或杀毒软件严密控制的C盘上）的目录下。我的那个文件是在F盘，只是在桌面创建了快捷方式而已....这也会被杀软严格监控？我将快捷方式去掉之后还是一样的结果。

引用 4 楼 zjq9931 的回复:[quote=引用 3 楼 idiot_fox 的回复:] [quote=引用 1 楼 zjq9931 的回复:] 能否贴上源码？ 个人觉得是系统问题。#include <stdio.h>  main() {     printf("Hello world!\n");     getchar(); } [/quote] 改成这样试试，没有装你的那个编译器：  int main() {     printf("Hello world!\n");     getchar();     return 0; } [/quote]我试过了，还是不行。

引用 12 楼 idiot_fox 的回复:引用 9 楼 zhao4zhong1 的回复:用depends.exe查看exe依赖的dlldebug可以加载进去，但是release版本的出现错误-“Access to F:\Temporary Folder\First\bin\Release\First.exe was denied” 很可能你的电脑染毒了，用杀毒软件杀杀。 或者 以管理员身份运行 以XP兼容模式运行

引用 10 楼 zhao4zhong1 的回复:引用 6 楼 idiot_fox 的回复:[quote=引用 5 楼 zhao4zhong1 的回复:] 程序员的常识之一：不要将程序源代码或项目或exe放在桌面这种复杂（多半带空格和汉字且在防火墙或杀毒软件严密控制的C盘上）的目录下。我的那个文件是在F盘，只是在桌面创建了快捷方式而已....这也会被杀软严格监控？ 带汉字的目录属于复杂目录，弄不好和全英文开发环境或操作系统的文件管理子系统不兼容。[/quote]我试了一下全英文目录，也是不行。

引用 3 楼 idiot_fox 的回复:[quote=引用 1 楼 zjq9931 的回复:] 能否贴上源码？ 个人觉得是系统问题。#include <stdio.h>  main() {     printf("Hello world!\n");     getchar(); } [/quote] 改成这样试试，没有装你的那个编译器：  int main() {     printf("Hello world!\n");     getchar();     return 0; }

引用 1 楼 zjq9931 的回复:能否贴上源码？ 个人觉得是系统问题。#include <stdio.h>  main() {     printf("Hello world!\n");     getchar(); }


Question: 关于字符的排序问题，大神们来看下,应该不至于使用链表吧

loop 3 loop 7 loop 8 loop 9 tunnel 3 tunnel 4 tunnel 1000

这样可好：  #include <stdio.h> #include <string.h> int mycmp(char *s1, char *s2) { 	char name1[20], name2[20]; 	long num1, num2; 	char *c; 	sscanf(s1, "%s%d", name1, &num1); 	sscanf(s2, "%s%d", name2, &num2); 	int res; 	res = strcmp(name1, name2); 	if (0 == res) 	{ 		return num1 - num2; 	} 	else return res; } void mysort(char **p, int n) { 	int i, j; 	for (i = 1; i < n; i++) 		for (j = 0; j < n - i; j++) 		{ 			if (mycmp(p[j], p[j + 1]) > 0) 			{ 				char *tmp; 				tmp = p[j]; 				p[j] = p[j+1]; 				p[j + 1] = tmp; 			} 		} } int main(void) { 	char *p[] = { "loop 7", "loop 9", "tunnel 1000", "loop 8", "tunnel 3", "loop 3", "tunnel 4" }; 	int n = sizeof(p) / sizeof(char*); 	mysort(p, n); 	int i; 	for (i = 0; i < n; i++) printf("%s\n", p[i]); 	return 0; }

用字符串比较函数和快速排序算法应该不复杂

典型的快速排序嘛

不用链表，用冒泡排序即可


Question: 看一下我这个快排那错了？

引用 8 楼 u011919606 的回复:[quote=引用 7 楼 liukeyong2110 的回复:] [quote=引用 6 楼 u011919606 的回复:] 你能不能给我说说为什么while换成if，我觉得在这里while和if一样，都是只执行一次quickSort.  递归变量的作用域，你传入的不是指针。所以呢，你函数里while循环里的low 和high没有改变，循环不会终止。  在while循环中添加 printf("%d,%d\n",low,high);                  // 调试一下你就知道了[/quote]  我懂你的意思了，当用while的时候，会一直卡在倒数第二步的递归上，无限循环下去。[/quote]  是的

引用 7 楼 liukeyong2110 的回复:[quote=引用 6 楼 u011919606 的回复:] 你能不能给我说说为什么while换成if，我觉得在这里while和if一样，都是只执行一次quickSort.  递归变量的作用域，你传入的不是指针。所以呢，你函数里while循环里的low 和high没有改变，循环不会终止。  在while循环中添加 printf("%d,%d\n",low,high);                  // 调试一下你就知道了[/quote]  我懂你的意思了，当用while的时候，会一直卡在倒数第二步的递归上，无限循环下去。

引用 6 楼 u011919606 的回复:你能不能给我说说为什么while换成if，我觉得在这里while和if一样，都是只执行一次quickSort.  递归变量的作用域，你传入的不是指针。所以呢，你函数里while循环里的low 和high没有改变，循环不会终止。  在while循环中添加 printf("%d,%d\n",low,high);                  // 调试一下你就知道了

看我的博客，可以参考

21行，while改成if即可。 再删去你的调试语句。  #include<stdio.h>  void quickSort(int *array, int low, int high); int findPos(int *array, int low, int high);  int main() { 	int i; 	int array[6] = { 8, 9, 3, 0, 4, 5 }; 	quickSort(array, 0, 5); 	for (i = 0; i<6; i++) 	{ 		printf("%d\n", array[i]); 	} 	return 0; }  void quickSort(int *array, int low, int high) { 	int pos; 	if (low < high) 	{ 		pos = findPos(array, low, high); 		printf("%d\n", pos); 		quickSort(array, low, pos - 1); 		quickSort(array, pos + 1, high); 	} }  int findPos(int *array, int low, int high) { 	int value = array[low]; 	while (low<high) 	{ 		while (low<high && value <= array[high]) //high指针所指的数据比value大的且high指针不等于low指针，high指针向左移 		{ 			high--; 		} 		array[low] = array[high];//high指针所指的数据比value小的，直接向左赋值 		while (low<high && value >= array[low])//low指针所指的数据比value小的且high指针不等于low指针，low指针向右移 		{ 			low++; 		} 		array[high] = array[low];//low指针所指的数据比value大的，直接向右赋值。 	} 	array[low] = value;  	return high; }

一共5处修改： #include<stdio.h>   void quickSort(int *array,int low,int high); int findPos(int *array,int low,int high);   int main() {     int i;     int array[6] = {8,9,3,0,4,5};     quickSort(array,0,5);     for(i=0;i<6;i++)     {         printf("%d\n",array[i]);     }     return 0; }   void quickSort(int *array,int low,int high) {     int pos;     if (low < high)  // 改1： while --> if     {         pos = findPos(array,low,high);         printf("%d\n",pos);         quickSort(array,low,pos-1);         quickSort(array,pos+1,high);     } }   int findPos(int *array,int low,int high) {     int value = array[low];     while(low<high)     {         while(low<high && value<=array[high]) //high指针所指的数据比value大的且high指针不等于low指针，high指针向左移         {             high--;         } if (low < high) // 改2         array[low++ /* 改3 */] = array[high];//high指针所指的数据比value小的，直接向左赋值         while(low<high && value>=array[low])//low指针所指的数据比value小的且high指针不等于low指针，low指针向右移         {             low++;         } if (low < high) // 改4         array[high-- /* 改5 */] = array[low];//low指针所指的数据比value大的，直接向右赋值。     }     array[low] = value;       return high; }

最好自己一步步调试一下，这样对自己有好处，对算法也可以理解的更透彻，这只是我个人的意见，希望对你有帮助

快速排序 http://blog.csdn.net/zhangxiangdavaid/article/details/25436609


Question: 大神 我C语言看书看了无数遍了 可是还是掌握不好 求助啊

嘛,努力学吧, 天才%1,  高手学的快的9%, 30%中等的, 50%中等的, 9%学的很慢,基本上会不了的, 1%自伤有问题, 你可以对号1下, 理论上编写程序时高中生可以干得,如果你入门慢点,可能是30%或50%里面的,学得慢也不是学不会, 慢慢努力就好!有3,5年时间,就可大成了

多上机,敲代码

只看不做是不行的

估计C/C++老师如果是这个形象，学C/C++的人就会多10倍吧。

引用 17 楼 zhao4zhong1 的回复:这个够清晰吧：  强烈推荐换上

目测你看的书太烂  c primer plus 看过么

引用 15 楼 q364367207 的回复:[quote=引用 14 楼 zhao4zhong1 的回复:] 就算你能将百度上能搜到的如何游泳相关的文字全部倒背如流，但你没真正下过水，你照样不会游泳。  每次上论坛看到赵老师的头像 都会被吓到~~ 老师 您用个清晰点的头像呗[/quote] 这个够清晰吧：

像素化的头像说明本ID是老人。

引用 14 楼 zhao4zhong1 的回复:就算你能将百度上能搜到的如何游泳相关的文字全部倒背如流，但你没真正下过水，你照样不会游泳。  每次上论坛看到赵老师的头像 都会被吓到~~ 老师 您用个清晰点的头像呗

我只记得  我的第一本c++书是  c++从入门到精通      特别棒还有视频  推荐

要不自学  跟项目  要不找比自己厉害的人 跟人家学习

引用 4 楼 user-16 的回复:[quote=引用 1 楼 qwqwqw408的回复:]想看书就成为高手是不可能的，只有实际写代码，天天写，才能成为大神。等你参与到项目开发中的时候，成长会很快的。想当年，我从java转入嵌入式C++开发，wince系统。那时候只懂C++基础，还不是半年就开发出来一套可视对讲系统。后面还开发了自己的UI框架，让C++做界面比其他语言都快，不用写代码，分分钟就能配置N个华丽的界面出来。 前辈，嵌入式就业前景好吗？我17年毕业[/quote]  嵌入式，看你做什么了。如果是做上位应用的话，没什么太大的前景。搞单片机开发，更是不行。。搞驱动开发，貌似还可以，比前两者强很多。。

我也在学。以前也是只看书。现在找了几个好的题目自己研究，学的速度挺快的。多动手就行了

我吃了这么多年饭,菜还是炒不好,求助

各种  oj

赞同楼上的话，先好好打基础。

只看书很枯燥的，可以上自己写点感兴趣的东西，提升成就感，同时可以在遇到的困难中不断进步

不要浮躁，在学校静下心来打好基础，当然有机会接触项目的话更好，等工作了都会有用武之地的

引用 1 楼 qwqwqw408的回复:想看书就成为高手是不可能的，只有实际写代码，天天写，才能成为大神。等你参与到项目开发中的时候，成长会很快的。想当年，我从java转入嵌入式C++开发，wince系统。那时候只懂C++基础，还不是半年就开发出来一套可视对讲系统。后面还开发了自己的UI框架，让C++做界面比其他语言都快，不用写代码，分分钟就能配置N个华丽的界面出来。 前辈，嵌入式就业前景好吗？我17年毕业


Question: Visual 6.0C++软件不能生成可执行文件问题

总是发现Path环境变量被某些软件安装时错误修改。比如带空格的目录名未加引号、带汉字的目录引起目录查找混乱等问题，严重影响系统查找可执行文件和dll。 编译此源代码，生成PathShortener.exe，然后在cmd窗口里面运行PathShortener.exe>path.txt，打开path.txt，手动将其内容拷贝粘贴覆盖修改‘我的电脑、属性、高级、环境变量、系统变量、Path、编辑、变量值’即可纠正设置错误的Path http://download.csdn.net/detail/zhao4zhong1/2652343


Question: C语言设计一个可以生成BMP格式图片的程序，大大们，求助呀

你还没有我发的代码都是VC6下的常识吗？

引用 1 楼 zhao4zhong1 的回复:仅供参考：#pragma comment(lib,"gdi32") #include <windows.h> #include <stdio.h>  int main() {     const DWORD uWidth = 18 + 17 * 256, uHeight = 18 + 17 * 128;      PBITMAPINFO pbmi = (PBITMAPINFO) LocalAlloc (LPTR, sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2);     pbmi->bmiHeader.biSize = sizeof (BITMAPINFOHEADER);     pbmi->bmiHeader.biWidth = uWidth;     pbmi->bmiHeader.biHeight = uHeight;     pbmi->bmiHeader.biPlanes = 1;     pbmi->bmiHeader.biBitCount = 1;     pbmi->bmiHeader.biSizeImage = ((uWidth + 31) & ~31) / 8 * uHeight;     pbmi->bmiColors[0].rgbBlue = 0;     pbmi->bmiColors[0].rgbGreen = 0;     pbmi->bmiColors[0].rgbRed = 0;     pbmi->bmiColors[1].rgbBlue = 255;     pbmi->bmiColors[1].rgbGreen = 255;     pbmi->bmiColors[1].rgbRed = 255;      HDC hDC = CreateCompatibleDC (0);     void * pvBits;     HBITMAP hBitmap = CreateDIBSection (hDC, pbmi, 0, &pvBits, NULL, 0);     SelectObject (hDC, hBitmap);     HFONT hFont = CreateFont (16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "宋体"); //  HFONT hFont = CreateFont (16, 0, 0, 0, 0, 0, 0, 0, SHIFTJIS_CHARSET, 0, 0, 0, 0, "宋体");     SelectObject (hDC, hFont);     BitBlt (hDC, 0, 0, uWidth, uHeight, NULL, 0, 0, WHITENESS);      char c[4];     int i, j;     for (i = 128; i < 256; i++) {         sprintf (c, "%02X", i);         TextOut (hDC, 1, (i - 127) * 17 + 1, c, 2);     }     for (j = 0; j < 256; j++) {         sprintf (c, "%02X", j);         TextOut (hDC, (j + 1)* 17 + 1, 1, c, 2);     }     for (i = 128; i < 256; i++) {         for (j = 0; j < 256; j++) {             c[0] = (char) i;             c[1] = (char) j;             TextOut (hDC, (j + 1) * 17 + 1, (i - 127) * 17 + 1, c, 2);         }     }     for (i = 0; i < 130; i++) {         MoveToEx (hDC, 0, i * 17, NULL);         LineTo (hDC, uWidth, i * 17);     }     for (j = 0; j < 258; j++) {         MoveToEx (hDC, j * 17, 0, NULL);         LineTo (hDC, j * 17, uHeight);     }      BITMAPFILEHEADER bmfh;     bmfh.bfType = *(PWORD) "BM";     bmfh.bfReserved1 = 0;     bmfh.bfReserved2 = 0;     bmfh.bfOffBits = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2;     bmfh.bfSize = bmfh.bfOffBits + pbmi->bmiHeader.biSizeImage;      HANDLE hFile = CreateFile ("goal.bmp", GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);     if (hFile != INVALID_HANDLE_VALUE) {         DWORD dwWritten;         WriteFile (hFile, &bmfh, sizeof (BITMAPFILEHEADER), &dwWritten, NULL);         WriteFile (hFile, pbmi, sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2, &dwWritten, NULL);         WriteFile (hFile, pvBits, pbmi->bmiHeader.biSizeImage, &dwWritten, NULL);          CloseHandle (hFile);     }      DeleteObject (hFont);     DeleteObject (hBitmap);     DeleteDC (hDC);     LocalFree (pbmi);      return 0; } 木用，报错啦


Question: 求大神帮助。

/* 自己慢慢写了。 写得不好。 大家以后提出建议哟！！ 开始时间：2015年6月19日 完成时间：2015年6月20日 程序目的：编写一个字母连连看游戏 */ #include <stdio.h> #include <stdlib.h> #include <time.h>  void random_order(char *,int); void show (); void display(char *,int); void main () {     char totall_letters[]="qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM";     char generate_letters[5]={0}, double_letters[10]={0}, letters[3][3];     int i,j,m,num1,num2,num=1;     show ();  //显示游戏规则     srand((unsigned)time(NULL));//随机字母生成     for (i=0;i<5;i++)     {          m=rand()%52;          generate_letters[i]=totall_letters[m];     }     loop:          {          srand((unsigned)time(NULL));//随机字母生成          for (i=0;i<5;i++)          {               m=rand()%52;               generate_letters[i]=totall_letters[m];          }          }          for (i=0;i<4;i++) //判断随机生成的字母中否有重复的字母          {             for (m=i+1;m<5;m++)             {                  if (generate_letters[m]==generate_letters[i])                     goto loop;             }          }     for (i=0;i<5;i++)//将随机获得的字母进行加倍     {         double_letters[i]=generate_letters[i];         m=9-i;         double_letters[m]=generate_letters[i];     }     random_order(double_letters,10);  //打乱数组排序     display(double_letters,10);  //显示字母排序     while (num<5)  //对输入的次数进行判断同时判断结果    {        while(1)  //提示输入位置并判断位置是否符合规则        {          printf("请输入需要消除的字母所在位置\n");          printf("      字母1：");          scanf ("%d",&num1);          printf("      字母2：");          scanf ("%d",&num2);          if (num1<10&&num2<10&&num1>0&&num2>0)          {              break;          }        }     if (double_letters[num1-1]==double_letters[num2-1])  //比较两个字母是否相等     {         double_letters[num1-1]='@';         double_letters[num2-1]='@';         display(double_letters,10);         num++;     }     else     {         printf("\n\n/  (ㄒoㄒ)/~~智商有待提高  ！！游戏结束！！\n\n");         return ;     }     }     printf("\n\n   O(∩_∩)O~~ 真聪敏  ！！恭喜闯关通过！！\n\n");     return ; }  void random_order(char *name,int length) {     char t;     int i,j; 	int cleartimes = 10;     while (cleartimes--)     {         i = rand()%length; 		j = rand()%length;         if (i==j) 			continue;         t=name[i];         name[i]=name[j];         name[j]=t;     } }  void show()    //显示游戏规则 {     printf("*******************************************\n");     printf("* 游戏讲解及规则:                         *\n");     printf("*     游戏运行后会在桌面上随机产生9个字母 *\n");     printf("*其中有8个字母是两两相同的。如果想消去两个*\n");     printf("*相同的字母，你必须在键盘上按对这个两个相 *\n");     printf("*字母所处的位置。如果你按到不成对的字母所 *\n");     printf("*在的位置，游戏结束。若4对成功消除，则闯关*\n");     printf("*通过！                                   *\n");     printf("*    注：字母所在位置是按行计数的。       *\n");     printf("*******************************************\n"); } void display(char *double_letters,int length) //显示字母排序 {     printf("\n*******************************************\n");     printf("游戏显示：\n");     printf(" *            %c   %c   %c                  *\n",double_letters[0],double_letters[1],double_letters[2]);     printf(" *            %c   %c   %c                  *\n",double_letters[3],double_letters[4],double_letters[5]);     printf(" *            %c   %c   %c                  *\n",double_letters[6],double_letters[7],double_letters[8]);     printf("\n*******************************************\n"); }

仅供参考：#include <windows.h> #include <stdio.h>  void ConPrint(char *CharBuffer, int len); void ConPrintAt(int x, int y, char *CharBuffer, int len); void gotoXY(int x, int y); void ClearConsole(void); void ClearConsoleToColors(int ForgC, int BackC); void SetColorAndBackground(int ForgC, int BackC); void SetColor(int ForgC); void HideTheCursor(void); void ShowTheCursor(void);  int main(int argc, char* argv[]) {    HideTheCursor();    ClearConsoleToColors(15, 1);    ClearConsole();    gotoXY(1, 1);    SetColor(14);    printf("This is a test...\n");    Sleep(5000);    ShowTheCursor();    SetColorAndBackground(15, 12);    ConPrint("This is also a test...\n", 23);    SetColorAndBackground(1, 7);    ConPrintAt(22, 15, "This is also a test...\n", 23);    gotoXY(0, 24);    SetColorAndBackground(7, 1);    return 0; }  //This will clear the console while setting the forground and //background colors. void ClearConsoleToColors(int ForgC, int BackC) {    WORD wColor = ((BackC & 0x0F) << 4) + (ForgC & 0x0F);    //Get the handle to the current output buffer...    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    //This is used to reset the carat/cursor to the top left.    COORD coord = {0, 0};    //A return value... indicating how many chars were written    //not used but we need to capture this since it will be    //written anyway (passing NULL causes an access violation).    DWORD count;     //This is a structure containing all of the console info    // it is used here to find the size of the console.    CONSOLE_SCREEN_BUFFER_INFO csbi;    //Here we will set the current color    SetConsoleTextAttribute(hStdOut, wColor);    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //This fills the buffer with a given character (in this case 32=space).       FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);        FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       //This will set our cursor position for the next print statement.       SetConsoleCursorPosition(hStdOut, coord);    } }  //This will clear the console. void ClearConsole() {    //Get the handle to the current output buffer...    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    //This is used to reset the carat/cursor to the top left.    COORD coord = {0, 0};    //A return value... indicating how many chars were written    //   not used but we need to capture this since it will be    //   written anyway (passing NULL causes an access violation).    DWORD count;    //This is a structure containing all of the console info    // it is used here to find the size of the console.    CONSOLE_SCREEN_BUFFER_INFO csbi;    //Here we will set the current color    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //This fills the buffer with a given character (in this case 32=space).       FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       //This will set our cursor position for the next print statement.       SetConsoleCursorPosition(hStdOut, coord);    } }  //This will set the position of the cursor void gotoXY(int x, int y) {    //Initialize the coordinates    COORD coord = {x, y};    //Set the position    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord); }  //This will set the forground color for printing in a console window. void SetColor(int ForgC) {    WORD wColor;    //We will need this handle to get the current background attribute    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    CONSOLE_SCREEN_BUFFER_INFO csbi;     //We use csbi for the wAttributes word.    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //Mask out all but the background attribute, and add in the forgournd color       wColor = (csbi.wAttributes & 0xF0) + (ForgC & 0x0F);       SetConsoleTextAttribute(hStdOut, wColor);    } }  //This will set the forground and background color for printing in a console window. void SetColorAndBackground(int ForgC, int BackC) {    WORD wColor = ((BackC & 0x0F) << 4) + (ForgC & 0x0F);;    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), wColor); }  //Direct console output void ConPrint(char *CharBuffer, int len) {    DWORD count;    WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), CharBuffer, len, &count, NULL); }  //Direct Console output at a particular coordinate. void ConPrintAt(int x, int y, char *CharBuffer, int len) {    DWORD count;    COORD coord = {x, y};    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    SetConsoleCursorPosition(hStdOut, coord);    WriteConsole(hStdOut, CharBuffer, len, &count, NULL); }  //Hides the console cursor void HideTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = FALSE; 	  SetConsoleCursorInfo(hStdOut, &cciCursor);    } }  //Shows the console cursor void ShowTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = TRUE; 	  SetConsoleCursorInfo(hStdOut, &cciCursor);    } }


Question: C语言，这个程序是什么意思？

蒙人玩的，没别的用途

for循环结果按次数 0112 2334 4556 6778 8,9,9,10 10,11,11,12 12,13,13,14 14,15,15,16 16,0,0,1 1,2,2,3 3,4,4,5, 5,6,6,7 7,8,8,9 9,10,10,11 11,12,12,13 13,14,14,15, 15,16,16,0 0,1,1,2 又回到第一次循环的状态，出不来

开始p[0]=1,p[1]=2,p[2]=3.......p[15]=16, 循环完后p[16]=0,test=0, while看走来是死循环， for循环两次 第一次，head=test既0 tezt=p[head]既上句赋值p[0]=1: 第二次循环 head=test这时test=1: test=p[head]既p[1]=2;  最后好像是死循环

输出应该是2

把他运行起来看结果

这个程序错误的吧，死循环吧


Question: 最近在做数据结构的课程设计，求大神帮忙看一下为什么便道里车辆进入停车场所收取费用按进入便道开始计算呢，怎么修改呢

题目要求 :设停车场是一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在停车场的最北端）,若停车场内已停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后进入的车辆必须先退出车场为它让路，待该辆车开出大门外，其他车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。试为停车场编制按上述要求进行管理的模拟程序。  以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码以及到达或离去的时刻。对每一组输入数据进行操作后的输出信息为：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。栈以顺序结构实现，队列以链表结构实现。

希望帮忙修改一下，谢谢了


Question: 麻烦大神解答关于alloc函数的实现问题

引用 5 楼 ahorro 的回复:谢谢，大意我大概明白了，但是还有一点疑问，就是 allocbuf + ALLOCSIZE - allocp >= n 为什么allocbuf+ALLOCSIZE指向的就是数组最后位置呢？allocbuf不是一定等于0吗，为什么还要加上它？ allocbuf是一个数组，全局变量，它的值是由编译器和操作系统确定的，不一定是多少，但是肯定不会是0。  对于一个数组 char a[123]; a就是该数组的起始位置，a+123就是该数组的结束位置。a+123就相当于&a[123] allocbuf就相当于a，ALLOCSIZE就相当于123

引用 2 楼 brookmill 的回复:static char allocbuf[ALLOCSIZE]; /* storage for alloc */  假定allocbuf的值是1000，ALLOCSIZE是100    static char *allocp = allocbuf;  /* next free position */ allocp指向allocbuf的起始地址，也就是1000  第一次调用，n=10    char *alloc(int n)    /* return pointer to n characters */    {        if (allocbuf + ALLOCSIZE - allocp >= n) {  /* it fits */ allocbuf+ALLOCSIZE就指向整个数组的末尾，也就是1100，减去allocp就是100，也就是现在剩余的空间，如果小于n就说明不够了            allocp += n; 把1000到1010的十个字节分配出去，allocp指向下次的可用空间的开头，也就是1010            return allocp - n; /* old p */ 返回1010-10也就是1000，就是实际上分配的空间        } else      /* not enough room */            return 0;    }  第二次调用，n=50    char *alloc(int n)    /* return pointer to n characters */    {        if (allocbuf + ALLOCSIZE - allocp >= n) {  /* it fits */ 现在的剩余字节数是1100-1010=90，够用            allocp += n; allocp=1010+50 = 1060，下次的空闲空间            return allocp - n; /* old p */ 返回1060-50=1010，也就是这次给分配的空间        } else      /* not enough room */            return 0;    } 第三次，n=60，1100-1060 = 40，不够了 谢谢，大意我大概明白了，但是还有一点疑问，就是 allocbuf + ALLOCSIZE - allocp >= n 为什么allocbuf+ALLOCSIZE指向的就是数组最后位置呢？allocbuf不是一定等于0吗，为什么还要加上它？

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！  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对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式...的值【比如printf("%p\n",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495

引用 1 楼 user-3 的回复:这段代碼從那裡看到的？ 原來注释就是這樣嗎？ 为什么*allocp = allocbuf 指向的是下一个空闲位置，不是初始位置allocbuf[0]吗？ 答：這裡一定是数組的起始地址，這注释應該是有錯誤    if (allocbuf + ALLOCSIZE - allocp >= n) 这句代码的具体意思 答：這裡是為了保證可以申請到有效的地內存。當申請內存大于1000字節時是不會申請成功的。  allocp += n; return allocp - n;   这两句代码是想操作什么，为什么加了又减？ 答：這裡我認為只有第二句有意義。  當然，還要看一下這段代碼的出處。是出自Brian W.Kernighan与Dennis M.Ritchie所著的C程序设计语言这本书，在指针部分的代码。 既然allocp等于allocbuf，相减不是等于0，为什么还要用allocbuf+ALLOCSIZE再减去alloc呢？


Question: 一个数据结构的问题，表示已经疯了

引用 1 楼 hnwyllmm 的回复:buf每次应该重新申请内存，而不应该用同一段内存，也不应该用栈上的内存 恩恩，我已经解决了

fgets读取文件，文件要以回车结束就好了。 或者按字节读取。或者一次性读到内存里面。

buf每次应该重新申请内存，而不应该用同一段内存，也不应该用栈上的内存


Question: 如何批处理去停用词？求大神帮助

先学会，读写文件，字符串处理，一步步来...

C:\>for /? 对一组文件中的每一个文件执行某个特定命令。  FOR %variable IN (set) DO command [command-parameters]    %variable  指定一个单一字母可替换的参数。   (set)      指定一个或一组文件。可以使用通配符。   command    指定对每个文件执行的命令。   command-parameters              为特定命令指定参数或命令行开关。  在批处理程序中使用 FOR 命令时，指定变量请使用 %%variable 而不要用 %variable。变量名称是区分大小写的，所以 %i 不同于 %I.  如果命令扩展被启用，下列额外的 FOR 命令格式会受到 支持:  FOR /D %variable IN (set) DO command [command-parameters]      如果集中包含通配符，则指定与目录名匹配，而不与文件     名匹配。  FOR /R [[drive:]path] %variable IN (set) DO command [command-parameters]      检查以 [drive:]path 为根的目录树，指向每个目录中的     FOR 语句。如果在 /R 后没有指定目录，则使用当前     目录。如果集仅为一个单点(.)字符，则枚举该目录树。  FOR /L %variable IN (start,step,end) DO command [command-parameters]      该集表示以增量形式从开始到结束的一个数字序列。     因此，(1,1,5) 将产生序列 1 2 3 4 5，(5,-1,1) 将产生     序列 (5 4 3 2 1)。  FOR /F ["options"] %variable IN (file-set) DO command [command-parameters] FOR /F ["options"] %variable IN ("string") DO command [command-parameters] FOR /F ["options"] %variable IN ('command') DO command [command-parameters]      或者，如果有 usebackq 选项:  FOR /F ["options"] %variable IN (file-set) DO command [command-parameters] FOR /F ["options"] %variable IN ("string") DO command [command-parameters] FOR /F ["options"] %variable IN ('command') DO command [command-parameters]      filenameset 为一个或多个文件名。继续到 filenameset 中的    下一个文件之前，每份文件都已被打开、读取并经过处理。     处理包括读取文件，将其分成一行行的文字，然后将每行     解析成零或更多的符号。然后用已找到的符号字符串变量值     调用 For 循环。以默认方式，/F 通过每个文件的每一行中分开     的第一个空白符号。跳过空白行。您可通过指定可选 "options"     参数替代默认解析操作。这个带引号的字符串包括一个或多个     指定不同解析选项的关键字。这些关键字为:          eol=c           - 指一个行注释字符的结尾(就一个)         skip=n          - 指在文件开始时忽略的行数。         delims=xxx      - 指分隔符集。这个替换了空格和跳格键的                           默认分隔符集。         tokens=x,y,m-n  - 指每行的哪一个符号被传递到每个迭代                           的 for 本身。这会导致额外变量名称的分配。m-n                           格式为一个范围。通过 nth 符号指定 mth。如果                           符号字符串中的最后一个字符星号，                           那么额外的变量将在最后一个符号解析之后                           分配并接受行的保留文本。         usebackq        - 指定新语法已在下类情况中使用:                           在作为命令执行一个后引号的字符串并且一个单                           引号字符为文字字符串命令并允许在 filenameset                           中使用双引号扩起文件名称。      某些范例可能有助:  FOR /F "eol=; tokens=2,3* delims=, " %i in (myfile.txt) do @echo %i %j %k      会分析 myfile.txt 中的每一行，忽略以分号打头的那些行，将     每行中的第二个和第三个符号传递给 for 程序体；用逗号和/或     空格定界符号。请注意，这个 for 程序体的语句引用 %i 来     取得第二个符号，引用 %j 来取得第三个符号，引用 %k     来取得第三个符号后的所有剩余符号。对于带有空格的文件     名，您需要用双引号将文件名括起来。为了用这种方式来使     用双引号，您还需要使用 usebackq 选项，否则，双引号会     被理解成是用作定义某个要分析的字符串的。      %i 专门在 for 语句中得到说明，%j 和 %k 是通过     tokens= 选项专门得到说明的。您可以通过 tokens= 一行     指定最多 26 个符号，只要不试图说明一个高于字母 'z' 或     'Z' 的变量。请记住，FOR 变量是单一字母、分大小写和全局的；而且，     同时不能有 52 个以上都在使用中。      您还可以在相邻字符串上使用 FOR /F 分析逻辑；方法是，     用单引号将括号之间的 filenameset 括起来。这样，该字符     串会被当作一个文件中的一个单一输入行。      最后，您可以用 FOR /F 命令来分析命令的输出。方法是，将     括号之间的 filenameset 变成一个反括字符串。该字符串会     被当作命令行，传递到一个子 CMD.EXE，其输出会被抓进     内存，并被当作文件分析。因此，以下例子:        FOR /F "usebackq delims==" %i IN (`set`) DO @echo %i      会枚举当前环境中的环境变量名称。  另外，FOR 变量参照的替换已被增强。您现在可以使用下列 选项语法:       ~I          - 删除任何引号(")，扩展 %I      %~fI        - 将 %I 扩展到一个完全合格的路径名      %~dI        - 仅将 %I 扩展到一个驱动器号      %~pI        - 仅将 %I 扩展到一个路径      %~nI        - 仅将 %I 扩展到一个文件名      %~xI        - 仅将 %I 扩展到一个文件扩展名      %~sI        - 扩展的路径只含有短名      %~aI        - 将 %I 扩展到文件的文件属性      %~tI        - 将 %I 扩展到文件的日期/时间      %~zI        - 将 %I 扩展到文件的大小      %~$PATH:I   - 查找列在路径环境变量的目录，并将 %I 扩展                    到找到的第一个完全合格的名称。如果环境变量名                    未被定义，或者没有找到文件，此组合键会扩展到                    空字符串  可以组合修饰符来得到多重结果:       %~dpI       - 仅将 %I 扩展到一个驱动器号和路径      %~nxI       - 仅将 %I 扩展到一个文件名和扩展名      %~fsI       - 仅将 %I 扩展到一个带有短名的完整路径名      %~dp$PATH:I - 搜索列在路径环境变量的目录，并将 %I 扩展                    到找到的第一个驱动器号和路径。      %~ftzaI     - 将 %I 扩展到类似输出线路的 DIR  在以上例子中，%I 和 PATH 可用其他有效数值代替。%~ 语法 用一个有效的 FOR 变量名终止。选取类似 %I 的大写变量名 比较易读，而且避免与不分大小写的组合键混淆。

是楼上的大神写的~我想问问  我要是想一次性的处理一个文件夹中全部文档应该如何改进这个程序呢？请大神指教

这代码，好熟啊，是我写的吗？

比较晚了，没心思细看，看着程序的思路是没有问题的。 你有没有运行过？运行过的结果是什么？ 还是不知道怎么用？ 如果不知道，我说明一下： stop.txt 停用词列表文件 src.txt 待处理的文件 des.txt 处理后的文件。


Question: 求大神相助，我的课设找了好久都不知道哪里出错了

F10单步调试一下看看么，你这么长代码，都懒得看懒得分析

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


Question: 求教一个关于C语言字符串的问题，直接使用“string”不可以

引用 2 楼 u013790834 的回复:TXBUFF是什么？是个字符串吗？你在while循环的时候只有*str++？TXBUFF这个东西不加吗？   TXBUFF是单片机的数据发送寄存器，给他赋值，直接就在串口发送出去了。

引用 1 楼 user-5 的回复:C语言静态字符串是存储在程序的静态存储区域，const  char *ptr = "..." 和 char ptr[] = "..." 的区别是左边的ptr是指针，指针放置在栈上，但是指向的区域则是静态存储空间中的字符串（应该是一个特殊的数据段里面），而右边的ptr是字符数组，全部内容保存在栈里面。难道你的单片机程序没有静态存储区域吗？  我也觉得奇怪，所以来问问，还没来得及在VC上试试。

引用 4 楼 mymtom 的回复:在C语言层面，写法没有问题的啊！  你头像是DATA的TB吗，这是我喜欢的英雄，可惜早就削弱成渣了。  我也觉得这个写法没问题，可是我的单片机就是不认，没理由这个单片机的编译器会不支持静态存储区的存储啊。

const 与指针配合的时候有很多种 用法的 const char *p char const  *p  char * const p

引用 8 楼 gzwgyfgpf 的回复:我觉得应该是const的缘故，你把字符指针的const去掉试试，前面的应该也可以  貌似无用

引用 3 楼 mymtom 的回复:while(*str != '/0') ===> while(*str != '\0')   这是个我在写帖子时候的笔误

在C语言层面，写法没有问题的啊！


Question: C语言编译报错（ACM上报错，但是三种编译器都通过）

中文空格和英文空格有差距？？TAT我的天.....

问题解决了。。是代码中有中文空格符号，非常隐蔽的问题，用notepad替换掉了中文空格，ACM上可以提交通过了，谢谢大神

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

编译器不同，差异可能很大的 我在我的机器上编译，加了两个头文件，用gcc(gcc version 4.4.6 20110731 (Red Hat 4.4.6-3) (GCC) )编译通过，代码如下： #include<stdio.h> #include <stdlib.h> #include <time.h> #include <string.h> int WQD=0x3f3f3f3f; typedef struct { 	int data; 	int fu; }jgt; jgt d[100];//建立100个结点   void Huffman(int n) { 	int m1,m2,x1,x2,t,i,j; 	for(i=0;i<n;i++) 	{ 		m1=m2=WQD; 		for(j=0;j<n+i;j++)//找到两个较小值的根结点 		{ 			if(m1>d[j].data&&d[j].fu==-1&&d[j].data!=0) 			{ 				m2=m1; 				m1=d[j].data; 				x2=x1; 				x1=j; 			} 			else if(m2>d[j].data&&d[j].fu==-1&&d[j].data!=0) 			{ 				x2=j; 				m2=d[j].data; 			} 		} 		if(m2!=WQD) 		{ 			t=n+i; 			d[t].data=m1+m2;//加入结点 			d[x1].fu=t; 			d[x2].fu=t; 		} 	} } int main() { 	clock_t start,finish; //测试运行时间  	start=clock(); 	char s[2000]; 	int i,l,c,p,zjs; 	while(scanf("%s",s)) 	{ 		if(strcmp(s,"END")==0) 			break; 		for(i=0;i<80;i++)//初始化 		{ 			d[i].data=0; 			d[i].fu=-1; 		} 		l=strlen(s);//记录字符串扯? 		for(i=0;i<l;i++) 			if(s[i]=='_') 				d[26].data++; 			else 				d[s[i]-'A'].data++; 		Huffman(27);//建立哈弗曼树 		for(i=0;i<=26;i++) 		{ 			c=0; 			if(d[i].data!=0) 			{ 				p=i; 				while(d[p].fu!=-1) 				{ 					c++; 					p=d[p].fu; 				} 				if(c==0) 					c=1; 				d[i].data=c; 			} 		} 		zjs=0;//zjs记录所需总字节数 		for(i=0;i<l;i++) 		{ 			if(s[i]=='_') 				zjs+=d[26].data; 			else 				zjs+=d[s[i]-'A'].data; 		} 		printf("%d %d %.1f\n",8*l,zjs,8.0*l*1.0/zjs); 		finish=clock(); 		printf("共耗时%.3lf秒",((double)finish-start)/1000); 	}           	return 0;  }


Question: 为什么C语言能稳居计算机语言排行榜第二

嗯，决定以后精通C语言和.net，哈哈。

就算工作中 用的是c++  java python 等等， 依然建议把c学好学精。   对你以后学其他语言都事半功倍。  学好了c， 给你一门其他语言，你从没接触过的语言，你都可以很自信的1周开始开发工作。

我学电气的，用c的话可以更有效率咯

我的经验，学会用C和python，可以干你想干的任何与编程有关的事情。ps. python排第几？

这个问题就和该学哪门编程语言好一样，其实没什么标准答案，关键在于你计划以后干什么工作，接触的是哪门语言，这是我个人结合老师的话的一点想法

引用 8 楼 luoweifu 的回复:引用 6 楼 zhao4zhong1 的回复:为什么C语言不能稳居计算机语言排行榜第一？因为事实就是从10年到现在基本都是排名第二，我觉得这已经很牛逼了。 因为商业应用层业务逻辑和手机APP开发的份额被java抢走了。

我感觉嵌入式做设备什么的，底层的硬件环境还是比较需要效率，仪表阿，电子设备啊，还都是在用c来推动吧，这是软件应用的一大块东西，当然越来越多的被android之类的替代了

随便举几例子，web服务器如：apache，nginx。数据库如:mysql。操作系统：linux,unix。java的jvm。windows的MSDN中API函数都是以C形式给出的。这些够了不？

低层开发用C容易构建，C有历史了，共享库也多，但是应用上层的开发都是高级语言了，JAVA  啥的。

因为抵制高级语言的人很多   毕竟老一批的程序员还健在啊 你不能指望快退休的人还来重新学语言啊

c大部分时间都在一二吧, 至于面向过程或者面向对象就难分了, 有些人用c++的class当做struct在用,还不就是在用c, 我觉得unix系多用c, 这一系很多呀象unix,linux(象苹果和安卓底层不都是嘛)

网搜一下咯！

C的却是面向过程的语言，但是，面向对象C照样能实现啊（比如gobject）。C语言的代码怎么会越来越少，我就是用C开发流媒体服务器，要知道操作系统都是用C写的，你就能明白C的地位了。

为什么C语言不能稳居计算机语言排行榜第一？


Question: 数学问题：让一个点画圆的同时向一个方向匀速运动，方程怎么写？

圆{x0,y0,r}的方程,参数a x=rcos(a)+y0 y=rsin(a)+y0 均匀画圆，用时为T，参数t a=t/T*2π 直线匀速移动,用时为T,起终点为{x00,y00},{x01,y01} x0=t/T*(x01-x00)+x00 y0=t/T*(y01-y00)+y00 带入圆的方程,得到xy关于t的方程 其中T,r,x00,y00,x01,y01为控制常数

高中数学 复习一下


Question: 一元多项式加减法计算器代码，我刚开始单独写了加法，然后写了减法，一起后不行，现在把代码放上去。望各位大神帮帮小女子

小女子，要学会调试哦


Question: C语言free问题，出现运行时错误CRT

引用 3 楼 zhao4zhong1 的回复:崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  仅供参考：//将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> 这个够我看很久了，谢谢。

引用 2 楼 threshold1980 的回复:你尝试单步跟一下，在崩溃前是不是指针指的空间已经是空的了，试图去free一个无效的地址嗯，已经找到错了。是malloc时申请的大小有错。

补充一下，楼主用的是vs2015


Question: 新手请教如何读取指定行字符串

引用 1 楼 user-4 的回复:没理解啥意思，如果是二维数组变量的话，不是直接写行数就可以跳转吗？ 不是二维数组是char *str

引用 3 楼 dabanzhu111 的回复:这功能我以前做过好像 326技术交流综合平台 http://www.sanerliu.com 能说一下当时你怎么做的吗

重新声明一个char*的数组，先写个循环，把每行分开放到里面，之后要第几行都只接调用  比如你声明的数组名叫s, 需要第一行，就s[0]，第二行s[1]....

仅供参考： #include <stdio.h> #include <string.h> #include <conio.h> FILE *f,*fl; long lastoffset=0,linenum=0; char ln[256]; int n,k; int main() {     fl=fopen("lastoffset","r");     if (fl) {         fscanf(fl,"%d %d",&lastoffset,&linenum);         fclose(fl);     }     f=fopen("data.txt","rb");     fseek(f,lastoffset,SEEK_SET);     while (1) {         if (NULL==fgets(ln,255,f)) {             lastoffset=0;             linenum=0;             break;         }         if ('\n'==ln[strlen(ln)-1]) ln[strlen(ln)-1]=0;         if ('\r'==ln[strlen(ln)-1]) ln[strlen(ln)-1]=0;         lastoffset=ftell(f);         linenum++;         printf("%8d: %s\n",linenum,ln);         k=getch();         if (k==27) break;//按Esc键提前退出     }     fclose(f);     fl=fopen("lastoffset","w");     fprintf(fl,"%d %d",lastoffset,linenum);     fclose(fl);     return 0; }

引用 6 楼 iam007008 的回复:[quote=引用 2 楼 mewiteor 的回复:] 除非每行的长度一样长 如果一样长怎么读取呢，另外在请教一下 一个字符串能不能从指定字节开始读取呢，比如先读取前面1000字节，然后下次再从1001字节开始读取。[/quote]那就从str[1001]开始

引用 2 楼 mewiteor 的回复:除非每行的长度一样长 如果一样长怎么读取呢，另外在请教一下 一个字符串能不能从指定字节开始读取呢，比如先读取前面1000字节，然后下次再从1001字节开始读取。

除非每行的长度一样长

没理解啥意思，如果是二维数组变量的话，不是直接写行数就可以跳转吗？


Question: 对fopen、fclose, fread和fwrite函数的使用不怎么会

使用命令重定向操作符可以使用重定向操作符将命令输入和输出数据流从默认位置重定 向到不同的位置。输入或输出数据流的位置即为句柄。  下表将列出可用的句柄。  句柄      句柄的数字代号 描述 STDIN     0              键盘输入 STDOUT    1              输出到命令提示符窗口 STDERR    2              错误输出到命令提示符窗口 UNDEFINED 3-9            这些句柄由应用程序单独定义，并且是各个工具特定的。  数字 0 到 9 代表前 10 个句柄。可以使用命令 Cmd.exe 运行程序并将该程序前 10 个 句柄中的任何一个重定向。要指定想使用的句柄，可在重定向操作符前面键入该句柄的 数字。如果未定义句柄，则默认的 < 重定向输入操作符是 0，而默认的 > 重定向输出 操作符是 1。键入 > 或 < 操作符之后，必须指定要读取或写入数据的位置。可以指定 文件名或另一个现有的句柄。  要指定重定向到现有句柄，请使用与 (&) 字符，后面接要重定向的句柄号 （例如 &句柄#）。例如，下面的命令可以将句柄 2（即 STDERR）重定向到 句柄 1（即 STDOUT）：  2>&1  下表列出了可用于将输入和输出数据流进行重定向的操作符。  重定向操作符 描述 > 将命令输出写入到文件或设备（例如打印机）中，而不是写在命令提示符窗口或句柄中。 < 从文件中而不是从键盘或句柄中读入命令输入。 >> 将命令输出添加到文件末尾而不删除文件中的信息。 >& 将一个句柄的输出写入到另一个句柄的输入中。 <& 从一个句柄读取输入并将其写入到另一个句柄输出中。 | 从一个命令中读取输出并将其写入另一个命令的输入中。也称作管道。  默认情况下，可以从键盘将命令输入（即 STDIN 句柄）发送到 Cmd.exe，然后由 Cmd.exe 将命令输出（即 STDOUT 句柄）发送到命令提示符窗口。  重定向输入 (<) 要将键盘输入重定向到文件或设备，请使用 < 操作符。例如，要从 File.txt 获取 sort 命令的输入，请键入：  sort<file.txt  File.txt 的内容将以字母顺序列表的方式显示在命令提示符窗口中。  < 操作符可以打开具有只读访问的指定文件名。所以，不能使用该操作符向文件中写入 信息。例如，如果以 <&2 启动程序，则所有试图读取句柄 0 的操作都将失败，因为句 柄 2 最初是以只写访问打开的。   注意  0 是 < 重定向输入操作符的默认句柄。 重定向输出 (>) 几乎所有的命令都将输出发送到命令提示符窗口。即使将输出发送到驱动器或打印机的 命令也会在命令提示符窗口显示消息和提示。  要将输出从命令提示符窗口重定向到文件或设备，请使用 > 操作符。可以在许多命令中 使用该操作符。例如，要将 dir 输出重定向到 Dirlist.txt，请键入：  dir>dirlist.txt  如果 Dirlist.txt 不存在，Cmd.exe 将创建该文件。如果 Dirlist.txt 存在，Cmd.exe 将使用 dir 命令的输出替换文件中的信息。  要运行 netsh routing dump 命令，然后将输出发送到 Route.cfg，请键入：  netsh routing dump>c:\route.cfg  > 操作符可以打开具有只写访问属性的指定文件。所以，不能使用该操作符读取文件。 例如，如果使用重定向 >&0 启动程序，则所有试图写入句柄 1 的操作都将失败，因为 句柄 0 最初是以只读访问打开的。   注意  1 是 > 重定向输出操作符的默认句柄。 复制句柄 重定向操作符 & 可以将输出或输入从一个指定句柄复制到另一个指定的句柄。例如， 要将 dir 输出发送到 File.txt 并将错误输出发送到 File.txt，请键入：  dir>c:\file.txt 2>&1  复制句柄时，可以复制该句柄原状态的所有特性。例如，如果一个句柄具有只写访问的 属性，则该句柄的所有副本都具有只写访问属性。不能将一个具有只读访问属性的句柄 复制到另一个具有只写访问属性的句柄。  使用 & 操作符重定向输入和副本 要将重定向输入操作符 (<) 与复制操作符 (&) 一起使用，指定的文件必须已经存在。 如果输入文件存在，Cmd.exe 将以只读方式打开该文件，然后将文件中包含的字符作为 输入发送到此命令（如同从键盘输入一样）。如果指定了句柄，Cmd.exe 将指定的句柄 复制到系统现有的句柄中。  例如，要以句柄 0 输入读取（即 STDIN）的方式打开 File.txt，请键入：  <file.txt  要打开 File.txt，并在内容排序后将输出发送到命令提示符窗口（即 STDOUT），请键入：  sort<file.txt  要查找 File.txt，然后将句柄 1（即 STDOUT）和句柄 2（即 STDERR）重定向到 Search.txt，请键入：  findfile file.txt>search.txt 2<&1  要以句柄 0 输入读取（即 STDIN）的方式复制用户定义句柄 3，请键入：  <&3  使用 & 操作符重定向输出和复制 如果将输出重定向到文件且指定了现有的文件名，Cmd.exe 将以只写方式打开文件并覆 盖该文件内容。如果指定了句柄，Cmd.exe 将文件复制到现有句柄中。  要将用户定义句柄 3 复制到句柄 1，请键入：  >&3  要将包括句柄 2（即 STDERR）的所有输出从 ipconfig 命令重定向到 句柄 1（即 STDOUT），然后将输出重定向到 Output.log，请键入：  ipconfig.exe>>output.log 2>&1  使用 >> 重定向操作符追加输出 要从命令中将输出添加到文件末尾而不丢失文件中已存在的任何信息，请使用两个连续 的大于号（即 >>）。例如，下面的命令可以将由 dir 命令生成的目录列表追加到 Dirlist.txt 文件：  dir>>dirlist.txt  要将 netstat 命令的输出追加到 Tcpinfo.txt 的末尾，请键入：  netstat>>tcpinfo.txt  使用管道操作符 (|) 管道操作符 (|) 可以提取一个命令的输出（默认情况下是 STDOUT），然后将其导入另 一个命令的输入中（默认情况下是 STDIN）。例如，下面的命令将对目录分类：  dir | sort  在本例中，将同时启动两个命令，但随后 sort 命令会暂停，直到它接收到 dir 命令 的输出为止。sort 命令使用 dir 命令的输出作为输入，然后将输出发送到 句柄 1（即 STDOUT）。  合并带重定向操作符的命令 可以通过合并带有其他命令和文件名的筛选器命令创建自定义命令。例如，可以使用以 下命令存储包含“LOG”字符串的文件名:  dir /b | find "LOG" > loglist.txt  dir 命令的输出通过 find 筛选器命令发送。包含字符串 "LOG" 的文件名作为文件名 列表（例如，NetshConfig.log、Logdat.svd 和 Mylog.bat）存储在文件 Loglist.txt 中。  要在相同命令中使用多个筛选器，请使用管道 (|) 分隔筛选器。例如，下面的命令将 搜索 C 盘上的每个目录以查找包含 "LOG" 字符串的文件名，并且在命令提示符窗口中 每次显示一屏：  dir c:\ /s /b | find "LOG" | more  利用管道 (|) 可以将 Cmd.exe 导向为通过 find 筛选器命令发送 dir 命令输出。 find 命令只选择包含字符串 "LOG" 的文件名。more 命令可以显示由 find 命令选择 的文件名（在命令提示符窗口中每次显示一屏）。有关筛选器命令的详细信息，请参阅 使用筛选器。

仅供参考：#include <iostream> #include <string> #include <algorithm> using namespace std; int COMPARE(string number1, string number2) {     int i,j;      int length1 = number1.size();     int length2 = number2.size();      if(number1.size() == 0) number1 = "0";     if(number2.size() == 0) number2 = "0";      j = 0;     for(i = 0; i < length1; ++i) {         if(number1[i] == '0') ++j;         else break;     }     number1 = number1.substr(j);      j = 0;     for(i = 0; i < length2; ++i) {         if(number2[i] == '0') ++j;         else break;     }     number2 = number2.substr(j);      length1 = number1.size();     length2 = number2.size();      if(length1 > length2) {         return 1;     } else if(length1 == length2) {         if(number1.compare(number2) > 0) {             return 1;         } else if(number1.compare(number2) == 0) {             return 0;         } else {             return -1;         }     } else {         return -1;     }      return 0; } string PLUS(string number1,string number2) {     int i;     int length1 = number1.size();     int length2 = number2.size();      string result="";      reverse(number1.begin(), number1.end());     reverse(number2.begin(), number2.end());      for(i = 0; i < length1 && i < length2; i++) {         char c = (char)(number1[i] + number2[i] - 48);         result = result + c;     }      while(i < length1) {         result = result + number1[i];         ++i;     }      while(i < length2) {         result = result + number2[i];         ++i;     }      int carry = 0;     for(i = 0; i < (int)result.size(); ++i) {         int value = result[i] - 48 + carry;         result[i] = (char)(value % 10 + 48);         carry = value / 10;     }      if(carry !=0 ) {         result = result + (char)(carry + 48);     }      for(i = result.size() - 1; i >= 0; i--) {         if(result[i] != '0') break;     }      result = result.substr(0, i + 1);      reverse(result.begin(), result.end());     if(result.length() == 0) result = "0";     return result; } string MINUS(string number1,string number2) {     int i;     string result = "";      int length1 = number1.size();     int length2 = number2.size();      if(COMPARE(number2,number1) > 0) {         return "-" + MINUS(number2, number1);     }      reverse(number1.begin(),number1.end());     reverse(number2.begin(),number2.end());      for(i = 0; i < length1 && i < length2; i++) {         char c = number1[i] - number2[i] + 48;         result = result + c;     }      if(i < length1) {         for(; i < length1; i++) {             result = result + number1[i];         }     }      int carry = 0;     for(i = 0; i < (int)result.length(); i++) {         int value = result[i] - 48 + carry;         if(value < 0) {             value = value + 10;             carry = -1;         } else carry = 0;         result[i]=(char)(value + 48);     }      for(i = result.size() - 1; i >= 0; i--) {         if(result[i] != '0')break;     }      result = result.substr(0, i+1);      reverse(result.begin(), result.end());     if(result.length()==0) result = "0";     return result; } string MULTIPLY(string number1, string number2) {     int i, j;     int *iresult;     int length1 = number1.size();     int length2 = number2.size();     string result = "";      reverse(number1.begin(), number1.end());     reverse(number2.begin(), number2.end());      iresult = (int*)malloc(sizeof(int) * (length1 + length2 + 1));     memset(iresult, 0, sizeof(int) * (length1 + length2 + 1));      for(i = 0; i < length1; i++) {         for(j = 0; j < length2; j++) {             iresult[i+j] += ((number1[i] - 48) * (number2[j] - 48));         }     }      int carry = 0;     for(i = 0; i < length1 + length2; i++) {         int value = iresult[i] + carry;         iresult[i] = value % 10;         carry = value / 10;     }      for(i = length1 + length2 - 1; i >= 0; i--) {         if(iresult[i] != 0)break;     }      for(; i >= 0; i--) {         result = result + (char)(iresult[i]+48);     }      free(iresult);      if(result == "") result = "0";     return result; } string factorial(string n) {     string temp = "1";     string i;     for(i = "1"; COMPARE(i, n) <= 0; i = PLUS(i, "1")) {         temp = MULTIPLY(temp, i);     }     return temp; } int main(void) {     cout << factorial("100") << endl;     return 0; }

我找过了，没有那种特别清楚的，我的电脑VC运行不了，想要运行结果也看不到

http://7666425.blog.51cto.com/7656425/1264690 网上很多，随便都能找到参考的


Question: 判断buf中的数据

#include<iostream> #include<stdio.h>  using std::cout; using std::endl;   int main(int argc, char **argv) {     char tmp[3][1024] = { "EB905716165790EBsfsfsfasdaf", "xsffEB905716165790EBdogfd.gf;gdk", "\0" };      for( int i = 0; i < 3; i++ )     {         if( 0 != strncmp(tmp[i], "EB905716165790EB", 16) ) // 比较前16个字符         {             // 如果没什么强制要求和需求必须使用memset，你可以用tmp[0] = '\0'让字符串为空串             //memset(tmp[i], 0, sizeof(tmp[i]) );             tmp[i][0] = '\0';         }          cout << tmp[i] << endl;     } }

memcmp Compare characters in two buffers.  int memcmp( const void *buf1, const void *buf2, size_t count );  Routine Required Header Compatibility  memcmp <memory.h> or <string.h> ANSI, Win 95, Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  The return value indicates the relationship between the buffers.  Return Value Relationship of First count Bytes of buf1 and buf2  < 0 buf1 less than buf2  0 buf1 identical to buf2  > 0 buf1 greater than buf2    Parameters  buf1  First buffer  buf2  Second buffer  count  Number of characters  Remarks  The memcmp function compares the first count bytes of buf1 and buf2 and returns a value indicating their relationship.  Example  /* MEMCMP.C: This program uses memcmp to compare  * the strings named first and second. If the first  * 19 bytes of the strings are equal, the program  * considers the strings to be equal.  */  #include <string.h> #include <stdio.h>  void main( void ) {    char first[]  = "12345678901234567890";    char second[] = "12345678901234567891";    int result;     printf( "Compare '%.19s' to '%.19s':\n", first, second );    result = memcmp( first, second, 19 );    if( result < 0 )       printf( "First is less than second.\n" );    else if( result == 0 )       printf( "First is equal to second.\n" );    else if( result > 0 )       printf( "First is greater than second.\n" );    printf( "Compare '%.20s' to '%.20s':\n", first, second );    result = memcmp( first, second, 20 );    if( result < 0 )       printf( "First is less than second.\n" );    else if( result == 0 )       printf( "First is equal to second.\n" );    else if( result > 0 )       printf( "First is greater than second.\n" ); }   Output  Compare '1234567890123456789' to '1234567890123456789': First is equal to second. Compare '12345678901234567890' to '12345678901234567891': First is less than second.   Buffer Manipulation Routines  See Also   _memccpy, memchr, memcpy, memset, strcmp, strncmp

你这个EB905716165790EB表示是ascii码？还是16进制的字节？不管是哪种情况，都不能用strcmp,用memcmp就可以了。

memcmp 上面打错了

一般控制数据协议，读取某一个字节就行了

取buffer前面的字符出来进行比对？

memcpy strncmp 都可以


Question: ACM一道题，关于二叉树的，老是Runtime Error，不知道哪里错了

仅供参考：#include <iostream> #include <stack> #include <queue> #include <locale.h> using namespace std; typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int CreateBiTree(BiTree &T) {//按先序序列创建二叉树     char data;     scanf("%c",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         T = NULL;     } else {         T = (BiTree)malloc(sizeof(BiTNode));         T->data = data;         //生成根结点         CreateBiTree(T->lchild);//构造左子树         CreateBiTree(T->rchild);//构造右子树     }     return 0; } void Visit(BiTree T) {//输出     if (T->data != '#') {         printf("%c ",T->data);     } } void PreOrder(BiTree T) {//先序遍历     if (T != NULL) {         Visit(T);               //访问根节点         PreOrder(T->lchild);    //访问左子结点         PreOrder(T->rchild);    //访问右子结点     } } void InOrder(BiTree T) {//中序遍历     if (T != NULL) {         InOrder(T->lchild);     //访问左子结点         Visit(T);               //访问根节点         InOrder(T->rchild);     //访问右子结点     } } void PostOrder(BiTree T) {//后序遍历     if (T != NULL) {         PostOrder(T->lchild);   //访问左子结点         PostOrder(T->rchild);   //访问右子结点         Visit(T);               //访问根节点     } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。     stack<BiTree> stack;     BiTree p = T;//p是遍历指针     while (p || !stack.empty()) {   //栈不空或者p不空时循环         if (p != NULL) {             stack.push(p);          //存入栈中             printf("%c ",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             p = stack.top();        //退栈             stack.pop();             p = p->rchild;          //访问右子树         }     } } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     stack<BiTree> stack;     BiTree p = T;//p是遍历指针     while (p || !stack.empty()) {   //栈不空或者p不空时循环         if (p != NULL) {             stack.push(p);          //存入栈中             p = p->lchild;          //遍历左子树         } else {             p = stack.top();        //退栈，访问根节点             printf("%c ",p->data);             stack.pop();             p = p->rchild;          //访问右子树         }     } }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     stack<BiTreePost> stack;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || !stack.empty()) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack.push(BT);             p = p->lchild;         }         while (!stack.empty() && (stack.top())->tag == 'R') {//左右子树访问完毕访问根节点             BT = stack.top();             stack.pop();//退栈             printf("%c ",BT->biTree->data);         }         if (!stack.empty()) {//遍历右子树             BT = stack.top();             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     } }  void LevelOrder(BiTree T) {//层次遍历     if (T == NULL) return;     BiTree p = T;     queue<BiTree> queue;//队列     queue.push(p);//根节点入队     while (!queue.empty()) {    //队列不空循环         p = queue.front();      //对头元素出队         printf("%c ",p->data);  //访问p指向的结点         queue.pop();            //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue.push(p->lchild);         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue.push(p->rchild);         }     } } int main() {     BiTree T;      setlocale(LC_ALL,"chs");     CreateBiTree(T);      printf("先序遍历        ：");PreOrder  (T);printf("\n");     printf("先序遍历(非递归)：");PreOrder2 (T);printf("\n");                                                printf("\n");     printf("中序遍历        ：");InOrder   (T);printf("\n");     printf("中序遍历(非递归)：");InOrder2  (T);printf("\n");                                                printf("\n");     printf("后序遍历        ：");PostOrder (T);printf("\n");     printf("后序遍历(非递归)：");PostOrder2(T);printf("\n");                                                printf("\n");     printf("层次遍历        ：");LevelOrder(T);printf("\n");      return 0; } //ABC##DE#G##F### //先序遍历        ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历        ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历        ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历        ：A B C D E F G //  ///       A ///      / ///     B ///    / \ ///   C   D ///      / \ ///     E   F ///      \ ///       G


Question: 我写了一个播放音乐的线程，怎样才能控制它按指定的按键就停止呢

仅供参考：#include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef WIN32     #include <windows.h>     #include <io.h>     #include <process.h>     #define  MYVOID             void #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  _vsnprintf         vsnprintf     #define  MYVOID             void * #endif //Log{ #define MAXLOGSIZE 20000000 #define ARRSIZE(x) (sizeof(x)/sizeof(x[0])) #include <time.h> #include <sys/timeb.h> #include <stdarg.h> char logfilename1[]="MyLog1.log"; char logfilename2[]="MyLog2.log"; char logstr[16000]; char datestr[16]; char timestr[16]; char mss[4]; CRITICAL_SECTION cs_log; FILE *flog; #ifdef WIN32 void Lock(CRITICAL_SECTION *l) {     EnterCriticalSection(l); } void Unlock(CRITICAL_SECTION *l) {     LeaveCriticalSection(l); } void sleep_ms(int ms) {     Sleep(ms); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } void sleep_ms(int ms) {     usleep(ms*1000); } #endif void LogV(const char *pszFmt,va_list argp) {     struct tm *now;     struct timeb tb;       if (NULL==pszFmt||0==pszFmt[0]) return;     if (-1==_vsnprintf(logstr,ARRSIZE(logstr),pszFmt,argp)) logstr[ARRSIZE(logstr)-1]=0;     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,"%03d",tb.millitm);     printf("%s %s.%s %s",datestr,timestr,mss,logstr);     flog=fopen(logfilename1,"a");     if (NULL!=flog) {         fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);         if (ftell(flog)>MAXLOGSIZE) {             fclose(flog);             if (rename(logfilename1,logfilename2)) {                 remove(logfilename2);                 rename(logfilename1,logfilename2);             }             flog=fopen(logfilename1,"a");             if (NULL==flog) return;         }         fclose(flog);     } } void Log(const char *pszFmt,...) {     va_list argp;      Lock(&cs_log);     va_start(argp,pszFmt);     LogV(pszFmt,argp);     va_end(argp);     Unlock(&cs_log); } //Log} int No_Loop=0; MYVOID testThread(void *pcn) {     int n,i;      n=(int)pcn;     i=0;     while (1) {         sleep_ms(1000);         Log("in testThread %d:i==%ds\n",n,++i);         if (i>=5) No_Loop=1;     } } int main(int argc,char * argv[]) {     int i; #ifdef WIN32     InitializeCriticalSection(&cs_log); #else     pthread_mutex_init(&cs_log,NULL);     pthread_t threads[1];     int threadsN;     int rc; #endif     Log("=========BEGIN==================\n"); #ifdef WIN32     _beginthread((void(__cdecl *)(void *))testThread,0,(void *)1); #else     threadsN=0;     rc=pthread_create(&(threads[threadsN++]),NULL,testThread,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1); #endif     i=0;     while (1) {         sleep_ms(100);         Log("in main:i==%d\n",++i);         if (No_Loop==1) break;//     }     Log("=========END====================\n"); #ifdef WIN32     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_log); #endif     return 0; } //2012-06-14 16:27:21.500 =========BEGIN================== //2012-06-14 16:27:21.609 in main:i==1 //2012-06-14 16:27:21.718 in main:i==2 //2012-06-14 16:27:21.828 in main:i==3 //2012-06-14 16:27:21.937 in main:i==4 //2012-06-14 16:27:22.046 in main:i==5 //2012-06-14 16:27:22.156 in main:i==6 //2012-06-14 16:27:22.265 in main:i==7 //2012-06-14 16:27:22.375 in main:i==8 //2012-06-14 16:27:22.484 in main:i==9 //2012-06-14 16:27:22.500 in testThread 1:i==1s //2012-06-14 16:27:22.593 in main:i==10 //2012-06-14 16:27:22.703 in main:i==11 //2012-06-14 16:27:22.812 in main:i==12 //2012-06-14 16:27:22.921 in main:i==13 //2012-06-14 16:27:23.031 in main:i==14 //2012-06-14 16:27:23.140 in main:i==15 //2012-06-14 16:27:23.250 in main:i==16 //2012-06-14 16:27:23.359 in main:i==17 //2012-06-14 16:27:23.468 in main:i==18 //2012-06-14 16:27:23.500 in testThread 1:i==2s //2012-06-14 16:27:23.578 in main:i==19 //2012-06-14 16:27:23.687 in main:i==20 //2012-06-14 16:27:23.796 in main:i==21 //2012-06-14 16:27:23.906 in main:i==22 //2012-06-14 16:27:24.015 in main:i==23 //2012-06-14 16:27:24.125 in main:i==24 //2012-06-14 16:27:24.234 in main:i==25 //2012-06-14 16:27:24.343 in main:i==26 //2012-06-14 16:27:24.453 in main:i==27 //2012-06-14 16:27:24.500 in testThread 1:i==3s //2012-06-14 16:27:24.562 in main:i==28 //2012-06-14 16:27:24.671 in main:i==29 //2012-06-14 16:27:24.781 in main:i==30 //2012-06-14 16:27:24.890 in main:i==31 //2012-06-14 16:27:25.000 in main:i==32 //2012-06-14 16:27:25.109 in main:i==33 //2012-06-14 16:27:25.218 in main:i==34 //2012-06-14 16:27:25.328 in main:i==35 //2012-06-14 16:27:25.437 in main:i==36 //2012-06-14 16:27:25.500 in testThread 1:i==4s //2012-06-14 16:27:25.546 in main:i==37 //2012-06-14 16:27:25.656 in main:i==38 //2012-06-14 16:27:25.765 in main:i==39 //2012-06-14 16:27:25.875 in main:i==40 //2012-06-14 16:27:25.984 in main:i==41 //2012-06-14 16:27:26.093 in main:i==42 //2012-06-14 16:27:26.203 in main:i==43 //2012-06-14 16:27:26.312 in main:i==44 //2012-06-14 16:27:26.421 in main:i==45 //2012-06-14 16:27:26.500 in testThread 1:i==5s //2012-06-14 16:27:26.531 in main:i==46 //2012-06-14 16:27:26.531 =========END====================

控制和播放应在不同的线程中

可以使用SuspendThread(...)挂起播放线程 就可以实现“暂停”了，ResumeThread(...)续挂起的线程 实现“继续”播放


Question: 能计算加减乘除表达式，求添加计算平方、三角函数的功能，在线等，急

楼主如果还想在这方面探究下去的话： http://www.codeproject.com/Articles/286121/Compiler-Patterns 或 参考Tiny C Compiler源代码。

前两天CSDN C/C++论坛离了zhao4zhong1这根胡萝卜还真开不了席了！

這個計算器 的計算，是不是只能計算 類似於a*b+c*d这样格式的表逹式？  對於三角函數，楼上已經說了。有對應的庫，google一下就有大把答案。

原理的话 平方可以用二分法 三角函数貌似只能用级数

再math中有好多库函数，可以利用

仅供参考：/*--------------------------------------- 函数型计算器(VC++6.0,Win32 Console)程序由 yu_hua 于2007-07-27设计完成 功能： 目前提供了10多个常用数学函数:     ⑴正弦sin     ⑵余弦cos     ⑶正切tan     ⑷开平方sqrt     ⑸反正弦arcsin     ⑹反余弦arccos     ⑺反正切arctan     ⑻常用对数lg     ⑼自然对数ln     ⑽ｅ指数exp     ⑾乘幂函数∧ 用法： 如果要求2的32次幂，可以打入2^32<回车> 如果要求30度角的正切可键入tan(Pi/6)<回车> 注意不能打入：tan(30)<Enter> 如果要求1.23弧度的正弦，有几种方法都有效： sin(1.23)<Enter> sin 1.23 <Enter> sin1.23  <Enter> 如果验证正余弦的平方和公式,可打入sin(1.23)^2+cos(1.23)^2 <Enter>或sin1.23^2+cos1.23^2 <Enter> 此外两函数表达式连在一起,自动理解为相乘如：sin1.23cos0.77+cos1.23sin0.77就等价于sin(1.23)*cos(0.77)+cos(1.23)*sin(0.77) 当然你还可以依据三角变换，再用sin(1.23+0.77)也即sin2验证一下。 本计算器充分考虑了运算符的优先级因此诸如：2+3*4^2 实际上相当于：2+(3*(4*4)) 另外函数名前面如果是数字,那么自动认为二者相乘. 同理，如果某数的右侧是左括号，则自动认为该数与括弧项之间隐含一乘号。 如：3sin1.2^2+5cos2.1^2 相当于3*sin2(1.2)+5*cos2(2.1) 又如：4(3-2(sqrt5-1)+ln2)+lg5 相当于4*(3-2*(√5 -1)+loge(2))+log10(5) 此外，本计算器提供了圆周率 Pi键入字母时不区分大小写,以方便使用。 ----------------------------------------*/ #include <iostream> #include <iomanip> #include <cstdlib> #include <cstring> #include <cctype> #include <cmath> #include <stdio.h> #include <string.h> #include <windows.h> using namespace std; const char Tab=0x9; const int  DIGIT=1; const int MAXLEN=16384; char s[MAXLEN],*endss; int pcs=15; double fun(double x,char op[],int *iop) {     while (op[*iop-1]<32) //本行使得函数嵌套调用时不必加括号,如 arc sin(sin(1.234)) 只需键入arc sin sin 1.234<Enter>         switch (op[*iop-1]) {         case  7: x=sin(x);  (*iop)--;break;         case  8: x=cos(x);  (*iop)--;break;         case  9: x=tan(x);  (*iop)--;break;         case 10: x=sqrt(x); (*iop)--;break;         case 11: x=asin(x); (*iop)--;break;         case 12: x=acos(x); (*iop)--;break;         case 13: x=atan(x); (*iop)--;break;         case 14: x=log10(x);(*iop)--;break;         case 15: x=log(x);  (*iop)--;break;         case 16: x=exp(x);  (*iop)--;break;         }     return x; } double calc(char *expr,char **addr) {     static int deep; //递归深度     static char *fname[]={ "sin","cos","tan","sqrt","arcsin","arccos","arctan","lg","ln","exp",NULL};     double ST[10]={0.0}; //数字栈     char op[10]={'+'}; //运算符栈     char c,*rexp,*pp,*pf;     int ist=1,iop=1,last,i;      if (!deep) {         pp=pf=expr;         do {             c = *pp++;             if (c!=' '&& c!=Tab)                 *pf++ = c;         } while (c!='\0');     }     pp=expr;     if ((c=*pp)=='-'||c=='+') {         op[0] = c;         pp++;     }     last = !DIGIT;     while ((c=*pp)!='\0') {         if (c=='(') {//左圆括弧             deep++;             ST[ist++]=calc(++pp,addr);             deep--;             ST[ist-1]=fun(ST[ist-1],op,&iop);             pp = *addr;             last = DIGIT;             if (*pp == '('||isalpha(*pp) && strnicmp(pp,"Pi",2)) {//目的是：当右圆括弧的右恻为左圆括弧或函数名字时，默认其为乘法                 op[iop++]='*';                 last = !DIGIT;                 c = op[--iop];                 goto operate ;             }         }         else if (c==')') {//右圆括弧             pp++;             break;         } else if (isalpha(c)) {             if (!strnicmp(pp,"Pi",2)) {                 if (last==DIGIT) {                     cout<< "π左侧遇）" <<endl;exit(1);                 }                 ST[ist++]=3.14159265358979323846264338328;                 ST[ist-1]=fun(ST[ist-1],op,&iop);                 pp += 2;                 last = DIGIT;                 if (!strnicmp(pp,"Pi",2)) {                     cout<< "两个π相连" <<endl;exit(2);                 }                 if (*pp=='(') {                     cout<< "π右侧遇（" <<endl;exit(3);                 }             } else {                 for (i=0; (pf=fname[i])!=NULL; i++)                     if (!strnicmp(pp,pf,strlen(pf))) break;                 if (pf!=NULL) {                     op[iop++] = 07+i;                     pp += strlen(pf);                 } else {                     cout<< "陌生函数名" <<endl;exit(4);                 }             }         } else if (c=='+'||c=='-'||c=='*'||c=='/'||c=='%'||c=='^') {             char cc;             if (last != DIGIT) {                 cout<< "运算符粘连" <<endl;exit(5);             }             pp++;             if (c=='+'||c=='-') {                 do {                     cc = op[--iop];                     --ist;                     switch (cc) {                     case '+':  ST[ist-1] += ST[ist];break;                     case '-':  ST[ist-1] -= ST[ist];break;                     case '*':  ST[ist-1] *= ST[ist];break;                     case '/':  ST[ist-1] /= ST[ist];break;                     case '%':  ST[ist-1] = fmod(ST[ist-1],ST[ist]);break;                     case '^':  ST[ist-1] = pow(ST[ist-1],ST[ist]);break;                     }                 } while (iop);                 op[iop++] = c;             } else if (c=='*'||c=='/'||c=='%') { operate:        cc = op[iop-1];                 if (cc=='+'||cc=='-') {                     op[iop++] = c;                 } else {                     --ist;                     op[iop-1] = c;                     switch (cc) {                     case '*':  ST[ist-1] *= ST[ist];break;                     case '/':  ST[ist-1] /= ST[ist];break;                     case '%':  ST[ist-1] = fmod(ST[ist-1],ST[ist]);break;                     case '^':  ST[ist-1] = pow(ST[ist-1],ST[ist]);break;                     }                 }             } else {                 cc = op[iop-1];                 if (cc=='^') {                     cout<< "乘幂符连用" <<endl;exit(6);                 }                 op[iop++] = c;             }             last = !DIGIT;         } else {             if (last == DIGIT) {                 cout<< "两数字粘连" <<endl;exit(7);             }             ST[ist++]=strtod(pp,&rexp);             ST[ist-1]=fun(ST[ist-1],op,&iop);             if (pp == rexp) {                 cout<< "非法字符" <<endl;exit(8);             }             pp = rexp;             last = DIGIT;             if (*pp == '('||isalpha(*pp)) {                 op[iop++]='*';                 last = !DIGIT;                 c = op[--iop];                 goto operate ;             }         }     }     *addr=pp;     if (iop>=ist) {         cout<< "表达式有误" <<endl;exit(9);     }     while (iop) {         --ist;         switch (op[--iop]) {         case '+':  ST[ist-1] += ST[ist];break;         case '-':  ST[ist-1] -= ST[ist];break;         case '*':  ST[ist-1] *= ST[ist];break;         case '/':  ST[ist-1] /= ST[ist];break;         case '%':  ST[ist-1] = fmod(ST[ist-1],ST[ist]);break;         case '^':  ST[ist-1] = pow(ST[ist-1],ST[ist]);break;         }     }     return ST[0]; } int main(int argc,char **argv) {     int a;      if (argc<2) {         if (GetConsoleOutputCP()!=936) system("chcp 936>NUL");//中文代码页         cout << "计算函数表达式的值。"<<endl<<"支持(),+,-,*,/,%,^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp"<<endl;         while (1) {             cout << "请输入表达式：";             gets(s);             if (s[0]==0) break;//             cout << s <<"=";             cout << setprecision(15) << calc(s,&endss) << endl;         }     } else if (argc==2 && 0==strcmp(argv[1],"/?")) {         if (GetConsoleOutputCP()!=936) system("chcp 936>NUL");//中文代码页         cout << "计算由≥1个命令行参数给出的函数表达式的值。最后一个参数是.0～.15表示将计算结果保留小数0～15位"<<endl<<"支持(),+,-,*,/,%,^^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp"<<endl;     } else {         strncpy(s,argv[1],MAXLEN-1);s[MAXLEN-1]=0;         if (argc>2) {             for (a=2;a<argc-1;a++) strncat(s,argv[a],MAXLEN-1);//将空格间隔的各参数连接到s             if (1==sscanf(argv[a],".%d",&pcs) && 0<=pcs && pcs<=15) {//最后一个参数是.0～.15表示将计算结果保留小数0～15位                 printf("%.*lf\n",pcs,calc(s,&endss));             } else {                 strncat(s,argv[a],MAXLEN-1);                 printf("%.15lg\n",calc(s,&endss));             }         } else {             printf("%.15lg\n",calc(s,&endss));         }     }     return 0; }

平方return x*x; 三角函数：直接库函数，#include <math.c> sin()


Question: 这里有个C语言数据结构(矩阵相加)的代码有问题,问题是出在哪里?

int elem[MAXSIZE]; 这里存放的是什么？


Question: [原创]一个大学生作业的地铁程序的源代码

没看懂楼主想问什么

引用 1 楼 wenpinglaoyao 的回复:没看懂楼主想问什么 LZ：马上就可以用手机查看地铁信息了


Question: 野指针问题，为什么这样不能释放

这个p的变量多余的吧，把char 转换为struct再释放，还不如直接释放    struct Ateacher* p = NULL;     if (myarray == NULL)     {         return;     }       for (int i = 0; i < count; i++)     {         p = myarray[i].a_name;         if (p != NULL)         {

好像之前已经对结构体里的成员一个成员赋空了，已经释放了，在此释放好像就有问题吧，再此释放，对象不存在了啊

我也觉得上楼上的原因，不是 tArray NULL的问题

引用 1 楼 love1937 的回复:line:112 tArray->a_name = NULL; // tArray已被释放，此处故障 对对对对对，已经释放了

引用 1 楼 love1937 的回复:line:112 tArray->a_name = NULL; // tArray已被释放，此处故障 ++


Question: 用c语言编写！！

仅供参考：#include <iostream> #include <string> using namespace std; inline int compare(string str1,string str2) {//相等返回0，大于返回1，小于返回-1          if (str1.size()>str2.size()) return 1; //长度长的整数大于长度小的整数     else if (str1.size()<str2.size()) return -1;     else                              return str1.compare(str2); //若长度相等，则头到尾按位比较 } string SUB_INT(string str1,string str2); string ADD_INT(string str1,string str2) {//高精度加法     int sign=1; //sign 为符号位     string str;     if (str1[0]=='-') {         if (str2[0]=='-') {             sign=-1;             str=ADD_INT(str1.erase(0,1),str2.erase(0,1));         } else {             str=SUB_INT(str2,str1.erase(0,1));         }     } else {         if (str2[0]=='-') {             str=SUB_INT(str1,str2.erase(0,1));         } else { //把两个整数对齐，短整数前面加0补齐             string::size_type L1,L2;             int i;             L1=str1.size();             L2=str2.size();             if (L1<L2) {                 for (i=1;i<=L2-L1;i++) str1="0"+str1;             } else {                 for (i=1;i<=L1-L2;i++) str2="0"+str2;             }             int int1=0,int2=0; //int2 记录进位             for (i=str1.size()-1;i>=0;i--) {                 int1=(int(str1[i])-'0'+int(str2[i])-'0'+int2)%10;                 int2=(int(str1[i])-'0'+int(str2[i])-'0'+int2)/10;                 str=char(int1+'0')+str;             }             if (int2!=0) str=char(int2+'0')+str;         }     }     //运算后处理符号位     if ((sign==-1)&&(str[0]!='0')) str="-"+str;     return str; } string SUB_INT(string str1,string str2) {//高精度减法     int sign=1; //sign 为符号位     string str;     int i,j;     if (str2[0]=='-') {         str=ADD_INT(str1,str2.erase(0,1));     } else {         int res=compare(str1,str2);         if (res==0) return "0";         if (res<0) {             sign=-1;             string temp =str1;             str1=str2;             str2=temp;         }         string::size_type tempint;         tempint=str1.size()-str2.size();         for (i=str2.size()-1;i>=0;i--) {             if (str1[i+tempint]<str2[i]) {                 j=1;                 while (1) {//zhao4zhong1添加                     if (str1[i+tempint-j]=='0') {                         str1[i+tempint-j]='9';                         j++;                     } else {                         str1[i+tempint-j]=char(int(str1[i+tempint-j])-1);                         break;                     }                 }                 str=char(str1[i+tempint]-str2[i]+':')+str;             } else {                 str=char(str1[i+tempint]-str2[i]+'0')+str;             }         }         for (i=tempint-1;i>=0;i--) str=str1[i]+str;     }     //去除结果中多余的前导0     str.erase(0,str.find_first_not_of('0'));     if (str.empty()) str="0";     if ((sign==-1) && (str[0]!='0')) str ="-"+str;     return str; } string MUL_INT(string str1,string str2) {//高精度乘法     int sign=1; //sign 为符号位     string str;     if (str1[0]=='-') {         sign*=-1;         str1 =str1.erase(0,1);     }     if (str2[0]=='-') {         sign*=-1;         str2 =str2.erase(0,1);     }     int i,j;     string::size_type L1,L2;     L1=str1.size();     L2=str2.size();     for (i=L2-1;i>=0;i--) { //模拟手工乘法竖式         string tempstr;         int int1=0,int2=0,int3=int(str2[i])-'0';         if (int3!=0) {             for (j=1;j<=(int)(L2-1-i);j++) tempstr="0"+tempstr;             for (j=L1-1;j>=0;j--) {                 int1=(int3*(int(str1[j])-'0')+int2)%10;                 int2=(int3*(int(str1[j])-'0')+int2)/10;                 tempstr=char(int1+'0')+tempstr;             }             if (int2!=0) tempstr=char(int2+'0')+tempstr;         }         str=ADD_INT(str,tempstr);     }     //去除结果中的前导0     str.erase(0,str.find_first_not_of('0'));     if (str.empty()) str="0";     if ((sign==-1) && (str[0]!='0')) str="-"+str;     return str; } string DIVIDE_INT(string str1,string str2,int flag) {//高精度除法。flag==1时,返回商; flag==0时,返回余数     string quotient,residue; //定义商和余数     int sign1=1,sign2=1;     if (str2 == "0") {  //判断除数是否为0         quotient= "ERROR!";         residue = "ERROR!";         if (flag==1) return quotient;         else         return residue ;     }     if (str1=="0") { //判断被除数是否为0         quotient="0";         residue ="0";     }     if (str1[0]=='-') {         str1   = str1.erase(0,1);         sign1 *= -1;         sign2  = -1;     }     if (str2[0]=='-') {         str2   = str2.erase(0,1);         sign1 *= -1;     }     int res=compare(str1,str2);     if (res<0) {         quotient="0";         residue =str1;     } else if (res == 0) {         quotient="1";         residue ="0";     } else {         string::size_type L1,L2;         L1=str1.size();         L2=str2.size();         string tempstr;         tempstr.append(str1,0,L2-1);         for (int i=L2-1;i<L1;i++) { //模拟手工除法竖式             tempstr=tempstr+str1[i];             tempstr.erase(0,tempstr.find_first_not_of('0'));//zhao4zhong1添加             if (tempstr.empty()) tempstr="0";//zhao4zhong1添加             for (char ch='9';ch>='0';ch--) { //试商                 string str;                 str=str+ch;                 if (compare(MUL_INT(str2,str),tempstr)<=0) {                     quotient=quotient+ch;                     tempstr =SUB_INT(tempstr,MUL_INT(str2,str));                     break;                 }             }         }         residue=tempstr;     }     //去除结果中的前导0     quotient.erase(0,quotient.find_first_not_of('0'));     if (quotient.empty()) quotient="0";     if ((sign1==-1)&&(quotient[0]!='0')) quotient="-"+quotient;     if ((sign2==-1)&&(residue [0]!='0')) residue ="-"+residue ;     if (flag==1) return quotient;     else         return residue ; } string DIV_INT(string str1,string str2) {//高精度除法,返回商     return DIVIDE_INT(str1,str2,1); } string MOD_INT(string str1,string str2) {//高精度除法,返回余数     return DIVIDE_INT(str1,str2,0); } int main() {     char ch;     string s1,s2,res;      while (cin>>s1>>ch>>s2) {         switch (ch) {             case '+':res=ADD_INT(s1,s2);break;             case '-':res=SUB_INT(s1,s2);break;             case '*':res=MUL_INT(s1,s2);break;             case '/':res=DIV_INT(s1,s2);break;             case '%':res=MOD_INT(s1,s2);break;             default :                   break;         }         cout<<res<<endl;     }     return(0); }

参考 http://blog.csdn.net/zhangxiangdavaid/article/details/46438865

长整数的运算何须链表？ 用string或字符串char*就行了


Question: 求助 关于二维数组赋值

引用 9 楼 gzwgyfgpf 的回复:这个内层循环好像有问题，赋值和输出不是一样的肯定输出是0，我把两个语句的顺序改了一下 for(i=0;i<=xdim;i=i+3) {  u[o][p]=use[i][j];  printf("%f\n",u[o][p]); o++;  } 真是，我2了，非常感谢！

#include <stdio.h> #include <string.h> //#include <process.h>  //#include <direct.h>    #include "WeatherSys.h"		// 天气系统数据结构，详见系统功能规格需求书   	float lon[600][600],lat[600][600]; 	float u[600][600],v[600][600],field[600][600],filtered[600][600];     float use[1500][1500];//???????????? 	int divided[600][600]; 	int divided1[600][600];  	float grid_interval_m; 	int weather_system_number; 	WEATHER_SYSTEM_ATTRIBUTES wsa[WEATHER_MAX];  	int make_grid_latlon(int xdim,int ydim,float lon1,float lat1,float lon2,float lat2,float lon3,float lat3,float iso2); 	void do_gradient(int xdim,int ydim,int skip_grid); 	void do_div_dir(int xdim,int ydim,int skip_grid); 	void do_vor_dir(int xdim,int ydim,int skip_grid);      	int do_filter(int xdim,int ydim,int skip_grid,int critical_radius,int influence_radius); 	int do_divide(int xdim,int ydim,int skip_grid,int plan,int arithmatic,float upper_thresh,float lower_tresh, 	float min_tresh,float thresh_interval,int area_arith,float area_thresh,float min_intensity,float max_border); 	int do_measurement(int xdim,int ydim,int skip_grid,int area_arith,int center_arith,int extreme_center_arith, 	int center_line_arith,int width_arith,int length_arith,float trough_tresh); 	void output_weather(char *filename,char *data_name);  	int data_type,yy,mm,dd,hh,sx,level,xdim,ydim; 	float lon3,lat3,lon1,lon2,lat1,lat2,jg,iso1,iso2,ph,jc; 	char elementname[40],filename[200],preprocess_code[20],output_file[200]; 	int map_project,field_model;     char filter_file[100]; 	char divide_file[100]; 	char weather_file[100]; 	char out_path[] =  "e:\\data\\out\\";  	 	 main() { 	FILE *fp,*fc,*fs;  	int element_number,i,j,k,o,p; 	char string[200],data_name[40]; 	int skip_grid,critical_radius,influence_radius; 	int plan,arithmatic; 	float upper_thresh,lower_thresh,min_thresh,thresh_interval,area_thresh,min_intensity,max_border; 	int area_arith,center_arith,ex_center_arith,center_line_arith,width_arith,length_arith; 	float trough_tresh;     char buff[100];  	char in_path[100];             fs = fopen("e:\\test.txt", "rw");//读取所有文件名    //strcpy(out_path,"e:\\data\\out\\");//指定输出文件路径        while(fgets(filename, 100, fs) != NULL)//当还有文件未处理    {    	   filename[strlen(filename)-1]='\0'; 	   printf("%s\n",filename);//循环获取要处理的文件名      ////////////////////////////////////////////////////////////////////////////////////////     //	读天气系统识别参数。各参数意义详见系统功能规格需求书 	if((fp=fopen("element.cfg","r"))==NULL) { 		printf("Can't open configure file element.cfg!\n"); 		return -1; 	} 	fscanf(fp,"%d",&element_number);	// 读要素数 	for(i=0;i<element_number;i++) { 		fscanf(fp,"%s%s%d%d%d",elementname,preprocess_code,&skip_grid,&critical_radius, 			&influence_radius);		// 读预处理参数：要素名   预处理代码  尺度跳点  滤波临界半径 滤波影响半径 		fscanf(fp,"%d%d%f%f%f%f%f%f%f",&plan,&arithmatic,&upper_thresh,&lower_thresh,	// 读划分参数 			&min_thresh,&thresh_interval,&area_thresh,&min_intensity,&max_border); //  划分算法规划  划分算法  上界阈值  下界阈值  最低阈值  阈值间隔  面积阈值 强度阈值 边界点阈值 		fscanf(fp,"%d%d%d%d%d%d%f",&area_arith,¢er_arith,&ex_center_arith,¢er_line_arith, 			&width_arith,&length_arith,&trough_tresh);		// 读测量参数 //  面积算法  几何中心算法  极值中心算法 中心线算法 区域宽度算法 区域长度算法 槽脊纵横比阈值  //	读数据文件 		 		strcpy(in_path,"e:\\data\\div 1km\\"); 	    strcat(in_path,filename);   //指定文件源路径 		if((fc=fopen(in_path,"r"))==NULL) { 			printf("Can't open data file %s!\n",filename); 			return -1;  		} 		fscanf(fc,"%s%d%s",string,&data_type,data_name);//get the first the line    		if(strcmp(string,"diamond")!=0) { 			printf("Data file %s is not a MICAPS data!\n",filename); 			fclose(fc); 			return -1; 		} 		if(data_type!=4 && data_type!=11) {		// 数据必须是 MICAPS4 或 MICAPS11 格式的网格点数据 			printf("data file %s is not a network data!\n",filename); 			fclose(fc); 			return -1; 		} 		if(data_type==4) { 			fscanf(fc,"%d%d%d%d%d%d",&yy,&mm,&dd,&hh,&sx,&level); 			fscanf(fc,"%f%f%f%f%f%f",&lon3,&lat3,&lon1,&lon2,&lat1,&lat2); 			fscanf(fc,"%d%d",&xdim,&ydim);//gird rule 			fscanf(fc,"%f%f%f%f%f",&jg,&iso1,&iso2,&ph,&jc);  			if (xdim<1000)//if 3KM ///////////////////////////////////////////////////////// 			{ 			for(j=0;j<ydim;j++)  			{ 				for(i=0;i<xdim;i++) 				{ 					fscanf(fc,"%f",&u[i][j]);  					printf("%f\n",u[i][j]); 				     				} 			} 			fclose(fc); 			}              			else if (xdim>=1000)//if 1KM ////////////////////////////////////////////////////////// 			{ 			 			//printf("%d\n",xdim); 			for(j=0;j<ydim;j++) { 				for(i=0;i<xdim;i++) fscanf(fc,"%f",&use[i][j]);   				} 			fclose(fc); 			//fill the u[][] 			p=0;             for(j=0;j<=ydim;j=j+3){ 				o=0; 				for(i=0;i<=xdim;i=i+3) {   					u[o][p]=use[i][j];  					o++;  					printf("%f\n",u[o][p]); 			}  				p++;  			 			}  			}         				printf("No pre-process!\n"); 				for(j=0;j<ydim;j++) 				{ 					for(i=0;i<xdim;i++) 					{ 						field[i][j]=u[i][j]; 					}//if get 3km data,adjust the i&j. 				} 			} 		}     完整代码过长，截取了声明部分和这个函数，后面的没放上来，谢谢

看下完整代码

引用 5 楼 zhangxiangDavaid 的回复:[quote=引用 4 楼 tdvb_123 的回复:] [quote=引用 2 楼 zhangxiangDavaid 的回复:]  	//取第0、3、6……行的数据 	o = 0; 	for (i = 0; i <= ydim; i += 3) { 		for (j = 0; j <= ydim; j++) {   //不用跳列吧 			u[o][p] = use[i][j]; 			printf("%f\n", u[o][p]); 			p++; 		} 		o++; 	}  谢谢您的回复， 行列都跳，而且按照您的程序，u数组依然是0，还有一个问题，就是u数组定义的是全局变量，如果把use定义成局部的，程序就会报UNKNOW SOFTWARE EXCEPTION的错误，不知道能否帮我解答一下，谢谢。[/quote] 列也跳。那就是j+=3; u怎么会依然是0呢？ u[o][p] = use[i][j]; printf("%f\n", u[o][p]); 那说明use[i][j]也是0[/quote]  我不解的就在这里，打印use数组时输出的是正确的内容，但是u数组时就全部都是0，并且如果我把两个数组全部定义成全局变量时不报错，但当一个全局，一个局部时，编译过，运行时直接跳出

引用 4 楼 tdvb_123 的回复:[quote=引用 2 楼 zhangxiangDavaid 的回复:]  	//取第0、3、6……行的数据 	o = 0; 	for (i = 0; i <= ydim; i += 3) { 		for (j = 0; j <= ydim; j++) {   //不用跳列吧 			u[o][p] = use[i][j]; 			printf("%f\n", u[o][p]); 			p++; 		} 		o++; 	}  谢谢您的回复， 行列都跳，而且按照您的程序，u数组依然是0，还有一个问题，就是u数组定义的是全局变量，如果把use定义成局部的，程序就会报UNKNOW SOFTWARE EXCEPTION的错误，不知道能否帮我解答一下，谢谢。[/quote] 列也跳。那就是j+=3; u怎么会依然是0呢？ u[o][p] = use[i][j]; printf("%f\n", u[o][p]); 那说明use[i][j]也是0

引用 2 楼 zhangxiangDavaid 的回复: 	//取第0、3、6……行的数据 	o = 0; 	for (i = 0; i <= ydim; i += 3) { 		for (j = 0; j <= ydim; j++) {   //不用跳列吧 			u[o][p] = use[i][j]; 			printf("%f\n", u[o][p]); 			p++; 		} 		o++; 	}  谢谢您的回复， 行列都跳，而且按照您的程序，u数组依然是0，还有一个问题，就是u数组定义的是全局变量，如果把use定义成局部的，程序就会报UNKNOW SOFTWARE EXCEPTION的错误，不知道能否帮我解答一下，谢谢。

有bug； 加一行：  	//取第0、3、6……行的数据 	o = 0; 	for (i = 0; i <= ydim; i += 3) { 		p = 0;    //加一行 		for (j = 0; j <= ydim; j++) {   //不用跳列吧 			u[o][p] = use[i][j]; 			printf("%f\n", u[o][p]); 			p++; 		} 		o++; 	}


Question: 你好，菜鸟求指导

看下这个： http://blog.csdn.net/zhangxiangdavaid/article/details/46606457

引用 11 楼 zhao4zhong1 的回复:个人经验：当刚接触一个新概念有点模糊不清的时候，急着跟人讨论还不如硬着头皮再多看看书或百度百科或维基百科对应或相关词条的解释呢。 不是急着和别人讨论，我只是想学的清楚一些，同样谢谢你的回复，我只是个初学者，没什么人来知道只能在网上和书上查看一些资料，学历比较低，有的时候，网上书上看的似懂非懂，呵呵

引用 10 楼 zhangxiangDavaid 的回复:[quote=引用 9 楼 a339299936 的回复:] [quote=引用 7 楼 zhangxiangDavaid 的回复:] [quote=引用 3 楼 a339299936 的回复:] 各位好，刚刚了解到了逆波兰、“栈”的概念、请问栈不就是数组吗？取值存值都有局限性，直接拿出来你想用的值不就可以了吗？干嘛要用“栈”？它有什么好处？ 了解下栈：http://blog.csdn.net/zhangxiangdavaid/article/details/26819603[/quote] 谢谢，我掌握了基本的栈操作和定义，但是我是想问，如果直接拿出来用栈内的值，不是更方便吗？为何还要一个一个的拿出来放进去，就算是有规律，但是这种规律不是更麻烦吗？[/quote]  引用 9 楼 a339299936 的回复:[quote=引用 7 楼 zhangxiangDavaid 的回复:] [quote=引用 3 楼 a339299936 的回复:] 各位好，刚刚了解到了逆波兰、“栈”的概念、请问栈不就是数组吗？取值存值都有局限性，直接拿出来你想用的值不就可以了吗？干嘛要用“栈”？它有什么好处？ 了解下栈：http://blog.csdn.net/zhangxiangdavaid/article/details/26819603[/quote] 谢谢，我掌握了基本的栈操作和定义，但是我是想问，如果直接拿出来用栈内的值，不是更方便吗？为何还要一个一个的拿出来放进去，就算是有规律，但是这种规律不是更麻烦吗？[/quote] 如果是数组存放的，当然可以随机存取；但如果是链表呢？此时显然不可随机存储[/quote] 谢谢解答，虽然还有一些不理解，但可以肯定，栈的实用性。

引用 9 楼 a339299936 的回复:[quote=引用 7 楼 zhangxiangDavaid 的回复:] [quote=引用 3 楼 a339299936 的回复:] 各位好，刚刚了解到了逆波兰、“栈”的概念、请问栈不就是数组吗？取值存值都有局限性，直接拿出来你想用的值不就可以了吗？干嘛要用“栈”？它有什么好处？ 了解下栈：http://blog.csdn.net/zhangxiangdavaid/article/details/26819603[/quote] 谢谢，我掌握了基本的栈操作和定义，但是我是想问，如果直接拿出来用栈内的值，不是更方便吗？为何还要一个一个的拿出来放进去，就算是有规律，但是这种规律不是更麻烦吗？[/quote]  引用 9 楼 a339299936 的回复:[quote=引用 7 楼 zhangxiangDavaid 的回复:] [quote=引用 3 楼 a339299936 的回复:] 各位好，刚刚了解到了逆波兰、“栈”的概念、请问栈不就是数组吗？取值存值都有局限性，直接拿出来你想用的值不就可以了吗？干嘛要用“栈”？它有什么好处？ 了解下栈：http://blog.csdn.net/zhangxiangdavaid/article/details/26819603[/quote] 谢谢，我掌握了基本的栈操作和定义，但是我是想问，如果直接拿出来用栈内的值，不是更方便吗？为何还要一个一个的拿出来放进去，就算是有规律，但是这种规律不是更麻烦吗？[/quote] 如果是数组存放的，当然可以随机存取；但如果是链表呢？此时显然不可随机存储

引用 7 楼 zhangxiangDavaid 的回复:[quote=引用 3 楼 a339299936 的回复:] 各位好，刚刚了解到了逆波兰、“栈”的概念、请问栈不就是数组吗？取值存值都有局限性，直接拿出来你想用的值不就可以了吗？干嘛要用“栈”？它有什么好处？ 了解下栈：http://blog.csdn.net/zhangxiangdavaid/article/details/26819603[/quote] 谢谢，我掌握了基本的栈操作和定义，但是我是想问，如果直接拿出来用栈内的值，不是更方便吗？为何还要一个一个的拿出来放进去，就算是有规律，但是这种规律不是更麻烦吗？

引用 3 楼 a339299936 的回复:各位好，刚刚了解到了逆波兰、“栈”的概念、请问栈不就是数组吗？取值存值都有局限性，直接拿出来你想用的值不就可以了吗？干嘛要用“栈”？它有什么好处？ 了解下栈：http://blog.csdn.net/zhangxiangdavaid/article/details/26819603

引用 5 楼 zhao4zhong1 的回复:百度百科自己搜就那么费劲吗？ 能百度，也就不来论坛讨论了

百度百科自己搜就那么费劲吗？

引用 2 楼 zhangxiangDavaid 的回复:波兰表达式更易于解析 解析？能举个例子吗？

波兰表达式更易于解析

请先尝试编写一个支持加、减、乘、除、()运算的计算器。看看不用逆波兰表达式，你的优先级是如何确定的。


Question: 一个排序程序，当数组长度超过10000时，程序报错。请大家来看看问题出在哪里。

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

我和你用的开发环境好像不一样，我建议你单步调试一下，应该就可以找出问题了

对于递归算法，递归过深可能会导致线程的栈空间不足。

超出在栈区大小吧 栈大小有限制的跟编译器有关，跟系统有关.  //一般都有 8K 以上...

静态数组长度有限制吧，不能定义的太大吧


Question: 请教一个关于字符串交换的问题

楼上各位已给出答案，我路过接个分好了。。。

char **tmp=NULL; *tmp=*NULL;      //出错

引用 1 楼 user-3 的回复:tmp是NULL时，*tmp无效 其实，自己不知道tmp内容是什么的时候，*tmp都是无效的，什么都可能，系统不挂就很不错了 恩明白了，主要是由于tmp被初始化成NULL，*tmp是无效的。 经过测试，当tmp不为NULL时，也是OK的 void swap_string1(char **p1, char **p2) { 	char **tmp = NULL; 	char *p = ""; 	tmp = &p; 	*tmp = *p1; 	*p1 = *p2; 	*p2 = *tmp; }