Question: 职工管理系统，一录入信息就会停止运行

你好歹把代码套上格式在发嘛，这样看的好累

Listpaixu，这函数名、。。。 要不改成“ListMalaxiangguo”

楼主，你的代码看着头大，我整理了一下，另外做了编译，编译结果附在后面；其余的你自己搞定好了，看着怕了。。  #include <stdio.h> #include <stdlib.h> #include <string.h> #include <malloc.h>  #define EMPLOYEEMAX  100  typedef struct st_Data { 	char      dsex; 	char      dname[EMPLOYEEMAX]; 	char      ddegree[EMPLOYEEMAX]; 	char      djob[EMPLOYEEMAX]; 	char      daddress[EMPLOYEEMAX]; 	long int  dborn_date,  dwork_date,  dtele_num; } DataInfo;  typedef struct Node { 	struct Node   *next; 	DataInfo       data; 	#ifndef STRUCT_data_ALIAS 	#define STRUCT_data_ALIAS 	#define  sex        data.dsex 	#define  name       data.dname 	#define  degree     data.ddegree 	#define  job        data.djob 	#define  address    data.daddress 	#define  born_date  data.dborn_date 	#define  work_date  data.dwork_date 	#define  tele_num   data.dtele_num 	#endif  // #define STRUCT_data_ALIAS } EMPLOYEENode;  // 链表初始化 void ListIniti(EMPLOYEENode **head) { 	if (NULL == (*head = (EMPLOYEENode *) malloc(sizeof(EMPLOYEENode)))) 	{ 		printf("Allocate memory for list failed!\n"); 		exit(1); 	} 	 	(*head)->next = NULL; }  // 职工信息的插入姓名并按照升序排列 EMPLOYEENode *ListInsert(EMPLOYEENode *head, DataInfo x) { 	EMPLOYEENode   *p,  *q,  *s;  	p = head->next; 	if(NULL == (q = (EMPLOYEENode *) malloc(sizeof(EMPLOYEENode)))) 	{ 		// 此处内存溢出... 		exit(1); 	}  	q->born_date = x.dborn_date; 	q->work_date = x.dwork_date; 	q->tele_num  = x.dtele_num; 	strncpy_s(q->name, strlen(x.dname)+1, x.dname, EMPLOYEEMAX); 	q->sex       = x.dsex; 	strncpy_s(q->degree, strlen(x.ddegree)+1, x.ddegree, EMPLOYEEMAX); 	strncpy_s(q->job, strlen(x.djob)+1, x.djob, EMPLOYEEMAX); 	strncpy_s(q->address, strlen(x.daddress)+1, x.daddress, EMPLOYEEMAX);  	// 如果只有链表的头结点，没有其他的结点，直接插入在头结点后面 	if(NULL == head->next) { 		head->next = q; 		head->next->next = NULL; 		return head; 	} 	 	for(/*NULL*/; p; p = p->next) { 		if(NULL != p->next) { 			// 位于两个结点之间 			if(strcmp(p->name, x.dname) < 0 && strcmp(p->next->name, x.dname) > 0) { 				s = p->next; 				p->next = q; 				q->next = s; 				break; 			} else if(strcmp(p->name, x.dname) < 0 && p->next == NULL) {  // 链表非空，并且在排序中是最后一个 				// else if(strcmp(p->name,x.name)==0)break;   //如果姓名相同则不插入信息} 				p->next = q; 				q->next = NULL; 				break; 			}  			// 位于链表头结点之后的位置 			if(strcmp(p->name, x.dname)>0) { 				s=head->next; 				head->next=q; 				q->next=s; 				break; 			} 		} 	} 	return head; }  void main(void) { 	DataInfo   x; 	EMPLOYEENode    *head; 	int        i,  n; 	FILE      *fp;  	// 初始化链表 	ListIniti(&head); 	 	printf("\n"); 	printf("*******************************************************************************\n" 	       "************************    欢迎使用职工管理系统    ***************************\n" 	       "*******************************************************************************\n" 	       "\n请输入要录入的职工人数n："); 	fflush(NULL); 	scanf_s("%d", &n); 	if(0 == n) { 		goto aa; 	} 	 	printf("请输入职工信息：\n姓名、性别、出生年月、工作年月、学历、职务、住址、电话\n"); 	for (i=0; i<n; i++)	{ 		scanf_s("%s %c %d %d %s %s %s %d", x.dname, &x.dsex, &x.dborn_date, &x.dwork_date, 			    x.ddegree, x.djob, x.daddress, &x.dtele_num); 		head = ListInsert(head, x); 	} 	 	if (fopen_s(&fp, "Employeetxt", "rd")) { 		printf("\t无法打开'Employee.txt'!\n"); 		exit(0); 	} 	put(head, fp); 	if (fclose(fp)) { 		printf("\t无法关闭'Employee.txt'!\n"); 		exit(0); 	} 	printLink(head);  	while(1) { aa:		printf("\n\t                      * 主菜单 *        \n" 		       "\t                        **********        \n" 		       "\t  \t0.结束管理系统\t\t\t1.新增职工信息\t\t\n" 			   "\t  \t2.删除职工信息\t\t\t3.查询职工信息\t\t\n" 			   "\t  \t4.修改职工信息\t\t\t5.职工信息排序\t\t\n" 		       "请输入您要选择的操作：");  		scanf_s("%d", &i); 		switch(i) 		{ 		case  0:  // 结束系统 			printf("\t\t您已经成功退出职工管理系统,谢谢使用!\n"); 			goto FINISH_LOOP;  		case  1:  // 新增一名职工 			printf("请输入职工信息：\n姓名、性别、出生年月、工作年月、学历、职务、住址、电话\n"); 			scanf_s("%s %c %d %d %s %s %s %d", x.dname, &x.dsex, &x.dborn_date, &x.dwork_date, 				    x.ddegree, x.djob, x.daddress, &x.dtele_num); 			head=ListInsert(head,x); 			printf("新增成功！请继续操作！\n"); 			printLink(head); 			 			// 保存在文件中 			put(head, fp); 			continue;  		case  2:  // 删除一名职工 			ListDelete(head); 			if (fopen_s(&fp, "Employee.txt", "w")) { 				printf("无法打开'职工名单.txt'!\n"); 				exit(0); 			} 			put(head,fp); 			if (fclose(fp)) { 				printf("无法关闭'Employee.txt'!\n"); 				exit(0); 			} 			continue;  		case  3:  // 查找一名职工 			Listfind(*head); 			continue;  		case  4:  // 修改职工信息 			ListModify(head); 			if (fopen_s(&fp, "Employee.txt", "w")) { 				printf("无法打开'Employee.txt'!\n"); 				exit(0); 			} 			put(head, fp); 			if (fclose(fp)) { 				printf("无法关闭'Employee.txt'!\n"); 				exit(0); 			} 			continue;  		case  5:  // 对职工信息进行排序 			EMPLOYEENode *p = head; 			Listpaixu(p);  // 函数未定义 			continue;  		default:  // 输入出错 			printf("输入出错！请再次输入！\n"); 			continue; 		}  FINISH_LOOP: 		break; 	} }   编译结果  1>------ 已启动全部重新生成: 项目: exam013, 配置: Debug Win32 ------ 1>正在删除项目“exam013”(配置“Debug|Win32”)的中间文件和输出文件 1>正在编译... 1>employee_cmp.c 1>f:\exam013\exam013\employee_cmp.c(130) : warning C4013: “put”未定义；假设外部返回 int 1>f:\exam013\exam013\employee_cmp.c(135) : warning C4013: “printLink”未定义；假设外部返回 int 1>f:\exam013\exam013\employee_cmp.c(165) : warning C4013: “ListDelete”未定义；假设外部返回 int 1>f:\exam013\exam013\employee_cmp.c(178) : warning C4013: “Listfind”未定义；假设外部返回 int 1>f:\exam013\exam013\employee_cmp.c(182) : warning C4013: “ListModify”未定义；假设外部返回 int 1>f:\exam013\exam013\employee_cmp.c(195) : error C2275: “EMPLOYEENode”: 将此类型用作表达式非法 1>        f:\exam013\exam013\employee_cmp.c(31) : 参见“EMPLOYEENode”的声明 1>f:\exam013\exam013\employee_cmp.c(195) : error C2065: “p”: 未声明的标识符 1>f:\exam013\exam013\employee_cmp.c(196) : warning C4013: “Listpaixu”未定义；假设外部返回 int 1>生成时间 0:00 1>生成日志保存在“********************************************” 1>exam013 - 2 个错误，6 个警告 ========== 全部重新生成: 0 已成功, 1 已失败, 0 已跳过 ==========

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


Question: 精度问题

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

浮点数在内存中有误差，很多十进制小数在二进制里就没办法精确表示（比如0.1） 十进制下的：70459.43的二进制下表示出来就是70459.429999999993.... 所以比较浮点数是否相等，应该比较两数差的绝对值是否足够小


Question: 简单C语言

#include<stdio.h> int main() {     int n,a,b,c;     printf("请输入两个整数（逗号隔开）:");     scanf("%d,%d",&a,&b);     n=b;     c=a%b;     while(c!=0)     {         a=b;         b=c;         c=a%b;     }     printf("\n最大公约数是:%d\n",b);     return 0; }

欧几里德辗转相除法


Question: 为什么说,非空的循环单链表first的链尾结点(由p所指向)满足 p->link=NULL

非空的就是p->link=first，答案C


Question: 这段代码为什么在输入书名时会一直显示书名已重复

关于自己是否适合编程的很简单的测试： 在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案：  A里面有10处以上文字或标点错误 B里面没有文字或标点错误并敢为此跟人打赌 C里面没有文字或标点错误并且字体和排版完全与原稿一致 D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感  A不适合编程（理由：打字准确度偏低、粗心大意） B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念） C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证） D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！）  如果想从A变成B的话，到我的资源http://download.csdn.net/detail/zhao4zhong1/4084259里面下载“适合程序员的键盘练习”

哈哈    楼上真细心

if(p->next!=NULL&&strcmp(p->next->bookname,book->bookname)==0); <---有分号！

不知道，都没在你代码里看到有“书名已重复”这几个字，你只上一半代码怎么知道


Question: 请问C语言怎么用realloc函数分配一个二维数组这样的内存?

int **a; a = (int **)realloc(NULL,10 * sizeof(int *)); for (int i = 0; i < 10; i ++)     a[i] = (int *)realloc(NULL,200 * sizeof(int));

realloc Reallocate memory blocks.  void *realloc( void *memblock, size_t size );  Routine Required Header Compatibility  realloc <stdlib.h> and <malloc.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  realloc returns a void pointer to the reallocated (and possibly moved) memory block. The return value is NULL if the size is zero and the buffer argument is not NULL, or if there is not enough available memory to expand the block to the given size. In the first case, the original block is freed. In the second, the original block is unchanged. The return value points to a storage space that is guaranteed to be suitably aligned for storage of any type of object. To get a pointer to a type other than void, use a type cast on the return value.  Parameters  memblock  Pointer to previously allocated memory block  size  New size in bytes  Remarks  The realloc function changes the size of an allocated memory block. The memblock argument points to the beginning of the memory block. If memblock is NULL, realloc behaves the same way as malloc and allocates a new block of size bytes. If memblock is not NULL, it should be a pointer returned by a previous call to calloc, malloc, or realloc.  The size argument gives the new size of the block, in bytes. The contents of the block are unchanged up to the shorter of the new and old sizes, although the new block can be in a different location. Because the new block can be in a new memory location, the pointer returned by realloc is not guaranteed to be the pointer passed through the memblock argument.  realloc calls malloc in order to use the C++ _set_new_mode function to set the new handler mode. The new handler mode indicates whether, on failure, malloc is to call the new handler routine as set by _set_new_handler. By default, malloc does not call the new handler routine on failure to allocate memory. You can override this default behavior so that, when realloc fails to allocate memory, malloc calls the new handler routine in the same way that the new operator does when it fails for the same reason. To override the default, call   _set_new_mode(1)  early in your program, or link with NEWMODE.OBJ.  When the application is linked with a debug version of the C run-time libraries, realloc resolves to _realloc_dbg. For more information about how the heap is managed during the debugging process, see Using C Run-Time Library Debugging Support.  Example  /* REALLOC.C: This program allocates a block of memory for  * buffer and then uses _msize to display the size of that  * block. Next, it uses realloc to expand the amount of  * memory used by buffer and then calls _msize again to  * display the new amount of memory allocated to buffer.  */  #include <stdio.h> #include <malloc.h> #include <stdlib.h>  void main( void ) {    long *buffer;    size_t size;     if( (buffer = (long *)malloc( 1000 * sizeof( long ) )) == NULL )       exit( 1 );     size = _msize( buffer );    printf( "Size of block after malloc of 1000 longs: %u\n", size );     /* Reallocate and show new size: */    if( (buffer = realloc( buffer, size + (1000 * sizeof( long )) ))          ==  NULL )       exit( 1 );    size = _msize( buffer );    printf( "Size of block after realloc of 1000 more longs: %u\n",              size );     free( buffer );    exit( 0 ); }   Output  Size of block after malloc of 1000 longs: 4000 Size of block after realloc of 1000 more longs: 8000   Memory Allocation Routines  See Also   calloc, free, malloc

再提供一个分配连续内存的方法：   int **a; a = (int **)malloc(10 * sizeof(int *)); a[0] = (int*)malloc(10*200*sizeof(int)); for (int i = 1; i < 10; i ++)     a[i] = a[0] + i * 200;

int **a; a = (int **)malloc(10 * sizeof(int *)); for (int i = 0; i < 10; i ++) 	a[i] = (int *)malloc(200 * sizeof(int));  realloc在a已经分配好的情况下，用于扩展内存。


Question: 怎么将输入A,B执行程序变成输入1，2执行程序

修改 一下就行，就像1楼那样

#include<stdio.h> int main() { 	void action1(int,int); 	void action2(int,int); 	char ch; 	int a=8,b=9; 	int A,B; 	printf("请输入你想要执行的功能:\n1:执行加法\n2:执行减法"); 	printf("\n"); 	ch=getchar(); 	switch(ch) 	{ 	case '1':action1(a,b);break; 	case '2':action2(a,b);break; 	default:printf("no answer"); 	} } void action1(int x,int y) { 	printf("%d",x+y); } void action2(int x,int y) { 	printf("%d",x-y); }


Question: 求问c语言关于顺序读写数据文件的作业

说下我的思路，打开原始文档文档，新建一个写文档。逐个读取原始文档数据并统计个数，遇到是数字的就写入到新文档。

读写方式各打开一个文件

这个过程，不是很好分析么 读写方式个打开一个文件 读入数据，统计单词，保存到另一个文件中


