Question: 停车场的一段代码，感觉是队列的插入问题，大神们来看看呀

引用 17 楼 Sniper_Pan的回复:大佬不敢当，调过了就好。 未初始化变量调试起来确实比较头疼，所以Effective系列都推荐 使用前定义，定义伴随初始化 我都有声明的时候初始化的习惯的，只是这里赋的是枚举值所以就没初始化嘿嘿嘿

引用 12 楼 u010808402 的回复:呃，使用1000降低sleep值后重现到，你可以搜下VS数据断点的打法。另外，调试过程中，发现有个除0错误。    代码较多，有时间再看吧  对了 你这根源应该是在empty[8]值变为-1，具体调试时由于rand可能位置不一样，需要重点查看什么地方修改了导致整个内存被修改。

大数据是指多大？有无其他重现条件？最好提供下具体数值

之前才看过停车场的代码，现在又来一个

#include<stdio.h> #include<Windows.h> #include<stdlib.h> #include<conio.h> #include<time.h>  enum operation{ 	enter = 1, 	inspot, 	leave };//车的状态，1为进入，2为在停车位中，3为离开  #define OK 0 #define ERROR 1 #define OVERFLOW -2 #define TRUE 1 #define FALSE 0  typedef int Status; typedef int ElemType;  typedef struct Car{ 	ElemType number; 	clock_t entertime; 	clock_t leavetime; 	ElemType spotnum; 	Car * next; } *Queueptr; typedef struct LinkedQueue{ 	Queueptr rear; 	Queueptr front; }LinkedQueue; typedef struct SqList{ 	ElemType *number; }SqList; //外部变量 SqList List; ElemType inspotcar; ElemType waitingcar; char output[12][2] = { 0 }; char empty[12] = { 0 }; int pos_i = 13;  Status InitList(SqList &List); Status EnQueue(LinkedQueue &queue); Status DeQueue(LinkedQueue &queue); Status Enter(LinkedQueue &queue, LinkedQueue &linkedqueue_leave); Status EnterQueue(LinkedQueue &queue); ElemType Findusefulspot(void); Status Leave(LinkedQueue &queue); Status Checkempty(ElemType number); Status Check(ElemType number); Status InitQueue(LinkedQueue &queue); Status InputInformation(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave); Status Screen(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave); Status Print(LinkedQueue &linkedqueue_leave); Status EnterOrLeave(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave); Status Information(LinkedQueue &linkedqueue); Status Enterlie(LinkedQueue &queue); Status Operter(ElemType num, LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave); Status Read(void); Status EXIT(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave, SqList &List); Status Pict(void); int main(void) { 	LinkedQueue linkedqueue; 	LinkedQueue linkedqueue_leave; 	srand((unsigned)time(NULL)); 	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); 	COORD pos = { 32, 11 }; 	SetConsoleTitle(TEXT("停车场管理")); 	SetConsoleCursorPosition(hOut, pos); 	printf("停车场管理\n"); 	pos.X = 40; 	pos.Y = 20; 	SetConsoleCursorPosition(hOut, pos); 	printf("姓名：杨锐彬\n"); 	pos.Y = 21; 	SetConsoleCursorPosition(hOut, pos); 	printf("学号：2015051599\n"); 	Sleep(3000); 	Read(); 	InitList(List); 	InitQueue(linkedqueue); 	InitQueue(linkedqueue_leave); 	InputInformation(linkedqueue, linkedqueue_leave); 	EXIT(linkedqueue, linkedqueue_leave, List); 	system("pause"); 	return 0; } Status EXIT(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave, SqList &List) { 	free(List.number); 	List.number = NULL; 	linkedqueue.front = linkedqueue.rear = NULL; 	linkedqueue_leave.front = linkedqueue.rear = NULL;  	return OK; } Status Read(void) { 	Pict(); 	printf("停车场说明：\n1、停车场总共有12个车位，当进入车位被挡住时将继续等待，比如4，5，6号车位都有车则无法进入1，2，3号车位\n2、车辆停放时间用的是系统时间（clock()函数取的系统时间），所以停放时间都比较小\n"); 	Sleep(6000); 	return OK; } Status InitList(SqList &List) { 	List.number = (ElemType*)malloc(sizeof(ElemType)* 12); 	return OK; } Status InitQueue(LinkedQueue &queue) { 	queue.rear = (Queueptr)malloc(sizeof(Car)); 	queue.front = queue.rear; 	if (!queue.front){ 		exit(OVERFLOW); 	} 	queue.front->next = NULL; 	return OK; } Status InputInformation(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave) { 	system("cls"); 	printf("共有多少车辆在排队中:"); 	fflush(stdout); 	rewind(stdin); 	scanf("%d", &waitingcar); 	EnterQueue(linkedqueue); 	Screen(linkedqueue, linkedqueue_leave); 	return OK; } Status Screen(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave) { 	system("cls"); 	srand((unsigned)time(NULL)); 	inspotcar = (rand() % 12) + 1; 	printf("停车场中已有%d辆车\n", inspotcar); 	Information(linkedqueue_leave); 	ElemType num = waitingcar; 	for (; waitingcar != 0 || inspotcar != 0;){ 		Pict(); 		Print(linkedqueue_leave); 		Sleep(2000); 		EnterOrLeave(linkedqueue, linkedqueue_leave);  	} 	system("cls"); 	Pict(); 	Print(linkedqueue_leave); 	system("pause"); 	return OK; } Status Pict(void) { 	system("cls"); 	printf("          *************************          \n"); 	printf("          *   1       2       3   *          \n"); 	printf("          *                       *          \n"); 	printf("          *   4       5       6   *          \n"); 	printf("***********                       ***********\n"); 	printf("                                             \n"); 	printf("                                             \n"); 	printf("***********                       ***********\n"); 	printf("          *   7       8       9   *          \n"); 	printf("          *                       *          \n"); 	printf("          *   10      11      12  *          \n"); 	printf("          *************************          \n"); 	return OK; } Status Print(LinkedQueue &linkedqueue_leave) { 	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); 	COORD pos; 	pos.X = 0; pos.Y = 13; 	SetConsoleCursorPosition(hOut, pos); 	printf("正有%d辆车在排队", waitingcar); 	fflush(stdout); 	pos.Y = 14; 	SetConsoleCursorPosition(hOut, pos); 	printf("正有%d辆车在车场中", inspotcar); 	fflush(stdout); 	pos.Y = 15; 	SetConsoleCursorPosition(hOut, pos); 	for (int i = 0; i < 12; i++){ 		printf("%d号车位有：", i + 1); 		fflush(stdout); 		if (output[i][1] == 0){ 			printf(" \n"); 		} 		else{ 			printf("粤A%d\n", List.number[i]); 		}  	} 	return OK; } Status Information(LinkedQueue &linkedqueue_leave) { 	for (int i = 0; i < inspotcar; i++){ 		Enterlie(linkedqueue_leave); 	} 	return OK; } Status Enterlie(LinkedQueue &linkedqueue_leave) { 	Queueptr point = (Queueptr)malloc(sizeof(Car)); 	if (!point){ 		exit(OVERFLOW); 	} 	point->entertime = clock(); 	point->number = (rand() % 9999) + 1; 	//分配车位 	ElemType num; 	while (1){ 		num = rand() % 12; 		if (Check(num) == OK){ 			output[num][0] = num + 1; 			output[num][1] = 1; 			point->spotnum = num; 			List.number[num] = point->number; 			break; 		} 	} 	linkedqueue_leave.rear->next = point; 	linkedqueue_leave.rear = point; 	return OK; } Status Check(ElemType number) { 	if (output[number][1] == 0){ 		return OK; 	} 	else{ 		return ERROR; 	} } Status EnterOrLeave(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave) { 	if (waitingcar == 0){ 		Operter(leave, linkedqueue, linkedqueue_leave); 		return OK; 	} 	if (inspotcar == 0){ 		Operter(enter, linkedqueue, linkedqueue_leave); 	} 	else{ 		ElemType num; 		if ((rand() % 2) == 0){ 			num = leave; 		} 		else{ 			num = enter; 		} 		Operter(num, linkedqueue, linkedqueue_leave); 		return OK; 	} } Status Operter(ElemType num, LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave) { 	if (num == enter){ 		Enter(linkedqueue, linkedqueue_leave); 	} 	else{ 		Leave(linkedqueue_leave); 	} 	return OK; } Status Enter(LinkedQueue &queue, LinkedQueue &linkedqueue_leave) { 	ElemType num = Findusefulspot(); 	if (num == 0){ 		return OK; 	} 	ElemType spot = rand() % num; 	DeQueue(queue); 	EnQueue(linkedqueue_leave); 	linkedqueue_leave.front->entertime = clock(); 	linkedqueue_leave.front->spotnum = empty[spot] + 1; 	linkedqueue_leave.front->number = rand() % 9999; 	output[empty[spot]][1] = 1; 	List.number[empty[spot]] = linkedqueue_leave.front->number; 	inspotcar += 1; 	waitingcar -= 1; 	return OK; } Status DeQueue(LinkedQueue &queue) { 	Queueptr point = queue.front; 	if (!point){ 		exit(OVERFLOW); 	} 	queue.front = queue.front->next; 	free(point); 	return OK; } Status EnQueue(LinkedQueue &queue) { 	Queueptr point = (Queueptr)malloc(sizeof(Car)); 	if (!point){ 		exit(OVERFLOW); 	} 	queue.rear->next = point; 	queue.rear = point;  	return OK; }

贴上改好的代码嘿嘿嘿

引用 13 楼 u010808402 的回复:[quote=引用 12 楼 u010808402 的回复:] 呃，使用1000降低sleep值后重现到，你可以搜下VS数据断点的打法。另外，调试过程中，发现有个除0错误。    代码较多，有时间再看吧  对了 你这根源应该是在empty[8]值变为-1，具体调试时由于rand可能位置不一样，需要重点查看什么地方修改了导致整个内存被修改。[/quote]嘿嘿谢谢大佬的调试，不过empty[8]的值是正确的，那是为了判断是否可行所故意设置的，然后VS我在可能出错的地方都打了断点，用2000的数据测试的，其实昨天下午就测试完成了，问题主要是赋值上，Operer()里面对num的赋值不正确，因为局部变量出来后就没了所以用的是未初始化的值，所以导致了错误，代码我已经改好啦，也用10000测试过没问题的～除0错误主要是因为判断出来的num = 0，这里在前面加一个等于0的情况跳转到某一特殊函数就可以了～谢谢大佬啦

