Question: 求大神看下有关递归的问题，thanks！

引用 7 楼 fly_dragon_fly 的回复:直接select int part(int *a,int l,int r){     int x=a[r];     int i =l-1;     for(int j=l;j<r;j++){         if(a[j]<=x) swap(a[++i],a[j]);     }     swap(a[++i],a[r]);     return i; }  int select(int *a,int l,int r,int k){     if(l==r) return a[l];     int piv =part(a,l,r),pos=piv-l+1;     if(pos==k) return a[piv];     if(k<pos) return select(a,l,piv-1,k);     return select(a,piv+1,r,k-pos); }++ 快速选择，和快速排序思路是一样的

// 伪代码，改良版算法，不用返回结构体，直接返回要求的值 Elem_t f(Sequence T, int k) { 	if (k == 1) 	{ 		return min(T); 	} 	else 	{ 		T.delete(min(T)); 		--k; 		return f(T, k); 	} }

引用 4 楼 ipqtjmqj 的回复: // 伪代码 // 思路：若k为1，其实就是求最小值，若k为2，则先把最小的删除，从剩下的数据里面求最小值 struct S { 	Sequence T; 	Elem_t elem; }; S f(S s, k) { 	if (k == 1) 	{ 		min_elem = min(T); 		s.T.delete(min_elem); 		return S(s, min_elem); 	} 	else return f(f(s, k - 1), 1); }   写错了，return S(s, min_elem)改成return S(s.T, min_elem);

引用 2 楼 u012990628 的回复:如果只是用排序，当然可以找到第k小元素，只是现在题目要求用递归的方法来解决。  归并排序可以用递归实现

如果只是用排序，当然可以找到第k小元素，只是现在题目要求用递归的方法来解决。

排序用递归，难道是要用快排？ 恕我孤陋寡闻


Question: 大神们帮忙看看是怎么回事啊！c语言，大数据的相乘，（大数据的加法）和（大数据和一位数相乘）的函数是对的，但是最后老是不能够运行

就是无法运行


Question: C语言简单的文件操作问题！

受教  引用 5 楼 zhao4zhong1 的回复:不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。 受教了

不好意思！各位 打错了  怪不得！

while ((ch = getchar())!= '\n')   你那个语句是什么鬼？

getchar不是读文件的

getchar();函数不是从文件里去数据吧。fgetc()函数吧。


Question: linux C 下 如何检查 sftp服务器上是否存在某文件？

兄弟，解决了吗，我的程序类似你这种问题，能get不能put


Question: 大神看过来：问一个有关指向指针的指针的问题

引用 13 楼 lm_whales 的回复:int a[100]={....}; int *p[100]={a,a+1,a+2,a+3,...,a+99}; sort(p,100);  **(p+i),,,,,  要这么做噢 只要 *（p+i）

改成：printf("%d",**(p+i));  注意细节问题

不是我是想比较数值，不是字符串，可以用关系运算符比较吧。 把&加上了以后还是不行，输出的是一串奇怪的数字... 求解答

...都改了还不行 问一下if那里是不是也要两个*才能比较值呢

不对，要加**（p+i)才能输出.................. 我一直以为指向指针的指针加两个**就是值，加一个*就是地址 原来指向数组的指针也要加两个*，才能输出值

你在字符串比较使用的是＜，要用函数str的。

不好意思啊...我好像没说明白...我现在懂了那个要交换地址而不是交换字符串了，我想问的是第二个程序错在哪了...那个scanf("%d",&a[i]);我已经改了还是不行，第二个程序比较的不是字符串，是数值.....还有zhao4zhong1大神说的很有道理...以后有时间我会去学汇编语言的...还有paschen说的**（p+i），那个p是在main函数里的，它指向一维数组，输出时加一个*就可以了吧。

除楼上说的，还有把 scanf("%d",a[i]);  要改成  scanf("%d",&a[i]);

scanf("%d",a[i]); 加引用，一般初学者必犯的错误

1) 交换指针,内容不一定能交换, 象你这个 定义 char*string[5], string的内容是const char *, 不能更改的 2) 字符比较不能用<

另外问一下如何调试一个程序，就是断点啊什么的，编译器是vc++6.0

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

当然用字符串比较了， 你比较字符串地址有何意义， 你不需要按照地址排序。 很少有需要比较地址（指针）的时候， 除非你是做内存管理 等等。  交换地址有两个原因， 1）是 常量不可以修改 2）是 修改字符串本身，比修改指针慢多了


Question: 请教一个小白问题。

引用 5 楼 qq_30881357 的回复:还是不懂。。。。。。。。  你想懂要看书啊。。一下说不清的

仅供参考：#pragma comment(lib,"user32") #pragma comment(lib,"gdi32") #include <windows.h> LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {     PAINTSTRUCT ps;     HDC hdc;     HFONT hfont,ohfont;     RECT r;     COLORREF oc;      switch(message) {     case WM_CLOSE://按Alt+F4退出         PostQuitMessage(0);         break;     case WM_PAINT:         BeginPaint(hWnd, &ps);         hdc = ps.hdc; // the device context to draw in         GetClientRect(hWnd, &r); // Obtain the window's client rectangle         hfont = CreateFont(200, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "宋体");         ohfont=(HFONT)SelectObject(hdc,hfont);         oc=SetTextColor(hdc,0x00C080FF);         SetBkMode(hdc, TRANSPARENT);         TextOut(hdc,r.left+r.right/2-600, r.top+r.bottom/2-100,"最短画图程序",12);         SelectObject(hdc,ohfont);         SetTextColor(hdc,oc);         DeleteObject(hfont);         EndPaint(hWnd, &ps);         break;     default:         return DefWindowProc(hWnd, message, wParam, lParam);     }     return 0; } int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {     MSG msg             = {0};     WNDCLASS wc         = {0};     HBRUSH hbrh;     hbrh=CreateSolidBrush(0x00000000);     wc.lpfnWndProc      = WndProc;     wc.hInstance        = hInstance;     wc.hbrBackground    = hbrh;     wc.lpszClassName    = "minwindowsapp";     wc.hCursor          = LoadCursor(NULL,IDC_ARROW);     if( FAILED(RegisterClass(&wc)) ) return 1;      if(FAILED(CreateWindow(wc.lpszClassName,                         "Minimal Windows Application",                         WS_POPUP|WS_VISIBLE,                         0,                         0,                         GetSystemMetrics(SM_CXSCREEN),                         GetSystemMetrics(SM_CYSCREEN),                         0,                         0,                         hInstance,                         NULL)))         return 2;      while( GetMessage( &msg, NULL, 0, 0 ) > 0 ) {         DispatchMessage( &msg );     }     DeleteObject(hbrh);     return 0; }

还是不懂。。。。。。。。

引用 1 楼 paschen 的回复:直接用SDK包里的API，所以VB属于快速开发语言啊  操作系统会提供一些标准通用控件  他建一个窗口需要注册窗口类，需要考虑消息循环等，不像VB那么方便

引用 1 楼 paschen的回复:直接用SDK包里的API，所以VB属于快速开发语言啊

应该是有可用的开发包

直接用SDK包里的API，所以VB属于快速开发语言啊

windows编程 win32项目 EasyX


Question: 求大神看一下两个查找出现了什么问题，我完全看不懂编译错误

估计是link错误吧…增量链接出错之类的问题

什么编译错误，给出错误信息

试了一下代码,没编译错误?


Question: 高分   求计算机源代码

我也来一个，通过链表方式处理 typedef struct _Operation{ 	char	opt;					//操作符 	int		a;						//操作数1 	int		b;						//操作数2 	struct _Operation* previous;	//前一个操作 	struct _Operation* next;		//后一个操作 } Operation;  const char* expression = "1*180+2*3-40/2*5-63/3*4";  void main(){ 	Operation* current = NULL; 	Operation* next = NULL; 	Operation* first = NULL;  	char opt; 	const char* priority = "*/+-"; 	int i,pidx,result,finish=0; 	char* str = (char*)malloc(strlen(expression)+1); 	strcpy(str,expression);  	for(i=strlen(str);i>0;){ 		i--;  		opt = str[i]; 		if(opt=='+' || opt=='-' || opt=='*' || opt=='/'){ 			current = (Operation*)malloc(sizeof(Operation)); 			current->b = atoi(str+i+1);		//操作符 			current->opt = opt; 			current->previous = NULL; 			current->next = next; 			if(next){ 				next->a = current->b; 				next->previous = current; 			}  			str[i] = 0; 			next = current; 		} 	} 	if(current){ 		current->a = atoi(str); 		first = current;			//至此，所有操作均保存在链表中  		for(pidx=0;pidx<=2;pidx+=2){ 			current = first; 			while(current){ 				next=current->next; 				//优先处理*/再处理+- 				if(current->opt == priority[pidx] || current->opt == priority[pidx+1]){ 					result = current->opt == '*' ? current->a * current->b : (current->opt=='/' ? current->a / current->b : (current->opt=='+' ? current->a + current->b : current->a - current->b)); 					if(current->previous){ 						current->previous->b = result; 						current->previous->next = current->next; 					} 					if(current->next){ 						current->next->a = result; 						current->next->previous = current->previous; 					} 					if(first == current) 						first = next; 					free(current);		//处理一个释放一个 				}  				current = next;			//处理下一操作 			} 		} 	}else{ 		//无运算符，直接返回结果 		result = atoi(str); 	}  	printf("%s=%d",expression,result); 	free(str); }

看http://jingyan.baidu.com/article/22fe7ced67cd443002617f98.html  每步有详细讲解，代码均有详细注释

给个简单, 无错误处理 int mixop(int left) {     int right;     char op;     if(scanf("%c",&op)!=1||(op=='\n')) return left;     scanf("%d",&right);     switch(op){         case '+':return left+mixop(right);         case '-':return left-mixop(right);         case '*':return mixop(left*right);         case '/':return mixop(left/right);         default: return left;     } }  int main() {     int left;     while(~scanf("%d",&left)){         printf("%d\n",mixop(left));     } }

需要三个步骤： 1. 解析字符串表达式为中缀表达式； 2. 将中缀表达式转换为后缀表达式：参考【调度场算法】（https://zh.wikipedia.org/wiki/%E8%B0%83%E5%BA%A6%E5%9C%BA%E7%AE%97%E6%B3%95）； 3. 计算后缀表达式。  试着写了个代码，没仔细检查，也没做优化，可以参考一下：  /*  * calc.c  *   * Copyright 2015 Che Hongwei <htc.chehw@gmail.com>  *   * This program is free software; you can redistribute it and/or modify  * it under the terms of the GNU General Public License as published by  * the Free Software Foundation; either version 2 of the License, or  * (at your option) any later version.  *   * This program is distributed in the hope that it will be useful,  * but WITHOUT ANY WARRANTY; without even the implied warranty of  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  * GNU General Public License for more details.  *   * You should have received a copy of the GNU General Public License  * along with this program; if not, write to the Free Software  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,  * MA 02110-1301, USA.  *   *   */   #include <stdio.h> #include <stdlib.h> #include <string.h>  #define BOOL int #define FALSE (0) #define TRUE (!FALSE)  enum ERRCODE { 	ERRCODE_INVALID = -1, 	ERRCODE_SUCCESS = 0, 	ERRCODE_FAILED = 1 };  enum NODE_TYPE { 	NODE_TYPE_invalid = -1, 	NODE_TYPE_val = 0, 	NODE_TYPE_op = 1 };   struct Node { 	int nodeType; 	union 	{ 		int value; 		char op; 	}; //	Node * next; };   #define MAX_NODES (100)    int shunting_yard(const char * in_str, struct Node out_queue[MAX_NODES]); double compute(struct Node queue[MAX_NODES], int count);   int main(int argc, char **argv) { 	const char * expr = "3+4*2/2-1*8"; 	struct Node queue[MAX_NODES]; 	int count; 	double result; 	 	memset(queue, 0, sizeof(queue)); 	 	printf("expr: %s\n", expr); 	 	count = shunting_yard(expr, queue); 	 	result = compute(queue, count); 	printf("result = %f\n", result); 	 	return 0; }  static BOOL is_op(char c) { 	switch(c) 	{ 		case '+': case '-': case '*': case '/': return TRUE; 		default: break; 	} 	return FALSE; }  static int op_prior(char op1, char op2) { 	if(op1 == '*' || op1 == '/') 	{ 		if(op2 == '+' || op2 == '-') return 1; 		else return 0; 	}else 	{ 		if(op2 == '+' || op2 == '-') return 0; 		else return -1; 	} }  /*************************  * int shunting_yard(const char * in_str, Node * out_queue)  * return value: 0 == error; >0 == element count; -1 = invalid parameters  **************************/ int shunting_yard(const char * in_str, struct Node out_queue[MAX_NODES]) { 	if(NULL == in_str || NULL == out_queue) return -1; 	 	const char * p, * begin, * p_end; 	char stack[MAX_NODES], op; 	int queue_index = 0; 	int stack_index = 0; 	 	memset(stack, 0, sizeof(stack)); 	 	begin = p = in_str; 	p_end = begin + strlen(in_str); 	 	// 为了简化代码，不考虑中间出现空格的情况。 	while(p < p_end) 	{ 		if(*p >= '0' && *p <= '9')  		{ 			p++; 			if(p == p_end || *p == '=') 			{ 				// push value to node queue 				out_queue[queue_index].nodeType = NODE_TYPE_val; 				out_queue[queue_index++].value = atoi(begin); 				break; 			} 		} 		else 		{ 			if(!is_op(*p)) return -1; // must be num or op 			 			// push value to node queue 			out_queue[queue_index].nodeType = NODE_TYPE_val; 			out_queue[queue_index++].value = atoi(begin); 			 			// 检查stack中运算符的优先级 			if(stack_index > 1) 			{ 				if(op_prior(stack[stack_index - 1], stack[stack_index - 2]) > 0) 				{ 					out_queue[queue_index].nodeType = NODE_TYPE_op; 					out_queue[queue_index++].op = stack[stack_index - 1]; 					stack_index--; 				} 				 			} 			 			op = *p++;			 			stack[stack_index++] = op;		 			begin = p; 			 		} 	}  	 	while(stack_index > 0) 	{ 		out_queue[queue_index].nodeType = NODE_TYPE_op; 		out_queue[queue_index++].op = stack[--stack_index];		 	} 	 	return queue_index; }   double compute(struct Node queue[MAX_NODES], int count) { 	double result; 	double stack[MAX_NODES]; 	int stack_index = 0; 	double val1, val2; 	int i; 	 	for(i = 0; i < count; i++) 	{ 		if(queue[i].nodeType == NODE_TYPE_val) 		{ 			stack[stack_index++] = (double)queue[i].value; 		}else 		{ 			if(stack_index < 2)  			{ 				fprintf(stderr, "invalid expression format!\n"); 				return 0.0; 			} 			val1 = stack[stack_index - 2]; val2 = stack[stack_index - 1]; 			stack_index -= 2; 			switch(queue[i].op) 			{ 				case '+':  					result = val1 + val2;					 					stack[stack_index++] = result; 					break; 				case '-': 					result = val1 - val2;					 					stack[stack_index++] = result; 					break; 				case '*':  					result = val1 * val2;					 					stack[stack_index++] = result; 					break; 				case '/': 					result = val1 / val2;					 					stack[stack_index++] = result; 					break; 				default: 					fprintf(stderr, "invalid expression format!\n"); 					return 0.0; 			} 		} 	} 	return result; 	 }


Question: 求大神~哈夫曼编码，那里错了

别沉啊………求大神呀

引用 1 楼 user-1 的回复:大括号不匹配，main前少了 }  有吗？没发现····求明示

大括号不匹配，main前少了 }


Question: 简单的小菜单功能实现！

引用 3 楼 user-1 的回复:http://www.bianceng.cn/Programming/C/201501/47575.htm  [quote=引用 4 楼 user-1 的回复:] 函数声明和函数定义不一致   万分感谢！