Question: 怎么获得其他进程的PE文件信息

这完全就是开玩笑嘛，得到目标进程的PE结构如果不读取的话，想在不注入的情况下，要用PEB模块。

MSDN98中的例子walker又名pwalk。 完整列出指定进程的内存使用情况，显示进程地址空间内容，装载哪些DLL，代码、数据、堆栈段分配在何处，可以用来检测内存泄漏，监测内存使用。http://download.csdn.net/detail/zhao4zhong1/3667896


Question: 递归生成二进制反射格雷码的伪代码看不懂啊

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

引用 3 楼 user-2 的回复:1) C++语法表示为 List BRGC(int n){ List L1,L2; if(n==1)   return L={0,1}; L1 = BRGC(n-1); L2 =Rev(L1); L1=0+L1; L2=1+L2; return L=L1+L2; }； 引用 3 楼 user-2 的回复:1) C++语法表示为 List BRGC(int n){ List L1,L2; if(n==1)   return L={0,1}; L1 = BRGC(n-1); L2 =Rev(L1); L1=0+L1; L2=1+L2; return L=L1+L2; }； 太感谢了，一点就通。。

这个算法是这样的 BRGC(1) -->L =0，1直接得出 计算 BRGC(2) 先计算 BRGC(1) 得到L1，L1翻转得到L2 L1 =0，1   L2=1，0 L1的每个码前面加上0，L2的每个码，前面加上1 合并得到 L BRGC(2) -->L  = 00，01，11，10 计算 BRGC(3) 先计算 BRGC(1) 得到L1，L1翻转得到L2 L1= 00，01，11，10 L2=10，11，01，00 L1的每个码前面加上0，L2的每个码，前面加上1 合并得到 L BRGC(3) -->L=000，001，011，010， 110，111，101，100 .................................


Question: 树的应用

http://download.csdn.net/detail/hansong1989/4277774  网上的

树 http://blog.csdn.net/zhangxiangdavaid/article/details/36189717

求代码! 谢谢大神们了

从实现看二叉树，和树 都是二叉链表，或者三叉链表结构（多了一个指向父节点的指针）

从实现上说，树的实现中，结构方面，根本和二叉树的实现没有区别， 只有算法 有区别， 二叉树改造成树 很简单 反之则不容易，二叉树是有特定顺序的， 树则没有这个必要，树只需要维持父节点和子节点之间的关系即可。 从一棵树，生成一个二叉树，必须明确，如何生成，因为二叉树，每个节点，只有两个子树，肯定不能保持树的原有结构  而 二叉树转换成树则是可以的 不过节点的作用必须变换一下，节点的位置也要变一下；  二叉树                                     树                                                                       root                           root ---------->    brother  (NULL)             lchild,rchild                       children----->brother ------->brother, lchild,rchild, lchild,rchild           children-->...  children-->..   children->brother .... ................................................................................................  二叉树转换成树，左子转换成 根  root 的子树即children节点，右子树转换成左子的brother节点 如此反复，即可  反之树转换成二叉树，必须另外制定规则，原来的父子节点关系，难以保持  树的前序后序遍历，递归算的跟二叉树略有，但差别不大，可以根据二叉树的算法改出来 非递归，可以通过修改递归算法实现。 层序遍历，主要是保存上一层的所有节点 和二叉树的算法，也是差别不大


Question: VS2015支持复合文字吗，如何查看它支持的C99特性

引用 7 楼 user-1 的回复:[quote=引用 5 楼 gblhack 的回复:] [quote=引用 2 楼 user-1 的回复:] int total = 0; 麻烦老师回复最后一个问题  如何查看VS2015支持C99哪些特性，有相应的文档吗[/quote]  可以去 msdn 上翻翻。那里不写的话，大概就只能自己试了 ...[/quote] 这样啊，我以为VS会对这个专门说明呢，既然没有就算了。十分感谢您的回答！

引用 5 楼 gblhack 的回复:[quote=引用 2 楼 user-1 的回复:] int total = 0; 麻烦老师回复最后一个问题  如何查看VS2015支持C99哪些特性，有相应的文档吗[/quote]  可以去 msdn 上翻翻。那里不写的话，大概就只能自己试了 ...

引用 4 楼 user-1 的回复:VS2015 貌似支持了。源文件扩展名需要为 .c 。 确实是，谢谢老师。

引用 2 楼 user-1 的回复:int total = 0; 麻烦老师回复最后一个问题  如何查看VS2015支持C99哪些特性，有相应的文档吗

引用 3 楼 gblhack 的回复:[quote=引用 2 楼 user-1 的回复:] int total = 0;  你的 total 没有初始化。 编译错误信息其实说得还是比较清楚的。 我刚才发现了，打算编辑呢，您回复了 ____________________________ 晕死，没仔细看错误，以为是使用了未声明的变量，原来是未初始化的，安全检查的问题，大家忽略这个错误吧。另外VS确实不支持复合文字，大家就说一下如何查看它支持C99哪些特性。[/quote]  VS2015 貌似支持了。源文件扩展名需要为 .c 。

引用 2 楼 user-1 的回复:int total = 0;  你的 total 没有初始化。 编译错误信息其实说得还是比较清楚的。 我刚才发现了，打算编辑呢，您回复了 ____________________________ 晕死，没仔细看错误，以为是使用了未声明的变量，原来是未初始化的，安全检查的问题，大家忽略这个错误吧。另外VS确实不支持复合文字，大家就说一下如何查看它支持C99哪些特性。

我更改了代码，声明了一个int数组，并且把参数改为了一个int指针，但还是报同样的错误。 这似乎不是支持复合文字与否的问题，请帮分析一下什么原因。 #include <stdio.h> int sum(int *p, int i) { 	int total; 	for (int j = 0; j < i; j++) 		total += p[j]; 	return total; } int main(void) { 	int age[2] = {21,26}; 	printf("%d", sum(age, 2)); 	return 0; }


Question: 编写文件同步求助

引用 2 楼 xysds 的回复:[quote=引用 1 楼 zhao4zhong1 的回复:] 搜“robocopy”  我是想编写，不是用现成的呢。[/quote] 为什么不自己编写DNA，而要用现成的受精卵呢？

不建议自己发明轮子，libuv有封装好的功能 http://nikhilm.github.io/uvbook/filesystem.html#file-change-events

linux: inotify bsd: kqueue windows: iocp  都有相应的文件系统watcher

引用 1 楼 zhao4zhong1 的回复:搜“robocopy”  我是想编写，不是用现成的呢。

搜“robocopy”


Question: C语言简单程序问题

请检查scanf的返回值。

问题已解决，数据输入时的格式没按scanf中定义的格式输入

谢谢大家给出解答！

scanf("%d,%d",&a,&b); <---- 两数中间你输入逗号了吗

程序没问题，怀疑你输入时输入的不对，两个数中间有个英文的逗号

应该是你输入格式的问题，如果两个数之间间隔的是空格，那么b应该是个垃圾值，你输入 8,9试试

scanf("%d,%d",&a,&b); <---- 两数中间你输入逗号了吗

scanf之后，先打印a，b 看是否a， b在调用max之前正确接收了


Question: VISUAL2013用c开发一个windows窗体程序找不到类怎么办,已经添加进去了还是找不到  sqlhelper类

c#???这并不是c

大神在哪，帮帮我吧，实在是不懂


Question: 求解

看下是否定义过两个'menu1

你应该贴出menu.h的内容。 你也可以参看我以前提的问题： http://bbs.csdn.net/topics/391873682

@user-3 你可以查看我以前的问题http://bbs.csdn.net/topics/391873682

我也有这个问题。。

源文件不需要include

#include <stdio.h> #include <stdlib.h> #include <string.h> #include "menu.h" #include "user.h" #include "manage.h" #include "station.h" #include "road.h" 不要那个


Question: 二叉树和普通双分支树的区别是什么?

树的范围涵盖了二叉树的范围，二叉树是树的其中一种；  二叉树高效、好用； 普通树通过一些特殊处理，可以转化为二叉树的求解问题

因为数据结构中，二叉树，树 可以看成两种数据结构吧 其实看成一种也没错，不过没啥实在意义 二叉树用树来实现，效率太低下了 而且二叉树有许多树不具有的独特性质  当然，本质上，二叉树就是一种树。

引用 1 楼 user-2 的回复:数据结构（类型）的实现方式， 和 现实世界，以及数学里面的数据类型是两回事  为什么教材上面说，二叉树不是树的特殊情形?

数据结构（类型）的实现方式， 和 现实世界，以及数学里面的数据类型是两回事


Question: 二叉树序列化的恢复算法，有疑问

仅供参考：#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: 不会改求教

inputjob函数中job *temp;改成job temp;


Question: 初学C语言向各位大大求教

还是不太懂，有什么好的算法呢

叉乘的符号

直接判断点的横坐标大小就行了，你的算法太繁琐

这应该只是一个叉乘的问题, 两个点相同没有顺逆之分吧 如果给的三个点分别为A, B,C, 令vb=B-A, vc=C-B , vb cross vc 结果, 大于0即右手系z+, 逆时针


Question: 新手，求解

求范围一般是建议先用筛法得到素数 const int MP=1e6; bool vis[MP]; void sieve() {     for(int i=2,ie=sqrt(MP+0.5);i<=ie;i++)if(!vis[i]){         for(long long j=(long long)i*i;j<=MP;j+=i) vis[j]=1;     } } int rev(int n,int r=0){     return n ? rev(n/10,r*10+n%10) : r; } int count(int m,int n){     int ans=0;     for(int i=m;i<=n;i++){          if(!vis[i]&&!vis[rev[i]]) ++ans;     }     return ans; }

纠正一个错误，刚才没有做详细的测试 第45行    for (int i = 2; i < number; i++)  i应该初始为2，否则4也会被判断为素数 @thefirstz 希望版主能给更改一下，谢谢。

虽然论坛不鼓励帮别人做作业，但由于一直是在论坛问问题，偶尔见一个自己能回答的，就试一下！也是复习自己刚学过知识。 程序加了一些简单的注释，你最好看一下实现的方法，然后自己清晰了之后再自己写一遍。 最后声明一下，我也是新手，有不足之处望指点。 //求m,n之间的绝对素数(包括m,n) #include <stdio.h> int prime(int number); //判断一个数是否为素数，1为真0为假 int num_back(int number); //取一个数的反数 void fun(int m, int n); //输出两个数之间的绝对素数 int main(void) { 	//没有做输入确认 	int m,n; 	scanf("%d",&m); 	getchar();//接受两数的间隔符 	scanf("%d",  &n); 	fun(m, n); 	return 0; } void fun(int m, int n) //输出两个数之间的绝对素数 { 	while (m <= n) 	{ 		if (prime(m))//判断是否为素数 			if (prime(num_back(m)))//取反后再判断是否为素数 				printf("%d\n", m);//都成立即为绝对素数，输出 		m++; 	}  } int num_back(int number) //取一个数的反数 { 	int a = 0, b = 0; 	while (number) 	{ 		a = number % 10;//取number的最后一位 		b = b * 10 + a;  //增加权重 		number = number / 10; //去掉number的最后一位 	} 	return b; } int prime(int number) //判断一个数是否为素数，1为真0为假 { 	int bool_i = 0; 	if (number < 2) //小于2返回假 		return 0; 	else if (number == 2)  //等于2直接返回真 		return 1; 	for (int i = 3; i < number; i++) // 		if ((number%i) == 0) //如果能被3到number之间的数整除就返回假 		{ 			bool_i = 0; 			break;  		} 		else 			bool_i = 1; 	return bool_i; }


Question: ASCII码值对应的键盘输入到底是多少？

//The _getch function reads a single character from the console without echoing. //Function can not be used to read CTRL+Break. //When reading a function key or an arrow key, //_getch must be called twice; the first call returns 0 or 0xE0, //and the second call returns the actual key code. #include <conio.h> #include <windows.h> void main() {     unsigned short k;      while (1) {         Sleep(100);         k=getch();         if (27==k) break;//按Esc键退出         if (0==k||0xe0==k) k|=getch()<<8;//非字符键         cprintf("%04x pressed.\r\n",k);     } }

getch()要调用两次 #include <stdio.h> #include <conio.h>  int main() {     unsigned char	ch;      while (1)     {         if(kbhit())         {             ch = getch();             if (ch == 0x1b) 				break;             if (ch == 0xe0)             {                 ch = getch();                 if (ch == 0x4b)                     printf("left\n");                 else if (ch == 0x4d)                     printf("right\n");                 else if (ch == 0x48)                     printf("up\n");                 else if (ch == 0x50)                     printf("down\n");             }         }     }      return 0; }