引用 3 楼 paschen的回复:问题不是去看出来的，是调试出来的，出错时点中断，通过调用堆栈、变量窗口观察分析原因  帮你调试时，printf("粤A%d\n", linkedqueue_leave.front->next->number); 这句中linkedqueue_leave.front->next还没有初始化已经使用了，导致出错 对呀对呀我也是这样一步一步过来的，可是我都赋值了呀，不应该不存在未初始化的问题呀

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

Status Checkempty(ElemType number) { 	for (int i = 0; i <= number; i++){ 		if (empty[i] == 0){ 			if ((output[1][1] == 1) && (output[3][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[3][1] == 1) && (output[4][1] == 1) && (output[5][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[4][1] == 1) && (output[3][1] == 1) && (output[2][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[1][1] == 1) && (output[3][1] == 1) && (output[4][1] == 1)){ 				empty[i] = -1; 			} 		} 		if (empty[i] == 1){ 			if ((output[3][1] == 1) && (output[4][1] == 1) && (output[5][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[4][1] == 1) && (output[3][1] == 1) && (output[2][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[0][1] == 1) && (output[4][1] == 1) && (output[5][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[0][1] == 1) && (output[2][1] == 1) && (output[4][1] == 1)){ 				empty[i] = -1; 			} 		} 		if (empty[i] == 2){ 			if ((output[3][1] == 1) && (output[4][1] == 1) && (output[5][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[1][1] == 1) && (output[5][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[0][1] == 1) && (output[4][1] == 1) && (output[5][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[1][1] == 1) && (output[4][1] == 1) && (output[5][1] == 1)){ 				empty[i] = -1; 			} 		} 		if (empty[i] == 9){ 			if ((output[6][1] == 1) && (output[10][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[6][1] == 1) && (output[7][1] == 1) && (output[8][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[6][1] == 1) && (output[7][1] == 1) && (output[11][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[6][1] == 1) && (output[7][1] == 1) && (output[10][1] == 1)){ 				empty[i] = -1; 			} 		} 		if (empty[i] == 10){ 			if ((output[6][1] == 1) && (output[7][1] == 1) && (output[8][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[6][1] == 1) && (output[7][1] == 1) && (output[11][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[7][1] == 1) && (output[8][1] == 1) && (output[9][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[7][1] == 1) && (output[9][1] == 1) && (output[11][1] == 1)){ 				empty[i] = -1; 			} 		} 		if (empty[i] == 11){ 			if ((output[6][1] == 1) && (output[7][1] == 1) && (output[8][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[7][1] == 1) && (output[8][1] == 1) && (output[10][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[7][1] == 1) && (output[8][1] == 1) && (output[9][1] == 1)){ 				empty[i] = -1; 			} 			if ((output[8][1] == 1) && (output[10][1] == 1)){ 				empty[i] = -1; 			} 		} 	} 	return OK; } Status Leave(LinkedQueue &queue) { 	ElemType em[12]; 	ElemType j = 0; 	for (int i = 0; i < 12; i++){ 		if (output[i][1] == 1){ 			em[j] = i; 			j += 1; 		} 	} 	ElemType num = rand() % j; 	output[em[num]][1] = 0; 	inspotcar -= 1;  	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); 	COORD pos = { 0, 27 }; 	SetConsoleCursorPosition(hOut, pos); 	printf("车牌为粤A%d的车出停车场，总停时间为：%.3lf秒", List.number[em[num]], ((double)(((queue.front->leavetime) - (queue.front->leavetime)) / CLOCKS_PER_SEC))); 	fflush(stdout); 	DeQueue(queue); 	Sleep(1000); 	return OK; }

#include<stdio.h> #include<Windows.h> #include<stdlib.h> #include<conio.h> #include<time.h>  enum operation{ 	enter = 1, 	inspot, 	leave };//车的状态，1为进入，2为在停车位中，3为离开  #define OK 0 #define ERROR 1 #define OVERFLOW -2 #define TRUE 1 #define FALSE 0  typedef int Status; typedef int ElemType;  typedef struct Car{ 	ElemType number = 0; 	clock_t entertime; 	clock_t leavetime; 	ElemType spotnum; 	Car * next; } *Queueptr; typedef struct LinkedQueue{ 	Queueptr rear; 	Queueptr front; 	int length = 0; }LinkedQueue; typedef struct SqList{ 	ElemType *number; }; //外部变量 SqList List; ElemType inspotcar; ElemType waitingcar; char output[12][2] = { 0 }; char empty[12] = { 0 }; int pos_i = 13;  Status InitList(SqList &List); Status EnQueue(LinkedQueue &queue); Status DeQueue(LinkedQueue &queue); Status Enter(LinkedQueue &queue,LinkedQueue &linkedqueue_leave); Status EnterQueue(LinkedQueue &queue); ElemType Findusefulspot(void); Status Leave(LinkedQueue &queue); Status Checkempty(ElemType number); Status Check(ElemType number); Status InitQueue(LinkedQueue &queue); Status InputInformation(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave); Status Screen(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave); Status Print(LinkedQueue &linkedqueue_leave); Status EnterOrLeave(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave); Status Information(LinkedQueue &linkedqueue); Status Enterlie(LinkedQueue &queue); Status Operter(ElemType num, LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave); Status Read(void); Status EXIT(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave, SqList &List); int main(void) { 	LinkedQueue linkedqueue; 	LinkedQueue linkedqueue_leave; 	srand((unsigned)time(NULL)); 	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); 	COORD pos = { 32, 11 }; 	SetConsoleTitle(TEXT("停车场管理")); 	SetConsoleCursorPosition(hOut, pos); 	printf("停车场管理\n"); 	Sleep(1000); 	Read(); 	InitList(List); 	InitQueue(linkedqueue); 	InitQueue(linkedqueue_leave); 	InputInformation(linkedqueue, linkedqueue_leave); 	EXIT(linkedqueue,linkedqueue_leave,List); 	system("pause"); 	return 0; } Status EXIT(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave, SqList &List) { 	return OK; } Status Read(void) { 	system("cls"); 	printf("          *************************          \n"); 	printf("          *   1       2       3   *          \n"); 	printf("          *                       *          \n"); 	printf("          *   4       5       6   *          \n"); 	printf("***********                       ***********\n"); 	printf("                                             \n"); 	printf("                                             \n"); 	printf("***********                       ***********\n"); 	printf("          *   7       8       9   *          \n"); 	printf("          *                       *          \n"); 	printf("          *   10      11      12  *          \n"); 	printf("          *************************          \n"); 	printf("停车场说明：\n停车场总共有12个车位，当进入车位被挡住时将继续等待，比如4，5，6号车位都有车则无法进入1，2，3号车位\n"); 	Sleep(3000); 	return OK; } Status InitList(SqList &List) { 	List.number = (ElemType*)malloc(sizeof(ElemType)* 12); 	return OK; } Status InitQueue(LinkedQueue &queue) { 	queue.rear= (Queueptr)malloc(sizeof(Car)); 	queue.front = queue.rear; 	if (!queue.front){ 		exit(OVERFLOW); 	} 	queue.front->next = NULL; 	return OK; } Status InputInformation(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave) { 	system("cls"); 	printf("共有多少车辆在排队中:"); 	fflush(stdout); 	rewind(stdin); 	scanf_s("%d", &waitingcar); 	EnterQueue(linkedqueue); 	Screen(linkedqueue, linkedqueue_leave); 	return OK; } Status Screen(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave) { 	system("cls"); 	srand((unsigned)time(NULL)); 	inspotcar = (rand() % 12) + 1; 	printf("停车场中已有%d辆车\n", inspotcar); 	Information(linkedqueue_leave); 	ElemType num = waitingcar; 	for (int i = 0; i <num ||(inspotcar>0); i++){ 		system("cls"); 		printf("          *************************          \n"); 		printf("          *   1       2       3   *          \n"); 		printf("          *                       *          \n"); 		printf("          *   4       5       6   *          \n"); 		printf("***********                       ***********\n"); 		printf("                                             \n"); 		printf("                                             \n"); 		printf("***********                       ***********\n"); 		printf("          *   7       8       9   *          \n"); 		printf("          *                       *          \n"); 		printf("          *   10      11      12  *          \n"); 		printf("          *************************          \n"); 		Print(linkedqueue_leave); 		Sleep(2000); 		EnterOrLeave(linkedqueue, linkedqueue_leave); 		 	} 	system("cls"); 	Print(linkedqueue_leave); 	system("pause"); 	return OK; } Status Print(LinkedQueue &linkedqueue_leave) { 	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); 	COORD pos; 	pos = { 0, 13 }; 	SetConsoleCursorPosition(hOut, pos); 	printf("正有%d辆车在排队", waitingcar); 	fflush(stdout); 	pos = { 0, 14 }; 	SetConsoleCursorPosition(hOut, pos); 	printf("正有%d辆车在车场中", inspotcar); 	fflush(stdout); 	pos = { 0, 15 }; 	SetConsoleCursorPosition(hOut, pos); 	for (int i = 0; i < 12; i++){ 		printf("%d号车位有：", i + 1); 		fflush(stdout); 		if (output[i][1] == 0){ 			printf(" \n"); 		} 		else{ 			printf("粤A%d\n",List.number[i]); 		} 		 	} 	return OK; } Status Information(LinkedQueue &linkedqueue_leave) { 	for (int i = 0; i < inspotcar; i++){ 		Enterlie(linkedqueue_leave); 	} 	return OK; } Status Enterlie(LinkedQueue &linkedqueue_leave) { 	Queueptr point = (Queueptr)malloc(sizeof(Car)); 	if (!point){ 		exit(OVERFLOW); 	} 	point->entertime = clock(); 	point->number = (rand() % 9999) + 1; 	//分配车位 	ElemType num; 	while (1){ 		num = rand() % 12; 		if (Check(num) == OK){ 			output[num][0] = num + 1; 			output[num][1] = 1; 			point->spotnum = num; 			List.number[num] = point->number; 			break; 		} 	} 	linkedqueue_leave.rear->next = point; 	linkedqueue_leave.rear = point; 	return OK; } Status Check(ElemType number) { 	if (output[number][1] == 0){ 		return OK; 	} 	else{ 		return ERROR; 	} } Status EnterOrLeave(LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave) { 	ElemType num; 	if (waitingcar == 0){ 		num = leave; 	} 	if (inspotcar == 0){ 		num = enter; 	} 	else{ 		if ((rand() % 2) == 0){ 			num = leave; 		} 		else{ 			num = enter; 		} 	} 	Operter(num, linkedqueue, linkedqueue_leave); 	return OK; } Status Operter(ElemType num, LinkedQueue &linkedqueue, LinkedQueue &linkedqueue_leave) { 	if (num == enter){ 		Enter(linkedqueue,linkedqueue_leave); 	} 	else{ 		Leave(linkedqueue_leave); 	} 	return OK; } Status Enter(LinkedQueue &queue,LinkedQueue &linkedqueue_leave) { 	ElemType num = Findusefulspot(); 	if (num == 0){ 		return OK; 	} 	ElemType spot = (rand() % (num + 1)); 	DeQueue(queue); 	EnQueue(linkedqueue_leave); 	linkedqueue_leave.front->entertime = clock(); 	linkedqueue_leave.front->spotnum = empty[spot] + 1; 	linkedqueue_leave.front->number = rand() % 9999; 	output[empty[spot]][1] = 1; 	List.number[empty[spot]] = linkedqueue_leave.front->number; 	inspotcar += 1; 	waitingcar -= 1; 	return OK; } Status DeQueue(LinkedQueue &queue) { 	Queueptr point = queue.front; 	if (!point){ 		exit(OVERFLOW); 	} 	queue.front = queue.front->next; 	free(point); 	return OK; } Status EnQueue(LinkedQueue &queue) { 	Queueptr point = (Queueptr)malloc(sizeof(Car)); 	if (!point){ 		exit(OVERFLOW); 	} 	queue.rear->next = point; 	queue.rear = point;  	return OK; } Status EnterQueue(LinkedQueue &linkedqueue) { 	for (int i = 0; i < waitingcar; i++){ 		EnQueue(linkedqueue); 	} 	return OK; } ElemType Findusefulspot(void) { 	if (inspotcar == 12){ 		return 0; 	} 	int j = 0; 	for (int i = 0; i < 12; i++){ 		if (output[i][1] == 0){ 			empty[j] = i; 			j += 1; 		} 	} 	Checkempty(j); 	ElemType em[13]; 	ElemType k = 0; 	for (int i = 0; i < j; i++){ 		if (empty[i] == -1){ 			; 		} 		else{ 			em[k] = empty[i]; 			k += 1; 		} 	} 	for (int i = 0; i < k; i++){ 		empty[i] = em[i]; 	} 	return k; }  }

引用 6 楼 qq423399099 的回复:出现错误是：0xC0000005:  读取位置 0xCDCDCDDD 时发生访问冲突。 这是对未初始化过的堆上申请的变量进行了操作。 printf("粤A%d\n", linkedqueue_leave.front->next->number);你这句的linkedqueue_leave.front->next并没有对其赋过值嘿嘿这个我解决啦，明白啦～不过还有一个新的问题，我把新的代码放在下一楼，这段代码会在大数据测试的时候，外部变量waitingcar突然一次性增大16的6次方，这个我断点找了好久还是没找出来原因。


Question: 为人不识C指针，看遍A片也枉然，菜鸟求助

int* y;这样的写法并不是指针数组，只是一个普通的一位指针而已 int *y[5];这样的形式才是指针数组

引用 6 楼 msw120 的回复:[quote=引用 4 楼 paschen 的回复:] y = (int*)malloc(sizeof(int) * 5);  这里的y不是数组，只是一个指针，但可以按数组方式访问  y[i] = *(y+i)  感谢大侠的回复，但是我还是没有弄懂，为什么 y[i]既可以赋值(y[i] = i)又可以赋地址(y[i] = &i)，我现在看的数据结构里面顺序表的插入操作是这样的  int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) // O(n)  {     TSeqList* sList = (TSeqList*)list;     int ret = (sList != NULL);     int i = 0;          ret = ret && (sList->length + 1 <= sList->capacity);     ret = ret && (0 <= pos);          if( ret )     {         if( pos >= sList->length )         {             pos = sList->length;         }                  for(i=sList->length; i>pos; i--)         {             sList->node[i] = sList->node[i-1];         }                  sList->node[i] = (TSeqListNode)node;        关键的这句用的指针赋值，在main函数里面的调用是SeqList_Insert(list, &i, 0);          sList->length++;     }          return ret; }  [/quote]  y[i] = &i; 得到的i的地址转换成的int值，在C++里不允许这样的隐式转换

这些东西最好不要想得太复杂。。。。。。

//现在就是搞不清这个指针什么时候用*，什么时候不用*了  需要注意的是这个* 在定义时和使用时是含义不同的 定义时的* 表示这是一个指针，比如  int *p;  就表示定义了一个指向整形变量的指针，使用的时候p就表示这个指针，如果在使用中出现了*，就表示取这个指针所指向的值 例如*p就表示一个值

理解和讨论之前请先学会如何观察！  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  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

引用 4 楼 paschen 的回复:y = (int*)malloc(sizeof(int) * 5);  这里的y不是数组，只是一个指针，但可以按数组方式访问  y[i] = *(y+i)  感谢大侠的回复，但是我还是没有弄懂，为什么 y[i]既可以赋值(y[i] = i)又可以赋地址(y[i] = &i)，我现在看的数据结构里面顺序表的插入操作是这样的  int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) // O(n)  {     TSeqList* sList = (TSeqList*)list;     int ret = (sList != NULL);     int i = 0;          ret = ret && (sList->length + 1 <= sList->capacity);     ret = ret && (0 <= pos);          if( ret )     {         if( pos >= sList->length )         {             pos = sList->length;         }                  for(i=sList->length; i>pos; i--)         {             sList->node[i] = sList->node[i-1];         }                  sList->node[i] = (TSeqListNode)node;        关键的这句用的指针赋值，在main函数里面的调用是SeqList_Insert(list, &i, 0);          sList->length++;     }          return ret; }

仅供参考： 《深入理解C指针》

int i;     int* y;     y = (int*)malloc(sizeof(int) * 5);     for(i=0;i<5;i++)     {         y[i] = i;         printf("%d\n",y[i]);     } 1、首先，y是一个指向整形数据的指针，如果有一个int型变量 int_data存储着一个整形数据，你可以通过y = &int_data来使y指向变量int_data的地址，此时y是一个地址，你要想查看这个地址上的值，就得通过*y的形式。 2、y = (int*)malloc(sizeof(int) * 5);这句话的可以理解为你申请了一块内存，该内存的大小正好可以保存5个整形数据，并且y指向了该内存的首地址。这5个整形数据对应的内存地址分别是y, y+1, y+2, y+3, y+4，他们也就是对应着&y[0], &y[1], &y[2], &y[3], &y[4]。 先说这些吧，不知你能理解嘛……


Question: 用c写出一个运动的小车，并用中断控制速度。

仅供参考：/***NOTE:     This is an interrupt service routine.  You can NOT compile this     program with Test Stack Overflow turned on and get an executable     file which will operate correctly. */  #include <stdio.h> #include <dos.h> #include <conio.h>  #define INTR 0X1C    /* The clock tick interrupt */  #ifdef __cplusplus     #define __CPPARGS ... #else     #define __CPPARGS #endif  void interrupt ( *oldhandler)(__CPPARGS);  int count=0;  void interrupt handler(__CPPARGS) { /* increase the global counter */    count++;  /* call the old routine */    oldhandler(); }  int main(void) { /* save the old interrupt vector */    oldhandler = getvect(INTR);  /* install the new interrupt handler */    setvect(INTR, handler);  /* loop until the counter exceeds 20 */    while (count < 20)       printf("count is %d\n",count);  /* reset the old interrupt handler */    setvect(INTR, oldhandler);     return 0; }


Question: 二，八，十，十六进制怎么运算啊？

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


Question: 用c语言编写一个小车运动的控制台应用程序

console屏幕处理例子程序。终端窗口屏幕处理相关API使用例子。来自MSVC20\SAMPLES\win32\console\ http://download.csdn.net/detail/zhao4zhong1/3461309

C++ Builder不规则图像透明贴图（位图的透明显示）三种方法及简单动画  http://blog.163.com/tab_98/blog/static/11924097201601510377824/  图形用户界面可以学习C++ Builder，入门比较容易。 仅供参考： 从C语言的菜单界面管理系统到C++ Builder的图形用户界面，一个简单的电话簿Demo例子 http://blog.163.com/tab_98/blog/static/1192409720158673337998/ 学C++还是C#、Java？ http://blog.163.com/tab_98/blog/static/11924097201511274543737/

你会写Java的话就不是很困难了。 把Windows.h引入，然后用这个函数SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), cd);这个函数你只需要管括号里cd这个参数，其他的不用管。cd是COORD类型的（好像是结构体类型），有两个成员变量x和y，也就是你控制台窗口的横坐标和纵坐标。按照你的思路不断改变这几个值就能在控制台下出现动态效果。


Question: 大神看看哪里出错了

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

printf("%d\n, b");   改成  printf("%d\n", b);

#include <stdio.h> #include <math.h> int main() {     int a,b,t; 	b=1; 	a=2; 	printf("请输入要求阶乘数的数:"); 	scanf("%d",&t); 	while(a<=t) 	{ 	     b=b*a; 		 a=a+1; 	} 	printf("阶乘结果为:%d\n",b); 	return 0; }

我这里使用递归调用，楼主可以看看这样的写法：  #include<stdio.h> #include<stdlib.h> int main() { 	int num; 	printf("请输入数字:\n"); 	scanf_s("%d", &num); 	printf("%d\n", fun(num)); 	system("pause"); 	return 0; }  int fun(int num) { 	if (num != 1) 	{ 		return num*fun(num - 1); 	} 	else if (num == 1) { 		return 1; 	} }   这里是一般的循环写法,这种写法和楼主的比较相似，可以拿去自己感受感受：  #include<stdio.h> #include<stdlib.h> int main() { 	int num; 	int result = 1; 	printf("请输入数字:\n"); 	scanf_s("%d", &num); 	while (num >= 1) { 		result = result * num; 		num--; 	} 	printf("%d\n", result); 	system("pause"); 	return 0; }

printf("%d\n", b);


Question: c如何作软件界面

CreateWindowEx、CreateDialog、DialogBox

貌似纯C语言跨平台的GUI库只有gtk

做界面还是 c++ 好一些， win32 api 都是c 接口的，C 语言可以直接用 SDK 来写界面的，mfc 那些只是对 api 的包装 tc的图形库是 DOS 时代的东西了，写的是 16 位程序 CPU 在 64 位模式下已经不再兼容 16 位程序了，就快被淘汰了

Quake3不是C做得界面？

c语言本身只是一种编程规则，本身不提供界面或者web之类的功能，不似java本身提供了界面的库。如果使用C编写界面就使用其它的库。如window 的sdk，linux的gtk等。

图形用户界面可以学习C++ Builder，入门比较容易。 仅供参考： 从C语言的菜单界面管理系统到C++ Builder的图形用户界面，一个简单的电话簿Demo例子 http://blog.163.com/tab_98/blog/static/1192409720158673337998/

可心使用WINDOWS SDK


Question: 请问如何用c语言制作数据库

这么多开源的数据库，为什么要自己制作一个，其中有很多问题需要考虑，数据量大会造成很多瓶颈

参考sqlite


Question: 如何运用单片机控制流水灯?

买块51开发版，现在一般都附带教程，照着做做，做多了就有感觉了。

有单片机培训的学习班。

买本书看，照着敲几个例子就有感觉了。


Question: 想建立一个函数，但是出现了Error，小白求解决

学习了，想得好累。。。。。。。。。

修改好了，还修改了些小问题，可以了，谢谢各路大神

引用 3 楼 paschen的回复:另外  printf("该方程在区间（-10，10）之间的根为:%d",y);break;  改成  printf("该方程在区间（-10，10）之间的根为:%f",y);break; 谢谢，确实是这些问题，程序还有其它问题，我重新修改下

引用 1 楼 BuBu高打火机的回复:问题挺多的，我一个一个来哈。 1、下面那个函数的定义，float fc(float y){}应该写在main函数之外。写在main函数下面即可 2、while条件语句中，调用fc时未给变量x值。（变量x只声明了，但是没有具体的值） 3、print函数中，%d应该改为%f（因为是浮点变量）。那个y根据你的意思应该是x吧。看看是不是写错了。 4、if语句之后应该带{}括号，因为你不光只有一句printf，还有一句break。两句以上就得用{}括起来。同理，下面的if也有同样的问题。  最后。。。你这个代码写的好乱。。。我觉得在这个基础上根本没法改。。。 谢谢大神，我当时以为自定函数要放在主函里。程序还有其它问题，输出不了根

fc函数要放在主函数外面，而不是里面   #include<stdio.h> #include<stdlib.h> float x,y,z,a,b,n,k,i,j,a1,b1; float fc(float y); int main() { 	printf("方程2*x^3-4*x^2+3x-6=0在区间（-10，10）之间的根为：\n"); 	a=-10,b=10,a1=fc(a),b1=fc(b); 	while(fc(x)!=0) 	{ 		n=(a+b)/2; 		z=fc(n); 		x=n; 		if(z==0) printf("该方程在区间（-10，10）之间的根为:%d",y);break; 		if(z*a1<0) b=n,b1=z; 		else z=n,a1=z; 	} 	return 0; }  float fc(float y) { 	y=2*y*y*y-4*y*y+3*y-6; 	return y; }


Question: dev c ++源文件未编译

刚刚我也是这个问题 找到正解了 按F11不行，F12就可以啦

刚刚我也是这个问题 找到正解了 把工具-编译选项-设定编译配置那里把TDM-GCC 4.9.2 64-bit Debug改成TDM-GCC 4.9.2 64-bit release就好了

print  改成 printf  之所以一直提示是因为你一直就没编译成功

print("\n总的输入字符数;%d",n); 这一行你的“printf”打错了。  根据你的情况，可能情况你并没有编译成功，无法运行

所谓的源文件未编译就是你程序中用到的某些函数无法在头文件中找到，在主程序中也没进行定义。


Question: 结构体赋值

Initializers Declarators can specify the initial value for objects. The only way to specify a value for objects of const type is in the declarator. The part of the declarator that specifies this initial value is called the “initializer.”  Syntax  initializer :  = assignment-expression = { initializer-list ,opt } ( expression-list )  initializer-list :  expression initializer-list , expression { initializer-list ,opt }  There are two fundamental types of initializers:   The initializer invoked using the equal-sign syntax   The initializer invoked using function-style syntax  Only objects of classes with constructors can be initialized with the function-style syntax. The two syntax forms also differ in access control and in the potential use of temporary objects. Consider the following code, which illustrates some declarators with initializers:  int      i = 7;                  // Uses equal-sign syntax. Customer Cust( "Taxpayer, Joe",  // Uses function-style                "14 Cherry Lane", //  syntax. Requires presence                "Manteca",        //  of a constructor.                "CA" );  Declarations of automatic, register, static, and external variables can contain initializers. However, declarations of external variables can contain initializers only if the variables are not declared as extern.  These initializers can contain expressions involving constants and variables in the current scope. The initializer expression is evaluated at the point the declaration is encountered in program flow, or, for global static objects and variables, at program startup. (For more information about initialization of global static objects, see Additional Startup Considerations in Chapter 2.)

引用 8楼paschen 的回复:引用 5 楼 loveqise的回复:[quote=引用 1楼赵4老师 的回复:]编译器不支持。这个是C99吗？ VS不支持C99标准  像C99中的VLA也是不支持的[/quote]我用三楼方法，｛｝里面为空报错，里面有参数才行，这是为什么

引用 3楼_zSir 的回复:如果是要初始化第二个元素，可以这样写：  #include <stdio.h> #include <string.h>  typedef struct lens {     float foclen;     float fstop;     char brand[30]; }LENS;  int main(void) {     LENS str1[10] = {         {},         {},         {500, 2, "Remarkatar"}     };      int i;     for(i = 0; i < 10; i++) {         printf("[%d] %.2f, %.2f, %s\n",                 i,                 str1[i].foclen,                 str1[i].fstop,                 str1[i].brand);     }      return 0; }  测试结果：  [0] 0.00, 0.00,  [1] 0.00, 0.00,  [2] 500.00, 2.00, Remarkatar [3] 0.00, 0.00,  [4] 0.00, 0.00,  [5] 0.00, 0.00,  [6] 0.00, 0.00,  [7] 0.00, 0.00,  [8] 0.00, 0.00,  [9] 0.00, 0.00, 我用vs，｛｝里面为空编译出错，里面

引用 5 楼 loveqise的回复:引用 1楼赵4老师 的回复:编译器不支持。这个是C99吗？ VS不支持C99标准  像C99中的VLA也是不支持的

引用 4楼AlbertS 的回复:没有这种写法，要是想初始化第3个元素，后面可以不写，前两个必须补全，参考一下3楼哦应该是C99吧

引用 2楼小灸舞 的回复:没有这种用法应该是C99吧

引用 1楼赵4老师 的回复:编译器不支持。这个是C99吗？

没有这种用法

编译器不支持。


参数个数太少了？

将你的int FmSend(int fd, char *send_buf,int data_len);改成（或封装）类似这种原型：void *FmSend(void *sndParam)，在调用pthead_ceate()。

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


Question: 菜鸟编码请教

引用 10 楼 qq_32722449的回复:scanf加个取地址符合 不好意思，看错了。。。。

scanf加个取地址符合

#pragma warning(disable:4996) //...

楼上正解，就是告诉你，这个函数不安全，新版本已经不用了，建议你使用较为安全的函数代替

引用 6 楼 qq_36356098 的回复:[quote=引用 5 楼 qq423399099 的回复:] 或者你贴一下你的错误。 莫非是让你用scanf_s? 严重性	代码	说明	项目	文件	行	禁止显示状态 错误	C4996	'scanf': This function or variable may be unsafe. Consider using scanf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.	牌面计算	d:\我的资料库\documents\visual studio 2015\projects\牌面计算\牌面计算\源.c	11	 [/quote]  因为scanf这个函数是不安全，可能造成缓冲区溢出，所以现在建议用scanf_s来代替 如果仍想用可以选择以下任何一种方法： 1、新建项目时不要勾选安全开发生命周期检查 2、在项目属性C/C++命令行中加上 /D _CRT_SECURE_NO_WARNINGS

引用 5 楼 qq423399099 的回复:或者你贴一下你的错误。 莫非是让你用scanf_s? 严重性	代码	说明	项目	文件	行	禁止显示状态 错误	C4996	'scanf': This function or variable may be unsafe. Consider using scanf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.	牌面计算	d:\我的资料库\documents\visual studio 2015\projects\牌面计算\牌面计算\源.c	11

或者你贴一下你的错误。 莫非是让你用scanf_s?

引用 3 楼 qq907482638 的回复:正常编译，而且初步输入输出都是对的 嗯 好的 谢谢指教 没错我就放心了 可能是使用软件不当 导致不对吧 因为之前用VS2015练习的时候都没问题 今天怎么试都出不来 还以为是我弄错了步骤

正常编译，而且初步输入输出都是对的

是这样的 我是一名初学者 我使用的是visula studio 2015这个软件 调试的时候弹框说发生生成错误 不明白怎么解决

可以正常编译，你指的错误是什么


Question: c语言求e值问题求解决

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

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

1.scanf("%d", n);改成scanf("%d", &n); 2.double i;改成double i = 0.0; 3.i = i + (1 / factorial(a));改成i = i + (1.0 / factorial(a));  #include<stdio.h> long factorial(long number); int main() { 	int n, a; 	double i = 0.0; 	printf("请输入一个近似项数(<=12)：\n"); 	scanf("%d", &n); 	for (a = 1; a <= n; a++) 	{ 		i = i + (1.0 / factorial(a)); 	} 	printf("e的近似值是：%f", i); 	return 0; } long factorial(long number) { 	if (number <= 1) 	{ 		return 1; 	} 	else 	{ 		return(number*factorial(number - 1)); 	} }

scanf("%d",n);  改成  scanf("%d",&n);


Question: 谁帮帮我！！c的二维数组问题！！谢谢！

printf("%d", p); 打印的是指针的值  改成   printf("%d", p[i]);  //这样才是输出指向元素的值

你打印的都是地址，如果打印值，得多加个*

书上也是这样讲的。。。二维数组的参数问题实在有点蒙啊！！

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


Question: 明明写了main函数 为什么还提示没有定义呢

大括号没对齐

有空运行下你的代码。。。。。

scaner 函数最后少好大括号  主函数中，ch=getchar;   改成 ch=getchar();

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

#include <stdio.h>                  /*定义I/O库所用的某些宏和变量*/ #include <string.h>                 /*定义字符串库函数*/ #include <conio.h>                 /*提供有关屏幕窗口操作函数*/ #include <ctype.h>                  /*分类函数*/ char prog[80] = { '\0' }, token[20];                     /*存放构成单词符号的字符串*/ char ch; int syn,                           /*存放单词字符的种别码*/ n, // sum,                           /*存放整数型单词*/ m, p;                           /*p是缓冲区prog的指针，m是token的指针*/ char  *key[10] = { "int", "char", "double", "for", "else", "if", "do", "while", "return" };  int IsKey(char *token){ 	for (int i = 0; i < 9; i++){ 		if (strcmp(token, key[i]) == 0) 			return 1; 	} 	return 0; }  void scaner(){ 	m = 0; 	//sum=0; 	for (n = 0; n < 8; n++) 		token[n] = '\0'; 	ch = prog[p++]; 	while (ch == ' ' || ch == '\t' || ch == '\n')//忽略空格 制表符 换行符  		ch = prog[p++]; 	/*ch为字母字符时*/ 	if (isalpha(ch)){ 		//token[m]=ch;  		while (isalpha(ch) || isdigit(ch)){    /*ch 为字母字符或者数字字符*/ 			token[m++] = ch; 			ch = prog[p++];    //获取下一个字符  		} 		token[m++] = '\0';    //'\0' 代表字符结束(空格) 		ch = prog[p--];       //回退字符  退还给输入串  		// syn=10;  		/*字符串的比较*/  		if (IsKey(token)) 			printf("%s\t$关键字\n\n", token);      //输出关键字	     		else 			printf("%s\t$普通标识符\n\n", token);//不是关键字 		//            if(strcmp(token,key[n])==0){ 		//                syn=n+1; 		//                break; 		//	} 	} 	//若开始判断的字符不是字母  判断是否是数字 	else{ 		if (isdigit(ch)){ 			while (isdigit(ch)){ 				token[m++] = ch; 				ch = prog[p++]; 			} 			token[m++] = '\0'; 			ch = prog[p--]; 			printf("%s\t$整数\n\n", token); 		} 		else{ 			switch (ch){ 			case'[': 			case']': 			case'(': 			case')': 			case'{': 			case'}': 			case',': 			case'"': 			case';': 				printf("%s\t$界符\n\n", token); break; 			case'+': 				ch = prog[p--]; 				token[1] = ch; 				if (ch == '=') 					printf("%s\t$运算符\n\n", token);//运算符"+="           				else if (ch == '+') 					printf("%s\t$运算符\n\n", token); //判断结果为"++"           				else { 					ch = prog[p--]; 					printf("%s\t$运算符\n\n", token); //判断结果为"+"          				} 				break; 			case'-': 				ch = prog[p--]; 				token[1] = ch; 				if (ch == '='){ 					printf("%s\t$运算符\n\n", token); 				} //运算符-=  				else if (ch == '-'){ 					printf("%s\t$运算符\n\n", token); //判断结果为"--"  				} 				else { 					ch = prog[p--]; 					printf("%s\t$运算符\n\n", token); //判断结果为"-"          				} 				break; 			case'*': 			case'/': 			case'!': 			case'=': 				ch = prog[p--]; 				if (ch == '='){ 					printf("%s\t$运算符\n\n", token);   // *= ; /= ;！= ; ==       				} 				else { 					ch = prog[p--]; 					printf("%s\t$运算符\n\n", token); 				}         break; 			case'<': 				ch = prog[p--]; 				token[1] = ch; 				if (ch == '='){ 					printf("%s\t$运算符\n\n", token); //判断结果为运算符"<="          				} 				else if (ch == '<'){ 					printf("%s\t$运算符\n\n", token); //判断结果为"<<"          				} 				else { 					ch = prog[p--]; 					printf("%s\t$运算符\n\n", token); //判断结果为"<"          				}         break; 			case'>': 				ch = prog[p--]; 				token[1] = ch; 				if (ch == '=') printf("%s\t$运算符\n\n", token); 				else { 					ch = prog[p--]; 					printf("%s\t$运算符\n\n", token); 				}         break; 			case'%': 				ch = prog[p--]; 				token[1] = ch; 				if (ch == '=') 					printf("%s\t$运算符\n\n", token);      // '%=' 				if (isalpha(ch)) 					printf("%s\t$类型标识符\n\n", token);       // int/float/double/char  '%d' ;'%f';'%c','%s'  				else { 					ch = prog[p--]; 					printf("%s\t$取余运算符\n\n", token); 				}        break; 			default: 				printf("无法识别字符!\n\n"); break; 			} 		} 	} } void main(){ 	ch = getchar(); 	do{ 		prog[p++] = ch; 		ch = getchar(); 	} while (ch != '#'); }

可以了 谢了	[Error] invalid conversion from 'int (*)()' to 'char' [-fpermissive]是哪里错了呢

scaner 是不是缺一个 }  main 的返回值类型没有？


Question: 如何读取txt数据保存到2个一维数组当中

引用 2 楼 user-3 的回复:http://blog.csdn.net/u013457167/article/details/47006737 可以参考这个，美中不足的是，行数需要用宏定义。

要用C来写。。。


Question: 汇编循环如何提前跳出

引用 3 楼 chimenghuanzhe的回复:[quote=引用 2 楼 user-3 的回复:] {             .....             jmp lastpos // 跳出             ..... lastpos: }问题是，对于lastpos这块，用什么来结尾。我也是试着 { ....... jmp bdian5 .......  bdian5:  end  }  但是没用，编译的时候报错，error C2400: “操作码”中的内联汇编语法错误；找到“end” 即，电脑无法识别end[/quote] 你标签可以写到大括号外面，要加语句可以就写个分号（空语句）

搜“堆栈平衡”

引用 5 楼 chimenghuanzhe 的回复:[quote=引用 4 楼 paschen 的回复:] [quote=引用 3 楼 chimenghuanzhe的回复:][quote=引用 2 楼 user-3 的回复:] {             .....             jmp lastpos // 跳出             ..... lastpos: }问题是，对于lastpos这块，用什么来结尾。我也是试着 { ....... jmp bdian5 .......  bdian5:  end  }  但是没用，编译的时候报错，error C2400: “操作码”中的内联汇编语法错误；找到“end” 即，电脑无法识别end[/quote] 你标签可以写到大括号外面，要加语句可以就写个分号（空语句）[/quote]perfect.解决了。  顺带问一下，一开始我是把整个子函数都反汇编了。然后生成整个代码。然后我是把包括最开始的  int jiafa(unsigned char a[],unsigned char b[],unsigned char c[],long int m)//尾数的数值部分相加 { __asm {  push di push sp  ........... pop sp pop di } }  .这样一来也能运行处正确结果。但是每次编译的时候总是警告我，改变了sp，改变了di之类的。我看了一下，如果在这个基础上反汇编，结果是在asm{}之外的部分，即子函数的头部还会产生push di，push sp这类入栈操作。同样后面还会产生第二次的出栈操作。问，虽然他有警告，但是根据先进后出的原则，最后出栈的才是最终的地址。也就是后出栈的把前面的覆盖了。所以我认为不会产生安全隐患对吧？[/quote]  那就不会

引用 4 楼 paschen 的回复:[quote=引用 3 楼 chimenghuanzhe的回复:][quote=引用 2 楼 user-3 的回复:] {             .....             jmp lastpos // 跳出             ..... lastpos: }问题是，对于lastpos这块，用什么来结尾。我也是试着 { ....... jmp bdian5 .......  bdian5:  end  }  但是没用，编译的时候报错，error C2400: “操作码”中的内联汇编语法错误；找到“end” 即，电脑无法识别end[/quote] 你标签可以写到大括号外面，要加语句可以就写个分号（空语句）[/quote]perfect.解决了。  顺带问一下，一开始我是把整个子函数都反汇编了。然后生成整个代码。然后我是把包括最开始的  int jiafa(unsigned char a[],unsigned char b[],unsigned char c[],long int m)//尾数的数值部分相加 { __asm {  push di push sp  ........... pop sp pop di } }  .这样一来也能运行处正确结果。但是每次编译的时候总是警告我，改变了sp，改变了di之类的。我看了一下，如果在这个基础上反汇编，结果是在asm{}之外的部分，即子函数的头部还会产生push di，push sp这类入栈操作。同样后面还会产生第二次的出栈操作。问，虽然他有警告，但是根据先进后出的原则，最后出栈的才是最终的地址。也就是后出栈的把前面的覆盖了。所以我认为不会产生安全隐患对吧？

引用 2 楼 user-3 的回复:{             .....             jmp lastpos // 跳出             ..... lastpos: }问题是，对于lastpos这块，用什么来结尾。我也是试着 { ....... jmp bdian5 .......  bdian5:  end  }  但是没用，编译的时候报错，error C2400: “操作码”中的内联汇编语法错误；找到“end” 即，电脑无法识别end

这个汇编程序是我从编号的c语言程序中反汇编出来的。对应的c语言程序是 for (i=m-1;i>=1;i--)        //计算每一位的值     {                 d[i]+=(a[i]+b[i]);     //涉及到进位所以，要用+=，而非直接=                 if (d[i]>9)                 { 					                     d[i]-=10;            //大于10的取个位                     d[i-1]++;            //高位加1                 } 				c[i]=d[i];     } 然后bdian5 是跳入下面的，不过下面的部分我直接用c语言写了。因为如果下面的也用他反汇编出来的东西，会导致必须把更下面的东西也带上。  所以，我准备在bdian5这个位置直接跳出。即，如果i<1;则跳出循环。可是我在汇编的指令中没找到跳出程序这个指令。都是跳到什么位置。


Question: 第三方开源源代码做成的库文件，动态库，修改了对应的c文件，相应的库文件没有任何更新怎么回事？

恩恩 昨天试了发现 我的格式化工具调用的居然是系统自带的库函数，不是我自己编译的库函数。  已经弄好啦 谢谢老师

.o还得链接生成对应的.so

使用ldd命令查看可执行文件依赖的.so

直接调用的自带的makefile 了 直接make  .之后我看了看不仅.o更新了，而且对应的.so的修改时间访问时间也更新了


Question: 如何返回一个二维数组，并调用。

你数组是动态分配的，直接传递指针就行了

仅供参考：#include <stdio.h> #include <stdlib.h> #include <malloc.h> int **newarr2d(int rows,int cols) {     int **p,i;      p=(int **)malloc(rows*sizeof(int *));     if (NULL==p) exit(1);     for (i=0;i<rows;i++) {         p[i]=(int *)malloc(cols*sizeof(int));         if (NULL==p[i]) exit(1);     }     return p; } void deletearr2d(int **p,int rows) {     int i;      for (i=0;i<rows;i++) {         free(p[i]);     }     free(p); } int main() {     int **arr2d,i,j,r,c;      r=4;     c=5;     //在堆中开辟一个4×5的二维int数组     arr2d=newarr2d(r,c);     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             arr2d[i][j]=i*c+j;         }     }     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             printf(" %2d",arr2d[i][j]);         }         printf("\n");     }     deletearr2d(arr2d,r);      r=6;     c=3;     //在堆中开辟一个6×3的二维int数组     arr2d=newarr2d(r,c);     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             arr2d[i][j]=i*c+j;         }     }     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             printf(" %2d",arr2d[i][j]);         }         printf("\n");     }     deletearr2d(arr2d,r);      return 0; } //  0  1  2  3  4 //  5  6  7  8  9 // 10 11 12 13 14 // 15 16 17 18 19 //  0  1  2 //  3  4  5 //  6  7  8 //  9 10 11 // 12 13 14 // 15 16 17 //


Question: C语言问题,总是报错

引用 4 楼 nn970510 的回复:.global add2  add2:   stmfd sp!, {v1-v6, lr}   add a1, a1, a2   ldmfd sp!, {v1-v6, pc}   .end 难道这个不是对add2的定义么，求问应该怎么改正  没有这种用法

后面的汇编是什么cpu的？ 你又用的产生什么cpu代码的编译器？

add2函数没有实现

你的代码里用了extern  那说明add2（）其他源文件里有定义，而实际上你并没有定义这个函数

add2函数没有定义


Question: 单链表里有三种类型元素，将它们按类型分为三个循环链表 这个算法哪里出错？

引用 1 楼 user-1 的回复:if( s->data >= 'a' && s->data <= 'z')  这句改成；  else if( s->data >= 'a' && s->data <= 'z') 真的很谢谢。。我没注意到这里


Question: 学C的第一个卡壳

Enter,Ctrl+Z,Enter

输入完毕回车，在新的行按Ctrl+Z，回车看结果。

第一章就学这个了啊？有点难啊。

Windows系统中一般采用阻塞式检查   Ctrl+Z、Unix/Linux系统下一般采用非阻塞式的检查   Ctrl+D。楼主是在Windows系统下，因此使用阻塞式的   Ctrl+Z   来标识流的结束。  http://blog.csdn.net/windlfb/article/details/6937212

(c= getchar ())!=EOF   EOF 是End Of File的缩写，是一个特殊字符。也可以改成*号或#号之类的字符作为结束。

ctrl + z 回车 才能退出循环，因为你循环条件是 (c= getchar ())!=EOF

Ctrl + Z，再回车


Question: c语言，如何实现向上翻页

仅供参考：#include <stdio.h> FILE *f; int c; long offset; char ln[100]; void main() {     f=fopen("a.txt","rb");//必须用b方式打开，否则文件当前读位置会受\x0d \x0a \x1a等字符的干扰     fseek(f,-1,SEEK_END);//倒数最后一个字节之前     while (1) {         c=fgetc(f);         if ('\n'==c) {             offset=ftell(f);//记住当前位置，即刚读字符后面             fgets(ln,100,f);             printf("%s",ln);             fseek(f,offset-2,SEEK_SET);//回到刚才读位置之前一个位置，即c所在位置之前一个位置         } else             if (fseek(f,-2,SEEK_CUR)) {//回到刚才读位置之前一个位置，即c所在位置之前一个位置失败，说明已读到文件开头                 fseek(f,0,SEEK_SET);                 fgets(ln,100,f);//读文件第一行内容                 printf("%s",ln);                 break;             }     }     fclose(f); }

翻页，行数是固定的，用fgets读行。

fseek是移动文件指针，和翻页没什么关系  http://en.cppreference.com/w/c/io/fseek

翻页是显示的事，跟读取文件内容关系不大。当然要显示的东西不在缓冲区中时，需要再次读文件


Question: Ｃ语言小蜜蜂问题，自己在编译器可行，但是提交超时，求问大虾ＱＡＱ

这个好像可以直接计算出结果    用数学公式算

加上之后变成错误答案了= =

@user-2 加上数组后还是不行诶= =

= =还真是，，，请问那该怎么修改可行呢？

简单加一句查表速度提升明显  int buf[50] = {0};  int num(int count) {     if (buf[count]) return buf[count];      if (count>2)         return buf[count] = (num(count - 1) + num(count - 2));     else         return buf[count] = count; }

1. 题目指出对于每个输入，都输出，共N个, 没有指出N多大 2. 我就试了一组   1, 49, debug下 等了10+秒还没出结果


Question: 括号匹配问题

引用 8 楼 paschen 的回复:[quote=引用 7 楼 xinye1230 的回复:] [quote=引用 6 楼 paschen 的回复:] [quote=引用 5 楼 xinye1230 的回复:] [quote=引用 3 楼 paschen 的回复:] 另外,scanf 接收 %c时，会将之前输入完留在缓冲区中的 \n接收了，所以建议改用getchar #include<stdio.h> #include<malloc.h> #include<string.h> #define STACK_INIT_SIZE 20 #define STACKINCREMENT 10  #define OK 1 #define ERROR 0 typedef char ElemType; typedef struct { /*建立一个栈的首结点*/     ElemType * base;     ElemType * top;     int stacksize; } SqStack; int InitStack(SqStack *s) { /*建立空的栈并返回首地址*/     s->base=((ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType)));     if (!s->base) return ERROR;     s->top=s->base;     s->stacksize=STACK_INIT_SIZE;     return OK; } int StackEmpty(SqStack *s) { /*判断栈是否为空*/     if (s->top==s->base) return OK;     else                 return ERROR; } int Push(SqStack *s,ElemType ch) { /*往栈顶插入元素即进栈*/     if (s->top-s->base>=s->stacksize) { /*判断是否栈满*/         s->base=((ElemType*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(ElemType)));         if (!s->base) return ERROR;         s->stacksize+=STACKINCREMENT;         s->top=s->base+s->stacksize;     }     *s->top++=ch;     return OK; } int Pop(SqStack *s,ElemType *ch) { /*让栈顶元素依次输出即出栈*/     if (StackEmpty(s)) return ERROR;     *ch=*(--s->top);     return OK; }  int main() { 	char ch; 	SqStack s; 	InitStack(&s); 	scanf("%c",&ch); 	while(ch!='#') 	{ 		if(ch=='('||ch=='['||ch=='{') 			Push(&s,ch); 		if(ch==')'||ch==']'||ch=='}') 		{ 			if(StackEmpty(&s)) 			{ 			 				printf("右多\n"); 				return 0; 			} 			Pop(&s,&ch); 			if((ch=='('&&ch!=')')||(ch=='['&&ch!=']')||(ch=='{'&&ch!='}')) 			{ 				 				printf("左右不匹配\n"); 				return 0; 			} 		} 		ch=getchar(); 	} 	if(!StackEmpty(&s)) 	{ 	 		printf("左多\n"); 		return 0; 	} 	else 	{ 	 		printf("正确\n"); 		return 1; 	} 	return 0;  } 这个代码我修改了  可是为什么执行的结果不正确呢？[/quote]  给出你输入的内容和希望的结果  你前面的scanf("%c",&ch); 也改成用getchar[/quote]  我把前面的scanf改成ch=getchar（）；但是结果还是不对  是不是 我的算法有错？本来括号就是匹配的，它总出现括号不匹配！[/quote]  Pop(&s,&ch); 这里的ch换一个变量，不然他把原来的c覆盖，你再比较没什么意思了[/quote] 我改成其他变量了  结果正确了  谢谢你。

谢谢  赵四老师、

引用 5 楼 xinye1230 的回复:[quote=引用 3 楼 paschen 的回复:] 另外,scanf 接收 %c时，会将之前输入完留在缓冲区中的 \n接收了，所以建议改用getchar #include<stdio.h> #include<malloc.h> #include<string.h> #define STACK_INIT_SIZE 20 #define STACKINCREMENT 10  #define OK 1 #define ERROR 0 typedef char ElemType; typedef struct { /*建立一个栈的首结点*/     ElemType * base;     ElemType * top;     int stacksize; } SqStack; int InitStack(SqStack *s) { /*建立空的栈并返回首地址*/     s->base=((ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType)));     if (!s->base) return ERROR;     s->top=s->base;     s->stacksize=STACK_INIT_SIZE;     return OK; } int StackEmpty(SqStack *s) { /*判断栈是否为空*/     if (s->top==s->base) return OK;     else                 return ERROR; } int Push(SqStack *s,ElemType ch) { /*往栈顶插入元素即进栈*/     if (s->top-s->base>=s->stacksize) { /*判断是否栈满*/         s->base=((ElemType*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(ElemType)));         if (!s->base) return ERROR;         s->stacksize+=STACKINCREMENT;         s->top=s->base+s->stacksize;     }     *s->top++=ch;     return OK; } int Pop(SqStack *s,ElemType *ch) { /*让栈顶元素依次输出即出栈*/     if (StackEmpty(s)) return ERROR;     *ch=*(--s->top);     return OK; }  int main() { 	char ch; 	SqStack s; 	InitStack(&s); 	scanf("%c",&ch); 	while(ch!='#') 	{ 		if(ch=='('||ch=='['||ch=='{') 			Push(&s,ch); 		if(ch==')'||ch==']'||ch=='}') 		{ 			if(StackEmpty(&s)) 			{ 			 				printf("右多\n"); 				return 0; 			} 			Pop(&s,&ch); 			if((ch=='('&&ch!=')')||(ch=='['&&ch!=']')||(ch=='{'&&ch!='}')) 			{ 				 				printf("左右不匹配\n"); 				return 0; 			} 		} 		ch=getchar(); 	} 	if(!StackEmpty(&s)) 	{ 	 		printf("左多\n"); 		return 0; 	} 	else 	{ 	 		printf("正确\n"); 		return 1; 	} 	return 0;  } 这个代码我修改了  可是为什么执行的结果不正确呢？[/quote]  给出你输入的内容和希望的结果  你前面的scanf("%c",&ch); 也改成用getchar

仅供参考：#include<stdio.h> #include<malloc.h> #include<string.h> #define STACK_INIT_SIZE 10 #define STACK_GROW_SIZE 5 #define ELEMTYPE char #define OK 1 #define ERROR 0 typedef struct { /*建立一个栈的首结点*/     ELEMTYPE * base;     ELEMTYPE * top;     int stacksize; } SpStack; int InitStack(SpStack *s) { /*建立空的栈并返回首地址*/     s->base=((ELEMTYPE*)malloc(STACK_INIT_SIZE*sizeof(ELEMTYPE)));     if (!s->base) return ERROR;     s->top=s->base;     s->stacksize=STACK_INIT_SIZE;     return OK; } int StackEmpty(SpStack *s) { /*判断栈是否为空*/     if (s->top==s->base) return OK;     else                 return ERROR; } int Push(SpStack *s,ELEMTYPE e) { /*往栈顶插入元素即进栈*/     if (s->top-s->base>=s->stacksize) { /*判断是否栈满*/         s->base=((ELEMTYPE*)realloc(s->base,(s->stacksize+STACK_GROW_SIZE)*sizeof(ELEMTYPE)));         if (!s->base) return ERROR;         s->stacksize+=STACK_GROW_SIZE;         s->top=s->base+s->stacksize;     }     *s->top++=e;     return OK; } int Pop(SpStack *s,ELEMTYPE *e) { /*让栈顶元素依次输出即出栈*/     if (StackEmpty(s)) return ERROR;     *e=*(--s->top);     return OK; } int Comp(ELEMTYPE a,ELEMTYPE b) {     if ((a=='('&&b!=')')       ||(a=='['&&b!=']')       ||(a=='{'&&b!='}')) {         return ERROR;     } else return OK; } int Count(SpStack *s) {     ELEMTYPE e[STACK_INIT_SIZE*2];     ELEMTYPE e1;     int i;      InitStack(s);     fgets(e,STACK_INIT_SIZE*2,stdin);     if ('\n'==e[strlen(e)-1]) e[strlen(e)-1]=0;     printf("%s\n",e);     for (i=0;e[i]!='\0';i++) {         switch (e[i]) {         case '(':         case '[':         case '{':             Push(s,e[i]);             break;         case ')':         case ']':         case '}':             if (StackEmpty(s)) {                 printf("%*s↖右括号多余\n",i+1,"");                 return(ERROR);             } else Pop(s,&e1);             if (!Comp(e1,e[i])) {                 printf("%*s↖左右匹配出错\n",i+1,"");                 return(ERROR);             }         }     }     if (!StackEmpty(s)) {         printf("%*s↖左括号多余\n",i,"");         return(ERROR);     } else {         printf("匹配正确\n");         return(OK);     } } void main() {     SpStack s;     Count(&s);     free(s.base); }

引用 7 楼 xinye1230 的回复:[quote=引用 6 楼 paschen 的回复:] [quote=引用 5 楼 xinye1230 的回复:] [quote=引用 3 楼 paschen 的回复:] 另外,scanf 接收 %c时，会将之前输入完留在缓冲区中的 \n接收了，所以建议改用getchar #include<stdio.h> #include<malloc.h> #include<string.h> #define STACK_INIT_SIZE 20 #define STACKINCREMENT 10  #define OK 1 #define ERROR 0 typedef char ElemType; typedef struct { /*建立一个栈的首结点*/     ElemType * base;     ElemType * top;     int stacksize; } SqStack; int InitStack(SqStack *s) { /*建立空的栈并返回首地址*/     s->base=((ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType)));     if (!s->base) return ERROR;     s->top=s->base;     s->stacksize=STACK_INIT_SIZE;     return OK; } int StackEmpty(SqStack *s) { /*判断栈是否为空*/     if (s->top==s->base) return OK;     else                 return ERROR; } int Push(SqStack *s,ElemType ch) { /*往栈顶插入元素即进栈*/     if (s->top-s->base>=s->stacksize) { /*判断是否栈满*/         s->base=((ElemType*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(ElemType)));         if (!s->base) return ERROR;         s->stacksize+=STACKINCREMENT;         s->top=s->base+s->stacksize;     }     *s->top++=ch;     return OK; } int Pop(SqStack *s,ElemType *ch) { /*让栈顶元素依次输出即出栈*/     if (StackEmpty(s)) return ERROR;     *ch=*(--s->top);     return OK; }  int main() { 	char ch; 	SqStack s; 	InitStack(&s); 	scanf("%c",&ch); 	while(ch!='#') 	{ 		if(ch=='('||ch=='['||ch=='{') 			Push(&s,ch); 		if(ch==')'||ch==']'||ch=='}') 		{ 			if(StackEmpty(&s)) 			{ 			 				printf("右多\n"); 				return 0; 			} 			Pop(&s,&ch); 			if((ch=='('&&ch!=')')||(ch=='['&&ch!=']')||(ch=='{'&&ch!='}')) 			{ 				 				printf("左右不匹配\n"); 				return 0; 			} 		} 		ch=getchar(); 	} 	if(!StackEmpty(&s)) 	{ 	 		printf("左多\n"); 		return 0; 	} 	else 	{ 	 		printf("正确\n"); 		return 1; 	} 	return 0;  } 这个代码我修改了  可是为什么执行的结果不正确呢？[/quote]  给出你输入的内容和希望的结果  你前面的scanf("%c",&ch); 也改成用getchar[/quote]  我把前面的scanf改成ch=getchar（）；但是结果还是不对  是不是 我的算法有错？本来括号就是匹配的，它总出现括号不匹配！[/quote]  Pop(&s,&ch); 这里的ch换一个变量，不然他把原来的c覆盖，你再比较没什么意思了

引用 6 楼 paschen 的回复:[quote=引用 5 楼 xinye1230 的回复:] [quote=引用 3 楼 paschen 的回复:] 另外,scanf 接收 %c时，会将之前输入完留在缓冲区中的 \n接收了，所以建议改用getchar #include<stdio.h> #include<malloc.h> #include<string.h> #define STACK_INIT_SIZE 20 #define STACKINCREMENT 10  #define OK 1 #define ERROR 0 typedef char ElemType; typedef struct { /*建立一个栈的首结点*/     ElemType * base;     ElemType * top;     int stacksize; } SqStack; int InitStack(SqStack *s) { /*建立空的栈并返回首地址*/     s->base=((ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType)));     if (!s->base) return ERROR;     s->top=s->base;     s->stacksize=STACK_INIT_SIZE;     return OK; } int StackEmpty(SqStack *s) { /*判断栈是否为空*/     if (s->top==s->base) return OK;     else                 return ERROR; } int Push(SqStack *s,ElemType ch) { /*往栈顶插入元素即进栈*/     if (s->top-s->base>=s->stacksize) { /*判断是否栈满*/         s->base=((ElemType*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(ElemType)));         if (!s->base) return ERROR;         s->stacksize+=STACKINCREMENT;         s->top=s->base+s->stacksize;     }     *s->top++=ch;     return OK; } int Pop(SqStack *s,ElemType *ch) { /*让栈顶元素依次输出即出栈*/     if (StackEmpty(s)) return ERROR;     *ch=*(--s->top);     return OK; }  int main() { 	char ch; 	SqStack s; 	InitStack(&s); 	scanf("%c",&ch); 	while(ch!='#') 	{ 		if(ch=='('||ch=='['||ch=='{') 			Push(&s,ch); 		if(ch==')'||ch==']'||ch=='}') 		{ 			if(StackEmpty(&s)) 			{ 			 				printf("右多\n"); 				return 0; 			} 			Pop(&s,&ch); 			if((ch=='('&&ch!=')')||(ch=='['&&ch!=']')||(ch=='{'&&ch!='}')) 			{ 				 				printf("左右不匹配\n"); 				return 0; 			} 		} 		ch=getchar(); 	} 	if(!StackEmpty(&s)) 	{ 	 		printf("左多\n"); 		return 0; 	} 	else 	{ 	 		printf("正确\n"); 		return 1; 	} 	return 0;  } 这个代码我修改了  可是为什么执行的结果不正确呢？[/quote]  给出你输入的内容和希望的结果  你前面的scanf("%c",&ch); 也改成用getchar[/quote]  我把前面的scanf改成ch=getchar（）；但是结果还是不对  是不是 我的算法有错？本来括号就是匹配的，它总出现括号不匹配！

引用 3 楼 paschen 的回复:另外,scanf 接收 %c时，会将之前输入完留在缓冲区中的 \n接收了，所以建议改用getchar #include<stdio.h> #include<malloc.h> #include<string.h> #define STACK_INIT_SIZE 20 #define STACKINCREMENT 10  #define OK 1 #define ERROR 0 typedef char ElemType; typedef struct { /*建立一个栈的首结点*/     ElemType * base;     ElemType * top;     int stacksize; } SqStack; int InitStack(SqStack *s) { /*建立空的栈并返回首地址*/     s->base=((ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType)));     if (!s->base) return ERROR;     s->top=s->base;     s->stacksize=STACK_INIT_SIZE;     return OK; } int StackEmpty(SqStack *s) { /*判断栈是否为空*/     if (s->top==s->base) return OK;     else                 return ERROR; } int Push(SqStack *s,ElemType ch) { /*往栈顶插入元素即进栈*/     if (s->top-s->base>=s->stacksize) { /*判断是否栈满*/         s->base=((ElemType*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(ElemType)));         if (!s->base) return ERROR;         s->stacksize+=STACKINCREMENT;         s->top=s->base+s->stacksize;     }     *s->top++=ch;     return OK; } int Pop(SqStack *s,ElemType *ch) { /*让栈顶元素依次输出即出栈*/     if (StackEmpty(s)) return ERROR;     *ch=*(--s->top);     return OK; }  int main() { 	char ch; 	SqStack s; 	InitStack(&s); 	scanf("%c",&ch); 	while(ch!='#') 	{ 		if(ch=='('||ch=='['||ch=='{') 			Push(&s,ch); 		if(ch==')'||ch==']'||ch=='}') 		{ 			if(StackEmpty(&s)) 			{ 			 				printf("右多\n"); 				return 0; 			} 			Pop(&s,&ch); 			if((ch=='('&&ch!=')')||(ch=='['&&ch!=']')||(ch=='{'&&ch!='}')) 			{ 				 				printf("左右不匹配\n"); 				return 0; 			} 		} 		ch=getchar(); 	} 	if(!StackEmpty(&s)) 	{ 	 		printf("左多\n"); 		return 0; 	} 	else 	{ 	 		printf("正确\n"); 		return 1; 	} 	return 0;  } 这个代码我修改了  可是为什么执行的结果不正确呢？

引用 1 楼 user-3 的回复:严重性	代码	说明	项目	文件	行	禁止显示状态 警告	C4477	“scanf”: 格式字符串“%c”需要类型“char *”的参数，但可变参数 1 拥有了类型“int”	Project1	c:\users\administrator\documents\visual studio 15\projects\project1\project1\main.c	61 什么意思？

scanf("%c",ch);  改成   scanf("%c",&ch);


Question: C语言中一维多项式求值

#include "1plyv.c"尽量不要include源文件 double plycv (a[],n,x)声明函数时需要带上类型。

这是上个世纪80年代的程序吧，K&R标准，不是ANSI的 看看新书吧

main函数的第二个参数应该是char**吧，其它语法错误向上面说的。。。

double plycv (a[],n,x) 后面少了大括号 {

你这哪是运行出错, 编译出错了.. 不看错误提示么, 你这是c语言么


Question: 急求帮忙解决二叉树遍历

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

你的CreatBiTree没有参数，但函数中递归调用时又传入了参数CreatBiTree(T->lchild);

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


Question: Ubuntu 重定向

已搞定 。 谢了

引用 4 楼 qq907482638 的回复:问题描述的有点少啊！！！ 1.如果echo_eof不是你的shell自带的命令，而是你自己写的程序。     请在程序的目录下 cd /home/xxx/program/   用. / 来启动程序，而不是直接使用程序名 例如./echo_eof   2.你是要把word.txt 里的内容输入到echo_eof里面？？如果不是echo_eof >word.txt注意箭头方向 3.你要把文件名写全，linux不是windows认为输出字符的一定是文本文件txt。请写word.txt。其实我用什么后缀都可以，word.psp,word.php, word.asfjslfjla 都是可以的。后缀不影响。。 引用 4 楼 qq907482638 的回复:问题描述的有点少啊！！！ 1.如果echo_eof不是你的shell自带的命令，而是你自己写的程序。     请在程序的目录下 cd /home/xxx/program/   用. / 来启动程序，而不是直接使用程序名 例如./echo_eof   2.你是要把word.txt 里的内容输入到echo_eof里面？？如果不是echo_eof >word.txt注意箭头方向 3.你要把文件名写全，linux不是windows认为输出字符的一定是文本文件txt。请写word.txt。其实我用什么后缀都可以，word.psp,word.php, word.asfjslfjla 都是可以的。后缀不影响。。  echo_eof 是我的写的程序 ，，我是照着C primer plus 写进去的， 然而 当前文件夹 没有执行exe文件 ，，书上就 echo_eof < words    我编译程序也改 成echo_eof.c  ，也创建了 words.txt文件 ， 用的GCC编译

引用 1 楼 user-2 的回复:./echo_eof   bash: ./echo_eof1: No such file or directory


Question: 大家讨论一下一个面试题，已知两点坐标，半径求圆心坐标。

计算几何大牛:http://www.codeproject.com/KB/recipes/Wykobi.aspx

数学问题 写出两个指定圆心半径的圆的方程式，求解。

这只是数学问题，建立方程后推出解来程序中只是带公式

引用 1 楼 zzdmfk 的回复:起点(x1,y1),止点(x2,y2).半径r,求圆心坐标x0和y0. 函数输入参数x1,y1,x2,y2,r.输出x0,y0.  求以(x1,y1)与(x2,y2)为圆心，r为半径的两个圆的交点即为所求

顺时针，逆时针可分两个函数实现。很难吧？


Question: 这个高精度计算pi值的程序用的是什么思想？急！！！

6楼能解释一下你的算法吗，本人小白

仅供参考：#include <stdio.h> long a=10000; long b; long c=2800; long d; long e; long f[2801]; long g; int main() {     for(;b-c;) f[b++]=a/5; //  while (1) { //      if (0==b-c) break; //      f[b]=a/5; //      b++; //  }      //f[0 - 2800] = 10000/5     for(;d=0,g=c*2;c-=14,printf("%.4d",e+d/a),e=d%a)           for(b=c;d+=f[b]*a,f[b]=d%--g,d/=g--,--b;d*=b); //  while (1) { //      d=0; //      g=c*2; //      if (0==g) break; //      b=c; //      while (1) { //          d+=f[b]*a; //          f[b]=d%--g; //          d/=g--; //          --b; //          if (0==b) break; //          d*=b; //      } //      c-=14; //      printf("%.4d",e+d/a); //      e=d%a; //  }  	return 0; }

赞同2楼说法，不过代码不能靠别人看出来，还是要自己写个流程出来，或者单步执行，查看监视变量的值你就知道是做什么的了。

能写跑这么慢的代码也是不容易啊. 用链表做大数运算也是人才啊..

唔看错了。这是newton/euler变换：pi/2=1+1/3*(1+2/5*(1+3/7*(1+...)))

arctan的展开式。pi/4=arctan(1)=1-1/3+1/5-1/7+...


Question: 求问定长顺序串如何从子函数传递到主函数？

楼上说的不正确  C中数组不能作为返回值，你可以返回指针，但指针不应指向局部变量

同意1楼，既然typedef了String，则可直接使用String作为新类型，如String arrToStr(char* pcArr)，当然，使用指针还是传值就看具体代码需求了

子函数的参数用定长串的指针，然后再对这个参数赋值

直接用Ｓtring类型就可以了


Question: 新人求帮助关于自学C++

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

就用VS2013或者VS2015吧，照着书上的例子慢慢敲就行，边敲边理解

当时学校用的是Dev c++，然后就一直用了。

用VS好了，用比较主流的IDE比较好，碰到问题了网上容易找到答案。 熟练了以后可以换别的IDE http://blog.csdn.net/cometnet/article/details/19551125 https://msdn.microsoft.com/en-us/library/w40768et.aspx

如果你买的是最新版的C++ Primer Plus，包含C++11内容，不用gcc，就用VS2013或者VS2015吧。

那就用windows系统吧，IDE可以选VS2015， MSDN我告诉你 上可以下载到

试试将http://www.cplusplus.com上面的例子代码挨个编译链接调试一番。

Visual Studio 6/2005/2008/2010/2012/2013 各版本编译器 下载 http://bbs.csdn.net/topics/390812579

c++ primer plus是本好书，适合刚入门的去看，建议你再去买本c++ primer（第五版），这是c++方面的最好的书，编程工具就用vs2013就可以了，网上有破解版下载


Question: 关于链表的 请教 请教

不要急于找出出错的根源，先让每一步数据处理可视化。 必要时也可以显示每个节点的起始地址。 可视化的照妖镜照到极致时，其bug幺蛾子自会现原形的。

将复杂数据结构的整个内容在处理它的每一步使用一小段代码按自己很容易理解的格式输出，非常有助于调试！或者可以说是“基础设施”

仅供参考：//不带表头结点的双向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> #include <locale.h> struct NODE {     int          data;     struct NODE *next;     struct NODE *prev; } *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;         q->prev=NULL;         if (NULL==p) {             head=q;             p=head;         } else {             p->next=q;             q->prev=p;             p=q;         }     }      //输出整个双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d<->",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         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=v;             q->next=head;             q->prev=NULL;             head->prev=q;             head=q;             break;         } else {             if (k-1==n) {                 q=(struct NODE *)malloc(sizeof(struct NODE));                 if (NULL==q) exit(1);                 q->data=v;                 q->next=p->next;                 q->prev=p;                 p->next->prev=q;                 p->next=q;                 break;             }         }         p=p->next;     }      //输出整个双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d<->",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         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;             head->prev=NULL;             free(q);             break;         } else {             if (k-1==n) {                 q=p->next;                 if (q) {                     p->next=q->next;                     if (q->next) q->next->prev=p;                     free(q);                 }                 break;             }         }         p=p->next;     }      //输出整个双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d<->",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         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;                  //或者                  //交换prev和next //              printf("swap %02d %02d\n",p->data,q->data);                 if (p==head) {//p是头                     if (p->next==q) {//pq挨着                         head=q;                         head->prev=NULL;                         p->next=q->next;                         p->prev=q;                         if (q->next) q->next->prev=p;                         q->next=p;                         q=p;                         p=head;                     } else {//pq不挨着                         head=q;                         head->prev=NULL;                         p2=p->next;                         p->next=q->next;                         p->prev=q->prev;                         if (q->next) q->next->prev=p;                         q->next=p2;                         p2->prev=q;                         q1->next=p;                         q=p;                         p=head;                     }                 } else {//p不是头                     if (p->next==q) {//pq挨着                         p1->next=q;                         p->next=q->next;                         p->prev=q;                         if (q->next) q->next->prev=p;                         q->next=p;                         q->prev=p1;                         q=p;                         p=p1->next;                     } else {//pq不挨着                         p1->next=q;                         p2=p->next;                         p->next=q->next;                         p->prev=q->prev;                         if (q->next) q->next->prev=p;                         q->next=p2;                         p2->prev=q;                         q->prev=p1;                         q1->next=p;                         q=p;                         p=p1->next;                     }                 }                  //输出整个双向链表 //              s=head; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d<->",s->data); //                  if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;} //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个双向链表并计算链表长度n     n=0;     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d<->",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         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->prev=q;             p=q;             q=q1;             if (NULL==q) break;         }         head=p;         head->prev=NULL;     }      //输出整个双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d<->",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         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;     head->prev=NULL;     s->next=q1;     q1->prev=s;     q->next=NULL;      //输出整个双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d<->",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         s=s->next;     }      //释放所有节点     p=head;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //创建10个节点的双向链表:93<->03<->60<->05<->57<->71<->02<->41<->26<->85<-> //将值为5的结点插入到双向链表的第3个结点前:93<->03<->05<->60<->05<->57<->71<->02<->41<->26<->85<-> //删除第5个节点:93<->03<->05<->60<->57<->71<->02<->41<->26<->85<-> //从小到大排序:02<->03<->05<->26<->41<->57<->60<->71<->85<->93<-> //将整个链表逆序:93<->85<->71<->60<->57<->41<->26<->05<->03<->02<-> //将双向链表中前4个结点和后6个结点进行互换:57<->41<->26<->05<->03<->02<->93<->85<->71<->60<-> //

感觉你说的我还是不太明白，建议每操作一步就输出所有变量的值，然后看看哪一步的变化与你想的不一样。  我看你用了引用， 所以可以用c＋＋吧， 那就直接用std::list;  typedef struct TRIANGLE{ int i; int j; int k; }TRIANGLE;  typedef struct MESH{ long int PNUM; long int TNUM; Point_PTR pArr; std::list<TRIANGLE> TriArr; } MESH, *Mesh_PTR;


Question: If 多层嵌套后，无法配对了。

细节决定成败，谨小慎微才行。

对应不到的那个else上面的if要用大括号围住，否则只是if的后一条语句属于if

引用 5 楼 zhao4zhong1 的回复:astyle自动整理c,c++,java源代码格式命令行工具源代码。 用astyle --help查看使用帮助。 http://download.csdn.net/detail/zhao4zhong1/5605415 谢谢

VS IDE中，选中要自动整理格式的代码片断，按Alt+F8键。

所以花扩号很重要, 不要随便省, 到时候烦的就是自己.  老赵说的那个工具非常好用, 自动格式化.  只要整个部分都用这个插件, 保证全部代码风格一致.

我已经找到答案了，标红的else上面的if后面应该对应语录块，我没加花括号，哈哈，不细心果然不行啊。谢谢大家了，

电脑不能上网，凑活一下吧，谢谢大家了。