函数声明和函数定义不一致   #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <string.h>    #define HONG 10 #define LIE 80  void output(int n ,char (*max)[LIE]); void ASCII_code_output(int n ,char (*max)[LIE]); void Sequence_output(int n ,char (* max)[LIE],int p); void output_string(int n ,char (* max)[LIE]);  int prinf_max(void) { 	int i = 0; 	puts("+-+-+-+-+-+-+-+-+-+-+-+-+-++-+-+-+-+-+-+-+-+-+-+-+-+-+"); 	puts("1. Output string list."); 	puts("2. ASCII code output string."); 	puts("3. Sequence output string by length."); 	puts("4. Output string by the length of the first word in the string."); 	puts("5. quit!"); 	puts("+-+-+-+-+-+-+-+-+-+-+-+-+-++-+-+-+-+-+-+-+-+-+-+-+-+-+"); 	while (!(i!=0)) 	{ 		printf("Please enter your choice 1-5："); 		scanf("%d", &i); 		getchar(); 	}  	return i; }  int main() { 	int ch=0; 	int i = 0, number = 0; 	char max[HONG][LIE] = { 0 }; 	char (*p)[LIE] = max;  	printf("Enter the 10 strings, confirm that please press enter\n"); 	while (i< HONG) 	{ 		printf("max [%d] = Continue input: ", i); 		gets(p[i++]);   		number = prinf_max(); 		if (number == 5) 		{ 			puts("Quit!"); break; 		} 		while (number > 5 || number < 0) 		{ 			puts("Invalid input!"); 			prinf_max(); 			system("cls"); 		} 		switch (number) 		{ 		case 1:output(i,max); break; 		case 2:ASCII_code_output(i-1,max); break; 		case 3:Sequence_output(i-1,max,strlen(max[i-1])); break; 		case 4:output_string(i - 1, max); break; 		} 	}  	return 0; }  void output(int n ,char (*max)[LIE]) { 	static int x = 0; 	int *p = &x; 	puts("----------------------------------"); 	for (; x < n; (*p)++) 	{ 		printf("Output string list: max [%d] =  %s\n", x, (max + x)); 	} 	puts("----------------------------------"); } void ASCII_code_output(int n ,char (*max)[LIE]) { 	int i = 0, x = 0;  	while (*(*(max+n)+i)) 	{ 		if (*(*(max + n) + i) >= 'A'&&*(*(max + n) + i) <= 'Z' || 			*(*(max + n) + i) >= 'a'&&*(*(max + n) + i) <= 'z') 		{ 			x = i; 			x++; 			while (*(*(max + n) + x) != '\0') 			{ 				if (*(*(max + n) + x) != ' ') 				{ 					if (*(*(max + n) + i) < *(*(max + n) + x)) 					{ 						char tmp = *(*(max + n) + i); 						*(*(max + n) + i) = *(*(max + n) + x); 						*(*(max + n) + x) = tmp; 					} 				} 				x++; 			} 		} 		i++; 	} 	puts("----------------------------------"); 	printf("ASCII code output string: max[%d]=", n); 	puts(*(max + n)); 	puts("----------------------------------"); } void Sequence_output(int n ,char (* max)[LIE],int p) { 	int x, y; 	puts("----------------------------------"); 	for (x = 0; x < p; x++) 	{ 		for (y = 0; y <= x; y++) 		{ 			putchar(*(*(max + n) + y)); 		} 		printf("\n"); 	} 	puts("----------------------------------"); } void output_string(int n ,char (* max)[LIE]) { 	int i = 0; 	puts("----------------------------------"); 	printf("Output string by the length of the first word in the string:"); 	while (*(*(max + n) + i)) 	{ 		if (*(*(max + n) + i) != ' ') 		{ 			putchar(*(*(max + n) + i)); 		} 		if (*(*(max + n) + i++) == ' ') 		{ 			break; 		} 	} 	printf("\n"); 	puts("----------------------------------"); }

引用 1 楼 wzj3514 的回复:我可以做的，我的 qq 114122360 我是要自己写！


Question: 实在没发现哪里错了。。。

引用 3 楼 myownroc 的回复:另外你这算法有点瑕疵，当n<=1时没有跳出循环谢谢，我也发现这个问题了

引用 2 楼 user-2 的回复:sum没有初始化为0谢谢

另外你这算法有点瑕疵，当n<=1时没有跳出循环

sum没有初始化为0

前面加一句sum = 0; 因为你的sum并不是0……


Question: C语言自动变量问题

这个要看系统内核对于栈上临时数据是否有清除操作而言了。 首先：局部自动变量一般是在栈上分配内存； 其次：有的系统使用完栈上数据后不做清除，所以值能留存，直到下一次覆写该内存地址的值，有的直接删掉，所以可能出现随机值。

引用 6 楼 paschen 的回复:编译当然不会出错，但你p指向的内存已被回收，之所以结果也是1是因为上面的值还没被其他内容覆盖，这是一种不确定行为++

这是局部变量，放在函数堆栈中，因为你现在是用指针访问的，而且这个堆栈还没有被释放（被重写），所以里面的内容还是1。但是，如果你用i来引用的话，编译器应该保错。这个现象，是由于编译器是无法对指针进行检查导致的。

从语言来说, i已经无效,, 所以p指向地址也应该无效,但编译器才不管这些, 运行了再说

应该是作用域的问题吧， p的作用域包含了if代码块里的i的作用域， 书上认为存储类不同可能， 我也不太确定，欢迎指正