包含windows.h头文件，里面作了定义，可以直接用：   #define KF_EXTENDED       0x0100 #define KF_DLGMODE        0x0800 #define KF_MENUMODE       0x1000 #define KF_ALTDOWN        0x2000 #define KF_REPEAT         0x4000 #define KF_UP             0x8000  #ifndef NOVIRTUALKEYCODES   /*  * Virtual Keys, Standard Set  */ #define VK_LBUTTON        0x01 #define VK_RBUTTON        0x02 #define VK_CANCEL         0x03 #define VK_MBUTTON        0x04    /* NOT contiguous with L & RBUTTON */  #if(_WIN32_WINNT >= 0x0500) #define VK_XBUTTON1       0x05    /* NOT contiguous with L & RBUTTON */ #define VK_XBUTTON2       0x06    /* NOT contiguous with L & RBUTTON */ #endif /* _WIN32_WINNT >= 0x0500 */  /*  * 0x07 : unassigned  */  #define VK_BACK           0x08 #define VK_TAB            0x09  /*  * 0x0A - 0x0B : reserved  */  #define VK_CLEAR          0x0C #define VK_RETURN         0x0D  #define VK_SHIFT          0x10 #define VK_CONTROL        0x11 #define VK_MENU           0x12 #define VK_PAUSE          0x13 #define VK_CAPITAL        0x14  #define VK_KANA           0x15 #define VK_HANGEUL        0x15  /* old name - should be here for compatibility */ #define VK_HANGUL         0x15 #define VK_JUNJA          0x17 #define VK_FINAL          0x18 #define VK_HANJA          0x19 #define VK_KANJI          0x19  #define VK_ESCAPE         0x1B  #define VK_CONVERT        0x1C #define VK_NONCONVERT     0x1D #define VK_ACCEPT         0x1E #define VK_MODECHANGE     0x1F  #define VK_SPACE          0x20 #define VK_PRIOR          0x21 #define VK_NEXT           0x22 #define VK_END            0x23 #define VK_HOME           0x24 #define VK_LEFT           0x25 #define VK_UP             0x26 #define VK_RIGHT          0x27 #define VK_DOWN           0x28 #define VK_SELECT         0x29 #define VK_PRINT          0x2A #define VK_EXECUTE        0x2B #define VK_SNAPSHOT       0x2C #define VK_INSERT         0x2D #define VK_DELETE         0x2E #define VK_HELP           0x2F  /*  * VK_0 - VK_9 are the same as ASCII '0' - '9' (0x30 - 0x39)  * 0x40 : unassigned  * VK_A - VK_Z are the same as ASCII 'A' - 'Z' (0x41 - 0x5A)  */  #define VK_LWIN           0x5B #define VK_RWIN           0x5C #define VK_APPS           0x5D  /*  * 0x5E : reserved  */  #define VK_SLEEP          0x5F  #define VK_NUMPAD0        0x60 #define VK_NUMPAD1        0x61 #define VK_NUMPAD2        0x62 #define VK_NUMPAD3        0x63 #define VK_NUMPAD4        0x64 #define VK_NUMPAD5        0x65 #define VK_NUMPAD6        0x66 #define VK_NUMPAD7        0x67 #define VK_NUMPAD8        0x68 #define VK_NUMPAD9        0x69 #define VK_MULTIPLY       0x6A #define VK_ADD            0x6B #define VK_SEPARATOR      0x6C #define VK_SUBTRACT       0x6D #define VK_DECIMAL        0x6E #define VK_DIVIDE         0x6F #define VK_F1             0x70 #define VK_F2             0x71 #define VK_F3             0x72 #define VK_F4             0x73 #define VK_F5             0x74 #define VK_F6             0x75 #define VK_F7             0x76 #define VK_F8             0x77 #define VK_F9             0x78 #define VK_F10            0x79 #define VK_F11            0x7A #define VK_F12            0x7B #define VK_F13            0x7C #define VK_F14            0x7D #define VK_F15            0x7E #define VK_F16            0x7F #define VK_F17            0x80 #define VK_F18            0x81 #define VK_F19            0x82 #define VK_F20            0x83 #define VK_F21            0x84 #define VK_F22            0x85 #define VK_F23            0x86 #define VK_F24            0x87  /*  * 0x88 - 0x8F : unassigned  */  #define VK_NUMLOCK        0x90 #define VK_SCROLL         0x91   只贴了部分

ch=getch();  //添加为: ch=getch();  printf("%d\n",ch); 测试你要的几个键.


Question: 这个栈最小应该多大?

第一个序列为初始序列  a，b，c，d，e，f  下面进行第一轮入栈出栈操作 操作             栈状态                      出栈序列 开始             栈空                             a 入栈          栈内  a b 入栈          栈内   b,a c入栈           栈内   c,b,a  c 出栈          栈内   b,a                  c  d入栈           栈内   d,b,a                c d出栈           栈内   b,a                  c,d b出栈           栈内    a                     c,d,b e入栈           栈内    e,a                c,d,b e出栈           栈内   a                   c,d,b,e a出栈           栈内   a                   c,d,b,e,a f入栈            栈内    f                    f出栈            栈空                        c,d,b,e,a,f 结束第一轮入栈出栈 于是生成第二个序列： c,d,b,e,a,f, 再次 入栈出栈  就可以生成第三个序列了 d,b,c,a,e,f 操作终止

引用 6 楼 lm_whales 的回复: 你说的"第一轮全部出栈后，得到第二个序列c,d,b,e,a,f,"是什么含义? 没有看懂。

1楼告诉你，如果仅仅是一次入栈出栈，那是不可能的 但是我们可以多来几次，谁说 栈只能用一次啊 又不是一次性输液管  题目的意思是入栈次序不可变，但是出栈只是可以出入交替，可以连续两次出栈。 原始序列是a，b，c，d，e，f  第一轮全部出栈后，得到第二个序列c,d,b,e,a,f, 可以第二轮入栈出栈，此时可以得到第三个序列d,b,c,a,e,f 实际上只进行了两轮，第三轮还没开始呢

我也觉得不可能, d后面要么是c,要么是e

引用 4 楼 lm_whales 的回复:做一个栈 测试一下就可以了 枚举所有可能性吧  1楼的方法应该是可行的，因为不允许3次出栈，但允许两次连续出栈。  是啊，我也觉得d后面要么是c要么是e 怎么可能是b呢?  没有看懂1L的解

谢谢，你说的第一轮，第二轮，等等，是什么含义呢，不太懂。 从第一轮如何得到第二轮的c,d,b,e,a,f?  谢谢。

可以啊，总共执行三轮即可，第一轮是a,b,c,d,e,f,第二轮是c,d,b,e,a,f,第三轮即可到达d,b,c,a,e,f，并且满足题中所给条件


Question: 求大神帮忙修改一下下，不知道哪里出错。期末作业。谢谢

void main() { 	struct worker *head=NULL; 	int n = 10;//在下一行函数调用的时候，要传递实参，所以此处要赋值，不能只是定义。 	select(n,head); }  暂时发现这一个错误，没有继续单步跟踪，楼主可以单步跟下。

好像不是，问了下，是float money那里没有先赋值为0，导致数据输不进去

谢谢 好人一生平安


Question: 编译时没问题，Build的时候出现这个错误

某个文件中应有 struct SSedu g_stud[100];

引用 2 楼 qq_32874397 的回复:[quote=引用 1 楼 user-1 的回复:] 某个文件中应有 struct SSedu g_stud[100];只要在一个CPP里声明就行了吗[/quote]只要一个，只能有一个

引用 1 楼 user-1 的回复:某个文件中应有 struct SSedu g_stud[100];只要在一个CPP里声明就行了吗


Question: 【在线等】c语言课程设计程序死机，

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

楼主的代码中void input(struct student *&p)函数中的pt（结构体指针）没有分配内存，就赋值，就会报错； 楼主可以单步跟下，看在哪一步出现程序崩溃，再修改。

引用 4 楼 qq_31829139的回复:引用 1楼user-4 的回复:我猜想：p = (struct student *)malloc(sizeof(LEN));  这句楼主要表达的意思是 p = (struct student *)malloc(LEN);改过，还是不能，死机中 main函数第二行你用关键字int写了一个函数

引用 2 楼 qq_33317084 的回复:[quote=引用 1 楼 user-4的回复:]我猜想：p = (struct student *)malloc(sizeof(LEN));  这句楼主要表达的意思是 p = (struct student *)malloc(LEN); #define 也就是宏定义那里能用下面定义的结构体？[/quote]  不懂你在说什么

引用 1 楼 user-4的回复:我猜想：p = (struct student *)malloc(sizeof(LEN));  这句楼主要表达的意思是 p = (struct student *)malloc(LEN); #define 也就是宏定义那里能用下面定义的结构体？


Question: C 语言里面 " ... " 是什么意思,请大神帮忙解释一下.

https://gcc.gnu.org/onlinedocs/gcc-5.3.0/gcc/Designated-Inits.html#Designated-Inits  引用To initialize a range of elements to the same value, write ‘[first ... last] = value’. This is a GNU extension. For example,       int widths[] = { [0 ... 9] = 1, [10 ... 99] = 2, [100] = 3 };

引用 2 楼 hy09070422 的回复:是范围的意思吗 从代码来看是指定范围,但我想知道 " ... " 的意义及用法

是范围的意思吗

代码中 " ... "  是什么意思??   #define NODE_MASK_ALL							\ ((nodemask_t) { {							\ 	[0 ... BITS_TO_LONGS(MAX_NUMNODES)-2] = ~0UL,			\ 	[BITS_TO_LONGS(MAX_NUMNODES)-1] = NODE_MASK_LAST_WORD		\ } })


Question: 怎么编译器都能对就是oj不对呢，求大神帮忙看看错误

你只需要定义 a,b,x,y 四个int 类型，考虑到 32位这个问题，定义成 unsinged 可以最大限度的利用32位 另外定义一个 循环变量 比如i 每次取到1组 a,b ，初始化x，y 为 0   i 取 a,到 b之间的每一个值，i为偶数，x 加上 i*i 为奇数 y加上 i*i*i------- 这里 if  else 足矣，不必用两个 if----- 如此累加到循环结束，输出x,y这两个值即可  多余代码全部删除。  遇到，题目里面有变量名的，直接使用，不必另外定义。这样更简单。

那我应该怎么改啊 到底是哪里错了我感觉对啊，就算是把32换成其他数字也不对，到底应该改哪里

你这完全理解错了32位的意思了，a,b之间完全可以多于32个数据 例如 a=1,b=100  100^3 *100 也不过 100^4 也就是1亿 所以，题目认为 32Bits 整数足够用了


Question: 写文件问题

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

好像不对啊还是这样

fp = fopen("road.txt","w");   w      Truncate file to zero length or create text  file  for  writing.               The stream is positioned at the beginning of the file. 将 w 改为 a+


Question: 求C语言编码，救急

可是程序要运行呢，允许一直都错

思路不都有了，网上找下弗洛伊德算法算法，应该不少，而且弗洛伊德算法其实挺简单的。


Question: 关于Opencv的imshow无法正常显示的问题（曾经看到别人说是越界问题，但是不知道怎么解决）

请问你们最后解决这个问题了吗，我试着把waitKey（0）的参数改了，确实没有报错了，但是这样图片就会自动退出了，这个问题的本质解决方案是什么呀

我也遇到你这样的问题，然后在imshow语句前加一个waitKey（30）等待就可以了。

你的问题解决了吗，我也遇到这样的问题了

我的图像也没有那么大，其实以前都是显示出来过的 但是，这个程序一直跑得就是有问题，不知道为什么

1，首先看你的opencv配置是否正确，其实就相当于看看程序中是否有哪个函数被红线标出 2，检查一下图像读取时后缀是否正确，并限制一下输入图像的大小 3，如果还不对，调试一下程序看看哪里有问题


Question: 写一个rtrim()函数，消除字符串后面的空格字符

void rtrim(char * str) { 	while(*str++); 	--str; 	while(*--str == ' '); 	++str; 	*str = '\0'; }  int main() {  	char str[100] = "12345     "; 	rtrim(str); 	//此时str为12345 	return 0; }

就是在字符串后面打一堆空格，要用rtrim函数消除掉空格

输入格式是什么啊，一个char*吗？ 有没有长度n啊 ？空格只出现在最后面吗？

厉害，多谢

引用 7 楼 qq_33341459 的回复: 字符串要自己输入，然后按回车运行的呀。 这样只是消除了最后的回车吧  void rtrim(char * str) { 	while(*str++); 	--str; 	while(1) 	{ 		char ch; 		ch = *--str; 		if(ch != ' ' && ch != '\r' && ch != '\n' && ch != '\t') 			break; 	} 	++str; 	*str = '\0'; }   这样把字符串结尾的空格 \r \n \t都清除

字符串有单字节字符串、多字节字符串和宽字符串。前两种里的空格都是' '，后一种是L' ' 没说清是哪一种，叫我们怎么搞。

字符串要自己输入，然后按回车运行的呀。 这样只是消除了最后的回车吧

引用 5 楼 qq_33341459 的回复: 这应该怎么改？  猜测你接收到的最后不是空格，而是'\n'字符

这应该怎么改？


Question: 为什么这个简单的函数实现不了，实在是想不通

引用 2 楼 paschen 的回复:你swap函数的参数是按值传递到函数内的，也就是说函数内操作的是复制后的一个副本，并不是你真正的参数 需要修改需要把指针传进去，交换指针指向的值 谢谢，知道怎么弄了，分你们两楼一人一半吧

查询： 值传递和地址传递的不同。  你这是值传递，x，y实际值不会交换。


Question: 写文件有问题 求解

求解啊 大神们

main 函数  #include <stdio.h> #include <stdlib.h> #include "road.h" /* run this program using the console pauser or add your own getch, system("pause") or input loop */ void read(struct road* ); int main() { 	struct road* r = NULL; 	r = road_init(); 	road_information(r); 	  	read(r);      	road_lookup(r); 	//road_count(r); 	 	return 0; } void read(struct road* r) { 	int i; 	struct road_node* p; 	FILE* fpp; 	fpp = fopen("road.txt","r"); 	if(fpp == NULL){ 		printf("文件打开失败\n"); 		return ; 	} 	p=r->head; 	 	for(i=0; i<init_road; i++){ 		fscanf(fpp,"%s %s\r\n",p->Name,p->ID); 		road_add(r,p->Name,p->ID); 		p = p->next; 	} 	fclose(fpp); }

Main函数呢，没有入口啊

标签写了 谢谢

有什么问题你倒是直说，不要含蓄害羞，难道让我们直接看完一段代码来猜你说的问题?


Question: 请问vs2015环境下，使用gets函数报错，一定要用gets_s函数，怎么办？

引用 8 楼 xusongge 的回复:#define _CRT_SECURE_NO_WARNINGS加了这句声明是没有用的VS2015照样告警。  还是使用gets_s来代替吧。  gets_s(s,sizeof(s));这样用也挺好的O(∩_∩)O

#define _CRT_SECURE_NO_WARNINGS

在程序前面加上这句话就行了 [code=c][/#define _CRT_SECURE_NO_WARNINGScode]

可以参看这里： https://msdn.microsoft.com/zh-cn/library/2029ea5f(v=vs.140).aspx

引用 3 楼 yyxgs 的回复:[quote=引用 1 楼 paschen 的回复:] 因为这个函数是不安全，只是建议用get_s来代替 如果仍想用可以选择以下任何一种方法： 1、新建项目时不要勾选安全开发生命周期检查 2、在项目属性C/C++命令行中加上 /D _CRT_SECURE_NO_WARNINGS   加了，还是没用[/quote]  应该是这个函数在新标准里已经被弃用了，或者可以使用fgets来代替

引用 1 楼 paschen 的回复:因为这个函数是不安全，只是建议用get_s来代替 如果仍想用可以选择以下任何一种方法： 1、新建项目时不要勾选安全开发生命周期检查 2、在项目属性C/C++命令行中加上 /D _CRT_SECURE_NO_WARNINGS   加了，还是没用

引用 2 楼 user-4 的回复:项目→属性→配置属性→C/C++→常规→SDL检查→否 (/sdl-) 然后就可以用gets了。   还是不行


Question: VC++6.0 布尔运算运行不了

同意楼上，vc6你就别想用bool类型了，要不你就用dev c

c语言里面没有bool类型，c99新增了个_Bool类型(vc6.0不支持c99)，头文件stdbool.h里面有bool类型的宏定义，实在不行你这样写 typedef enum {false，true} bool;

什么叫运算不了，程序没问题 你指的是需要怎么输入，程序结果和你预期的不同吗？把问题说明白一点


Question: 弱弱问一下，真能做到单机并发100万个TCP连接吗？

好奇的搜了一下 http://www.cnblogs.com/mydomain/archive/2013/05/27/3100835.html

搜“连接 五元组”


Question: 菜鸟求助，关于将十进制数转成二进制的问题，这段书上的代码我很难理解

引用 10 楼 xusongge的回复:引用 9 楼 u011133403 的回复:[quote=引用 6 楼 xusongge的回复:][quote=引用 3 楼 u011133403 的回复:] n >>= 1 这个操作其实和 除2 是一个意思。但是n是十进制数十进制数往右移不是除以10？？ 你认为是十进制，在计算机中都是二进制，所以所说的右移都是在二进制上说的。[/quote]照这样说，那用递归除2取余的方法计算二进制，，比如计算3的二进制，计算机已经将3存储为011，那011除2是多少？余数是多少？难道计算机除2相当于把011右移一位，变成01，余数就是移出来的1？[/quote] 楼主不要这么纠结，楼主的代码就是把计算机中整型在计算机中是怎么存储的。比如3在计算机中就是 00000000 00000000 00000000 00000011  。

引用 6 楼 xusongge的回复:引用 3 楼 u011133403 的回复:n >>= 1 这个操作其实和 除2 是一个意思。但是n是十进制数十进制数往右移不是除以10？？ 你认为是十进制，在计算机中都是二进制，所以所说的右移都是在二进制上说的。

引用 9 楼 u011133403 的回复:引用 6 楼 xusongge的回复:[quote=引用 3 楼 u011133403 的回复:] n >>= 1 这个操作其实和 除2 是一个意思。但是n是十进制数十进制数往右移不是除以10？？ 你认为是十进制，在计算机中都是二进制，所以所说的右移都是在二进制上说的。[/quote]照这样说，那用递归除2取余的方法计算二进制，，比如计算3的二进制，计算机已经将3存储为011，那011除2是多少？余数是多少？难道计算机除2相当于把011右移一位，变成01，余数就是移出来的1？

按位与&和右移>>都是二进制运算。

引用 4 楼 u011133403 的回复:ps[i] = (01 & n) + '0'; 和 ps[i] = (1 & n) + '0';一样的。就是用当前n的最后一位与1&，来判定该位是否为1，然后加上字符0的ACSII码，转换成字符。存储在字符数组中。最后一起打印出来。那比如n=34，分别用4和3与1&，那这结果是啥？

引用 2 楼 u011133403 的回复:C语言程序开发 - 范例宝典？C Primer 普拉斯

n >>= 1 这个操作其实和 除2 是一个意思。

C语言程序开发 - 范例宝典？

和1与 等价于 除2取余


Question: 求助，C语言输入一个字符串，然后删除某个字符，再输出字符串

引用 9 楼 _郭的回复:[quote=引用 8 楼 qq_30864029 的回复:] [quote=引用 3 楼 _郭的回复:]我发现3个问题。。 1. 我忘记复制最后的“}” 了 2. 我看到你的名字叫永恒郭。。 3. 我大概看了下你的代码,for循环的逻辑表达式 a[i]和a[j]你想要的是什么效果，最后要删除的字符你为什么用/0，如果这个字符在字符串中间，那后面的字符串不要了吗，如果你一定要修改的话，可以改为0，然后输出的时候判断是否为0就可以了。 1，这个没关系。2，把名字和姓倒过来就是我名字了。3，我在第一个循环的最后加上等于’\0’是因为如果要删除的特殊字符串出现在最后，我的那个内部的循环去不掉这几个字符。如:abcds!!!，这样的话，我的内部循环就只能计算出！的个数而去除不掉！，这就需要最后的那个＝’\0’来把第一个！改成\0，让字符串就此结束。。。。谢谢你的回答[/quote] 昨天之前我显示的名字也是和你一样倒着写的。我觉得你把这个程序复杂化了，而且我觉得自己写的每一句代码都要清楚它存在的意义，不然可能就会出现自己的代码自己看不懂的情况。我也是初学者，共同学习！[/quote] 嗯，和七楼说的一样，外边那个循环跟本就用不到，浪费了。

外层for如用于顺序读字符串内容，内层for用于计数并删除相同的字符。外层for没什么用，这种重复纯属浪费，在a[j-count]='\0';后添加i=j-count;或break;终止for循环跳出； char *StrDelCh(char *s,char c) {   char *p=s,*q=s;   for(;*p;p++)     if(*p != c )       q==p ? q++ : *q++ = *p;   *q = '\0';   return s; }

引用 3 楼 _郭的回复:我发现3个问题。。 1. 我忘记复制最后的“}” 了 2. 我看到你的名字叫永恒郭。。 3. 我大概看了下你的代码,for循环的逻辑表达式 a[i]和a[j]你想要的是什么效果，最后要删除的字符你为什么用/0，如果这个字符在字符串中间，那后面的字符串不要了吗，如果你一定要修改的话，可以改为0，然后输出的时候判断是否为0就可以了。 1，这个没关系。2，把名字和姓倒过来就是我名字了。3，我在第一个循环的最后加上等于’\0’是因为如果要删除的特殊字符串出现在最后，我的那个内部的循环去不掉这几个字符。如:abcds!!!，这样的话，我的内部循环就只能计算出！的个数而去除不掉！，这就需要最后的那个＝’\0’来把第一个！改成\0，让字符串就此结束。。。。谢谢你的回答

引用 1 楼 _郭的回复:自己写的自己都看不懂。。。你还是先找一下这个问题的原因吧，在我学习的这段时间还没有出现过自己写的代码自己看不懂的情况。。 看的时候漏了一个条件，现在看懂了

引用 4 楼 user-4的回复:你的代码就是从后往前拷了, 只是奇怪自己写的怎么看不懂 看的时候漏了一个条件，现在看懂了。

你的代码就是从后往前拷了, 只是奇怪自己写的怎么看不懂

引用 8 楼 qq_30864029 的回复:[quote=引用 3 楼 _郭的回复:]我发现3个问题。。 1. 我忘记复制最后的“}” 了 2. 我看到你的名字叫永恒郭。。 3. 我大概看了下你的代码,for循环的逻辑表达式 a[i]和a[j]你想要的是什么效果，最后要删除的字符你为什么用/0，如果这个字符在字符串中间，那后面的字符串不要了吗，如果你一定要修改的话，可以改为0，然后输出的时候判断是否为0就可以了。 1，这个没关系。2，把名字和姓倒过来就是我名字了。3，我在第一个循环的最后加上等于’\0’是因为如果要删除的特殊字符串出现在最后，我的那个内部的循环去不掉这几个字符。如:abcds!!!，这样的话，我的内部循环就只能计算出！的个数而去除不掉！，这就需要最后的那个＝’\0’来把第一个！改成\0，让字符串就此结束。。。。谢谢你的回答[/quote] 昨天之前我显示的名字也是和你一样倒着写的。我觉得你把这个程序复杂化了，而且我觉得自己写的每一句代码都要清楚它存在的意义，不然可能就会出现自己的代码自己看不懂的情况。我也是初学者，共同学习！

我改了一下你的一下代码，但我没有对字符串进行删除，只是在输出的时候增加了一个筛选 #include <stdio.h> #include <windows.h> int main() { 	char a[100] = {0}; 	char ch = 0; 	scanf("%s",a); 	fflush(stdin); //清空缓冲区 	printf("请输入要删除的字符:"); 	scanf(" %c", &ch); 	for (int i = 0; i < 100; i++) 	{ 		 		if (a[i] != ch && a[i] != 0) 			putchar(a[i]); 	} 	system("pause"); 	return 0;


Question: 来帮菜鸟找找错吧！

不知道为什么代码发上来空格就没了。。。请各位大神凑活着看吧

pop是函数, 都没有加上()

程序可以直接嵌入进来，格式什么的就没问题了。你的程序里边is_empty()用错了，其它错误也有，自己看看函数怎么用的吧

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


Question: 大神帮帮我把

好的

没什么要求的话 就一个一个加呗。。。 int a[26] or struct{char ,int} 这行吗？


Question: 代码优化求助

运行更慢了，计算一个方程都需要比较长的时间...

去掉所有sqrt

提供一点思路试试看,令a.b,c,d代表上面4个数 1) 构造 a^2+b^2的一个表sum, 排序供以后查找( 按平方和, b,a为顺序) 2) 循环d,c, sqrt(m/4)<=d<=sqrt(m), m/2>=d*d ? sqrt(m/2-d*d) : 0<=c<=d,剩下值(m-c*c-d*c)在sum表二分查找, 判断b是否<=即可

若改为 int num = 0, imax = sqrt(re / 4), jmax = sqrt(re / 3), kmax = sqrt(re / 2); 即在循环体外计算sqrt，程序的确更快了，但仍然达不到1.0 s的要求，总感觉是不是要换一种算法才行，但又不知道该怎么做?


Question: c中的malloc

你只是申请了一个5字节内存（内容未知）,streln 是根据字符末尾'\o'来判断长度的！

不知道字符串结束符'\0'的位置？

首先你要弄清楚stelen的功能，它是如何实现的

其实这个9也是随机的，不一定都是9.也有可能很大很大。所以最好malloc后可以用memset 去进行初始化。

strlen的含义;搂住要先弄清.

原因你字符串p还没有初始化 strlen是根据字符串最后的\0判断长度的，所以得到的结果是不确定的，你不知道什么时候会遇到0 另外，动态分配的内存返回的是指针，你可以把分配的内存作为数组用，但他不是数组类型，没办法获得其大小了， 如果需要知道分配了多大，需要自己保存分配时的值


Question: 求助带通配符的字符串匹配问题

#include <stdio.h> #include <stdlib.h> #include <ctype.h>  //摘自《代码之美》 //match2(regexp,text) // 字符     含义 // .        匹配任意的单个字符 // ^        匹配输入字符串的开头 // $        匹配输入字符串的结尾 // *        匹配前一个字符的零个或者多个出现 int matchhere(char *regexp, char *text); int matchstar(int c, char *regexp, char *text) {// matchstar: search for c*regexp at beginning of text    do {// a * matches zero or more instances        if (matchhere(regexp, text)) return 1;    } while (*text != '\0' && (*text++ == c || c == '.'));    return 0; } int matchhere(char *regexp, char *text) {// matchhere: search for regexp at beginning of text    if (regexp[0] == '\0') return 1;    if (regexp[1] == '*') return matchstar(regexp[0], regexp+2, text);    if (regexp[0] == '$' && regexp[1] == '\0') return *text == '\0';    if (*text!='\0' && (regexp[0]=='.' || regexp[0]==*text)) return matchhere(regexp+1, text+1);    return 0; } int match2(char *regexp, char *text) {// match: search for regexp anywhere in text     if (regexp[0] == '^') return matchhere(regexp+1, text);     do {// must look even if string is empty         if (matchhere(regexp, text)) return 1;     } while (*text++ != '\0');     return 0; }  //match1(regexp,text) // 字符     含义 // ?        匹配任意的单个字符 // *        匹配零个或者多个字符 int match_imp(const char *d,int dcur,const char *s,int scur) {     if(!d[dcur]) return (!s[scur])?1:0;     if (d[dcur]=='?') return match_imp(d,dcur+1,s,scur+1);     else if(d[dcur]=='*') {         do {             if (match_imp(d,dcur+1,s,scur)) return 1;         } while (s[scur++]);         return 0;     } else return (tolower(d[dcur])==tolower(s[scur]) && match_imp(d,dcur+1,s,scur+1))?1:0; } int match1(char* s1, char* s2) {     return match_imp(s1,0,s2,0); }  int main() {     printf("%d==match1(abc ,abc)\n",match1("abc" ,"abc"));     printf("%d==match1(a?c ,abc)\n",match1("a?c" ,"abc"));     printf("%d==match1(a*c ,abc)\n",match1("a*c" ,"abc"));     printf("-------------------\n");     printf("%d==match1(abc ,abd)\n",match1("abc" ,"abd"));     printf("%d==match1(a?c ,abd)\n",match1("a?c" ,"abd"));     printf("%d==match1(a*c ,abd)\n",match1("a*c" ,"abd"));     printf("\n");     printf("%d==match2(abc ,abc)\n",match2("abc" ,"abc"));     printf("%d==match2(^a  ,abc)\n",match2("^a"  ,"abc"));     printf("%d==match2(c$  ,abc)\n",match2("c$"  ,"abc"));     printf("%d==match2(a.c ,abc)\n",match2("a.c" ,"abc"));     printf("%d==match2(a.*c,abc)\n",match2("a.*c","abc"));     printf("-------------------\n");     printf("%d==match2(ABC ,abc)\n",match2("ABC" ,"abc"));     printf("%d==match2(^B  ,abc)\n",match2("^B"  ,"abc"));     printf("%d==match2(A$  ,abc)\n",match2("A$"  ,"abc"));     printf("%d==match2(a..c,abc)\n",match2("a..c","abc"));     printf("%d==match2(a.*d,abc)\n",match2("a.*d","abc"));     return 0; } //1==match1(abc ,abc) //1==match1(a?c ,abc) //1==match1(a*c ,abc) //------------------- //0==match1(abc ,abd) //0==match1(a?c ,abd) //0==match1(a*c ,abd) // //1==match2(abc ,abc) //1==match2(^a  ,abc) //1==match2(c$  ,abc) //1==match2(a.c ,abc) //1==match2(a.*c,abc) //------------------- //0==match2(ABC ,abc) //0==match2(^B  ,abc) //0==match2(A$  ,abc) //0==match2(a..c,abc) //0==match2(a.*d,abc) //

应该是简单的递归 bool match_imp(const char *s,int scur,const char *d,int dcur) {     if(!d[dcur]) return !s[scur];     if(d[dcur]=='?') return match_imp(s,scur+1,d,dcur+1);     else if(d[dcur]=='*')     {         do{             if(match_imp(s,scur,d,dcur+1)) return true;         }while(s[scur++]);         return false;     }else return tolower(s[scur])==tolower(d[dcur])&&match_imp(s,scur+1,d,dcur+1); } int match(char* s1, char* s2) {     return match_imp(s1,0,s2,0); }

MARK一个。。。。。

2楼是说这个代码不支持多个* ？ 你试运行过了？