int *p = NULL; if (1) { int i = 1;  // &i = 0x7fff5fbffa6c p = &i;  // p = 0x7fff5fbffa6c } printf("\n"); //加这一行再试试 printf("%d", *p);  // p =0x7fff5fbffa6c, p = 1

错误的程序可能得到任何结果，包括期望得到的结果。


Question: 大神们 求帮助！！

这个很基础，建议楼主自己动手试下，遇到问题可以来论坛讨论，可以把代码附上，会有很多人帮你解答的

简单,找大二的要

比我还懒

有在这等，还不如去网上搜呢，这个概率更大，这题网上都能搜到的，你还注册帐号来提问。

顶楼上的！ 说明你上课没认真听！ 说真的这样的问题很简单的！ 既然老师让你写着 说明最少也是教到数组指针那里了， 都学到这了！还写不出这样的程序 ，只能说明你没认真学，也没认真做 我是实话实说 ！

你得自己写个大概，然后到这里来问具体问题。 这么上来让别人给编程序，有回复的可能性不大。也显得你自己一点都没付出。   当然，你赌这个概率就另说了。


Question: hack.c怎么通过注入msg.dll的方式使得messageBox标题从"message"变成“hacked”

我使用ollydbg看到message地址是0x6E721000 这样可以完成任务 但是由于dll每次基地址不一样 每次都要变换一次代码中message的地址才可以得到正确的输出 用LoadLibrary函数可以得到dll入口地址 messa偏移量也是固定的 哪问题是：怎么才能通过偏移量+基地址得到message的地址呢？    #include <windows.h> #include<stdio.h>  int main(int argc, char *argv[]) {     int pid = 0;     HANDLE hproc = 0;     char *s = "Hacked";      // YOU MAY NEED MORE LOCAL VARIABLES     // PLEASE ADD THEM HERE 	int address_i=0x6e721000; 	DWORD storage=0x00; 	HMODULE hDllLib = LoadLibrary("msg.dll"); 	FARPROC fpFun = GetProcAddress(hDllLib,"ShowMsg"); 	printf("%x\n",fpFun);      //shouMsg地址 	storage=(DWORD)fpFun; 	 	PBYTE   pCodeRemote = NULL; 	HANDLE hChange=0; 	hChange=(HANDLE)fpFun; 	printf("%x\n",hChange); 	DWORD   dwNumBytesXferred = 0; 	PBYTE   pCode      = NULL;     DWORD   dwSizeOfCode = 0;          HANDLE  hThread	   = 0;     DWORD   dwThreadId = 0;     int	    exitcode   = 0; 	//sprintf(address_i,"%x",fpFun); 	/*  __asm{ 		lea eax,s 		push eax 		call fpFun 		mov storage,eax 	}  */      if (argc < 2) {         printf("Usage: %s pid\n", argv[0]);         return -1;     }     pid = atoi(argv[1]);     if (pid <= 0) {         printf("[E]: pid must be positive (pid>0)!\n");          return -2;     }  	pCode = (PBYTE)code;     dwSizeOfCode = sizeof(code); 	     hproc = OpenProcess(PROCESS_CREATE_THREAD          | PROCESS_QUERY_INFORMATION         | PROCESS_VM_OPERATION          | PROCESS_VM_WRITE          | PROCESS_VM_READ,         FALSE, pid);   // FILL YOUR CODE HERE 	WriteProcessMemory(hproc,(LPVOID)address_i, s, 11,  NULL); 	 		 		     return 0; }

(1) 请按照下列要求生成msg.dll:   > cl /c msg.c   > link /DLL /DYNAMICBASE msg.obj (2) 请按照下列要求编译链接生成hellow.exe文件:   > cl /c hellow.c   > link /DYNAMICBASE:no /BASE:0x00400000 hellow.obj msg.lib


Question: 求大神帮我看看这个程序错在哪

引用 1 楼 ChWeshun的回复:c这个变量都没有用到啊，simple里面最后一个can't应该是can吧，没看到题目我也不清楚，题目应该有多空格的测试数据吧，没说单词之间只能有一个空格吧，你再试试，我也是新手。 打错了，sample

例子有没有问题, 为什么?都在后面


Question: C语言小白问一个关于指针的问题~~~~~

#include <stdio.h> int strcmp(char *p1,char *p2); int main() { char s1[99],s2[99];//定义字符串 必须加长度 char *p1,*p2; p1=s1; p2=s2; printf("Please enter 2 strings:\n"); scanf("%s%s",s1,s2); printf("the result is %d",strcmp(p1,p2)); return 0; }   int strcmp(char *p1,char *p2) {   int m;  while(*p1!='\0'&&*p2!='\0')  { 	p1++; 	p2++; 	if( (*(p1)>*(p2))||(*(p1)<*(p2)))   	{  		m=*p1-*p2;   		break;   	}  	if(*(p1)==*(p2))    	m=0;  } return m; }   根据个人习惯改了下，经测试可以达到你的要求。

#include <stdio.h> int strcmp(char *p1,char *p2); int main() { char s1[99],s2[99];//定义字符串 必须加长度 char *p1,*p2; p1=s1; p2=s2; printf("Please enter 2 strings:\n"); scanf("%s%s",s1,s2); printf("the result is %d",strcmp(p1,p2)); return 0; }   int strcmp(char *p1,char *p2) {   int m;  while(*p1!='\0'&&*p2!='\0')  { 	p1++; 	p2++; 	if( (*(p1)>*(p2))||(*(p1)<*(p2)))   	{  		m=*p1-*p2;   		break;   	}  	if(*(p1)==*(p2))    	m=0;  } return m; }  根据个人习惯改了下，经测试，达到你的要求。

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

感谢各位大神啊，高激动这么多人回复

小细节没仔细看了，只看大方向上的。 while((flag=0)&&(*p1!='\0')) { if( (*(p1++)>*(p2++))||(*(p1++)<*(p2++))) { m=*p1-*p2; flag=1; }  else if((*(p1++)==*(p2++))) m=0; 你这里想法是测试两个字符大于或小于怎么样做，然后如果相等怎么样做。但是你上下两个字符都不一样，因为你上面执行后++了，两个不一样结果肯定不对

有一些问题，可能还有其他，你先改了这些看一下，可能还有其他问题：  首先你没检查p2是否到\0 其次，如果p1为空，将不会进入循环，返回的m将是一个不确定的值 另外，可以不用定义flag，当满足条件时break即可

第一个：是的。系统自动将字符看做是一个ASCII数值进行运算。 第二个：可以的，他们都是字符指针，字符数组当右值运算时，自动看做是首元素的指针。 你的strcmp函数里不应该是“flag=0”而是“flag==0”

while(*p1!='\0'||*p2!='\0')   这样就都可以了   你测试一下

#include <stdio.h> int strcmp(char *p1,char *p2); int main() { char s1[99],s2[99];//定义字符串 必须加长度 char *p1,*p2;  printf("Please enter 2 strings:\n"); scanf("%s%s",s1,s2); p1=s1; p2=s2; printf("the result is %d",strcmp(p1,p2)); return 0; }   int strcmp(char *p1,char *p2) {   int m=0;  while(*p1!='\0'&&*p2!='\0')  { 	if( (*(p1)>*(p2))||(*(p1)<*(p2)))   	{  		m=m+*p1-*p2;   	}  	else     		m=0;    	p1++; 	p2++;  } return m; }

跑一下单步就知道问题在哪了 while((flag=0)&&(*p1!='\0'))中(flag=0)&&(*p1!='\0') <--> 0&&(*p1!='\0') <--> 0  实际运行的是  int strcmp(char *p1,char *p2) { int m,flag=0;  return m; } 由于m未赋值，VC的初值是0xcccccccc，即-858993460

printf("Please enter 2 strings:"); scanf("%s %s",&s1,&s2);       //s1,s2已经是首地址了,不用加&       因此改为scanf("%s %s",s1,s2);

有两个问题不太明白 第一个 对于字符的比较 系统自动认为是比较ASCII码吗，对于字符相减，系统就自动转为ASCII码相减吗 第二个 char *p1,*p2; p1=s1; p2=s2; printf("the result is %d",strcmp(p1,p2)); 这四行中可不可以去掉前三行，直接让s1，s2 作实参呀  十分感谢


Question: leetcode的Longest Palindromic Substring根据别人的代码改为c语言，求正确答案？

抱歉之前的回答没看清你问的问题，你的代码感觉有点长，没有仔细去看，不介意的话可以用我写的这个（特意去跑了一遍，可以通过）：  char* longestPalindrome(char* s) { 	int len = strlen(s); 	if (len < 2) return s; 	int left = 0, right = 0; 	for (int i = 0; len - 1 - i > (right - left + 1) / 2;) { 		int l = i; int r = i; 		while (r < len - 1 && s[r + 1] == s[r]) r++; //找到所有的重复字母 		i = r + 1; 		while (l > 0 && r < len - 1 && s[l - 1] == s[r + 1]) {  //以重复字母片段的左右向两边扩散 			r++; 			l--; 		} 		if (r - l > right - left) { // 筛选最长的回文 			left = l; 			right = r; 		} 	} 	s[right + 1] = '\0';  	return s + left; }

是否正确在leetcode上跑一下不就知道了么

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

楼上的说的不对。。。 我是无奈啊。。。。。。。 否则也不会这么做了。。。。。。  以下代码提到leetcode中通过！！！！  #include <stdio.h> #include <stdlib.h> #include <string.h>  char* longestPalindrome(char *s) { 	char *d = NULL; 	char *rsl = NULL; 	int *p = NULL; 	int length = 0; 	int newLen = 0; 	int i = 0; 	int j = 0; 	int C = 0; 	int R = 0; 	int im = 0; 	int maxLen = 0; 	int center = 0; 	int start = 0;  	length = strlen(s); 	newLen = 2 * length + 2; 	d = (char *)malloc(sizeof(char) * newLen); 	if(d == NULL) 	{ 		printf("d is NULL..."); 		return NULL; 	} 	for(i = 0; i < length; i++) 	{ 		d[j++] = '#'; 		d[j++] = s[i]; 	} 	d[j++] = '#'; 	d[j] = '\0';  	p = (int *)malloc(sizeof(int) * newLen); 	if(p == NULL) 	{ 		printf("The p is NULL!\n"); 		return NULL; 	}  	for(i = 1; i < newLen - 1; i++) 	{ 		im = 2 * C - i; 		if(im > 0 && i + p[im] <= R) 			p[i] = p[im]; 		else 			p[i] = 0;  		while(d[i + 1 + p[i]] == d[i - 1 - p[i]] && i - 1 - p[i] >= 0)  			p[i]++;  		if(i + p[i] > R) 		{ 			C = i; 			R = i + p[i]; 		} 	}  	free(d);  	for(i = 1; i < newLen - 1;i++) 	{ 		if(p[i] > maxLen) 		{ 			maxLen = p[i]; 			center = i; 		} 	}  	free(p);  	start = center - maxLen > 0 ? (center - maxLen) / 2 : (maxLen - center) / 2; 	rsl = (char *)malloc(sizeof(char) * maxLen); 	if(rsl == NULL) 	{ 		printf("rsl is NULL......\n"); 		return NULL; 	} 	for(i = 0; i < maxLen; i++) 	{ 		rsl[i] = s[i + start]; 	} 	rsl[maxLen] = '\0'; 	return rsl; }  int main() { 	char *s = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; 	char *d = NULL; 	d = longestPalindrome(s); 	if(d != NULL) 		printf("%s\n", d); 	return 0; }


Question: 数组的地址加4是多少？

不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！

不同的系统，int类型所占字节不一样。数组名就是首地址，为何&

int类型是四个字节，假如数组首元素的地址是100，那么加四个int应该是116才对。

int *ip=ints+3; 等价  int *ip=&ints[3];

假如指针类型是T （T不是void*）， 指针+n  移动的距离是   n*sizeof(T) 也就 是说int*指针加1就已经移动了4了

你试试ints+4是不是104，不要看&ints+4，因为ints本来就是首元素地址，如果再取地址就很难说是什么值。

ints本身就是数组起始地址啊

引用 8 楼 user-10 的回复:ints的类型是int [20] 那么&ints的类型是int (*)[20]，指向一个有20个int元素的数组的指针 因此，&ints+4的值是ints向后4*20*sizeof(int)  在32位环境，sizeof(int) = 4的情况下 假定ints数组在内存中的起始位置是100， &ints+4的值是420  ++

引用 8 楼 user-10 的回复:ints的类型是int [20] 那么&ints的类型是int (*)[20]，指向一个有20个int元素的数组的指针 因此，&ints+4的值是ints向后4*20*sizeof(int)  在32位环境，sizeof(int) = 4的情况下 假定ints数组在内存中的起始位置是100， &ints+4的值是420 正解。 ints类型是Int* &ints类型是Int(*)[20]


Question: 关于if后面的return

引用 3 楼 fefe82 的回复:引用 2 楼 sinat_32955693 的回复:[quote=引用 1楼user-3 的回复:]你的isPrime不是所有路径都有返回值，如果不满足if，你也需要指定一个返回值我在第一个if后再加个返回0它是可以正常输出，就是说只有这一个if的话无论满不满足都会返回n么？  一个有返回值的函数没有遇到 return 就结束是一个未定义行为，也就是说，什么都可能发生。[/quote] 最可能发生的就是寄存器eax（Win32）或寄存器rax（Win64）的值被当作函数返回值返回了。

引用 3楼fefe82 的回复:引用 2 楼 sinat_32955693 的回复:[quote=引用 1楼user-3 的回复:]你的isPrime不是所有路径都有返回值，如果不满足if，你也需要指定一个返回值我在第一个if后再加个返回0它是可以正常输出，就是说只有这一个if的话无论满不满足都会返回n么？  一个有返回值的函数没有遇到 return 就结束是一个未定义行为，也就是说，什么都可能发生。[/quote]这样啊，谢谢

引用 2 楼 sinat_32955693 的回复:引用 1楼user-3 的回复:你的isPrime不是所有路径都有返回值，如果不满足if，你也需要指定一个返回值我在第一个if后再加个返回0它是可以正常输出，就是说只有这一个if的话无论满不满足都会返回n么？  一个有返回值的函数没有遇到 return 就结束是一个未定义行为，也就是说，什么都可能发生。


Question: cgi处理上传的文件，图片

有时不将“调用函数名字＋各参数值，进入函数后各参数值，中间变量值，退出函数前准备返回的值，返回函数到调用处后函数名字＋各参数值＋返回值”这些信息写日志到文件中是无论如何也发现不了问题在哪里的，包括捕获各种异常、写日志到屏幕、单步或设断点或生成core文件、……这些方法都不行！ 写日志到文件参考下面： #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef WIN32     #include <windows.h>     #include <io.h> #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  _vsnprintf         vsnprintf #endif //Log{ #define MAXLOGSIZE 20000000 #define MAXLINSIZE 16000 #include <time.h> #include <sys/timeb.h> #include <stdarg.h> char logfilename1[]="MyLog1.log"; char logfilename2[]="MyLog2.log"; static char logstr[MAXLINSIZE+1]; char datestr[16]; char timestr[16]; char mss[4]; CRITICAL_SECTION cs_log; FILE *flog; #ifdef WIN32 void Lock(CRITICAL_SECTION *l) {     EnterCriticalSection(l); } void Unlock(CRITICAL_SECTION *l) {     LeaveCriticalSection(l); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } #endif void LogV(const char *pszFmt,va_list argp) {     struct tm *now;     struct timeb tb;      if (NULL==pszFmt||0==pszFmt[0]) return;     _vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,"%03d",tb.millitm);     printf("%s %s.%s %s",datestr,timestr,mss,logstr);     flog=fopen(logfilename1,"a");     if (NULL!=flog) {         fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);         if (ftell(flog)>MAXLOGSIZE) {             fclose(flog);             if (rename(logfilename1,logfilename2)) {                 remove(logfilename2);                 rename(logfilename1,logfilename2);             }         } else {             fclose(flog);         }     } } void Log(const char *pszFmt,...) {     va_list argp;      Lock(&cs_log);     va_start(argp,pszFmt);     LogV(pszFmt,argp);     va_end(argp);     Unlock(&cs_log); } //Log} int main(int argc,char * argv[]) {     int i; #ifdef WIN32     InitializeCriticalSection(&cs_log); #else     pthread_mutex_init(&cs_log,NULL); #endif     for (i=0;i<10000;i++) {         Log("This is a Log %04d from FILE:%s LINE:%d\n",i, __FILE__, __LINE__);     } #ifdef WIN32     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_log); #endif     return 0; } //1-78行添加到你带main的.c或.cpp的那个文件的最前面 //81-85行添加到你的main函数开头 //89-93行添加到你的main函数结束前 //在要写LOG的地方仿照第87行的写法写LOG到文件MyLog1.log中


Question: 求指教 一道逻辑题  如何用C语言程序解决

简化版：//爱因斯坦难题,C语言数组实现 //提示： //   1、英国人住红色房子 //   2、瑞典人养狗 //   3、丹麦人喝茶 //   4、绿色房子在白色房子左面 //   5、绿色房子主人喝咖啡 //   6、抽PALL MALL香烟的人养鸟 //   7、黄色房子的主人抽DUNIILL香烟 //   8、住在中间房子的人喝牛奶 //   9、挪威人住第一间房 //  10、抽BLENDS香烟的人住在养猫人的隔壁 //  11、养马的人住在抽DUNHILL香烟的人隔壁 //  12、抽BLUE MASTER的人喝啤酒 //  13、德国人抽PRINCE的香烟 //  14、挪威人住蓝色房子的隔壁 //  15、抽BLENDS香烟的人有一个喝水的邻居 //    那谁是养鱼的呢？ #include <stdio.h> #include <locale.h> #define N 5 int a[N]; int b[120][5];//存放5!全排列情况 int num=0; int sum=1; void swap(int i, int offset) {     int temp;     temp=a[offset];     a[offset]=a[i];     a[i]=temp; } void print() {     int i;     for (i=0;i<N;i++) b[num][i]=a[i];     num++; } void perm(int offset) {     int i;     if (offset==N-1) {         print();         return;     }     for (i=offset;i<N;i++)  {         swap(i,offset);         perm(offset+1);         swap(i,offset);     } } int main() {     int i,k,r1,r2,r3,r4,r5;     int c[5][5]={0};//数组c记录了表格中按照每行国色烟饮宠，每列12345号房     int cou[6]={0}; //数组cou记录了每个国家的人入住的房号，顺序见下面的注释     int col[6]={0}; //数组col记录了每个颜色的房号，顺序见下面的注释     int cig[6]={0}; //数组cig记录了每个烟的房号，顺序见下面的注释     int dri[6]={0}; //数组dri记录了每个饮料的房号，顺序见下面的注释     int pet[6]={0}; //数组pet记录了每个宠物的房号，顺序见下面的注释      setlocale(LC_ALL,"chs");     for(i=0;i<N;i++) a[i]=i+1;     perm(0);     /*Einstein Problem        Country:  England ,Switzerland,Danmark,Germany   ,Norway          Color:  Red     ,Green      ,White  ,Yellow    ,Blue      Cigarette:  PallMall,Dunhill    ,Blends ,BlueMaster,Prince          Drink:  Tea     ,Coffee     ,Beer   ,Water     ,Milk            Pet:  Dog     ,Bird       ,Fish   ,Cat       ,Horse     */     for (r1=0;r1<120;r1++) {         if (b[r1][0]!=5) continue; //挪威人不住第一间房，退出         c[0][0]=b[r1][0];cou[c[0][0]]=1;         c[1][0]=b[r1][1];cou[c[1][0]]=2;         c[2][0]=b[r1][2];cou[c[2][0]]=3;         c[3][0]=b[r1][3];cou[c[3][0]]=4;         c[4][0]=b[r1][4];cou[c[4][0]]=5;     for (r2=0;r2<120;r2++) {         if (b[r2][1]!=5) continue; //挪威人隔壁不是蓝色房子，退出         c[0][1]=b[r2][0];col[c[0][1]]=1;         c[1][1]=b[r2][1];col[c[1][1]]=2;         c[2][1]=b[r2][2];col[c[2][1]]=3;         c[3][1]=b[r2][3];col[c[3][1]]=4;         c[4][1]=b[r2][4];col[c[4][1]]=5;     for (r3=0;r3<120;r3++) {         c[0][2]=b[r3][0];cig[c[0][2]]=1;         c[1][2]=b[r3][1];cig[c[1][2]]=2;         c[2][2]=b[r3][2];cig[c[2][2]]=3;         c[3][2]=b[r3][3];cig[c[3][2]]=4;         c[4][2]=b[r3][4];cig[c[4][2]]=5;     for (r4=0;r4<120;r4++) {         if (b[r4][2]!=5) continue; //住在中间房子的人不是喝牛奶，退出         c[0][3]=b[r4][0];dri[c[0][3]]=1;         c[1][3]=b[r4][1];dri[c[1][3]]=2;         c[2][3]=b[r4][2];dri[c[2][3]]=3;         c[3][3]=b[r4][3];dri[c[3][3]]=4;         c[4][3]=b[r4][4];dri[c[4][3]]=5;     for (r5=0;r5<120;r5++) {         c[0][4]=b[r5][0];pet[c[0][4]]=1;         c[1][4]=b[r5][1];pet[c[1][4]]=2;         c[2][4]=b[r5][2];pet[c[2][4]]=3;         c[3][4]=b[r5][3];pet[c[3][4]]=4;         c[4][4]=b[r5][4];pet[c[4][4]]=5;         if (             (col[1]==cou[1])//英国人住红色房子          && (cou[2]==pet[1])//瑞典人养狗          && (cou[3]==dri[1])//丹麦人喝茶          && (col[2] <col[3])//绿色房子在白色房子左面          && (col[2]==dri[2])//绿色房子主人喝咖啡          && (cig[1]==pet[2])//抽Pall Mall 香烟的人养鸟          && (col[4]==cig[2])//黄色房子主人抽 Dunhill 香烟          && ((cig[3]==(pet[4]-1))||(cig[3]==(pet[4]+1)))//抽Blends香烟的人住在养猫的人隔壁          && ((pet[5]==(cig[2]-1))||(pet[5]==(cig[2]+1)))//养马的人住抽Dunhill 香烟的人隔壁          && (cig[4]==dri[3])//抽Blue Master的人喝啤酒          && (cou[4]==cig[5])//德国人抽Prince 香烟          && ((dri[4]==(cig[3]-1))||(dri[4]==(cig[3]+1)))//抽Blends香烟的人有一个喝水的邻居         ) {             printf("\n---这里是第%d个答案---\n",sum);             printf("%-10s%-10s%-10s%-10s%-10s\n","房1","房2","房3","房4","房5");             sum++;             for (k=0;k<5;k++) printf("%-10.4s","英国瑞典丹麦德国挪威"+(c[k][0]-1)*4);//国家             printf("  ---1\n");             for (k=0;k<5;k++) printf("%-10.4s","红色绿色白色黄色蓝色"+(c[k][1]-1)*4);//颜色             printf("  ---2\n");             for (k=0;k<5;k++) printf("%-10.10s","PallMall  Dunhill   Blends    BlueMasterPrince"+(c[k][2]-1)*10);//香烟             printf("  ---3\n");             for (k=0;k<5;k++) printf("%-10.4s","茶  咖啡啤酒水  牛奶"+(c[k][3]-1)*4);//饮料             printf("  ---4\n");             for (k=0;k<5;k++) printf("%-10.2s","狗鸟鱼猫马"+(c[k][4]-1)*2);//宠物             printf("  ---5\n");         }     }//r5     }//r4     }//r3     }//r2     }//r1     printf("\n计算结束\n");     return 0; } // //---这里是第1个答案--- //房1       房2       房3       房4       房5 //挪威      丹麦      英国      德国      瑞典        ---1 //黄色      蓝色      红色      绿色      白色        ---2 //Dunhill   Blends    PallMall  Prince    BlueMaster  ---3 //水        茶        牛奶      咖啡      啤酒        ---4 //猫        马        鸟        鱼        狗          ---5 // //---这里是第2个答案--- //房1       房2       房3       房4       房5 //挪威      德国      瑞典      丹麦      英国        ---1 //绿色      蓝色      白色      黄色      红色        ---2 //PallMall  Prince    Blends    Dunhill   BlueMaster  ---3 //咖啡      水        牛奶      茶        啤酒        ---4 //鸟        鱼        狗        猫        马          ---5 // //---这里是第3个答案--- //房1       房2       房3       房4       房5 //挪威      德国      瑞典      丹麦      英国        ---1 //绿色      蓝色      白色      黄色      红色        ---2 //PallMall  Prince    Blends    Dunhill   BlueMaster  ---3 //咖啡      水        牛奶      茶        啤酒        ---4 //鸟        猫        狗        鱼        马          ---5 // //---这里是第4个答案--- //房1       房2       房3       房4       房5 //挪威      德国      瑞典      英国      丹麦        ---1 //绿色      蓝色      白色      红色      黄色        ---2 //PallMall  Prince    Blends    BlueMasterDunhill     ---3 //咖啡      水        牛奶      啤酒      茶          ---4 //鸟        猫        狗        马        鱼          ---5 // //---这里是第5个答案--- //房1       房2       房3       房4       房5 //挪威      德国      瑞典      英国      丹麦        ---1 //绿色      蓝色      黄色      红色      白色        ---2 //Blends    Prince    Dunhill   BlueMasterPallMall    ---3 //咖啡      水        牛奶      啤酒      茶          ---4 //鱼        猫        狗        马        鸟          ---5 // //---这里是第6个答案--- //房1       房2       房3       房4       房5 //挪威      德国      英国      丹麦      瑞典        ---1 //绿色      蓝色      红色      黄色      白色        ---2 //PallMall  Prince    Blends    Dunhill   BlueMaster  ---3 //咖啡      水        牛奶      茶        啤酒        ---4 //鸟        鱼        马        猫        狗          ---5 // //---这里是第7个答案--- //房1       房2       房3       房4       房5 //挪威      德国      英国      丹麦      瑞典        ---1 //绿色      蓝色      红色      黄色      白色        ---2 //PallMall  Prince    Blends    Dunhill   BlueMaster  ---3 //咖啡      水        牛奶      茶        啤酒        ---4 //鸟        猫        马        鱼        狗          ---5 // //计算结束 //

引用 4 楼 zhao4zhong1 的回复:剽窃也是一种技能！ //爱因斯坦难题,C语言数组实现 //提示： //   1、英国人住红色房子 //   2、瑞典人养狗 //   3、丹麦人喝茶 //   4、绿色房子在白色房子左面 //   5、绿色房子主人喝咖啡 //   6、抽PALL MALL香烟的人养鸟 //   7、黄色房子的主人抽DUNIILL香烟 //   8、住在中间房子的人喝牛奶 //   9、挪威人住第一间房 //  10、抽BLENDS香烟的人住在养猫人的隔壁 //  11、养马的人住在抽DUNHILL香烟的人隔壁 //  12、抽BLUE MASTER的人喝啤酒 //  13、德国人抽BRINCE的香烟 //  14、挪威人住蓝色房子的隔壁 //  15、抽BLENDS香烟的人有一个喝水的邻居 //    那谁是养鱼的呢？ #include <stdio.h> #define N 5 int a[N]; int b[120][5];//存放5!全排列情况 int num = 0; int sum = 1; void swap(int i, int offset) {     int temp;     temp = a[offset];     a[offset] = a[i];     a[i] = temp; } void print() {     int i;     for (i=0;i<N;i++) b[num][i]=a[i];     num++; } void perm(int offset) {     int i;     if (offset == N-1) {         print();         return;     }     for (i = offset; i < N; i++)  {         swap(i, offset);         perm(offset + 1);         swap(i, offset);     } } int main() {     int i,k,r1,r2,r3,r4,r5,fish;     int c[5][5]={0};//数组c记录了表格中按照每行国色烟饮宠，每列12345号房     int cou[6]={0}; //数组cou记录了每个国家的人入住的房号，顺序见下面的注释     int col[6]={0}; //数组col记录了每个颜色的房号，顺序见下面的注释     int cig[6]={0}; //数组cig记录了每个烟的房号，顺序见下面的注释     int dri[6]={0}; //数组dri记录了每个饮料的房号，顺序见下面的注释     int pet[6]={0}; //数组pet记录了每个宠物的房号，顺序见下面的注释     for(i=0;i<N;i++) a[i]=i+1;     perm(0);     /*Einstein Problem        Country:  England ,Switzerland,Danmark,Germany   ,Norway          Color:  Red     ,Green      ,White  ,Yellow    ,Blue      Cigarette:  PallMall,Dunhill    ,Blends ,BlueMaster,Prince          Drink:  Tea     ,Coffee     ,Beer   ,Water     ,Milk            Pet:  Dog     ,Bird       ,Fish   ,Cat       ,Horse     */     for (r1=0;r1<120;r1++) {         if (b[r1][0]!=5) {//挪威人不住第一间房，退出             continue;         }         c[0][0]=b[r1][0];cou[c[0][0]]=1;         c[1][0]=b[r1][1];cou[c[1][0]]=2;         c[2][0]=b[r1][2];cou[c[2][0]]=3;         c[3][0]=b[r1][3];cou[c[3][0]]=4;         c[4][0]=b[r1][4];cou[c[4][0]]=5;     for (r2=0;r2<120;r2++) {         if (b[r2][1]!=5) {//挪威人隔壁不是蓝色房子，退出             continue;         }         c[0][1]=b[r2][0];col[c[0][1]]=1;         c[1][1]=b[r2][1];col[c[1][1]]=2;         c[2][1]=b[r2][2];col[c[2][1]]=3;         c[3][1]=b[r2][3];col[c[3][1]]=4;         c[4][1]=b[r2][4];col[c[4][1]]=5;     for (r3=0;r3<120;r3++) {         c[0][2]=b[r3][0];cig[c[0][2]]=1;         c[1][2]=b[r3][1];cig[c[1][2]]=2;         c[2][2]=b[r3][2];cig[c[2][2]]=3;         c[3][2]=b[r3][3];cig[c[3][2]]=4;         c[4][2]=b[r3][4];cig[c[4][2]]=5;     for (r4=0;r4<120;r4++) {         if (b[r4][2]!=5) {//住在中间房子的人不是喝牛奶，退出             continue;         }         c[0][3]=b[r4][0];dri[c[0][3]]=1;         c[1][3]=b[r4][1];dri[c[1][3]]=2;         c[2][3]=b[r4][2];dri[c[2][3]]=3;         c[3][3]=b[r4][3];dri[c[3][3]]=4;         c[4][3]=b[r4][4];dri[c[4][3]]=5;     for (r5=0;r5<120;r5++) {         c[0][4]=b[r5][0];pet[c[0][4]]=1;         c[1][4]=b[r5][1];pet[c[1][4]]=2;         c[2][4]=b[r5][2];pet[c[2][4]]=3;         c[3][4]=b[r5][3];pet[c[3][4]]=4;         c[4][4]=b[r5][4];pet[c[4][4]]=5;         if (             (col[1]==cou[1])//英国人住红色房子          && (cou[2]==pet[1])//瑞典人养狗          && (cou[3]==dri[1])//丹麦人喝茶          && (col[2] <col[3])//绿色房子在白色房子左面          && (col[2]==dri[2])//绿色房子主人喝咖啡          && (cig[1]==pet[2])//抽Pall Mall 香烟的人养鸟          && (col[4]==cig[2])//黄色房子主人抽 Dunhill 香烟          && ((cig[3]==(pet[4]-1))||(cig[3]==(pet[4]+1)))//抽Blends香烟的人住在养猫的人隔壁          && ((pet[5]==(cig[2]-1))||(pet[5]==(cig[2]+1)))//养马的人住抽Dunhill 香烟的人隔壁          && (cig[4]==dri[3])//抽Blue Master的人喝啤酒          && (cou[4]==cig[5])//德国人抽Prince 香烟          && ((dri[4]==(cig[3]-1))||(dri[4]==(cig[3]+1)))//抽Blends香烟的人有一个喝水的邻居         ) {             printf("\n---这里是第%d个答案---\n房1       房2       房3       房4       房5     \n",sum);             sum++;             for (k=0;k<5;k++) {//国家                 switch (c[k][0]) {                 case 1:printf("英国      ");break;                 case 2:printf("瑞典      ");break;                 case 3:printf("丹麦      ");break;                 case 4:printf("德国      ");break;                 case 5:printf("挪威      ");break;                 default:break;                 }             }             printf("  ---1\n");             for (k=0;k<5;k++) {//颜色                 switch (c[k][1]) {                 case 1:printf("红色      ");break;                 case 2:printf("绿色      ");break;                 case 3:printf("白色      ");break;                 case 4:printf("黄色      ");break;                 case 5:printf("蓝色      ");break;                 default:break;                 }             }             printf("  ---2\n");             for (k=0;k<5;k++) {//香烟                 switch (c[k][2]) {                 case 1:printf("PallMall  ");break;                 case 2:printf("Dunhill   ");break;                 case 3:printf("Blends    ");break;                 case 4:printf("BlueMaster");break;                 case 5:printf("Prince    ");break;                 default:break;                 }             }             printf("  ---3\n");             for (k=0;k<5;k++) {//饮料                 switch (c[k][3]) {                 case 1:printf("茶        ");break;                 case 2:printf("咖啡      ");break;                 case 3:printf("啤酒      ");break;                 case 4:printf("水        ");break;                 case 5:printf("牛奶      ");break;                 default:break;                 }             }             printf("  ---4\n");             for (k=0;k<5;k++) {//宠物                 switch (c[k][4]) {                 case 1:printf("狗        ");break;                 case 2:printf("鸟        ");break;                 case 3:printf("鱼        ");fish=k+1;break;                 case 4:printf("猫        ");break;                 case 5:printf("马        ");break;                 default:break;                 }             }             printf("  ---5\n");         }     }//r5     }//r4     }//r3     }//r2     }//r1     printf("\n计算结束.\n");     return 0; } // //---这里是第1个答案--- //房1       房2       房3       房4       房5 //挪威      丹麦      英国      德国      瑞典        ---1 //黄色      蓝色      红色      绿色      白色        ---2 //Dunhill   Blends    PallMall  Prince    BlueMaster  ---3 //水        茶        牛奶      咖啡      啤酒        ---4 //猫        马        鸟        鱼        狗          ---5 // //---这里是第2个答案--- //房1       房2       房3       房4       房5 //挪威      德国      瑞典      丹麦      英国        ---1 //绿色      蓝色      白色      黄色      红色        ---2 //PallMall  Prince    Blends    Dunhill   BlueMaster  ---3 //咖啡      水        牛奶      茶        啤酒        ---4 //鸟        鱼        狗        猫        马          ---5 // //---这里是第3个答案--- //房1       房2       房3       房4       房5 //挪威      德国      瑞典      丹麦      英国        ---1 //绿色      蓝色      白色      黄色      红色        ---2 //PallMall  Prince    Blends    Dunhill   BlueMaster  ---3 //咖啡      水        牛奶      茶        啤酒        ---4 //鸟        猫        狗        鱼        马          ---5 // //---这里是第4个答案--- //房1       房2       房3       房4       房5 //挪威      德国      瑞典      英国      丹麦        ---1 //绿色      蓝色      白色      红色      黄色        ---2 //PallMall  Prince    Blends    BlueMasterDunhill     ---3 //咖啡      水        牛奶      啤酒      茶          ---4 //鸟        猫        狗        马        鱼          ---5 // //---这里是第5个答案--- //房1       房2       房3       房4       房5 //挪威      德国      瑞典      英国      丹麦        ---1 //绿色      蓝色      黄色      红色      白色        ---2 //Blends    Prince    Dunhill   BlueMasterPallMall    ---3 //咖啡      水        牛奶      啤酒      茶          ---4 //鱼        猫        狗        马        鸟          ---5 // //---这里是第6个答案--- //房1       房2       房3       房4       房5 //挪威      德国      英国      丹麦      瑞典        ---1 //绿色      蓝色      红色      黄色      白色        ---2 //PallMall  Prince    Blends    Dunhill   BlueMaster  ---3 //咖啡      水        牛奶      茶        啤酒        ---4 //鸟        鱼        马        猫        狗          ---5 // //---这里是第7个答案--- //房1       房2       房3       房4       房5 //挪威      德国      英国      丹麦      瑞典        ---1 //绿色      蓝色      红色      黄色      白色        ---2 //PallMall  Prince    Blends    Dunhill   BlueMaster  ---3 //咖啡      水        牛奶      茶        啤酒        ---4 //鸟        猫        马        鱼        狗          ---5 // //计算结束. // 谢谢赵老师

http://wenku.baidu.com/link?url=DfxMdqHGPQRgS4WUOZ2o_CkgPE9XsxITyJxzC6l-_cS7s0RgXuiIAguJUu0mTZG0LVUXyrwH3lo9tpF7lJJdoBIYuzbmSTzDx6xCj8V_Q0y  昨天惹祸了。 办公室的鱼缸里养了几只透明的小虾，领导戴着眼镜看半天，问我养的什么我说，虾啊－－！ 领导一愣，走了… 于是赶紧大声地解释说，虾啊领导！..领导虾啊。领导真是虾。领导确实是虾啊！

引用 1 楼 zhao4zhong1 的回复:https://www.baidu.com/s?wd=C%E8%AF%AD%E8%A8%80%20%E8%8B%B1%E5%9B%BD%E4%BA%BA%E4%BD%8F%E7%BA%A2%E8%89%B2%E6%88%BF%E5%AD%90&rsv_spt=1&rsv_iqid=0x9a7d76730000b363&issp=1&f=8&rsv_bp=1&rsv_idx=2&ie=utf-8&tn=baiduhome_pg&rsv_enter=0&oq=c%E8%AF%AD%E8%A8%80%20%E8%8B%B1%E5%9B%BD%E4%BA%BA%E4%BD%8F%E7%BA%A2%E8%89%B2%E6%88%BF%E5%AD%90&rsv_t=e864%2FCAPH2zbzXpntzyHGAC29X5UfT5yiRTKXrG5ZRa%2ByyCIPTJMzv7zkM%2BY8ldXInc5&rsv_pq=e2c3b63c0000cae9&inputT=37961&rsv_sug4=37961 赵老师 网上这些答案  我大可以自己推理解决  但是用C语言解决  我不知道怎么做


Question: 顺序表主函数里，往顺序表中存数据，然后打印出来怎么和预期效果不一样啊，是没存进去数据吗，求指导

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

引用 1 楼 user-2 的回复:InitList_sq中设置L.length 为0，Length一直为0 charu函数中执行完了第一句就返回了明白了  谢谢  调试好了

引用 4 楼 zhao4zhong1 的回复:main里面最后的for应改为     for(i=0;i<L.length;i++)调试好了谢谢您 原来有很多注意不到的地方

main里面最后的for应改为     for(i=0;i<L.length;i++)

charu的第一句     if(i<1||i>L.length) return 0; 应改为     if(i<1||i>L.length+1) return 0;

charu里面return 0;之前加一句++L.length;


Question: 关于(临时变量)栈区的释放问题(疑惑)

引用 4 楼 qldsrx 的回复:按照你的意思，销毁必须是要写入其它内容，但是这个写入也有开销，是没任何必要的。你访问的是不确定数据，而不是非法数据，也许会被其它地方给改写，但你的这个逻辑里面只执行了一个函数，没有改写的机会。 我明白了 ,感谢两位大神@qldsrx @赵4老师

int *a ;野指针 a;局部自动变量不会自动初始化 *a = 100  向一个不能确定是什么位置的内存单元，写入整型数据100,恰巧没出问题。 p=a;用野指针 给全局变量指针p赋值，结果p还是一个野指针 return a；返回一个野指针。  如此而已 你的程序和你的问题无关。

#include <stdio.h>  int *p;  int * fuc() {     int b;     int *a=&b;     *a = 100;     printf("a=%p,*a=%d\n",a,*a);     p=a;     return a;  }  int * fuc2() {     int b;     int *a=&b;     *a = 222;     printf("a=%p,*a=%d\n",a,*a);     p=a;     return a;  }  int * fuc3() {     char b[4]={'\x12','\x34','\x56','\x78'};     int *a=(int *)&b[0];     return a; }  int main(int argc,const char *argv[] ) {      fuc();     printf("after fun  p=%p,*p=%d\n",p,*p);     fuc2();     printf("after fun2 p=%p,*p=%d\n",p,*p);     fuc3();     printf("after fun3 p=%p,*p=%d\n",p,*p);      return 0; }  //a=0012FF44,*a=100 //after fun  p=0012FF44,*p=100 //a=0012FF38,*a=222 //after fun2 p=0012FF38,*p=222 //after fun3 p=0012FF38,*p=1244984 //

再另外，你程序中的a是个野指针，你应该写成int a = 100; p = &a;

内存不在有效，但该内存的值保留了之前留下的，但当其他函数/变量等使用时就会将其覆盖了


Question: 大伙看看这段代码

都是大神啊 ,受教了.

sizeof(i) 得到的是unsigned int 类型   在比较时会将long类型的-1转换成unsigned int ， 导致比较结果不地  可以写成：if (i < (long)sizeof(i))

#include <stdio.h> int main(int argc, char** argv) {      long i = -1;        if (i < (signed)sizeof(i)) { printf("OK\n"); } else { printf("error\n"); } return 0;  }


Question: error C2143: syntax error : missing ';' before '*'错误求大神！

我终于把这个问题弄出来了······心力交猝····· 首先，谢谢各位大神 以下献给也许某一天犯了一样错误的正在百度的和我一样的小白：  死在了互相包含上 //A.h文件 #include B.h class a {   B::b(); ```` } //B.h文件 #include A.h class B {   A::a() } 就是这个意思。 改： 加前向声明 //A.h文件 #include B.h class B; class a {   B::b(); ```` } //B.h文件 #include A.h//这货还是要写上啊，不写还是会错····· class A; class B {   A::a() } 完了。

引用 4 楼 baidu_27994971 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] 偶遇到类似问题都是用 “每次用/*...*/注释掉不同部分再重新编译，直到定位到具体语法出错的位置。” 的方法解决的。 好吧·····同一个.h,在类的外面定义一个结构体，然后在类里面使用这个结构体，是直接用吗？用不用声明什么的？[/quote] 需要前置声明

引用 3 楼 zhao4zhong1 的回复:偶遇到类似问题都是用 “每次用/*...*/注释掉不同部分再重新编译，直到定位到具体语法出错的位置。” 的方法解决的。 好吧·····同一个.h,在类的外面定义一个结构体，然后在类里面使用这个结构体，是直接用吗？用不用声明什么的？

错误定位在哪行  你给的文件不全，不好帮你调试，你检查括号是否对称，还有语句是否完整，有没用分号结束


Question: 编译用c语言编写的应用程序时链接库编译和用库源码直接编译占用内存有没有区别，主要是.bss段的占用区别

静态链接的话，.a 实际就是一堆 .o 放一起了，应该和全用源码是一样的。

引用 2 楼 fangqingwang 的回复:我用批处理的方式编译，只是链接库的时候编译不能通过，同时链接库和加入库的源码才能编译通过，应该不是那么简单 静态库编译选项要和 可执行程序的一样。


Question: 小白求问C语言问题——如何实现如果在一定时间内没有输入就跳过一段代码，继续执行下面的？

#include <windows.h> #include <conio.h>  int main() { 	printf("如果你三秒钟之内什么也不输入，我就输出-1。\n"); 	Sleep(3000); 	if(!_kbhit()) 		printf("-1\n"); 	else 		printf("输入了%c", getchar()); 	return 0; }

另可这样改进：把判断放在一个循环里，同时在循环中检查时间是否超出，这样在用户有输入的情况下不用等3秒后才往后执行

第18行 if (k==0 || k==0xe0) k=(k<<8)|_getch(); 应改为 if (k==0 || k==0xe0) k|=_getch()<<8;

继承楼上： #include <windows.h> #include <conio.h> #include <stdio.h> #include <locale.h> int main() {     int k;      setlocale(LC_ALL,"chs");     printf("如果你三秒钟之内什么也不输入，我就输出-1。\n");     Sleep(3000);     if(!_kbhit())         printf("-1\n");     else {         printf("输入了");         while (1) {             if (_kbhit()) {                 k=_getch();                 if (k==0 || k==0xe0) k=(k<<8)|_getch();                 if (0x21<=k && k<=0x7E) printf("%c",k);                 else printf("<%04x>",(unsigned)k);             } else break;         }         printf("\n");     }     return 0; }

多谢大神们了 真的很有帮助


Question: 大神们来刷道简单的OJ题吧

_control87, _controlfp Get and set the floating-point control word.  unsigned int _control87( unsigned int new, unsigned int mask );  unsigned int _controlfp( unsigned int new, unsigned int mask );  Routine Required Header Compatibility  _control87 <float.h> Win 95, Win NT  _controlfp <float.h> Win 95, Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  The bits in the value returned indicate the floating-point control state. See FLOAT.H for a complete definition of the bits returned by _control87.  Parameters  new  New control-word bit values  mask  Mask for new control-word bits to set  Remarks  The _control87 function gets and sets the floating-point control word. The floating-point control word allows the program to change the precision, rounding, and infinity modes in the floating-point math package. You can also mask or unmask floating-point exceptions using _control87. If the value for mask is equal to 0, _control87 gets the floating-point control word. If mask is nonzero, a new value for the control word is set: For any bit that is on (equal to 1) in mask, the corresponding bit in new is used to update the control word. In other words, fpcntrl = ((fpcntrl & ~mask) | (new & mask)) where fpcntrl is the floating-point control word.  Note   The run-time libraries mask all floating-point exceptions by default.  _controlfp is a platform-independent, portable version of _control87. It is nearly identical to the _control87 function on Intel (x86) platforms and is also supported by the MIPS and ALPHA platforms. To ensure that your floating-point code is portable to MIPS or ALPHA, use _controlfp. If you are targeting x86 platforms, use either _control87 or _controlfp.   The difference between _control87 and _controlfp is the way these two functions treat DENORMAL values. For Intel (x86) platforms, _control87 can set and clear the DENORMAL OPERAND exception mask. ALPHA platforms do not support this exception, and _controlfp does not modify the DENORMAL OPERAND exception mask. The following example demonstrates the difference:  _control87( _EM_INVALID, _MCW_EM ); // DENORMAL is unmasked by this call _controlfp( _EM_INVALID, _MCW_EM ); // DENORMAL exception mask remains unchanged  The possible values for the mask constant (mask) and new control values (new) are shown in Table R.1. Use the portable constants listed below (_MCW_EM, _EM_INVALID, and so forth) as arguments to these functions, rather than supplying the hexadecimal values explicitly.  ALPHA platforms support the DENORMAL input and output values in software. The default behavior of Windows NT on these platforms is to flush the DENORMAL input and output values to zero. _controlfp provides a new mask to preserve and flush the input and output DENORMAL values.   Intel (x86) platforms support the DENORMAL input and output values in hardware. The behavior is to preserve DENORMAL values. _control87 does not provide a mask to change this behavior. The following example demonstrates this difference:  controlfp( _DN_SAVE, _MCW_DN);   // Denormal values preserved by software on ALPHA. NOP on x86 controlfp( _DN_FLUSH, _MCW_DN);   // Denormal values flushed to zero by hardware on Alpha. Ignored on x86  Table R.1   Hexadecimal Values  Mask Hex Value Constant Hex Value  _MCW_DN (Denormal control) 0x03000000    _DN_SAVE  _DN_FLUSH     0x00000000  0x01000000   _MCW_EM (Interrupt exception) 0x0008001F    _EM_INVALID  _EM_DENORMAL  _EM_ZERODIVIDE  _EM_OVERFLOW  _EM_UNDERFLOW  _EM_INEXACT     0x00000010  0x00080000  0x00000008  0x00000004  0x00000002  0x00000001   _MCW_IC (Infinity control) 0x00040000    _IC_AFFINE  _IC_PROJECTIVE     0x00040000  0x00000000   _MCW_RC (Rounding control) 0x00000300    _RC_CHOP  _RC_UP  _RC_DOWN  _RC_NEAR     0x00000300  0x00000200  0x00000100  0x00000000   _MCW_PC (Precision control) 0x00030000    _PC_24 (24 bits)  _PC_53 (53 bits)  _PC_64 (64 bits)     0x00020000  0x00010000  0x00000000     Example  /* CNTRL87.C: This program uses _control87 to output the control   * word, set the precision to 24 bits, and reset the status to   * the default.  */  #include <stdio.h> #include <float.h>  void main( void ) {    double a = 0.1;     /* Show original control word and do calculation. */    printf( "Original: 0x%.4x\n", _control87( 0, 0 ) );    printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a );     /* Set precision to 24 bits and recalculate. */    printf( "24-bit:   0x%.4x\n", _control87( _PC_24, MCW_PC ) );    printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a );     /* Restore to default and recalculate. */    printf( "Default:  0x%.4x\n",            _control87( _CW_DEFAULT, 0xfffff ) );    printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a ); }     Output  Original: 0x9001f 0.1 * 0.1 = 1.000000000000000e-002 24-bit:   0xa001f 0.1 * 0.1 = 9.999999776482582e-003 Default:  0x001f 0.1 * 0.1 = 1.000000000000000e-002   Floating-Point Support Routines  See Also   _clear87, _status87

如果有人特意构造出一个double不能表示的超小或超大或超精度的根，你用double是无论如何也无法算出它的。 参考include\float.h: ... #define DBL_DIG         15                      /* # of decimal digits of precision */ #define DBL_EPSILON     2.2204460492503131e-016 /* smallest such that 1.0+DBL_EPSILON != 1.0 */ #define DBL_MANT_DIG    53                      /* # of bits in mantissa */ #define DBL_MAX         1.7976931348623158e+308 /* max value */ #define DBL_MAX_10_EXP  308                     /* max decimal exponent */ #define DBL_MAX_EXP     1024                    /* max binary exponent */ #define DBL_MIN         2.2250738585072014e-308 /* min positive value */ #define DBL_MIN_10_EXP  (-307)                  /* min decimal exponent */ #define DBL_MIN_EXP     (-1021)                 /* min binary exponent */ #define _DBL_RADIX      2                       /* exponent radix */ #define _DBL_ROUNDS     1                       /* addition rounding: near */ ...

+，-0 新版本的编译器支持+0，-0； 老版本的编译器往往统一为0， 或者是可以设置的，或可以控制的。 +0，-0 在参与计算时候，通常并无区别，只是计算结果为+0，-0是有区别的。

大神能讲的简单点么。。。小白看不懂啊


Question: 已有C源文件和头文件，用什么编译器，如何,生成DOS下.exe

bc++3.1 帮助里面对每个函数都有一小段能拷贝出来运行看效果的例子程序。非常适合初学C语言。相比较而言VC带的帮助MSDN就没有。http://download.csdn.net/source/2805028

BC,TC 都可以 MS也是有DOS下的C的 也是两个版本 MSC，quick C 直到VC

还可以用 Watcom C 号称最快

DOS？ 那就是 Turbo C

MASM ？

【C/C++程序设计学习与实验系统】 自带Turbo C、VC6 编译器，自带DOSBox，TC生成的exe可以直接在DOSBox下运行。


Question: 数组按指针间接取值怎么出错了，为什么？

抱歉，误导大家了。改成mp=&matrix  或者mp=matrix   都可以的！

引用 4 楼 u012237109 的回复:mp=&matrix[3][4]; &这个表示取数组的所以指针  改为mp=matrix[3][4];   别乱回复好吗

mp=&matrix[3][4]; 越界了

注意这一句mp=&matrix[3][4]; matrix[3][4]是什么？这表示二维数组的第3行第4列，然而。。。你的matrix根本就没这么大。。。


Question: id=6d9a926cf49846f286a37a8af7cab7f8 =后面是加了什么进制怎么还原

引用 8 楼 qq_33068399 的回复:[quote=引用 7 楼 paschen 的回复:] [quote=引用 6 楼 qq_33068399 的回复:] [quote=引用 5 楼 DelphiGuy 的回复:] id=6d9a926cf49846f286a37a8af7cab7f8 16个字节，估计就是md5做的hash。  恩。都说是这样的  那如果ID=123456  我加密成id=959d4976ef1144b086f423fe8c103f7b    我可以用ID=123456 打开网页吗[/quote]   那你加密了干嘛[/quote]   别人加的[/quote]   具体看他程序怎么处理加密与解密

引用 7 楼 paschen 的回复:[quote=引用 6 楼 qq_33068399 的回复:] [quote=引用 5 楼 DelphiGuy 的回复:] id=6d9a926cf49846f286a37a8af7cab7f8 16个字节，估计就是md5做的hash。  恩。都说是这样的  那如果ID=123456  我加密成id=959d4976ef1144b086f423fe8c103f7b    我可以用ID=123456 打开网页吗[/quote]   那你加密了干嘛[/quote]   别人加的

引用 6 楼 qq_33068399 的回复:[quote=引用 5 楼 DelphiGuy 的回复:] id=6d9a926cf49846f286a37a8af7cab7f8 16个字节，估计就是md5做的hash。  恩。都说是这样的  那如果ID=123456  我加密成id=959d4976ef1144b086f423fe8c103f7b    我可以用ID=123456 打开网页吗[/quote]   那你加密了干嘛

引用 5 楼 DelphiGuy 的回复:id=6d9a926cf49846f286a37a8af7cab7f8 16个字节，估计就是md5做的hash。  恩。都说是这样的  那如果ID=123456  我加密成id=959d4976ef1144b086f423fe8c103f7b    我可以用ID=123456 打开网页吗

引用 2 楼 paschen 的回复:你是用什么方法加密的，而且有些加密方式是不可逆的，就是逆推不回去的 那如果ID=123456  我加密成id=959d4976ef1144b086f423fe8c103f7b    我可以用ID=123456 打开网页吗

你是用什么方法加密的，而且有些加密方式是不可逆的，就是逆推不回去的

加密说错了


Question: [算法求助] 谁是最懒的老鼠？

#include <stdio.h> #include <math.h>  #define N 20 #define K 10  typedef struct node{     int position;     int distance; }data;  data pos[N][K];  int main() {     int n, k;     int i, j, m;     int minPositon;         //logic order          while (scanf("%d%d", &n, &k) != EOF) {         for(i=0; i<n; ++i)             for(j=0; j<k; ++j)                 scanf("%d", &pos[i][j].position);         if(n==1) {             printf("0\n");             continue;         }         for (i=1; i<n; ++i)             for(j=0; j<k; ++j) {                 pos[i][j].distance = abs(pos[i][j].position - pos[i-1][0].position) + pos[i-1][0].distance;                                  for(m=1; m<k; ++m)                     if (pos[i][j].distance > (abs(pos[i][j].position                                                   - pos[i-1][m].position) + pos[i-1][m].distance))                         pos[i][j].distance = abs(pos[i][j].position                                                  - pos[i-1][m].position) + pos[i-1][m].distance;             }         minPositon = 0;         for(i=1; i<k; ++i)             if (pos[n-1][minPositon].distance > pos[n-1][i].distance) {                 minPositon = i;             }         printf("%d\n", pos[n-1][minPositon].distance);     }     return 0; }

上面是解答这道题的代码，用的是动态规划

引用 6 楼 lm_whales 的回复:对每次的食物序列 排序 把 1000个位置 分成10等分或M等分处则相等 如果有三个序列的点处在同一个等分处则最短必在此范围内 ，如果有三序列的点聚集在每一个等分两侧 最短也可能在此处 没有扩大范围再找，有缩小范围再找 当点数小于 6个时候可以直接比较了。 抱歉，我对图这一块不太熟悉，能麻烦你在给个代码实现吗？

引用 3 楼 lm_whales 的回复:这不是随机，已经不是随机了 而是 每次出现一个食物位置序列 这样就是三次的位置之间最短即可。 能给个算法吗？

动态规划 就可以了

麻烦大神帮忙一下

帮这道题想了一个好玩的背景，不知道是不是画蛇添足了，要是描述不到位，请不要骂我 这道题，是关于“最短路径的问题”。用数学语言讲：在x轴上，移动k次，如何使得移动的距离最短（其中，每次只能移动到指定几个点中的一个）。 请大神，帮忙解一下


Question: 来个牛人吧！！！！

引用 4 楼 paschen的回复:自己动手，丰衣足食，有细节的问题可来论坛讨论 串口一直发零是怎么回事？？？

问问题都不会，还好意思叫牛人进来。虽然我不是

问问题都不会，还好意思叫牛人进来。虽然我不是

引用 1 楼 user-4的回复:神呐，没有平台要求吗？引脚怎么接都不管？ Tring 和echo随便接吧

引用 4 楼 paschen的回复:自己动手，丰衣足食，有细节的问题可来论坛讨论 为什么我的串口接收不到距离？

自己动手，丰衣足食，有细节的问题可来论坛讨论

没有人吗？？？

神呐，没有平台要求吗？引脚怎么接都不管？


Question: 鲁智深吃馒头，这个程序怎么写，一点头绪都没有！

引用 8 楼 baijiaheizhiganmao 的回复:一个约瑟夫环换个马甲就出来了,骗小盆友呢! 我说的是定义这道题的人,不是贴主.

一个约瑟夫环换个马甲就出来了,骗小盆友呢!

如果C++可以直接list, 或者模拟一个简单的链表, 答案是joseph(100,5) int L[1002],R[1002]; int joseph(int n,int d) {     L[1] =n,L[n]=n-1,R[1]=2,R[n]=1;     for(int i=2;i<n;i++){         L[i] =i-1;         R[i] =i+1;     }     int cur=1;     while(cur!=R[cur]){         for(int i=0;i<d;i++) cur=R[cur];         int prev =L[cur];         R[L[prev]] =cur;         L[cur] =L[prev];     }     return cur; }

好烂，也不知道逻辑对不对  #include <stdio.h>  int main() { 	int a[100] = {0}; 	int i,n,j,k;//i是99个馒头 				//n是代表和尚编号 				//j是指一次跳5个人,若其中k也就是3个人,已经分了，那么n要再加1 				//表示跳过此人 	for(i=0,n=4; i< 99; i++,n=n+5) 	{ 		if(n>=100) 			n=n-100;         	k=3; 		j=n-1; 		while(k--) 		{ 			if(a[j--] == 1) 				n++; 		} 		 		while(a[n] == 1) 		{ 			n++; 			if(n>=100) 			{ 				n=n-100; 			} 		} 		a[n]=1; 	} 	 	for(i=0; i<100; i++) 	{ 		if(a[i] == 0) 			printf("%d\n",i); 	}  }

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

耶稣的叛徒...话说长老包不包括在99个和尚里?

引用 2 楼 user-7 的回复:楼上正解，我就赚个苦劳吧。 #include <stdio.h>  typedef struct _Item{ 	int number; 	struct _Item* next; } Item,*PItem;  void main(){ 	Item items[100]; 	for(int i=0;i<100;i++){ 		items[i].number = i+1;	//按照习惯，编号从1开始 		items[i].next = items + i + 1; 	} 	items[99].next = items;  	Item *current = items; 	int index = 1; 	while(current->next != current){ 		//当前报1，则2、3、4依次传递 		for(int j=0;j<3;j++){ 			current = current->next; 		} 		//下一人吃馒头 		printf("%3d:第%3d个和尚吃馒头\n",index++,current->next->number); 		//下一人退出后，报4的人后面跟着下下一人 		current->next = current->next->next; 		//转下下一人报数1，进入下一循环 		current = current->next; 	}  	printf("\n鲁智深排在第%2d位\n\npress any key to exit...",current->number); 	getchar(); }   不用游标而是指针的静态链表， 好理解又不用动态分配内存。 佩服佩服。

标准的 Joseph problem 可以用数学方法，也可以用环形队列， 环形队列可以用环形链表实现。 环形链表实现的环形队列最好理解。 这就是那个约瑟夫环的问题


Question: 求助 ListView无法初始化

好吧，资源文件的属性错了……


Question: 求大神 改好这个源程序  ...发现了好多错误··本人新手 谢谢··

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

引用 2 楼 qq_33065723 的回复:本来就是没有分号 但是出来后 报错 我加上后就没报错了··大括号那里错了 我在文本文档上输入的=  = 括号 自己都没找出来   你先把程序格式改好了，用代码框发代码，我帮你看下

大括号不对称，还有void main() 后面怎么有个分号


Question: 输入一个数字转换为2进制，程序，将一个换成数组后，就出现了BUG，求高手看看!

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

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

引用 4 楼 user-2的回复:发你错误的代码来啊，另一次说完好好吗 系统只允许发三次回复，我已经都删除了。。

引用 4 楼 user-2的回复:发你错误的代码来啊，另一次说完好好吗 你能帮我改一下，怎么在循环里面使用指针数组，只要在循环里面，数据就会有问题

发你错误的代码来啊，另一次说完好好吗

然后我对程序做了一点小修改，说是修改，不过就是把number换成了number[10]而已，指针也是

#define _CRT_SECURE_NO_WARNINGS  #include <stdio.h> #include <malloc.h>  //调用two_binary函数,将10进制数转换为2进制,需要2个参数,第1个是整型变量,第2个是保存有多少位二进制的指针(需要指向整型变量),函数返回储存着顺向二进制的字符串指针 int* two_binary(long long number, int *precord) { 	int j = 0;  	//指针a和b都分配100个整型内存 	int *a = (int*)calloc(100, sizeof(int)); 	if (!a) 	{ 		printf("内存分配错误!\n"); 		return 0; 	}  	int *b = (int*)calloc(100, sizeof(int)); 	if (!b) 	{ 		printf("内存分配错误!\n"); 		return 0; 	}  	//将计算出来逆向二进制储存到a指针,直到要整型变量等于0 	do 	{ 		*(a + *precord) = number % 2; 		number /= 2; 		++*precord; 	} while (number != 0);  	//在循环中将顺向二进制给b指针 	for (j = 0;j < *precord;++j) 	{ 		*(b + j) = *(a + (*precord - j - 1)); 	}  	//释放a指针,b指针由主函数释放 	free(a); 	a = NULL;  	return b; }  int main(void) { 	while (1) 	{ 		int i = 0;  		int *p = NULL;           //指向length变量,储存two_binary函数有多少位2进制 		int length = 0; 		int *precord = &length;  		int number = 0;          //提示输入一个数,如果输入了0,就退出 		printf("输入一个数: "); 		scanf("%d", &number); 		if (number == 0) 		{ 			free(p); 			p = NULL; 			return 0; 		}  		p = two_binary(number, precord);   //调用two_binary函数,用p接收返回储存2进制的指针  		//用循环输出p指针里面的二进制 		for (i = 0;i < *precord;++i) 		{ 			printf("%d", *(p + i)); 		} 		printf("\n\n");  		//释放指针 		free(p); 		p = NULL; 	}  	while (1) 	{ 		getchar(); 	} 	return 0; }

这是上面的运行结果，很正常!


Question: 高手在哪里？？？？？

引用 2 楼 DwwwT 的回复:引用 1 楼 cyfcsd 的回复:已发，注意查收 已收到  如满意请结贴给分，ok？

引用 1 楼 cyfcsd 的回复:已发，注意查收 已收到

已发，注意查收


Question: 如何拷贝结构体指针

引用 5 楼 paschen 的回复:[quote=引用 4 楼 yangsong235 的回复:] [quote=引用 1 楼 paschen 的回复:] *p2 = *p1;  这种方法，p1和p2不是指向的同一块内存吗[/quote]  指向同一块内存是  p2 = p1;   补基础啊。。[/quote]  谢谢，的确是这样的

引用 1 楼 paschen 的回复:*p2 = *p1;  恩，相当简洁

引用 4 楼 yangsong235 的回复:[quote=引用 1 楼 paschen 的回复:] *p2 = *p1;  这种方法，p1和p2不是指向的同一块内存吗[/quote]  指向同一块内存是  p2 = p1;   补基础啊。。

引用 1 楼 paschen 的回复:*p2 = *p1;  这种方法，p1和p2不是指向的同一块内存吗

引用 2 楼 liganglester 的回复:需要新申请一块该结构体内存，内容copy过去，内存地址给p2。  貌似没有别的一步到位的方法。  能否直接给出代码呢

*p2 = *p1;


Question: 预编译宏问题

VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898

能否提供这方面知识的书名，哪本书，我们可以看。看

引用 5 楼 weixin_30563001 的回复:[quote=引用 1 楼 fefe82的回复:]展开 z=Y 的时候，Y 的定义是 "X*2"，X 的定义是 "2" 。  所以： z=Y   -->    z=X*2 --> z=2*2  ===========  宏定义里的 token 是不会进行宏替换的。 你说的token是什么意思…本人是小白[/quote]  在预编的时候，源文件会被处理成一个 preprocessing token 序列，preprocessing token包括: 头文件名，标识符，预处理数字，字符常量，字符串常量，运算符及标点，其它。

把#undef放到后面，结果(http://codepad.org/8EVmnXls)就为6了  #define X 3 #define Y X*2 int z = Y; #undef X #define X 2 #include <stdio.h> int main() { 	printf("%d", z); 	return 0; }

引用 1 楼 fefe82的回复:展开 z=Y 的时候，Y 的定义是 "X*2"，X 的定义是 "2" 。  所以： z=Y   -->    z=X*2 --> z=2*2  ===========  宏定义里的 token 是不会进行宏替换的。 你说的token是什么意思…本人是小白

#define X 3 #undef X  这两句相当于没有用

z 的值为4


Question: 【算法求助】计算概率

不知道楼主说的什么算法 思路不都是先列公式再编程对公式求解吗 公式好像是全概率公式，这个真心愧对概率论老师惹

《概率论与数理统计》

用排列方法,令a(n)为n个人随机抽取不上台的次数, 那么概率就是p(n) =a(n)/n! 这里a(n)=(n-1)*(a(n-1)+a(n-2)) a(1)=0,a(2)=1,数字比较大, 直接用double运算就可以了 double a[31]={0},p[31]={0};     a[2]=1;     p[2]=0.5;     for(int i=3;i<=30;i++){         a[i] =(i-1)*(a[i-1]+a[i-2]);         p[i] =a[i]/a[i-1]*p[i-1]/i;     }

这个问题等同于 N个不同的字母的N序列，第N位置不是序号为N字母的概率.

我记得可以用“二项展开”来求，但是忘记了。额额

引用 2 楼 user-5 的回复:这是数学问题，另你也没说清楚抽了之后放不放回 哈哈，写程序不就是解决数学问题嘛 每个人正好抽一张，不放回去

这是数学问题，另你也没说清楚抽了之后放不放回


Question: 刚学C的新手求教，以下C程序输出不正确。请指点。

引用 4 楼 Victor0757 的回复:[quote=引用 2 楼 paschen 的回复:] 输入时不用限制精度，算完输出的结果按需要精度输出即可  谢谢版主。我按照一楼的方法改了程序，输出结果正常。  请问怎么把分给1楼呢？[/quote]  结帖可以给分

引用 2 楼 paschen 的回复:输入时不用限制精度，算完输出的结果按需要精度输出即可  谢谢版主。我按照一楼的方法改了程序，输出结果正常。  请问怎么把分给1楼呢？

引用 1 楼 qq_31772373 的回复:scanf() 并没有能控制输入精度的吧 只能对输入数据的最大字段宽度进行控制的吧  scanf("%f", &inches);  谢谢，按你的方法在scan();中把.2删除掉之后输出结果正常。但是不知道为什么编译器没有出错提示？

输入时不用限制精度，算完输出的结果按需要精度输出即可


Question: 求大神帮忙简化程序

考虑了一下，第一感是用堆栈或是队列法消除递归，不过涉及的递归调用太复杂，比较难转换。  仔细看了一下这一段代码，  int gx1(int x1) { 	int min,temp,i; 	if(x1==0 || x1==1)	 		min = x1;	 	else 	{ 	   min=(gx1(0)+1)%n; 	   for (i=1;i<=x1-1;i++) 	   { 		   temp=(gx1(i)+1)%n; 		   if (temp<min) 			min=temp; 		}	    	} 	return min; }   发现可以逆向思维一下：gx1()这个函数被反复调用了若干次，可以考虑先写一个初始化过程，把所有的gx(x1) 【0 < x1< m】的结果都依次计算出来并保存至一个数组，然后直接从数组中读取结果。    int * gx1_data = NULL;  /***************************  * int calc_gx1()  * return value: 0 == success; 1 = error  * **************************/ int calc_gx1() { 	if(NULL == gx1_data) gx1_data = (int *)malloc(m * sizeof(int)); 	if(NULL == gx1_data) return 1; 	int x1, i, min, temp; 	gx1_data[0] = 0; gx1_data[1] = 1;  	for(x1 = 2; x1 < m; x1++) 	{ 		min = (0 + 1) % n; // gx1(0) == 0 		for(i = 1; i < x1; i++) 		{ 			temp = (gx1_data[i] + 1) % n; 			if(temp < min) min = temp; 		} 		gx1_data[x1] = min; 	} 	return 0; }   gx2、gx3、gx4也可以用同样的方法，先直接计算出所有的结果并保存至gx2_data[m * m], gx3_data[m * m * m]和gx4_data[m * m * m * m]，这样就将gx4(x1,x3,x3,x4)这种复杂的递归调用转化为数组的写入和读取的简单问题。  如果内存不够，可以考虑使用外部存储，在文件中读写。

动态分配内存，用循环代替递归

看了下代码，逻辑明白，也觉得这样写太罗嗦，但一时自己又想不到怎么改进，所以也比较关注你这个问题的各种解，所以拿你的代码在stackoverflow也贴了下，有个人给的答案如下： #include <stdio.h>  #define m 8  int main() {    int min;    int min1;    int min2;    int min3;    int min4;     FILE* fp = stdout;    for(int x1=1;x1<m;x1++)    {       min1 = x1;       for(int x2=1;x2<m;x2++)       {          min2 = min1;          if ( min2 > x2 )             min2 = x2;           for(int x3=1;x3<m;x3++)          {             min3 = min2;             if ( min3 > x3 )                min3 = x3;              for(int x4=1;x4<m;x4++)             {                min4 = min3;                if (min4 > x4 )                   min4 = x4;                 min=min4;                fprintf(fp, "g(%d,%d,%d,%d)=%d\n",x1,x2,x3,x4,min);             }             fprintf(fp,"\n");          }          fprintf(fp,"\n");       }       fprintf(fp,"\n");    }    fclose(fp);    return 0; }  不过这样时间复杂度并不会减少，随着m的增大还是会消耗 O(N^4)   原始链接：http://stackoverflow.com/questions/33863407/how-to-optimize-the-c-code-when-m-is-too-big-it-cannt-opration/33863570#33863570

加大默认的堆栈大小。 VC6： 工程、设置、连接、分类：输出、堆栈分配、保留：64000000 VS20XX： 项目、属性、配置属性、链接器、系统、堆栈保留大小：64000000

@赵4老师,修改默认的堆栈后还是运行不出来

@Gdreamlend，程序修改后变量n是不是不能修改了

通常程序默认栈大小是1M，可以对默认栈大小进行设置，但如果要使用很大的数组，一般都考虑在堆上分配

是更改程序设置中默认的参数吗


Question: 求大神用C语言设计一个简单的计算器，进行加减乘除，可带括号，不限定运算式的输入长度

在现实世界中，除时间和空间可能是无限的以外，其它任何事物都是有限的。

引用 1楼user-2 的回复:去网上搜，一箩筐一箩筐的  http://blog.csdn.net/pdcxs007/article/details/40158437好的，谢谢。


Question: C语言问题

去掉 # include <string.h> 这行也行。

引用 3 楼 dsq2753919456 的回复:啊，太机智了。果然是因为和库函数名重复了。顺便问一下版主是软件工程 师吗？  不是啊，业余的，我专业和计算机没关系

啊，太机智了。果然是因为和库函数名重复了。顺便问一下版主是软件工程 师吗？

没发现问题，给出错误提示

没有错，只是strcat与标准库函数名字冲突了，换一个名字吧。


Question: C语言打印A形图案。在线等，急！！！

void output(int cnt,char ch){     while(cnt--) putchar(ch); } int main() {     int n;    while(~scanf("%d",&n) && n>2){         for(int i=1;i<=n;i++){             output(n-i,' ');             putchar('*');             if(i==(n+1)/2){                 for(int j=1;j<=2*i-2;j++) putchar('*');             }else if(i>=2) {                 output(2*(i-2)+1,' ');                 putchar('*');             }             puts("");         }    } }


int wscanf( const wchar_t *format [,argument]... );

引用 10 楼 zhao4zhong1 的回复:MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO http://pan.baidu.com/s/1bnGo0Vl 先下载安装MSDN98 再参考MSDN98\SAMPLES\VC98\SDK\WINUI\INPUT\IME\*.* 又见到赵老师了，在哪都能碰到你，幸会

引用 10 楼 zhao4zhong1 的回复:MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO http://pan.baidu.com/s/1bnGo0Vl 先下载安装MSDN98 再参考MSDN98\SAMPLES\VC98\SDK\WINUI\INPUT\IME\*.* 好的。

引用 5 楼 paschen 的回复:[quote=引用 4 楼 csdnxinshou2 的回复:] [quote=引用 3 楼 paschen 的回复:] [quote=引用 2 楼 csdnxinshou2 的回复:] [quote=引用 1 楼 liganglester 的回复:] 我理解你就是希望自己的程序可以输入中文吧  如果你的程序是在中文系统下编译运行，那不用特别处理就可以输入中文。  如果是非中文系统，你的程序需要支持unicode。  具体地，win32函数有两套，一套是支持非unicode编码，一套支持unicode的。前者是A结尾，后者W结尾。例如：TextOutA（），TextOutW（）。  为了开发者使用方便，微软给每个函数都定义了宏，用来在unicode和非unicode模式间切换，例如TextOut（）。  这样，开发者主要调用TextOut就可以了，实际调用的函数会根据unicode宏定义自动切换。 TextOutW()不是输出函数吗?我要输入函数。[/quote]  你可以创建文本框之类的让用户输入，然后读取，如果是在控制台用scanf[/quote] 有没有不用控件的方法?[/quote]  那你希望用什么，复制内容到剪贴板、读文件或是别的什么[/quote] 想做个记事本这样的直接输入中文就可以了。

引用 5 楼 paschen 的回复:[quote=引用 4 楼 csdnxinshou2 的回复:] [quote=引用 3 楼 paschen 的回复:] [quote=引用 2 楼 csdnxinshou2 的回复:] [quote=引用 1 楼 liganglester 的回复:] 我理解你就是希望自己的程序可以输入中文吧  如果你的程序是在中文系统下编译运行，那不用特别处理就可以输入中文。  如果是非中文系统，你的程序需要支持unicode。  具体地，win32函数有两套，一套是支持非unicode编码，一套支持unicode的。前者是A结尾，后者W结尾。例如：TextOutA（），TextOutW（）。  为了开发者使用方便，微软给每个函数都定义了宏，用来在unicode和非unicode模式间切换，例如TextOut（）。  这样，开发者主要调用TextOut就可以了，实际调用的函数会根据unicode宏定义自动切换。 TextOutW()不是输出函数吗?我要输入函数。[/quote]  你可以创建文本框之类的让用户输入，然后读取，如果是在控制台用scanf[/quote] 有没有不用控件的方法?[/quote]  那你希望用什么，复制内容到剪贴板、读文件或是别的什么[/quote] 就象scanf()这样的直接可以输入的。不需要控件的。有没有?

引用 2 楼 csdnxinshou2 的回复:[quote=引用 1 楼 liganglester 的回复:] 我理解你就是希望自己的程序可以输入中文吧  如果你的程序是在中文系统下编译运行，那不用特别处理就可以输入中文。  如果是非中文系统，你的程序需要支持unicode。  具体地，win32函数有两套，一套是支持非unicode编码，一套支持unicode的。前者是A结尾，后者W结尾。例如：TextOutA（），TextOutW（）。  为了开发者使用方便，微软给每个函数都定义了宏，用来在unicode和非unicode模式间切换，例如TextOut（）。  这样，开发者主要调用TextOut就可以了，实际调用的函数会根据unicode宏定义自动切换。 TextOutW()不是输出函数吗?我要输入函数。[/quote]  你可以创建文本框之类的让用户输入，然后读取，如果是在控制台用scanf

引用 4 楼 csdnxinshou2 的回复:[quote=引用 3 楼 paschen 的回复:] [quote=引用 2 楼 csdnxinshou2 的回复:] [quote=引用 1 楼 liganglester 的回复:] 我理解你就是希望自己的程序可以输入中文吧  如果你的程序是在中文系统下编译运行，那不用特别处理就可以输入中文。  如果是非中文系统，你的程序需要支持unicode。  具体地，win32函数有两套，一套是支持非unicode编码，一套支持unicode的。前者是A结尾，后者W结尾。例如：TextOutA（），TextOutW（）。  为了开发者使用方便，微软给每个函数都定义了宏，用来在unicode和非unicode模式间切换，例如TextOut（）。  这样，开发者主要调用TextOut就可以了，实际调用的函数会根据unicode宏定义自动切换。 TextOutW()不是输出函数吗?我要输入函数。[/quote]  你可以创建文本框之类的让用户输入，然后读取，如果是在控制台用scanf[/quote] 有没有不用控件的方法?[/quote]  那你希望用什么，复制内容到剪贴板、读文件或是别的什么

引用 3 楼 paschen 的回复:[quote=引用 2 楼 csdnxinshou2 的回复:] [quote=引用 1 楼 liganglester 的回复:] 我理解你就是希望自己的程序可以输入中文吧  如果你的程序是在中文系统下编译运行，那不用特别处理就可以输入中文。  如果是非中文系统，你的程序需要支持unicode。  具体地，win32函数有两套，一套是支持非unicode编码，一套支持unicode的。前者是A结尾，后者W结尾。例如：TextOutA（），TextOutW（）。  为了开发者使用方便，微软给每个函数都定义了宏，用来在unicode和非unicode模式间切换，例如TextOut（）。  这样，开发者主要调用TextOut就可以了，实际调用的函数会根据unicode宏定义自动切换。 TextOutW()不是输出函数吗?我要输入函数。[/quote]  你可以创建文本框之类的让用户输入，然后读取，如果是在控制台用scanf[/quote] 有没有不用控件的方法?

引用 1 楼 liganglester 的回复:我理解你就是希望自己的程序可以输入中文吧  如果你的程序是在中文系统下编译运行，那不用特别处理就可以输入中文。  如果是非中文系统，你的程序需要支持unicode。  具体地，win32函数有两套，一套是支持非unicode编码，一套支持unicode的。前者是A结尾，后者W结尾。例如：TextOutA（），TextOutW（）。  为了开发者使用方便，微软给每个函数都定义了宏，用来在unicode和非unicode模式间切换，例如TextOut（）。  这样，开发者主要调用TextOut就可以了，实际调用的函数会根据unicode宏定义自动切换。 TextOutW()不是输出函数吗?我要输入函数。

引用 7 楼 csdnxinshou2 的回复:[quote=引用 5 楼 paschen 的回复:] [quote=引用 4 楼 csdnxinshou2 的回复:] [quote=引用 3 楼 paschen 的回复:] [quote=引用 2 楼 csdnxinshou2 的回复:] [quote=引用 1 楼 liganglester 的回复:] 我理解你就是希望自己的程序可以输入中文吧  如果你的程序是在中文系统下编译运行，那不用特别处理就可以输入中文。  如果是非中文系统，你的程序需要支持unicode。  具体地，win32函数有两套，一套是支持非unicode编码，一套支持unicode的。前者是A结尾，后者W结尾。例如：TextOutA（），TextOutW（）。  为了开发者使用方便，微软给每个函数都定义了宏，用来在unicode和非unicode模式间切换，例如TextOut（）。  这样，开发者主要调用TextOut就可以了，实际调用的函数会根据unicode宏定义自动切换。 TextOutW()不是输出函数吗?我要输入函数。[/quote]  你可以创建文本框之类的让用户输入，然后读取，如果是在控制台用scanf[/quote] 有没有不用控件的方法?[/quote]  那你希望用什么，复制内容到剪贴板、读文件或是别的什么[/quote] 想做个记事本这样的直接输入中文就可以了。[/quote]  记事本不就是个Edit控件，支持多行的，不知你什么意思


Question: 判断是否是同一棵二叉搜索树。多组数据该怎么修改代码

return SameBST( OrangeBST->Right , BST->Right  ) ;这句错了

为何没有销毁树的代码  每组中，每个序列，只需要和第一个比较就好了，因为生成的二叉树必须是全同的 因此，只需要初始序列，和比较序列两个序列，就够用了 具体做法是 读取N,L 生成初始序列  first, 接着循环生成 比较序列 next 如果相同，销毁 next 重建序列 否则，输出结论"No"  这样就处理好一组数据了 此时销毁 这两个二叉树。 输出结论。“Yes” 另外也可以用数组表示二叉树这样就不需要销毁了 注意N<=10 每个序列，可以用最多十个节点表示。

引用 4 楼 user-1 的回复:return SameBST( OrangeBST->Right , BST->Right ) ; 这句错了 这个判断实际上是不对的，没有找到确切位置， 确切位置是 if( BST->Data != OrangeBST->Data )//根节点数据不同          return 0 ;  因为 if(BST==NULL&&OrangeBST==NULL)//两边都为空         return 1 ;     if( BST->Data != OrangeBST->Data )//根节点数据不同         return 0 ; 这个判断，不能保证，在二者有一个为空的时候，不出错。 后面那种判断， if( (BST->Left==NULL&&OrangeBST->Left!=NULL) || (BST->Left!=NULL&&OrangeBST->Left==NULL) )//一边左子树为空另一棵左子树非空         return 0 ;     if( BST->Left!=NULL && OrangeBST->Left!=NULL && BST->Left->Data!=OrangeBST->Left->Data)//两边左子树非空但元素不同         return 0 ;     if(  BST->Left!=NULL&&OrangeBST->Left!=NULL && BST->Left->Data == OrangeBST->Left->Data)//两边左子树都非空并且元素相同,判断右子树         return SameBST( OrangeBST->Right , BST->Right  ) ; 1是太复杂而没有必要， 2是很难找出错误，条件太多了，  代码应该力求简洁 这样才比较容易判断哪里出错。  对于比较复杂的表达式，最好分开几行写。 当然，更好的是，代码里不出现这种复杂的表达式。  C,C++ 语言，并不要求 所有 代码写在一行上， 所以一行最好只写功能单一的代码 条件表达式太复杂，应该分行写。 任何表达式过于复杂，都应该分行写，以便调试的时候，比较容易定位错误。 恩恩，记住了。你的方法使代码简洁不少呢

int SameBST( BinTree OrangeBST , BinTree BST ) {     ///根节点相等判断 1 同为空节点，返回 1     if(BST==NULL  && OrangeBST==NULL)//两边都为空                 return 1 ;     if(BST==NULL)return 0; ///只有一个空节点，比较序列为空，返回 0     if  (OrangeBST==NULL)return 0; 只有一个空节点，原始序列为空，返回 0          if( BST->Data != OrangeBST->Data )//根节点数据不同          return 0 ;      return SameBST( OrangeBST->Left , BST->Left  )              && SameBST( OrangeBST->Right , BST->Right  ); }  这样就可以了，左右子树不必另外处理，各用一个递归调用足矣。


Question: 如何理解这段代码！请大神指点！

写这段代码的，如果不是故意为了让新手看不懂（用了一个不必要的指向指针的指针），就是水平有问题。  稍微修改了一下代码，加上点注释，看看是否会容易理解些：   struct ListNode * remove_elements(struct ListNode * head, int val) { 	assert(NULL != head); 	struct ListNode * toRemove, *p; 	 	p = head; 	// 判断移除的是否为head 	if(head->val == val) 	{ 		toRemove = head; 		head = head->next; 		free(toRemove); 		return head; 	} 	 	// 遍历链表，根据val值查找需要移除的第一个node 	while(NULL != p->next) 	{ 		if(p->next->val == val) /* found one */ 		{ 			toRemove = p->next; 			p->next = p->next->next;			 			free(toRemove); 			break; 		} 		p = p->next; 	} 	 	return head; }

//不带表头结点的单向链表 #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-> //

如果你给的程序是书上的代码，你尽快把它丢掉，重新买本吧。

p = 猜  pp = 猜 猜  猜 不 着 你 就 是 大 菜 B！  c++高手写出的代码只有高手才看的懂，菜B永远是看不懂。 答：哦 什么Java，垃圾啦，什么C语言，low啦。 答：阿哦 c++是最牛逼的语言。 答：哦哦哦  结论：万物皆下品，唯有C++。

// Win32Blank.cpp : Defines the entry point for the console application. //  #include "stdafx.h" #include <stdio.h> #include <stdlib.h>  struct ListNode { 	int val; 	struct ListNode *next; };  void PrintList(ListNode *list) { 	struct ListNode *tmpNode = list;  	while (tmpNode != NULL) 	{ 		printf("%d ", tmpNode->val); 		tmpNode = tmpNode->next; 	} 	printf("\n"); }  struct ListNode* removeElements(struct ListNode* head, int val)  { 	struct ListNode *tmpNode = NULL; 	struct ListNode *preNode = NULL; 	struct ListNode *deleteNode = NULL;  	preNode = tmpNode = head;  	while (tmpNode != NULL)  	{ 		if (tmpNode->val == val)  		{   			if (tmpNode == head) 			{ 				head = tmpNode->next; 				deleteNode = tmpNode; 				tmpNode = tmpNode->next; 				free(deleteNode); 			} 			else 			{ 				preNode->next = tmpNode->next; 				deleteNode = tmpNode; 				tmpNode = tmpNode->next; 				free(deleteNode); 			} 		}  		else 		{ 			preNode = tmpNode; 			tmpNode = tmpNode->next;  		}	 	} 	return head; }  ListNode *MakeNode(int val) { 	ListNode *tmpNode = new ListNode; 	tmpNode->val = val; 	tmpNode->next = NULL; 	return tmpNode; }  int CreateList(ListNode **head, int *data, int len) { 	if (len < 1 || data == NULL || head == NULL) 	{ 		return -1; 	}  	*head = MakeNode(data[0]); 	ListNode *preNode = *head; 	 	for (int i=1; i<len; ++i) 	{ 		ListNode *tmpNode = MakeNode(data[i]); 		preNode->next = tmpNode; 		preNode = tmpNode; 	}  	return 0; }  int main(int argc, char* argv[]) { 	int data[10] = {1, 2, 3, 4, 5, 1, 7, 8, 9, 2}; 	ListNode *head = NULL; 	CreateList(&head, data, 10); 	PrintList(head);  	head = removeElements(head, 1); 	PrintList(head);  	head = removeElements(head, 2); 	PrintList(head);  	system("pause"); 	return 0; }

struct ListNode* removeElements(struct ListNode* head, int val)  {     struct ListNode **pp, *p;      pp = &head; //pp初始是链表头的地址     while (*pp) {         p = *pp;         if ((*pp)->val == val) { /* found one */ 如果元素值等于val             *pp = p->next;  //移到下一节点             free(p);  //释放为val的这个节点（还应该有些操作）         } else             pp = &p->next; //移到下一节点     }      return head; }

这段代码是删除所有值为val的结点，写的并不好而已。

这是查找并销毁链表节点吧，  就利用指针沿着链表挨个查找那个val， 然后val的前驱和后继直接相连， val就被‘孤立’出来了，就free它，就算是删除这个节点了  数据结构其实理解这个过程就好  欢迎补充指正


Question: 链表运行过程中出异常！指教

观察如下结构体： struct stu{  int num; double cort; struct stu * next; }; 使用malloc分配内存内存不会进行初始化，所有next会是随机值，这也是为什么while循环异常退出的原因

# include<stdio.h> # include<malloc.h> #include <stdlib.h> struct stu{  int num; double cort; struct stu * next; }; struct stu *s1(); int Output(struct stu * head); //输出链表  struct stu *s2(struct stu *head); int main() { struct stu *t; 	int i = 0; 	 	t=s1();//创建新链表  	 	 	s2(t);//删除链表某个结点   	return 0; }  struct stu *s1() { 	struct stu * head; 	head = (struct stu *)malloc(sizeof(struct stu)); 	struct stu *s1; 	struct stu *s2; 	s2=s2=head; 	do 	{ 		 		if(head==NULL) 		{ 			exit(1); 		} 		else 		{ 			printf("创建学生成绩管理系统\n"); 			s1 = (struct stu *)malloc(sizeof(struct stu)); 			printf("输入学生学号:"); 			scanf("%d",&s1->num); 			printf("输入学生成绩:"); 			scanf("%lf",&s1->cort); 			printf("\n"); 			s2->next=s1; 			s2=s1;	 		} 	}while(s1->num); 	 	s2->next = NULL; 	pOutput(head);//输出链表  	return head; } int pOutput(struct stu * head){ struct stu *p; p=head; while(p->next!=NULL) {  printf("%d\n%lf\n",p->next->num,p->next->cort); p = p->next; } 	return 0; } struct stu *s2(struct stu *head) { 	 	struct stu *s1; 	struct stu *s2; 	struct stu *headl; 	struct stu *te; 	struct stu *tse; 	int n = 0; 	headl=head; 	if(headl==NULL) 	{ 		printf("链表为空\n"); 	} 	printf("输入要删除的学号:"); 	scanf("%d",&n); 	s2 = headl; 	if(headl->next->num==n) 	{ 		if(headl->next->next==NULL) 			return 0; 		else 		{ 			tse=headl->next; 			headl->next=tse->next; 		} 		free(tse); 	} 	else 	{ 	s1=s2->next; 	while(s1->next!=NULL & s1->next->num!=n) 	{ 		s1=s1->next; 	} 	te=s1->next; 	s1->next=s1->next->next; 	free(te); 	} 	pOutput(headl); 	return headl; }

在哪里的基础是改了一下下

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

好像都没返回值， 代码太长而且没有缩进，手机看好麻烦

引用 1 楼 user-5的回复:别说运行，编译都有问题，你s1和s2函数需要返回一个int值啊 我编译可以过。。。。。

别说运行，编译都有问题，你s1和s2函数需要返回一个int值啊


Question: 新手求教，如何实现在程序运行的任意时刻按q键退出

本来控制台程序在输入时按Ctrl+C或Ctrl+Break就可以退出的。 楼主的程序即使实现了按q随时退出，万一哪天输入内容中有q咋办？比如需要输入qq12345678

只能另外开个线程来实现了

while(scanf("%d",&var)!=1)//就是利用scanf的返回值判断是否输入非整形 {          quit(); }//手机客户端可能排版不好看，轻喷！  不知道是不是这么个意思

引用 2 楼 qq_33031101 的回复:是控制台程序，怎样在执行scanf是也能实现按q键退出  如果想要任意时刻都会的话可以用多线程来实现，用一个线程捕捉键盘消息   	INPUT_RECORD irInBuf; 	DWORD cNumRead; 	ReadConsoleInput(GetStdHandle(STD_INPUT_HANDLE),&irInBuf,1,&cNumRead);  	if(irInBuf.EventType == KEY_EVENT && irInBuf.Event.KeyEvent.bKeyDown)//键盘事件 		if(irInBuf.Event.KeyEvent.wVirtualKeyCode == xxx && GetConsoleWindow()==GetForegroundWindow())                  //然后处理

是控制台程序，怎样在执行scanf是也能实现按q键退出

什么类型程序，如果是控制台的话你只能不断监视，GUI程序可以注册热键或者根据消息响应来实现


Question: hdoj-1002 A+B problemII 不明白哪里错了（WA）

只改动2个地方是不够的。请试以下输入：  1 9 9  #2程序输出： Case 1: 9 + 9 = 8

O(∩_∩)O谢谢你的耐心分析，不过只需要改动2个地方即可------>  #include<stdio.h> #include<string.h> #define N 1005   int common(int a, int b){     if(a<b){         return a;     }     else{         return b;     } } int rest(int a, int b){     int temp;     if(b>a){         temp = b;          b = a;         a = temp;     }     return (a-b-1); } int main() {     char num1[N], num2[N], sum1[N], sum2[N]; // num存储输入的数,sum存储结果      int n;           while(scanf("%d", &n)!=EOF){ // n为要输入的行数                int k, i = 0, add=0;               for(; i<n; i++){                           if(i){ // Output a blank line between two test cases.                 printf("\n");             }                           scanf("%s%s", num1, num2);                           int len1 = strlen(num1); // 计算两个输入数的位数              int len2 = strlen(num2);                           int long1 = len1-1, long2 = len2-1; // 对应的下标                        if( len1 >= len2 ){                 k = long2;                 for(; k>=0; k--){                     sum2[k] = (num1[long1]-'0') + (num2[long2]-'0')+add;                     if(sum2[k]>=10){                         sum2[k] -= 10;                         add = ((num1[long1]-'0' )+ (num2[long2]-'0')+add)/10;                     }                     else{              //改动一                         add = 0;                     }                     long1--;                     long2--;                 }                 k = len1-len2-1;                 for(; k>=0; k--){                     sum1[k] = (num1[k]-'0')+add;                     if(sum1[k]>=10 && k>0){                         sum1[k] -= 10;                         add = ((num1[k]-'0')+add)/10;                     }                      else{                         add = 0;                     }                 }             }             else{                 k = long1;                 for(; k>=0; k--){                     sum2[k] = (num1[long1]-'0') + (num2[long2]-'0')+add;                     if(sum2[k]>=10){                         sum2[k] -= 10;                         add = ((num1[long1]-'0' )+ (num2[long2]-'0')+add)/10;                     }                     else{              //改动二                         add = 0;                     }                      long1--;                     long2--;                 }                 k = len2-len1-1;                 for(; k>=0; k--){                     sum1[k] = (num2[k]-'0')+add;                     if(sum1[k]>=10 && k>0){                         sum1[k] -= 10;                         add = ((num2[k]-'0')+add)/10;                     }                      else{                         add = 0;                     }                 }             }             int lenSum1 = rest(len1, len2);             int lenSum2 = common(len1, len2);             printf("Case %d:\n", i+1);             printf("%s + %s = ", num1, num2);             k = 0;             for(; k<=lenSum1; k++){                 printf("%d", sum1[k]);             }             k = 0;             for(; k<lenSum2; k++){                 printf("%d", sum2[k]);             }             printf("\n");         }     }     return 0; }

LZ程序中的问题是： 1 没有在每个用例开始处把变量add清零 2 计算过程中没有进位时没有把变量add清零 3 输出时没有输出尚未使用的进位值  如下修改可AC：  #include<stdio.h> #include<string.h> #define N 1005  int common(int a, int b){   if(a<b){     return a;   }   else{     return b;   } } int rest(int a, int b){   int temp;   if(b>a){     temp = b;      b = a;     a = temp;   }   return (a-b-1); } int main() {   char num1[N], num2[N], sum1[N], sum2[N]; // num存储输入的数,sum存储结果    int n;    scanf("%d", &n); //改 while(scanf("%d", &n)!=EOF){ // n为要输入的行数       int k, i = 0, add=0;      for(; i<n; i++){       if(i){ // Output a blank line between two test cases.         printf("\n");       }        scanf("%s%s", num1, num2);        int len1 = strlen(num1); // 计算两个输入数的位数        int len2 = strlen(num2);        int long1 = len1-1, long2 = len2-1; // 对应的下标         add=0; //加       if( len1 >= len2 ){         k = long2;         for(; k>=0; k--){           sum2[k] = (num1[long1]-'0') + (num2[long2]-'0')+add;           if(sum2[k]>=10){             sum2[k] -= 10;             add = ((num1[long1]-'0' )+ (num2[long2]-'0')+add)/10;           }            else{             add = 0; //加           }           long1--;           long2--;         }         k = len1-len2-1;         for(; k>=0; k--){           sum1[k] = (num1[k]-'0')+add;           if(sum1[k]>=10 && k>0){             sum1[k] -= 10;             add = ((num1[k]-'0')+add)/10;           }            else{             add = 0;           }         }       }       else{         k = long1;         for(; k>=0; k--){           sum2[k] = (num1[long1]-'0') + (num2[long2]-'0')+add;           if(sum2[k]>=10){             sum2[k] -= 10;             add = ((num1[long1]-'0' )+ (num2[long2]-'0')+add)/10;           }            else{             add = 0; //加           }           long1--;           long2--;         }         k = len2-len1-1;         for(; k>=0; k--){           sum1[k] = (num2[k]-'0')+add;           if(sum1[k]>=10 && k>0){             sum1[k] -= 10;             add = ((num2[k]-'0')+add)/10;           }            else{             add = 0;           }         }       }       int lenSum1 = rest(len1, len2);       int lenSum2 = common(len1, len2);       printf("Case %d:\n", i+1);       printf("%s + %s = ", num1, num2);       if (add) printf("%d", add); //加       k = 0;       for(; k<=lenSum1; k++){         printf("%d", sum1[k]);       }       k = 0;       for(; k<lenSum2; k++){         printf("%d", sum2[k]);       }       printf("\n");     }   //删 }   return 0; }


Question: C语言float数组的问题

引用 5 楼 paschen 的回复:这是语法规定，浮点字面值可以用十进制或科学计数法（指数用E或e）表示，默认为double，在数值后加F或f表示单精度，加L或l表示扩展精度  了解了，谢谢

不是因为超范围。而只是单纯的因为你用 double 来初始化 float 。  在每个常量后面加一个 f 吧。 4.6f 2.6f 5.2f ...

引用 3 楼 user-3 的回复:[quote=引用 2 楼 paschen 的回复:] 2.2这种常量本身就是double类型，float类型需要在后面加f，写成2.2f 2.2为啥是double型而不是float？有点糊涂了。。。。。。[/quote]  这是语法规定，浮点字面值可以用十进制或科学计数法（指数用E或e）表示，默认为double，在数值后加F或f表示单精度，加L或l表示扩展精度

引用 3 楼 user-3 的回复:[quote=引用 2 楼 paschen 的回复:] 2.2这种常量本身就是double类型，float类型需要在后面加f，写成2.2f 2.2为啥是double型而不是float？有点糊涂了。。。。。。[/quote]  http://en.cppreference.com/w/c/language/floating_constant

引用 2 楼 paschen 的回复:2.2这种常量本身就是double类型，float类型需要在后面加f，写成2.2f 2.2为啥是double型而不是float？有点糊涂了。。。。。。


Question: acm大一新手初尝试..两道题目如下,大神快到碗里来orz

不是很了解ACM的规则-_- 第一个用位运算，或者遍历字符串试试 第二个可以做字符串循环判断吧，可能写的麻烦点


Question: 新手求解一道题

bool isDividedBy3(int x) {         return x%3 == 0?true:false; }  用三目吧，简洁又高效

引用 10 楼 xiexiaohuahua 的回复:[quote=引用 7 楼 zhangxiangDavaid 的回复:]  int x(int s) {     if(s%3==0)         printf("能被3整除");     else         printf("不能被3整除"); }  为什么要是int x(int s),不能直接int s呢？[/quote] 前者是函数，后者是变量

引用 7 楼 zhangxiangDavaid 的回复: int x(int s) {     if(s%3==0)         printf("能被3整除");     else         printf("不能被3整除"); }  为什么要是int x(int s),不能直接int s呢？

引用 8 楼 zhangxiangDavaid 的回复:void x(int s); 谢了

引用 5 楼 L799826351 的回复:[quote=引用 4 楼 zhangxiangDavaid 的回复:]  int x(int s) { if(s%3==0) s=1; else s=0; return s;  那如果我想把最后输出的该为 中文 怎么改，能被3整除，不能被3整除 我希望能输出这个[/quote]  int x(int s) {     if(s%3==0)         s=1;     else         s=0;     return s;

void x(int s);

引用 4 楼 zhangxiangDavaid 的回复: int x(int s) { if(s%3==0) s=1; else s=0; return s;  那如果我想把最后输出的该为 中文 怎么改，能被3整除，不能被3整除 我希望能输出这个

#include<iostream> using namespace std; int x(int); int main() { 	int a; 	cout<<"请输入一个数："; 	cin>>a; 	cout<<""<<a<<"="<<x(a)<<endl; 	return 0; } int x(int) { 	int s; 	if(s%3==0) 		s=1; 	else 		s=0; 	return s; } 你那个我看不懂，我是大一刚学C++的，这是我写的 这个输出结果都是=0，我想把下面的S=1换成能被3整除，S=0换成不能被3整除，不知道怎么换，求教 ，希望你明白我的意思。

#include <iostream>  using namespace std;  bool isDividedBy3(int x) {         if(x%3 == 0)                 return true;         return false; }  int main() {         int a;         while(cin>>a) {                 if( isDividedBy3(a) )                         cout << a << " is divided by 3." << endl;                 else                         cout << a << " is not divided by 3." << endl;         } }

用C++做，谢谢各位大大


Question: Visual studio 2015 异常中断问题

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

scanf_s 这里的问题  如果你希望用户输入 日月年的中间是用 \\ 分隔，那么你需要写成"%d\\\\%d\\\\%d" 否则输入时需要输入成这样：  01\01\2015


Question: vs2010输入源代码不提示参数

会有啊，另外如果觉得本身的功能不够强大，可以安装个VA插件

引用 4 楼 csdnxinshou2 的回复:[quote=引用 3 楼 user-1 的回复:] [quote=引用 2 楼 csdnxinshou2 的回复:] [quote=引用 1 楼 user-1 的回复:] 会有啊，另外如果觉得本身的功能不够强大，可以安装个VA插件 我输入 #include <Windows.h> VS提示的。 后面函数就没提示什么情况?[/quote]  printf是可变参数的函数，所以可能有点不同，你在其他函数时，输入括号或逗号，会提示下一个参数（用粗体显示）[/quote] 其他也没有提示。什么情况?[/quote]  那不知道了，那你安装visual assist x插件吧，这个插件功能很强大，可以高效率的写代码

引用 3 楼 user-1 的回复:[quote=引用 2 楼 csdnxinshou2 的回复:] [quote=引用 1 楼 user-1 的回复:] 会有啊，另外如果觉得本身的功能不够强大，可以安装个VA插件 我输入 #include <Windows.h> VS提示的。 后面函数就没提示什么情况?[/quote]  printf是可变参数的函数，所以可能有点不同，你在其他函数时，输入括号或逗号，会提示下一个参数（用粗体显示）[/quote] 其他也没有提示。什么情况?

引用 2 楼 csdnxinshou2 的回复:[quote=引用 1 楼 user-1 的回复:] 会有啊，另外如果觉得本身的功能不够强大，可以安装个VA插件 我输入 #include <Windows.h> VS提示的。 后面函数就没提示什么情况?[/quote]  printf是可变参数的函数，所以可能有点不同，你在其他函数时，输入括号或逗号，会提示下一个参数（用粗体显示）

引用 1 楼 user-1 的回复:会有啊，另外如果觉得本身的功能不够强大，可以安装个VA插件 我输入 #include <Windows.h> VS提示的。 后面函数就没提示什么情况?


Question: 鞍点代码问题

a[i][j]<=a[t][j]

if(a[i][j]>=a[i][t])   //同行最大 { f++; } if(a[i][j]<=a[j][t]) //同列最小??     //改为if(a[i][j]<=a[t][j]) { f++; }


Question: 这断代码貌似凡是涉及到判断链表非空的时候，就不会执行，请各位帮忙看看

引用 3 楼 zxhuser-1 的回复:建议下参考一下输入输出和链表的创建 https://github.com/user-1/Senior-middle-school/blob/master/Filling%20in%20the%20gaps.c 谢谢 问题已经解决了

引用 1 楼 zxhuser-1 的回复:别说执行了，编译都出错 我用VC编译的没有问题的，运行就有问题了

别说执行了，编译都出错


Question: 求助！！初学者,使用malloc出现的问题，帮我看看这个是什么原因，怎么修改？谢谢啊

你在Ini_c中分配的内存是分配到了该函数内的局部变量fia_0指针中，而不是全局变量的那个fia_0  应该要写成：fia_0 = (double ***)malloc((XCell+1)*sizeof(double**)); 吧，前面去年double***