引用 1 楼 zhao4zhong1 的回复:仅供参考：//摘自《代码之美》 // 字符     含义 // .        匹配任意的单个字符 // ^        匹配输入字符串的开头 // $        匹配输入字符串的结尾 // *        匹配前一个字符的零个或者多个出现 #include <stdio.h> int matchhere(char *regexp, char *text);  int matchstar(int c, char *regexp, char *text) {// matchstar: search for c*regexp at beginning of text    do {// a * matches zero or more instances        if (matchhere(regexp, text)) return 1;    } while (*text != '\0' && (*text++ == c || c == '.'));    return 0; } int matchhere(char *regexp, char *text) {// matchhere: search for regexp at beginning of text    if (regexp[0] == '\0') return 1;    if (regexp[1] == '*') return matchstar(regexp[0], regexp+2, text);    if (regexp[0] == '$' && regexp[1] == '\0') return *text == '\0';    if (*text!='\0' && (regexp[0]=='.' || regexp[0]==*text)) return matchhere(regexp+1, text+1);    return 0; }  int match(char *regexp, char *text) {// match: search for regexp anywhere in text     if (regexp[0] == '^') return matchhere(regexp+1, text);     do {// must look even if string is empty         if (matchhere(regexp, text)) return 1;     } while (*text++ != '\0');     return 0; } void main() {     printf("%d==match(abc ,abc)\n",match("abc" ,"abc"));     printf("%d==match(^a  ,abc)\n",match("^a"  ,"abc"));     printf("%d==match(c$  ,abc)\n",match("c$"  ,"abc"));     printf("%d==match(a.c ,abc)\n",match("a.c" ,"abc"));     printf("%d==match(a.*c,abc)\n",match("a.*c","abc"));     printf("-------------------\n");     printf("%d==match(ABC ,abc)\n",match("ABC" ,"abc"));     printf("%d==match(^B  ,abc)\n",match("^B"  ,"abc"));     printf("%d==match(A$  ,abc)\n",match("A$"  ,"abc"));     printf("%d==match(a..c,abc)\n",match("a..c","abc"));     printf("%d==match(a.*d,abc)\n",match("a.*d","abc")); } //1==match(abc ,abc) //1==match(^a  ,abc) //1==match(c$  ,abc) //1==match(a.c ,abc) //1==match(a.*c,abc) //------------------- //0==match(ABC ,abc) //0==match(^B  ,abc) //0==match(A$  ,abc) //0==match(a..c,abc) //0==match(a.*d,abc)  这个例子相当漂亮，不过 多个通配符（主要是多个*号），必须另外处理，因为中间的字符串是可伸缩的 最好的办法是两头向中间匹配 单个字符的通配符，以及固定个数个字符，都比较简单，因为只有相等才算匹配， 如果，采用近似匹配（模糊匹配？），那就更麻烦了，就必须知道如何近似才行。


Question: 关于积分的编程，为什么我的代码不行；

void main（） { short  temp =0,templast=0,voff=0; int Compare =0,OUT=0,b1=0; float Total=0.0; while(1) { if(temp>0x0000) {  if(Total<Compare/1.0&&b1==0&&temp>templast)    {             Total+=((temp+Total)/600000;//求积分值              OUT = 1;    }  if(Total>=Compare/1.0&&b1==0)    {      OUT = 1;     voff=temp;    //记住此刻的采样值     b1=1;         }   if(tempAD<=voff&&b1==1)  //当这个采样值再次来临时；    {      OUT = 0;      Total=0.0;      voff=0;      b1=0;          }    templast=temp; //将这一次循环的采样值记住，便于与下次循环比较 } else {OUT = 1;} } } 楼上的程序不完整

我发现问题了，其实我上传的程序还是没有足够完整的，COPY的不完整，不过我发现问题不是出在代码上了。 还是硬件的问题，不是写的代码有问题，不过在上面发的代码确实有问题。

2楼说的很好。

程序写的有问题啊，除了不完整之外，语法错误也很明显，自己调试着看看吧

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


Question: 关于底层函数封装的问题

可以简化程序，同时使用致的接口，把尽可能的实现细节葳起来，公开相对容易的接口 有些封装封装的浅，有些封装的深，当然封装后可能会略有开销，不过可以使开发更容易

另外，很多函数功能太多，用起来太复杂，需要很多时间去学习怎么使用。 而封装后，只针对特定功能，一看就懂， 不需要花费很多时间去学习使用那些复杂的库函数（API）了

猜的不错，大概就是这样  另外一个好处是，简化接口 没封装前，可能功能很杂乱 封装后，不需要的功能，可以不支持 只封装需要的功能。代码可控。


Question: 编译不报错 但是运行没有结果

#2楼正解，这一类问题，楼主可以单步调试发现问题，很简单。你的循环语句走不出来。

if (i < 13){             i++;         }                   else if (i == 13 && j != 4){             i = 1;             j++;         }                   else if (i == 13 && j == 4 && flag){  //i到13，j到4，flag为真的条件             i = -1;             j = 1; //            count++;             flag = 0;         }                   if (i == 13 && j == 4 && !flag){ //i在上面都被置为-1了，j都为1了，永远到不了这个条件             break;         }

代码一直在CreateList中的while (1)里面出不来，你的退出条件一直满足不到，请逐步运行跟踪原因

这是题目：  有两副扑克牌，牌的顺序都是：大王、小王、黑 桃、红桃、方块、梅花四种花色排列，其中每种花色 又按A,2,3，……J,Q,K的顺序排列，有个人把这两副 扑克牌上下叠放在一起，然后从上到下把单数张的丢 掉，把双数张放在最底层，直到剩下最后一张牌，那 么这张牌是什么？


Question: 贪吃蛇改进

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


Question: error C2143: syntax error : missing ';' before 'type'

int PerfectNum() 函数中最后面那个for循环少了大括号 }   加上后这样：  int PerfectNum() { 	int m, n, sum = 0, i = 1, j, k, x = 0, y, p = 0; 	int a[1000], b[1000];  	a[0] = 0; 	for (m = 2; m <=1000; m++) 	{ 		k = m / 2; 		n = 0; 		for (j = 1; j <= k; j++) 		{ 			if(m % j == 0) 			{ 				n += j; 				x++; 				b[x] = j; 			} 		} 		if(m == n) 		{ 			p++; 			printf("%d = ", m); 			for(y = 1; y <= x; i++) 			{ 				if(y == x) 				{ 					printf("%d", b[y]); 				} 				printf("%d + ", b[y]); 			} 			a[0]++; 			while (i <= a[0]) 			{ 				a[i] = m; 				i++; 			} 			sum += m; 		} 	} 	printf("%d = ", sum); 	for (i = 1; i <= a[0]; i++) 	{ 		if(i == a[0]) 		{ 			printf("%d\n", a[i]); 		} 		else 		{ 			printf("%d + ", a[i]); 		} 		printf("%d", p); 		return p; 	} }


Question: 如下代码，如果输入字符，为什么会造成死循环？

引用 6 楼 sheao11 的回复:我已经解决了，代码如下： /* Balances a checkbook */  #include <stdio.h>  int main(void) {     char cmd;     float balance = 0.0f, credit, debit;      printf("*** ACME checkbook-balancing program ***\n");     printf("Commands: a=clear, b=credit, c=debit, ");     printf("d=balance, e=exit\n\n");      printf("Enter command: ");     for (;;) {         cmd = getchar();         if (cmd == '\n') {             printf("Enter command: ");             continue;         } else {          }           switch (cmd) {             case 'a':                 balance = 0.0f;                 break;             case 'b':                 printf("Enter amount of credit: ");                 scanf("%f", &credit);                 balance += credit;                 break;             case  'c':                 printf("Enter amount of debit: ");                 scanf("%f", &debit);                 balance -= debit;                 break;             case 'd':                 printf("Current balance: $%.2Lf\n",balance);                 break;             case 'e':                 return 0;             default:                 printf("Commands: a=clear, b=credit, c=debit, ");                 printf("d=balance, e=exit\n\n");                 break;         }     } }  关键就是会有个\n符，解决了这个问题就行

case 'e':                  return 0;              default:                  printf("Commands: a=clear, b=credit, c=debit, ");                  printf("d=balance, e=exit\n\n");                  break; 你这也没break啊肯定会一直循环的，要出来for循环再return0：

原因是比如你输入a，但是实际接收到了a 和 回车的\n，于是循环时先执行了case 'a':，第二轮循环缓冲区还有\n，于是执行了default  可以在cmd = getchar();后面再加一个getchar();把\n给接收了

上面代码有误，本来switch语句是接收int型的，有死循环；有人建议改成接收字符，上面没改完全，现在改完全了，但是会重复输出，输出如下 *** ACME checkbook-balancing program *** Commands: a=clear, b=credit, c=debit, d=balance, e=exit  Enter command: b Enter amount of credit: 10000 Enter command: Commands: a=clear, b=credit, c=debit, d=balance, e=exit  Enter command: d Current balance: $10000.00 Enter command: Commands: a=clear, b=credit, c=debit, d=balance, e=exit  Enter command: 0 Commands: a=clear, b=credit, c=debit, d=balance, e=exit  Enter command: Commands: a=clear, b=credit, c=debit, d=balance, e=exit  Enter command:   代码如下： /* Balances a checkbook */  #include <stdio.h>  int main(void) {     char cmd;     float balance = 0.0f, credit, debit;      printf("*** ACME checkbook-balancing program ***\n");     printf("Commands: a=clear, b=credit, c=debit, ");     printf("d=balance, e=exit\n\n");      for (;;) {         printf("Enter command: ");         cmd = getchar();          switch (cmd) {             case 'a':                 balance = 0.0f;                 break;             case 'b':                 printf("Enter amount of credit: ");                 scanf("%f", &credit);                 balance += credit;                 break;             case  'c':                 printf("Enter amount of debit: ");                 scanf("%f", &debit);                 balance -= debit;                 break;             case 'd':                 printf("Current balance: $%.2Lf\n",balance);                 break;             case 'e':                 return 0;             default:                 printf("Commands: a=clear, b=credit, c=debit, ");                 printf("d=balance, e=exit\n\n");                 break;         }     } }

for (;;) {          printf("Enter command: ");          i = scanf("%d", &cmd);          if (i == 0) {              printf("Input error!\n");              continue;          } continue 不对，应该是break

哦，源代码应该是： /* Balances a checkbook */  #include <stdio.h>  int main(void) {     int cmd, i;     double balance = 0.0, credit, debit;      printf("*** ACME checkbook-balancing program ***\n");     printf("Commands: 0=clear, 1=credit, 2=debit, ");     printf("3=balance, 4=exit\n\n");      for (;;) {         printf("Enter command: ");         i = scanf("%d", &cmd);         if (i == 0) {             printf("Input error!\n");             continue;         }          switch (cmd) {             case 'a':                 balance = 0.0L;                 break;             case 'b':                 printf("Enter amount of credit: ");                 scanf("%f", &credit);                 balance += credit;                 break;             case  'c':                 printf("Enter amount of debit: ");                 scanf("%f", &debit);                 balance -= debit;                 break;             case 'd':                 printf("Current balance: $%.2Lf\n",balance);                 break;             case 'e':                 return 0;             default:                 printf("Commands: 0=clear, 1=credit, 2=debit, ");                 printf("3=balance, 4=exit\n\n");                 break;         }     } }


Question: 求大神指教。

input函数中if(head=NULL)这句应该要表示的意思是if(head==NULL)吧


Question: json格式转为excel格式

先转为.csv格式(半角逗号间隔列，回车换行间隔行的纯文本)，再用Excel读.csv


Question: 一个关于 printf 很奇怪的问题！！！

引用 6 楼 aqiu348503 的回复:可能运行了上一次编译的程序 支持。  重建所有。

这条语句语法没有问题， 建议楼主把代码贴出来大家才能寻找问题

可能运行了上一次编译的程序

引用 9 楼 vshuo7013 的回复:问题已解决，是因为我的数组中有‘\r’ ，重新回到行首，覆盖改了前面内容。 原来如比

问题已解决，是因为我的数组中有‘\r’ ，重新回到行首，覆盖改了前面内容。

你Ad_buff变量里存的是什么，类型是字符串吗，是否为空，没代码不好给你解释，你先自己检查下，还是不对把代码发上来

是缓冲的问题吗？上一个printf里有么有\n？

把你的输出整个截图上来看看

单就这一句来看是没有问题的，可见出错的原因在别的地方

你要把所有代码贴上来


Question: c语言、string处理

你这太繁琐了。不采纳~没研究。你也去研究下sscanf 吧。 引用 1 楼 fly_dragon_fly 的回复:char *buf[]={         szBuf1,szBuf2,szBuf3,szBuf4,szBuf5,szBuf6,szBuf7     };     char *p=szBuf;     for(int i=3;i&&*p;p++) if(*p=='~') --i;     for(int i=0;i<7;i++){         char *pn =p;         while(*pn&&*pn!='~') ++pn;         if(pn==p) break;         memcpy(buf[i],p,pn-p);         buf[i][pn-p]='\0';         p =pn+1;     }

谢谢，研究出来了。懂得了sscanf的用法。

sscanf(szBuf, "%*[^~]~%*[^~]~%*[^~]~%[^~]~%[^~]~%[^~]~%[^~]~%[^~]~%[^~]~%[^~]", ...

我用的VC6.0的使用这个函数匹配不到？  引用 3 楼 zhao4zhong1 的回复:[quote=引用 2 楼 rogone 的回复:]  sscanf(szBuf, "%*s~%*s~%*s~%s~%s~%s~%s~%s~%s~%s", szBuf1, szBuf2, szBuf3, szBuf4, szBuf5, szBuf6, szBuf7);  顶！  作为一个C程序员，对  scanf,sscanf,fscanf  printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离手，曲不离口”的。 [/quote]  引用 2 楼 rogone 的回复: sscanf(szBuf, "%*s~%*s~%*s~%s~%s~%s~%s~%s~%s~%s", szBuf1, szBuf2, szBuf3, szBuf4, szBuf5, szBuf6, szBuf7);

sscanf与scanf类似，都是用于输入的，只是后者scanf以键盘(stdin)为输入源，前者sscanf以固定字符串为输入源。

引用 2 楼 rogone 的回复: sscanf(szBuf, "%*s~%*s~%*s~%s~%s~%s~%s~%s~%s~%s", szBuf1, szBuf2, szBuf3, szBuf4, szBuf5, szBuf6, szBuf7);  顶！  作为一个C程序员，对  scanf,sscanf,fscanf  printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离手，曲不离口”的。


Question: 线性链表问题

仅供参考：//带表头结点的单向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> struct NODE {     int          data;     struct NODE *next; } H,*head,*p,*q,*q1,*s1,*s2,*s3,*s4,*s; int i,j,k,n,t,m; int main() {     srand(time(NULL));      //填写头节点数据     H.data=-1;     H.next=NULL;     head=&H;      //创建10个节点的单链表     p=head;     for (i=0;i<10;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) return 1;         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         p->next=q;         p=q;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将值为5的结点插入到单链表的第k个结点前     k=3;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) return 1;             q->data=5;             q->next=p->next;             p->next=q;             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //删除第k个节点     k=5;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=p->next;             if (q) {                 p->next=q->next;                 free(q);             }             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //从小到大排序     for (p=head;p!=NULL && p->next!=NULL;p=p->next) {         for (q=p->next;q!=NULL && q->next!=NULL;q=q->next) {             if (p->next->data > q->next->data) {                  //交换data //              printf("swap %02d %02d\n",p->next->data,q->next->data); //              t=p->next->data;p->next->data=q->next->data;q->next->data=t;                  //或者                  //交换next //              printf("swap %02d %02d\n",p->next->data,q->next->data);                 s1=p->next;                 s2=p->next->next;                 s3=q->next;                 s4=q->next->next;                  if (s2!=s3) {                      p->next=s3;                     s3->next=s2;                      q->next=s1;                     s1->next=s4;                 } else {                      p->next=s3;                     s3->next=s1;                            q=s3;                     s1->next=s4;                 }                  //输出整个单链表 //              s=head->next; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d->",s->data); //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将整个链表逆序     if (head->next!=NULL && head->next->next!=NULL) {         p=head->next;         q=p->next;         p->next=NULL;         while (1) {             q1=q->next;             q->next=p;             p=q;             q=q1;             if (NULL==q) break;         }         head->next=p;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将单链表中前 m 个结点和后 n 个结点进行互换,m+n为链表总长10     m=4;     n=6;     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m+1==k) {             q=p;         }         s=p;         p=p->next;     }     s1=head->next;     head->next=q->next;     s->next=s1;     q->next=NULL;      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //释放所有节点     p=head->next;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //84->28->20->23->96->19->59->97->29->41-> //84->28->05->20->23->96->19->59->97->29->41-> //84->28->05->20->96->19->59->97->29->41-> //05->19->20->28->29->41->59->84->96->97-> //97->96->84->59->41->29->28->20->19->05-> //41->29->28->20->19->05->97->96->84->59-> //

再供参考：//不带表头结点的单向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> #include <locale.h> struct NODE {     int          data;     struct NODE *next; } *head,*p,*q,*s,*p1,*p2,*q1,**ta; int i,k,n,t,m,v,N=10; int main() {     setlocale(LC_ALL,"chs");     srand(time(NULL));      head=NULL;      printf("创建%d个节点的单链表:",N);//创建N个节点的单链表     p=head;     for (i=0;i<N;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) exit(1);         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         if (NULL==p) {             head=q;             p=head;         } else {             p->next=q;             p=q;         }     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      k=3;     v=5;     printf("将值为%d的结点插入到单链表的第%d个结点前:",v,k);//将值为v的结点插入到单链表的第k个结点前     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) exit(1);             q->data=5;             q->next=head;             head=q;             break;         } else {             if (k-1==n) {                 q=(struct NODE *)malloc(sizeof(struct NODE));                 if (NULL==q) exit(1);                 q->data=5;                 q->next=p->next;                 p->next=q;                 break;             }         }         p=p->next;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      k=5;     printf("删除第%d个节点:",k);//删除第k个节点     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=head;             head=head->next;             free(q);             break;         } else {             if (k-1==n) {                 q=p->next;                 if (q) {                     p->next=q->next;                     free(q);                 }                 break;             }         }         p=p->next;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      printf("从小到大排序:");//从小到大排序     for (p=head,p1=NULL;p!=NULL;p1=p,p=p->next) {         for (q=p->next,q1=p;q!=NULL;q1=q,q=q->next) {             if (p->data > q->data) {                  //交换data //              printf("swap %02d %02d\n",p->data,q->data); //              t=p->data;p->data=q->data;q->data=t;                  //或者                  //交换next //              printf("swap %02d %02d\n",p->data,q->data);                 if (p==head) {//p是头                     if (p->next==q) {//pq挨着                         head=q;                         p->next=q->next;                         q->next=p;                         q=p;                         p=head;                     } else {//pq不挨着                         head=q;                         p2=p->next;                         p->next=q->next;                         q->next=p2;                         q1->next=p;                         q=p;                         p=head;                     }                 } else {//p不是头                     if (p->next==q) {//pq挨着                         p1->next=q;                         p->next=q->next;                         q->next=p;                         q=p;                         p=p1->next;                     } else {//pq不挨着                         p1->next=q;                         p2=p->next;                         p->next=q->next;                         q->next=p2;                         q1->next=p;                         q=p;                         p=p1->next;                     }                 }                  //输出整个单链表 //              s=head; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d->",s->data); //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个单链表并计算链表长度n     n=0;     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         n++;         s=s->next;     }      printf("将整个链表逆序:");//将整个链表逆序     if (n>=2) {         p=head;         q=p->next;         p->next=NULL;         while (1) {             q1=q->next;             q->next=p;             p=q;             q=q1;             if (NULL==q) break;         }         head=p;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      m=4;     n=6;     printf("将单链表中前%d个结点和后%d个结点进行互换:",m,n);//将单链表中前m个结点和后n个结点进行互换,m+n为链表总长     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m==k) {             q=p;         }         s=p;         p=p->next;     }     q1=head;     head=q->next;     s->next=q1;     q->next=NULL;      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //释放所有节点     p=head;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //创建10个节点的单链表:08->74->07->23->03->99->31->56->88->16-> //将值为5的结点插入到单链表的第3个结点前:08->74->05->07->23->03->99->31->56->88->16-> //删除第5个节点:08->74->05->07->03->99->31->56->88->16-> //从小到大排序:03->05->07->08->16->31->56->74->88->99-> //将整个链表逆序:99->88->74->56->31->16->08->07->05->03-> //将单链表中前4个结点和后6个结点进行互换:31->16->08->07->05->03->99->88->74->56-> //

看看linux内核里面的list.h头文件，极佳的链表实现，从此再也不用自己写链表了

#include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct node_t {     int data;     struct node_t *next; }LINK;   //-------创建,返回链表头 LINK *create(void) {     LINK *new_t=NULL;     LINK *tail=NULL;    static LINK head={0,NULL};//链表头设置为静态变量,可以返回     int num;     while(1)     {         printf("please input a num:");         scanf("%d",&num);         if(num==-1)         {             break;         }          //------为链表节点申请空间         new_t=(LINK *)malloc(sizeof(LINK));         if(new_t==NULL)         {             return NULL;         }         new_t->data=num;         new_t->next=NULL;          //------节点插入链表         for(tail=&head;tail->next!=NULL;tail=tail->next)             ;         tail->next=new_t;     }     return &head; }  //-------释放内存 void free_mem(LINK *head) {      LINK *new_t=NULL;       LINK *tail=NULL;       for(tail=head->next;tail!=NULL;tail=new_t)       {           new_t=tail->next;           free(tail);       }       printf("\nthe mem is over!\n"); }  //-------打印 void show(LINK *head) {      LINK *tail=NULL;     for(tail=head->next;tail!=NULL;tail=tail->next)     {         printf("%d ",tail->data);     }     printf("\n"); }  //-----定点插入 LINK *insert_index(LINK *head,const int num,int index) {      LINK *new_t=NULL;      LINK *tail=NULL;      int count=0;      new_t=(LINK *)malloc(sizeof(LINK));      if(new_t==NULL)      {          return NULL;      }      new_t->data=num;      new_t->next=NULL;      for(tail=head->next;tail!=NULL;tail=tail->next)      {          count++;          if(count==index)          {              break;          }      }      new_t->next=tail->next;      tail->next=new_t;      return head; }  //------删除元素 LINK *del(LINK *head,const int num) {     LINK *new_t=NULL;     LINK *tail=NULL;      for(tail=head->next;tail!=NULL;tail=new_t->next)     {         new_t=tail;//指向当前的节点         tail=tail->next;//移下个节点         if(tail->data==num)         {             break;//相同,就退出         }     }     new_t->next=tail->next;     free(tail);     return head;  }  int main(void) {       LINK *head=NULL;      LINK *head2=NULL;      LINK *head3=NULL;      head =create();      show(head);      head2 =insert_index(head,9999,3);      show(head2);      head3=del(head,9999);      show(head3);      free_mem(head);      printf("\n");     printf("Hello World!\n");     return 0; }  //-----------你的露点太多了，包括代码的规范性、变量的初始化、等。看看我自己写的吧

引用 9 楼 zhujinqiang的回复:题目和源代码来自那本书啊？楼主 这是我自己写的代码。。

InitList函数中分配完内存后又把list赋值为NULL？

题目和源代码来自那本书啊？楼主

引用 7 楼 user-7的回复:int InitList( struct LNode *list,int n) 这个函数，你调用时InitList(&L,n) 函数中list确实指向的是L的地址，但你在函数接下来部分修改了list指向的值，并不会改变L中的内容 要改变指针，那你需要传入函数的则是指针的指针 看的不怎么懂我这是哪块知识不过关？

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

引用 2 楼 fly_dragon_fly的回复:int InitList( struct LNode *list,int n) L是局部变量, &L的地址不能再分配了, 里面还有置为NULL的操作 看不懂你的回复

那应该怎么改才能正确呢？

引用 1 楼 qq_33316244的回复:InitList函数中分配完内存后又把list赋值为NULL？ 不是需要把头结点置空吗？


Question: 用C语言完成数据结构中循环队列

base是int *，分配内存却按char分配，这样真的好吗?再者main里面读取字符记住回车也是一个字符，可以用scanf("%c ",d);或者读取完后刷新输入缓冲区，或者用个循环把这行余下字符全部读取丢弃

rewind(stdin);scanf("%c",&d);


Question: 求大神用C语言编一个编写一个简易的航班预订系统（带注释）

课程设计尽量自己做吧，又不难

引用 4 楼 zhao4zhong1 的回复:百度搜相关关键字。四爷你看你下面二楼～有个和你一样的人

我也想看看谁能写出来，楼上的头像更牛Ｘ

用php+mysql不是更好吗？楼上头像牛X

没有人回复吗

50分空手套白狼

百度搜相关关键字。

解决没，我也有个

**课程设计

这不是我大一/大二的课设题目吗? 某非楼主和我是同一所大学的?


Question: 编写函数，求平面上两点最长距离

inline double dis(int x0,int x1,int y0,int y1){     return sqrt((x0-x1)*(x0-x1)+(y0-y1)*(y0-y1)); } double get() {     int x[101],y[101];     double ans=1e300;     for(int i=0;i<100;i++) for(int j=i+1;j<100;j++){         ans=min(ans,dis(x[i],x[j],y[i],y[j]));     }     return ans; }

归根结底是个算法问题，先把算法想清楚。

略优化楼上： inline double dis(int x0,int x1,int y0,int y1){     return (x0-x1)*(x0-x1)+(y0-y1)*(y0-y1); } double get() {     int x[101],y[101];     double ans=1e300;     for(int i=0;i<100;i++) for(int j=i+1;j<100;j++){         ans=min(ans,dis(x[i],x[j],y[i],y[j]));     }     return sqrt(ans); }

x，排序，y排序 水平和垂直各10等分在同一窗口内以及相邻窗口内取最小 在最远窗口内取最大


Question: 急求！！！！

将数组s改成指针，右值去掉大括号

int fun(char *p)  { 	int m = 0; 	while(*p) 	{ 		if(*p>='A' && *p<='Z') 			++m; 		++p; 	} 	return m; }  int main() { 	char s[20]={ "I am 20 years oLd!"}; 	int m; 	m = fun(s); 	return 0; }


Question: 关于随机数的问题?

楼主需要多多细心啊

不错，能自己发现问题就好，有别的问题再来讨论吧

引用 1 楼 duanlim2008 的回复:靠，刚才看自己发的帖子才发现，居然把10当成了一个字符。笨死  解决了就好，有问题再问

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

靠，刚才看自己发的帖子才发现，居然把10当成了一个字符。笨死


Question: C 语言实现函数里面定义函数的方法!!!!!!!!!!!!!

另一种方法是利用嵌入式汇编， 只是不同硬件汇编语言语法不同， 也很难说，这是可移植的。

引用 33 楼 paschen 的回复:http://blog.chinaunix.net/uid-20753645-id-1877932.html  关于 blog 中所说：   #include <stdio.h> #include <stdlib.h>  int fun1(void); int main(int argc, char *argv[]) {     fun1();     return 0; }  int fun1(void) {     printf("in fun1!\n");       void fun2(void) {         printf("in fun2!\n");     }     fun2();     return 0; }   $ gcc --std=c99 test.c $ gcc --std=c99 -pedantic test.c test.c: In function ‘fun1’: test.c:15:6: warning: ISO C forbids nested functions [-Wpedantic]       void fun2(void) {       ^   另见： https://gcc.gnu.org/onlinedocs/gcc-5.3.0/gcc/Nested-Functions.html#Nested-Functions gcc 关于 nested-function 的文档 引用一下第一句： 引用A nested function is a function defined inside another function. Nested functions are supported as an extension in GNU C, but are not supported by GNU C++.

没发现C99文档哪里说支持嵌套的函数定义。不但C99没找到，C11也没说。 个人表示莫名其妙、莫名惊诧。  引用 33 楼 paschen 的回复:http://blog.chinaunix.net/uid-20753645-id-1877932.html

引用 20 楼 lm_whales 的回复:C++lamda表达式也可以达到这个目的，估计C++是不会支持了 实在不行，C++还可以在函数内部定义类，结构，可以在他们内部定义函数。  现在只讨论 C 语言里实现函数定义里嵌套函数定义

引用 33 楼 paschen 的回复:http://blog.chinaunix.net/uid-20753645-id-1877932.html   谢谢,终于找到方法了,不过我的实现不是按上面的方法,不过我觉得上面的有道理.

引用 27 楼 DelphiGuy 的回复:[quote=引用 25 楼 linzertling 的回复:] 你坚信跟能不能是两码事，函数里边定义函数本身的语言你给我举出一个试试  Pascal就可以，还有很多其他语言Ada、Algol68、Modula2、Simula67等等。   {$APPTYPE CONSOLE} program test;  function NestedFunc1(): integer;   function NestedFunc2(): integer;     function NestedFunc3(): integer;     begin       result := 1;     end;   begin     result := NestedFunc3 + 1;   end; begin   result := NestedFunc2 + 1; end;  begin   writeln(NestedFunc1); end.  [/quote]    果然是老手,佩服佩服!!!

引用 25 楼 linzertling 的回复:你坚信跟能不能是两码事，函数里边定义函数本身的语言你给我举出一个试试  明天我公布答案,有些事,转换一下思维就可以实现拉!!

引用 26 楼 qwer_boo 的回复:现在就说吧，回复你的人之所以不多，我觉得大家都觉得话题比较无聊~~  在我公布答案之前,你可以发表对这个问题的看法  有的人是不想回复,有的人是没法回复,毕竟这个问题不是简单问题.

引用 28 楼 linzertling 的回复:[quote=引用 27 楼 DelphiGuy 的回复:] [quote=引用 25 楼 linzertling 的回复:] 你坚信跟能不能是两码事，函数里边定义函数本身的语言你给我举出一个试试  Pascal就可以，还有很多其他语言Ada、Algol68、Modula2、Simula67等等。   {$APPTYPE CONSOLE} program test;  function NestedFunc1(): integer;   function NestedFunc2(): integer;     function NestedFunc3(): integer;     begin       result := 1;     end;   begin     result := NestedFunc3 + 1;   end; begin   result := NestedFunc2 + 1; end;  begin   writeln(NestedFunc1); end.  [/quote]  这些个语言我不了解，也不想再了解了，因为在函数里边定义函数本身就没什么意思，这就像是数学里边的复合函数一样，本质还是加减乘除[/quote]  有用，第一是有封装的思想，实现某个功能的函数可能比较复杂、代码量大，需要把它分解成若干函数，写成独立的一系列函数当然也是可以的，但是封装性不好，不如写成一个主函数的子函数好（高内聚）。第二是子函数可以访问它上级（无论多少级）函数的局部变量，这个是并列的若干单独函数做不到的，后者只能用全局变量了。

引用 27 楼 DelphiGuy 的回复:[quote=引用 25 楼 linzertling 的回复:] 你坚信跟能不能是两码事，函数里边定义函数本身的语言你给我举出一个试试  Pascal就可以，还有很多其他语言Ada、Algol68、Modula2、Simula67等等。   {$APPTYPE CONSOLE} program test;  function NestedFunc1(): integer;   function NestedFunc2(): integer;     function NestedFunc3(): integer;     begin       result := 1;     end;   begin     result := NestedFunc3 + 1;   end; begin   result := NestedFunc2 + 1; end;  begin   writeln(NestedFunc1); end.  [/quote]  这些个语言我不了解，也不想再了解了，因为在函数里边定义函数本身就没什么意思，这就像是数学里边的复合函数一样，本质还是加减乘除

引用 25 楼 linzertling 的回复:你坚信跟能不能是两码事，函数里边定义函数本身的语言你给我举出一个试试  Pascal就可以，还有很多其他语言Ada、Algol68、Modula2、Simula67等等。   {$APPTYPE CONSOLE} program test;  function NestedFunc1(): integer;   function NestedFunc2(): integer;     function NestedFunc3(): integer;     begin       result := 1;     end;   begin     result := NestedFunc3 + 1;   end; begin   result := NestedFunc2 + 1; end;  begin   writeln(NestedFunc1); end.

现在就说吧，回复你的人之所以不多，我觉得大家都觉得话题比较无聊~~

你坚信跟能不能是两码事，函数里边定义函数本身的语言你给我举出一个试试

大家好，明天公布 C 语言里如何在函数定义里实现新的函数定义方法  所用的格式就是下面这种  void a(void) {     ....      void b(void)      {          ....      }     .... }   ！！！

引用 22 楼 DelphiGuy 的回复:c的话除了使用gcc编译的话还没有什么好办法，struct那个方法也不适用于c。 就是要在 C 里面实现函数的定义里面定义新的函数！！！  void a(void) {     ....      void b(void)      {          ....      }     .... }

取一个指针，指向一块代码区？然后把整一个结构放在一个函数壳里面吧？

引用 5 楼 paschen 的回复:你可以创造一种语言让他可以，但C标准里没这样的说法  C 语言真的可以实现,而且这种用法符合 C99 标准!!!!!!!

你可以创造一种语言让他可以，但C标准里没这样的说法


Question: setlinestyle提示错误

closegraph; 该函数后面少了个括号。


Question: 研究蛇形矩阵的输入输出算法

#include <iostream>  using namespace std; int main() {  	int n; 	int i,j; 	cin >> n; 	cout << "要得到的菱形的大小：" << endl; 	for ( i = 0; i <= n;i++) 	{ 		for (int j = 0; j <n - i;j++) 			cout << " "; 		for (j = 0; j <i; j++) 			cout << "* "; 		cout << endl; 	} 	for (i = n-1; i >= 0; i--) 	{ 		for (int j = 0; j < n - i; j++) 			cout << " "; 		for (j = 0; j < i; j++) 			cout << "* "; 		cout << endl; 	} 	system("pause"); 	return 0; } 刷存在感 还有怎么没有c++写的代码

引用 5 楼 赵4老师的回复:其实我只是不能免俗地刷存在感而已。 哈哈，你是学生还是工作了？

引用 5 楼 zhao4zhong1 的回复:其实我只是不能免俗地刷存在感而已。排名下降了,刷个分先

其实我只是不能免俗地刷存在感而已。

引用 3 楼 zhao4zhong1 的回复:仅供参考：//n=1, //1 //n=2, //12 //34 //n=3, //126 //357 //489 //n=4, //  1  2  6  7 //  3  5  8 13 //  4  9 12 14 // 10 11 15 16 //n=5, //  1  2  6  7 15 //  3  5  8 14 16 //  4  9 13 17 22 // 10 12 18 21 23 // 11 19 20 24 25 //之字形 //模仿蚂蚁爬的过程 #include <stdio.h> #define MAXN 9 int m[MAXN][MAXN]; int i,x,y,dx,dy,n,n2,k; void main() {     for (i=1;i<=MAXN;i++) {         n2=i*i;         k=1;         if (n2>9) k=3;         x=0;         y=0;         dx=1;         dy=-1;         n=1;         m[y][x]=n;         while (1) {             if (n>=n2) break;             n++;             x=x+dx;             y=y+dy;             if (y>=i) {                 x=x+2;                 y=i-1;                 dx=1;                 dy=-1;             }             if (x>=i) {                 y=y+2;                 x=i-1;                 dx=-1;                 dy=1;             }             if (y<0) {                 y=0;                 dx=-1;                 dy=1;             }             if (x<0) {                 x=0;                 dx=1;                 dy=-1;             }             m[y][x]=n;         }         for (y=0;y<i;y++) {             for (x=0;x<i;x++) {                 printf("%*d",k,m[y][x]);             }             printf("\n");         }         printf("-------------%d--------------\n",i);     } } //1 //-------------1-------------- //12 //34 //-------------2-------------- //126 //357 //489 //-------------3-------------- //  1  2  6  7 //  3  5  8 13 //  4  9 12 14 // 10 11 15 16 //-------------4-------------- //  1  2  6  7 15 //  3  5  8 14 16 //  4  9 13 17 22 // 10 12 18 21 23 // 11 19 20 24 25 //-------------5-------------- //  1  2  6  7 15 16 //  3  5  8 14 17 26 //  4  9 13 18 25 27 // 10 12 19 24 28 33 // 11 20 23 29 32 34 // 21 22 30 31 35 36 //-------------6-------------- //  1  2  6  7 15 16 28 //  3  5  8 14 17 27 29 //  4  9 13 18 26 30 39 // 10 12 19 25 31 38 40 // 11 20 24 32 37 41 46 // 21 23 33 36 42 45 47 // 22 34 35 43 44 48 49 //-------------7-------------- //  1  2  6  7 15 16 28 29 //  3  5  8 14 17 27 30 43 //  4  9 13 18 26 31 42 44 // 10 12 19 25 32 41 45 54 // 11 20 24 33 40 46 53 55 // 21 23 34 39 47 52 56 61 // 22 35 38 48 51 57 60 62 // 36 37 49 50 58 59 63 64 //-------------8-------------- //  1  2  6  7 15 16 28 29 45 //  3  5  8 14 17 27 30 44 46 //  4  9 13 18 26 31 43 47 60 // 10 12 19 25 32 42 48 59 61 // 11 20 24 33 41 49 58 62 71 // 21 23 34 40 50 57 63 70 72 // 22 35 39 51 56 64 69 73 78 // 36 38 52 55 65 68 74 77 79 // 37 53 54 66 67 75 76 80 81 //-------------9--------------  在哪都能看到你，华为比赛论坛上也能看到你！

噢，多了一个n，只有n条直线 直线族为 x+y=0 ... x+y=2（n-1） 终点坐标是 (n-1,n-1)  区域 为 x=0,x=n-1 y=0,y=n-1

首先把这个矩阵看成是点集 他的坐标系是 X轴自左向右 Y轴自上向下  坐标轴是    OX (0,0)~(0,n) OY(0,0)~(n,0) 走的路线是 x+y=0 x+y=1 x+y=2 x+y=i ....... x+y=n 直到 x+y=2n 共2n+1 条直线 每次从y=0 ->x=0,然后 换个i 再从 x=0，到y=0 走到  （n,0） 或者（0,n)开始转换边界 改为  (n,i) 或者（i,n）为边界继续走直到 (n,n)  即是直线族 x+y=i在区域 x=0,x=n,y=0,y=n 之间的所有整数坐标点。


Question: 关于C语言文件读写问题

看了你两个问题说白了都是读写文件， 这很基础的东西 http://blog.csdn.net/strongwangjiawei/article/details/7786085

看你这么诚恳的问问题，我还是提醒你几个问题吧。 1、在论坛提问题，最好用大神、高手等等来称呼别人，用小弟、本人等等来称呼自己，用老师、学生显得太严肃。 2、贴代码只需要贴有问题的部分，没问题的代码就不要贴了，大家看起来很累。 3、不要随意让别人给你写代码，这样很不好。 4、看你这个问题，其实就是不知道如何读写文件，你只需要找本书，或者上网查查如何读写文件即可，这样你自己才能成长。


Question: 深奥的问题

如果作为全局变量，你得这样写；   int a = 1; int b = 2; int y =a + b;   否则是错误的，全局区中不能有执行语句，只能有变量的初始化

关键是楼主你选的什么编译器，你的编译器对第二种写法报不报错，如果不报错，那就是你想说明全局变量，局部变量，数据存储位置的区别？？不明白深奥在哪里

理解和讨论之前请先学会如何观察！  计算机组成原理→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对应的汇编并单步执行观察相应内存和寄存器变化。）

前者是全局变量，存在于全局区，后者是main中局部变量，存在于堆栈中 如果只需要在main中使用，通常不建议存成全局变量，具体原因： 1、全局变量在整个程序运行期间都存在，空间效率低 2、全局变量各函数均可用，很容易导致想不到的BUG，容易引起命名冲突，不利于高度 当然也不是说不用，需要合理的运用

全局变量和局部变量的区别嘛.确实要彻底弄明白还是不太容易的. 我到现在都只会正确的用,没有彻底弄懂过.

我去，我重新注意到了标题。。。这个好像是一些常识性的东西，怎么变成深奥的问题了

我的理解是前一个是局部变量，也就是main函数私有，后者是全局变量，所有函数都可以访问。

引用 1 楼 醉花阴柳的回复:变量存储的内存位置不同 而且你在函数外赋值，这是错误的，只能初始化

变量存储的内存位置不同


Question: 为啥不能编译

谢谢各位,谢谢

如此简单的程序错误还是挺多的，建议先把基础语法搞懂

错误比较多，简单改了一下，如下： #include<stdio.h>   int sf(char *s1,char *s2);  int main(void) { 	char s1[20],s2[20]; 	scanf("%s %s",s1,s2); 	int result = sf(s1,s2); 	printf("------\n"); 	printf("s1 is %s\n", s1); 	printf("s2 is %s\n", s2); 	printf("The result is %d", result);  	return 0; }  int sf(char *s1, char *s2) /*比较两个字符数组的大小*/ {  	while(*s1 == *s2) 	{   		if(*s1 == '\0' && *s2 == '\0') return 0; 		else if (*s1 == '\0' || *s2 == '\0') break; 		s1++; 		s2++;    	}  	return (*s1 - *s2); }    1.  注意代码可读性。 2.  建议找本经典教材学学。   当初没人教我编程，纯靠自学，走了很多弯路，甚是遗憾。

你int main() 后面少了一个大括号{  其次sf函数里return (*s-*t); 这里的s和t是什么，前面没定义过 建议把基础打好啊

看一下编译提示,应该蛮清楚的


Question: 为啥不能执行预期功能：？将字符数组倒着输出

\0怎么了？

注意字符串结尾是\0

谢谢老师,我知道了

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

什么地方不对, 倒着输出不用操作数组, 循环变量倒着走就行 for(int i=k-1;i>=0;i--)


Question: typedef 与 #define区别中的理解？

ypedef char *pStr1; #define pStr2 char *; pStr1 s1, s2; pStr2 s3, s4; 上述的变量定义中，s1、s2、s3都被定义为char *，而s4则定义成了char， 不是我们所预期的指针变量，根本原因就在于#define只是简单的字符串替换， 而typedef则是为一个类型起新名！  说的很清楚了啊！容易理解！  pStr2直接替换成了 char*就就可以了！ pStr2 s3, s4; 等价于 char* s3,s4; s4就是一个char的类型  而typedef却不是替换！ pStr1 s1, s2;  注意pStr1是一个类型了，代表了char*，不是替换的关系，而是代表，或者说定义了，typedef就是重定义一样！ pStr1 s1, s2;  这句话的意思是定义了一个pStr1类型的两个变量s1,s2 ；

其实很好理解，使用typedef 表示给一个类型起了一个别名你可以理解为一个新类型。而#define只是简单替换，所以你的定义语句等价为   char *s1;char *s2;   char *s3 ,s4;（与char *s3;char s4;等价）这样你清楚了吗？

其实不用想太复杂 一个是宏定义，简单的字符替换  另外一个是类型别名，跨平台开发用

一个是替换 一个是类型定义

1. 对于变量类型，以下规则适用： 变量类型 变量名1, 变量名2; ==> 变量类型 变量名1; 变量类型 变量名2; int i1, i2;    ==> int i1;   int i2; char *s1, *s2; ==> char *s1; char *s2; char *s3, ch;  ==> char *s3; char ch;在上述例子中，如果你将 * 和 s1、s2、s3 当作整体，和 i1、i2 比较一下，可以看出几乎一样。 星号的书写是应该放在类型名后面还是变量前面，一直争执不断。我个人喜欢靠近变量，原因如上。  例如，定义新类型 PTRCHAR 如下：typedef char * PTRCHAR;几个声明语句可以按照如下方式展开理解：PTRCHAR s1, s2;  ==> PTRCHAR s1; PTRCHAR s2;  ==> char *s1; char *s2; PTRCHAR s3, *s4; ==> PTRCHAR s3; PTRCHAR *s4; ==> char *s3; char **s4;2. 对于宏，仅仅是文字层面的替换，此时尚未进行对语法分析的层面。 例如，定义宏 CHARPTR 如下：#define CHARPTR char *几个声明语句可以按照如下方式展开理解：CHARPTR s1, s2;  ==> char *s1, s2;  ==> char *s1; char s2; CHARPTR s3, *s4; ==> char *s3, *s4; ==> char *s3; char *s4;

// PTRCHAR 像“int”一样是新类型 typedef char *PTRCHAR; // CHARPTR 是“char *”的简单替换 #define CHARPTR char *  int i1, i2; PTRCHAR s1, s2; // -> int i1; int i2; PTRCHAR s1; PTRCHAR s2; // -> int i1; int i2; char *s1; char *s2;  int *i3, i4; CHARPTR s3, s4; // -> int *i3, i4; char * s3, s4; // -> int *i3; int i4; char * s3; char s4;

typedef 定义了一种新的类型，编译器会对这种类型做必要的检测  #define只是定义了一个替换规则，编译器不检测，只做简单替换

typedef char *pStr1; #define pStr2 char *; pStr1 s1, s2; pStr2 s3, s4;  你可以理解成 char *s3,s4； 也就是 char *s3; char s4;  你可以改成 pStr2 s3;pStr2 s4;这样s4就被定义成指针。 归根原因是typedef  是将定义类型做了个别名，#define 只是替换相应字符；

建议群主去看Microsoft定义的一系列头文件，看看里面什么时候用#define什么时候用typedef。看多了就懂了。 我就是这样学习的。

理解和讨论之前请先学会如何观察！  搜“盲人摸太阳”

吃透了这句话就可以了。  根本原因就在于#define只是简单的字符串替换， 而typedef则是为一个类型起新名字。

这么简单还问…… 你根本没理解如何声明指针。 如果char *s3,*s4;  s3 s4 都被声明为char类型指针。 如果char s3,s4;  s3 s4都被声明为char类型普通变量。 如果char *s3,s4;  则s3被声明为char类型指针，s4为char类型普通变量。 既然你知道#define只是替换，那你把第二个语句中的替换就好了啊，替换完是不是我写的第二个如果中的情况？ 好好读读书

樓主，11樓和13樓都說的沒錯，#define pStr2 char *，首先後面沒有分號；其次你仔細看就會發現char和*之間有個空格， 當定義pStr2 S3,S4時，由於是#define,pStr2會被替換成char空格*，就是執行的實際是char *S3，S4。意思就是#define 只是個替換的作用，編譯之前#define定義的所有pStr2代碼部分就被替換掉了，

宏的作用是 把你后面写得或长或短的东西 直接用一个名词替代 其作用和你直接把后面那堆敲进去在编译器来看是一个样的  typedef仅仅只是把一个已知的名称类型 定义成为另外一个名称而已。 两者作用差得老远了

typedef 出来的标识符，具备类型检查

#define就是查找替换 其实一替换就很清楚了  char * s1, s2 请问s2是什么类型？

typedef 相当于是给一个类型 取了个别名 代号 就像是 class {}class1, 这样。 而define只是替换 一个值，不能替换类型的

这也是一个编程规范了，一般我们都是一个变量一个变量的声明，这样可以避免一个笔误，如char *p1,p2;你写成char *p1; char *p2 就不会了

既然帖子被标为推荐，朕也来说几句。 关于# define，楼主是明白的，不解释。 关键字typedef的作用是将一个标识符定义为它被声明的那种类型。它被声明为什么类型，它就是那种类型的别名。比如： typedef int Integer; typedef char * PCHAR; typedef int F (int); 以上，标识符Integer是int类型的别名，F是一个函数类型的别名，该函数接受一个int类型的参数，返回类型是int。在此之后，就可以声明这两种类型的其它标识符，例如： int f (int x) {/* ... ... */} void g (const char * s1, const char * s2) {/* ... ... */}  int main (void) {     Integer x = 0;    //S1     F f;                    //S2     PCHAR s1 = "House of cards", s2 = s1;    //S3     g (s1, s2);     return f (x); } 以上，在S1中，x的类型是Integer，Integer是int的别名，所以x的类型是int；在S2中，f的类型是F，F是函数类型int (int)的别名，所以S2等价于 int f (int); 在S3中，s1和s2的类型都是PCHAR，PCHAR是指针char *的别名，所以s1和s2都是char *类型。即，都是指向char的指针。

其实要理解这个例子只需要理解指针的定义， 1.当定义两个指针时，这样定义： char *a, *b; 2.而如果定义了 char *a, b; 则是定义了一个指针，一个变量；  那么再汇过来理解题目就好理解了，#define只是进行了替换，这样就形成了上面2所示的例子，而用typedefine则是直接把一个类型定义成了另外一个类型，那么这时候就不是简单的替换了。


Question: 用C语言实现cookies的购物车功能，大神来。。

对不同网站，编码算法不同。具体算法在服务器端的代码中。

引用 9 楼 zhao4zhong1 的回复:发挥你的主观能动性！  用c语言编写响应报文头，设置 "Set-Cookie: name=make\r\n"，然后从请求报文中取出Cookie: name=make。现在我要分析这个Cookie，请问赵老师  这个name=make键值怎么解析，这个键值是经过编码的吗？ 我最主要的就是要知道这个cookies的时间，目的是要实现用户是否超时，超时就返回登录界面。   赵老师冬至快乐，别忘了吃饺子。。。

引用 9 楼 zhao4zhong1 的回复:发挥你的主观能动性！  我先自主研究一会

发挥你的主观能动性！

引用 7 楼 zhao4zhong1 的回复:https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=2&tn=baiduhome_pg&wd=CGI%20cookies&rsv_spt=1&oq=%26lt%3BGI%20cookies&rsv_pq=9416bb140004286f&rsv_t=12a4eXM5gRWxHUacy3hRV%2BzdXSNaJVaKyVOywBAbCy300BV6%2BJDUJoqMGZ4poMzS04dD&rsv_enter=0&rsv_sug3=20&rsv_sug1=15&rsv_sug4=1246&rsv_sug=1   赵老师，用C语言进行编解码set-cookies  的键值   怎么进行啊

大概流程是这样 但是就是无从下手 怎么办

引用 3 楼 zhao4zhong1 的回复:https://www.baidu.com/s?wd=C%E8%AF%AD%E8%A8%80%E5%AE%9E%E7%8E%B0cookies%E7%9A%84%E8%B4%AD%E7%89%A9%E8%BD%A6&rsv_spt=1&rsv_iqid=0xe6e9e2a00000448d&issp=1&f=8&rsv_bp=0&rsv_idx=2&ie=utf-8&tn=baiduhome_pg&rsv_enter=0&rsv_n=2&rsv_sug3=1&inputT=1593&rsv_sug4=1593   那些都是用其他语言的，用C语言怎么写啊，赵老师。。。


Question: 杭电acm1019题，为什么我的总是wrong answer?

把以下一行： t=a*b/maxgy(a,b); 改为： t=a/maxgy(a,b)*b; 即可AC。

1) long long 更保险 实在不行长整数计算 2）如楼上所述，先除后乘更保险

你以为用long就不溢出了吗, 没用的, 换成先除约数再乘

你倒是把错误信息提供出来吧，另外iostream.h不是C++的标准库里的头文件吗？

在百度搜“求n个数的最小公倍数”

求n个数的最小公倍数~


Question: L"Buffer is too small && 0"

仅供参考：/*--------------------------------------- 函数型计算器(VC++6.0,Win32 Console) 功能： 目前提供了10多个常用数学函数:     ⑴正弦sin     ⑵余弦cos     ⑶正切tan     ⑷开平方sqrt     ⑸反正弦arcsin     ⑹反余弦arccos     ⑺反正切arctan     ⑻常用对数lg     ⑼自然对数ln     ⑽ｅ指数exp     ⑾乘幂函数^     ⑿向上取整ceil     ⒀向下取整floor     ⒁四舍五入取整round 用法： 如果要求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 round(double dVal, short iPlaces) {//iPlaces>=0     char s[30];     double dRetval;      sprintf(s,"%.*lf",iPlaces,dVal);     sscanf(s,"%lf",&dRetval);     return (dRetval); } 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;         case 17: x=ceil(x);   (*iop)--;break;         case 18: x=floor(x);  (*iop)--;break;         case 19: x=round(x,0);(*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","ceil","floor","round",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,ceil,floor,round"<<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,ceil,floor,round"<<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; }


Question: vs2012新建项目出现问题

Visual C++ 2010 Express简体中文版http://pan.baidu.com/s/1bnwRVLt

不知，没遇过，彻底卸载了重新安装下


Question: 关于一道算法题，求大神们来看看我的思路

感谢！！！！！！！！

引用 3 楼 pcboyxhy 的回复:标准的快排啊， 用螺母把螺丝分区，每次分区得到三个结果， A1，完全匹配的一对 A2，比螺母小的螺丝 A3，比螺母大的螺丝 将1中的螺丝取出，用它对螺母分区，可以得到 B1. 比螺丝小的螺母 B2. 比螺丝大的螺母 A2跟B1一一对应，A3跟B2一一对应，对(A2,B1)和(A3,B2)分别执行上述的算法，直至完全匹配 ++++++

引用 2 楼 mewiteor 的回复:我们不能拿两个螺母作比较，也不能拿两个螺钉作比较所以不能直接快排，但每个螺钉都可以将螺母按大小分成1~3组，每个螺母也可以将螺钉按大小分成1~3组，然后就是分治了。

是属于nlgn, 排序之后还需要比对吗, 题目不是说要找到每一对, 暗示一一配对的


Question: windows下多线程生产、消费问题

用事件来通知其他线程。暂存的数据一般放在队列中(读写时注意同步保护)

上面看错…线程的话就用事件吧…

Windows下用事件和内存映射吧

参考： Microsoft SDK\samples\winbase\SharedMem\Consumer.Cpp Microsoft SDK\samples\winbase\SharedMem\Makefile Microsoft SDK\samples\winbase\SharedMem\Producer.Cpp Microsoft SDK\samples\winbase\SharedMem\Queue.h Microsoft SDK\samples\winbase\SharedMem\ReadMe.Txt Microsoft SDK\samples\winbase\SharedMem\Common.h

《Windows核心编程》

搜索进程间通信，很多方法


Question: 求大神解决，这个迷宫小游戏运行后可以玩，但是一旦旁边有墙，在向右走的话就黑屏，按其他键就又恢复，唯独是向右黑屏……最好告诉小白怎么改，在哪改加什么代码，不要文字

仅供参考：#include <conio.h> #include <windows.h>  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); } void HideTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = FALSE;       SetConsoleCursorInfo(hStdOut, &cciCursor);    } }  void ShowTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = TRUE;       SetConsoleCursorInfo(hStdOut, &cciCursor);    } } void GetWH(int *w,int *h) {     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     CONSOLE_SCREEN_BUFFER_INFO csbi;     if (GetConsoleScreenBufferInfo(hStdOut, &csbi)) {         *w=csbi.srWindow.Right;         *h=csbi.srWindow.Bottom;     } else {         *w=80;         *h=25;     } } 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);    } }  int main() {     unsigned short k;     int x,y,w,h;      SetConsoleOutputCP(437);     ClearConsole();     GetWH(&w,&h);     x=w/2;y=h/2;     HideTheCursor();     ConPrintAt(x,y,"\xdb",1);     while (1) {         Sleep(50);         k=getch();         if (27==k) break;//按Esc键退出         if (0==k||0xe0==k) k|=getch()<<8;//非字符键         switch (k) {             case 0x48e0:case 0x04800://上                 if (y>0) {                     ConPrintAt(x,y," ",1);                     y--;                     ConPrintAt(x,y,"\xdb",1);                 }             break;             case 0x50e0:case 0x05000://下                 if (y<h) {                     ConPrintAt(x,y," ",1);                     y++;                     ConPrintAt(x,y,"\xdb",1);                 }             break;             case 0x4be0:case 0x04b00://左                 if (x>0) {                     ConPrintAt(x,y," ",1);                     x--;                     ConPrintAt(x,y,"\xdb",1);                 }             break;             case 0x4de0:case 0x04d00://右                 if (x<w-1) {                     ConPrintAt(x,y," ",1);                     x++;                     ConPrintAt(x,y,"\xdb",1);                 }             break;         } //      cprintf("%04x pressed.\r\n",k);      }     ClearConsole();     ShowTheCursor();     return 0; }

在每个case后面加上 else { 	system("cls"); 	drawmg1(); 	break; } 应该就可以了

求解决呀！ 求解决呀！ 求解决呀！ 求解决呀！

引用 1 楼 aaa461534727的回复:求解决呀！ 求解决呀！ 求解决呀！ 求解决呀！ 自顶！！！！！！！！！！！！！！！！！

有没有大神呀！求助呀！！！！！！！！！！


Question: 简单的C语言 ，为什么结果是这样

每天回帖即可获得10分可用分！  打酱油，嘿嘿

静态变量和作用域的问题

简单的三步循环，第一个num是个自动变量，第二个num是静态变量，静态变量的初始化和自动变量不同，从程序就能看出来

重定义的变量，没意义

引用 8楼user-9 的回复:int num;//栈变量，局部变量 static num=1;//静态全局变量 二者存储位置和管理不一样，对于编译器，会给他们重命名不同的变量名，比如num1,num2，这个会根据不同编译器设置来看， 你就认为俩个是不同的变量就OK了。谢谢

引用 7楼paschen 的回复:引用 6 楼 qq_33028645 的回复:[quote=引用 3 楼 u011133403 的回复:] 这个设计变量的作用域，第一个num作用域为整个函数，而第二个为包含其的大括号的代码块，又由于你定义的是static,所以也能实现累加的效果。感觉这两个num并不是同一个变量，是不是这样的？  对，不是同一个，把代码调整好就看得明白了[/quote]谢谢了啊

代码格式让我不想看。

楼主先把代码写规范了就看得出了，你大括号全在一排自己把自己搞晕

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

引用 6 楼 qq_33028645 的回复:引用 3 楼 u011133403 的回复:这个设计变量的作用域，第一个num作用域为整个函数，而第二个为包含其的大括号的代码块，又由于你定义的是static,所以也能实现累加的效果。感觉这两个num并不是同一个变量，是不是这样的？  对，不是同一个，把代码调整好就看得明白了

引用 2 楼 paschen 的回复:楼主先把代码写规范了就看得出了，你大括号全在一排自己把自己搞晕 不好意思，这个代码我是粘贴的，你知道用编译器编写都不会这样的，我放一排还麻烦呢