Question: 线程完全没有运行怎么办

没有wait? windows开线程需要waitforsingleobject，等待线程终止后在注销句柄等东西

pthread_create(&pro_thread, &attr, pro_main,NULL); 返回值是什么 确定创建成功了吗

pthread_create(&pro_thread, &attr, pro_main,NULL);  sleep(1000); 或者用 pthread_join函数 pthread_attr_destroy(&attr);


Question: c中的 动态数组 与进阶的 结构体动态创建 问题

都是running-time是产生的，理论上没有问题，要考虑的是效率和碎片

哦原来是我误解了 开始的 char *colname[n]; 其实是定义了n个指针，并没有为他分配内存，而直到运行到了 for（i = 0; i < n; i++） {    colname[i] = (char*)malloc(sizeof(a.colname[i]) * sizeof(char));  } 的时候，才真正为其分配了内存，接着就可以对colname[i]中放对应的字符了。 strcat(colname[i], a[i].colname);  引用 1 楼 turingo 的回复:都是可以动态分配的，n1可以是变量，可以：  colname = (char*)malloc(n1 * sizeof(char)); ... a = (struct sample1*)malloc(n2 * sizeof(struct sample1));   [quote=引用 楼主 InSpirit1 的回复:] struct sample1 {																			//定义结构体变量，并分配64组 	char tabname[64]; 	char value[64]; 	char expression[64]; }; 	struct sample1 a[256] = {NULL};	   //初始化为0  char colname[4096] = "";				 char value[4096] = ""; .....                                      //赋值a[i].tabname,a[i].value的过程 .....                                      // .....                                      // for(int i = 0; i < n; i++)                 //字符串拼接 { 	strcat(colname, a[i].colname); 	strcat(colname, ","); 	strcat(value, "'"); 	strcat(value, a[i].value); 	strcat(value, "',"); }  这是我程序的大致结构。 1、由于定义的char数组为4096太多了，我想将其优化为动态数组，我看用malloc和free可实现。 网上的例子都将colname = (char*)malloc(n1 * sizeof(char));中的n1当成已知量，而我的n1是变量，每次循环大小不一样，能否贴个类似的例子给我参考下 2、如何将结构体定义的struct sample1 a[256]也设置成动态内存，而不是固定的256组？[/quote]

可以是动态的阿！这就是处理动态数据的一个比较好的办法阿！ 你只要你传进去对应的需要分配的参数的实际大小就好了！

都是可以动态分配的，n1可以是变量，可以：  colname = (char*)malloc(n1 * sizeof(char)); ... a = (struct sample1*)malloc(n2 * sizeof(struct sample1));  引用 楼主 InSpirit1 的回复:struct sample1 {																			//定义结构体变量，并分配64组 	char tabname[64]; 	char value[64]; 	char expression[64]; }; 	struct sample1 a[256] = {NULL};	   //初始化为0  char colname[4096] = "";				 char value[4096] = ""; .....                                      //赋值a[i].tabname,a[i].value的过程 .....                                      // .....                                      // for(int i = 0; i < n; i++)                 //字符串拼接 { 	strcat(colname, a[i].colname); 	strcat(colname, ","); 	strcat(value, "'"); 	strcat(value, a[i].value); 	strcat(value, "',"); }  这是我程序的大致结构。 1、由于定义的char数组为4096太多了，我想将其优化为动态数组，我看用malloc和free可实现。 网上的例子都将colname = (char*)malloc(n1 * sizeof(char));中的n1当成已知量，而我的n1是变量，每次循环大小不一样，能否贴个类似的例子给我参考下 2、如何将结构体定义的struct sample1 a[256]也设置成动态内存，而不是固定的256组？


Question: 求教一个free的问题

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步对应汇编一行！  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “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 楼 user-5 的回复:楼上的，在看看楼主的代码先吧  *pOutputstr=""; //这个是干啥？ 这里的意思是把""这个字符串常量的地址赋值给*pOutputstr的， //你之前自己malloc的地址指针已经丢失了(也就是内存泄漏)， //你后面free的不是malloc的地址，是静态地址，你free肯定出错阿！   谢谢大神，靠，这么快，两星两勋章了

引用 3 楼 zhao4zhong1 的回复:可能因为你少写了红色部分 strncpy(*pOutputstr, "", 1);(*pOutputstr)[1]=0; 导致越界访问。  崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处。  判断是否越界访问，可以在数组的最后一个元素之后对应的地址处设置数据读写断点。如果该地址对应其它变量干扰判断，可将数组多声明一个元素，并设置数据读写断点在该多出元素对应的地址上。 #include <time.h> #include <stdlib.h> #include <windows.h> int main() {     int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]      srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。     while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。         b[(a=rand()%11)]=0;         Sleep(100);         b[(a=rand()%11)]=1;         Sleep(100);         b[(a=rand()%11)]=2;         Sleep(100);         b[(a=rand()%11)]=3;         Sleep(100);         b[(a=rand()%11)]=4;         Sleep(100);     }     return 0; } 赵老师，可能是我提问里面表达得不是很清晰，我说的是strncpy(*pOutputstr, "", 1);这种方法是不会出问题的，而是*pOutputstr="";这样出问题了

#pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！

楼主，看看四楼的就说的很到位了，你的本质还是指针问题 ,*pOutputstr是个指针你前面已经为他分配了一片内存空间了，*pOutputstr="";（按你的意思这句话应该是**pOutputstr="";你这里估计是想用那句话替代strcpy，但是你不知道strcpy的实现机制，strcpy虽然传递的是指针，但是修改的是指针所指向的内容。就像你这里二级指针的运用，想重新为他分配空间，只能传递个二级指针，否则只是修改了形参值。）就相当于你让他指向了“”所在的内存空间，这可是字符串字面量啊，free释放的是什么位置？人家放在什么位置？你要释放人家，操作系统能答应？况且你前面申请的那两个字节内存呢，怎么释放?简单的写几句话就行！  char *s = "hello";//之后改为char s[] = "hello";试试 s[0] = 'H';     //可猜测其位置

引用 4 楼 user-5 的回复:楼上的，在看看楼主的代码先吧  *pOutputstr=""; //这个是干啥？ 这里的意思是把""这个字符串常量的地址赋值给*pOutputstr的， //你之前自己malloc的地址指针已经丢失了(也就是内存泄漏)， //你后面free的不是malloc的地址，是静态地址，你free肯定出错阿！     只能 free  malloc, calloc, realloc 产生的指针，并且指针不能移动

Continumax(&pOutputstr, intputstr) 这里的第一个参数没错吗？

引用 1 楼 zhao4zhong1 的回复:2个字节就别malloc了吧。 static char buf[2]; *pOutputstr = (char*)buf;  另外 strncpy(*pOutputstr, "", 1);(*pOutputstr)[1]=0; 赵老师，我知道可以不用malloc，我想弄清楚的是为什么我问的那种情况会异常崩溃：）


Question: 请教这题怎么做

int is_white(int ch) {     if(ch == ' ' || ch == '\n' || ch == '\r' || ch == '\v' || ch == '\t' || ch == '\f')           return 1;     else           return 0;       } void deblank(char string[]) {      char *src;      char *dst;      char str[100] = {0};      char ch;      /*      **set two pointers to begining of the string      **,then move to 2nd character in the string      */      src = string;      dst = str;      /*      **Examine the string from the source string      */      while((ch = *src++) != '\0')      {                if(is_white(ch))                {                     if(src == string || !is_white(*(dst-1)))/*空格出现在串首或者它的前一个字符不是空格则存储为空格*/                             *dst++ = ' ';                           }                else                            *dst++ = ch;      }      *dst = '\0';      printf("%s\n",str);           } 这是两个函数，当然也可以归纳为一个函数，用这两个函数就能满足你的条件了，主函数我就没写了

你自己写的这个不是统计有多少个空格么，而且其中有错误


Question: select后recv的问题

引用 5 楼 hepeizhong2010 的回复:我用select指定超时时间来检测状态。在我select返回大于0时，说明描述符已经就绪了，那我recv应该能得到数据，可是为什么recv错误，错误代码10035，无法立即完成一个非阻止性套接字操作。而我等待一段时间再recv就能得到数据，我的问题就在这里。  select函数用法就写错了 改成这样！ select(clientC+1, &r, 0, 0, &timeout);

《TCP-IP详解卷二：实现》

引用 2 楼 max_min_ 的回复: int select(int nfds, fd_set *readfds, fd_set *writefds,            fd_set *exceptfds, struct timeval *timeout);  //能说下你select是要干啥呢? //1 如果当成sleep作用的话，前面都设置空 //2 如果是监听套接字的话，第一个参数是监听的套接值+1 select(clientC+1, &r, 0, 0, &timeout); 是这样的，我想用select做recv的超时，我得到select的返回值为1，可是马上recv的话返回的是-1.

1. socket 编程要检查返回值 2. 学会查函数的原型--google

ret = select(0, 0, &r, 0, &timeout); 的第二个参数是rd, 第三个参数是wd 第四个参数是ed, 你第三个参数应该放在第二个参数上： ret = select(0, &r, 0, 0, &timeout);


Question: 求助，有关C函数的初级问题

问题已解决，但其中原理是什么呢？

引用 4 楼 u012373530 的回复:scanf ("%lf%lf",&a,&b); 你这里的"%lf%lf"不是以逗号隔开的，所以你输入应该以空格隔开，比如输入： 5.55555   6.666666 或者你把"%lf%lf"改为"%lf,%lf" 支持&同意这种观点 或者将scanf ("%lf%lf",&a,&b);改为scanf ("%lf,%lf",&a,&b);,控制台输入方式同楼主的截图所示。

printf() double 格式用 %f

前后格式对应起来就好

想怎么输入都行的话，参考下面： #include <stdio.h> char s[]="123 ab 4"; char *p; int v,n,k; void main() {     p=s;     while (1) {         k=sscanf(p,"%d%n",&v,&n);         printf("k,v,n=%d,%d,%d\n",k,v,n);         if (1==k) {             p+=n;         } else if (0==k) {             printf("skip char[%c]\n",p[0]);             p++;         } else {//EOF==k             break;         }     }     printf("End.\n"); } //k,v,n=1,123,3 //k,v,n=0,123,3 //skip char[ ] //k,v,n=0,123,3 //skip char[a] //k,v,n=0,123,3 //skip char[b] //k,v,n=1,4,2 //k,v,n=-1,4,2 //End.

引用 1 楼 turingo 的回复:输入的时候把逗号改为空格。  [quote=引用 楼主 k91191 的回复:] 我编写了这样一段代码想要返回两个数的的最小值： #include <stdio.h> double min (double x,double y); int main (void) { 	double a,b,c; 	scanf ("%lf%lf",&a,&b); 	printf ("a=%lf,b=%lf\n",a,b);         c=min (a,b); 	printf ("%lf\n",c); 	return 0; }  double min (double x,double y) {           if (x<y)      return x;       else       return y; }  结果却是： 为什么b和最终结果都为0.000000[/quote] 狗哥正解啊

输入的时候把逗号改为空格。  引用 楼主 k91191 的回复:我编写了这样一段代码想要返回两个数的的最小值： #include <stdio.h> double min (double x,double y); int main (void) { 	double a,b,c; 	scanf ("%lf%lf",&a,&b); 	printf ("a=%lf,b=%lf\n",a,b);         c=min (a,b); 	printf ("%lf\n",c); 	return 0; }  double min (double x,double y) {           if (x<y)      return x;       else       return y; }  结果却是： 为什么b和最终结果都为0.000000


Question: c/c++查看cpu温度、硬盘温度、内存温度。求完整代码

cpu温度怎么获取求代码

您好谢谢您，您这个我有。谢谢您

内存温度怎么获取？

希望这个对你有点帮助 http://zhaofuguang.blog.163.com/blog/static/3787330320111129553376/

可以查看自己机器，到别人就不行，我用的2010.

// q1.cpp : 定义控制台应用程序的入口点。 //  #include "stdafx.h"  #include <afxcoll.h> #include<cstring> #define _WIN32_DCOM #include <iostream> using namespace std; #include <comdef.h> #include <Wbemidl.h>  # pragma comment(lib, "wbemuuid.lib")  int _tmain(int argc, _TCHAR* argv[]) { 	CString m_strTest;  	CoInitializeEx(0,COINIT_MULTITHREADED); 	try  	{ 		if(SUCCEEDED(CoInitializeSecurity(NULL,-1,NULL,NULL,RPC_C_AUTHN_LEVEL_DEFAULT,RPC_C_IMP_LEVEL_IMPERSONATE,NULL,EOAC_NONE,NULL)))  		{ 			IWbemLocator *pLoc=NULL; 			if(SUCCEEDED(CoCreateInstance(CLSID_WbemLocator,0,CLSCTX_INPROC_SERVER,IID_IWbemLocator,(LPVOID *)&pLoc))) 			{ 				IWbemServices *pSvc=NULL; 				if(SUCCEEDED(pLoc->ConnectServer(_bstr_t(L"ROOT\\WMI"),NULL,NULL,0,NULL,0,0,&pSvc))) 				{ 					if(SUCCEEDED(CoSetProxyBlanket(pSvc,RPC_C_AUTHN_WINNT,RPC_C_AUTHZ_NONE,NULL,RPC_C_AUTHN_LEVEL_CALL,RPC_C_IMP_LEVEL_IMPERSONATE,NULL,EOAC_NONE))) 					{ 						IEnumWbemClassObject* pEnumerator=NULL; 						if(SUCCEEDED(pSvc->ExecQuery(bstr_t("WQL"),bstr_t("SELECT * FROM MSAcpi_ThermalZoneTemperature"),WBEM_FLAG_FORWARD_ONLY|WBEM_FLAG_RETURN_IMMEDIATELY,NULL,&pEnumerator))) 						{ 							IWbemClassObject *pclsObj; 							ULONG uReturn=0; 							while(pEnumerator) 							{ 								pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);  								if(0==uReturn) 								break; 								VARIANT vtProp; 								VariantInit(&vtProp); 								pclsObj->Get(L"CurrentTemperature", 0, &vtProp, 0, 0);     								VARIANT vtProp1; 								VariantInit(&vtProp1); 								pclsObj->Get(L"Win32_BIOS", 0, &vtProp1, 0, 0);    								VARIANT vtProp2; 								VariantInit(&vtProp2); 								pclsObj->Get(L" Win32_Processor", 0, &vtProp2, 0, 0);  								VARIANT vtProp3; 								VariantInit(&vtProp3); 								pclsObj->Get(L"VendorSpecific", 0, &vtProp3, 0, 0); 								 								//BSTR bstrInfoBIOS = (L"Select * from Win32_BIOS"); 								//wmigetsysteminformation(bstrInfoBIOS); 								wcout<<vtProp1.intVal<<"dsds"<<vtProp2.intVal<<"dsd"<< vtProp2.cVal<<"dsd"<< vtProp3.intVal<< endl; 								wcout << "Current CPU Temperature : " << (vtProp.intVal - 2732)/10.0 << endl; 								 								VariantClear(&vtProp); 								pclsObj->Release(); 							} 						} 					} 					pSvc->Release(); 				} 				pLoc->Release(); 			} 		} 	} catch (_com_error err) { }  	HRESULT hres;  	hres =  CoInitializeEx(0, COINIT_MULTITHREADED);   	hres =  CoInitializeSecurity( 		NULL,  		-1,                          // COM authentication 		NULL,                        // Authentication services 		NULL,                        // Reserved 		RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication  		RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation   		NULL,                        // Authentication info 		EOAC_NONE,                   // Additional capabilities  		NULL                         // Reserved 		);   	IWbemLocator *pLoc = NULL;  	hres = CoCreateInstance( 		CLSID_WbemLocator,              		0,  		CLSCTX_INPROC_SERVER,  		IID_IWbemLocator, (LPVOID *) &pLoc);   	 	IWbemServices *pSvc = NULL;  	 	hres = pLoc->ConnectServer( 		_bstr_t(L"ROOT\\WMI"), // Object path of WMI namespace 		NULL,                    // User name. NULL = current user 		NULL,                    // User password. NULL = current 		0,                       // Locale. NULL indicates current 		NULL,                    // Security flags. 		0,                       // Authority (e.g. Kerberos) 		0,                       // Context object  		&pSvc                    // pointer to IWbemServices proxy 		);  	hres = CoSetProxyBlanket( 		pSvc,                        // Indicates the proxy to set 		RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx 		RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx 		NULL,                        // Server principal name  		RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx  		RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx 		NULL,                        // client identity 		EOAC_NONE                    // proxy capabilities  		);   	IEnumWbemClassObject* pEnumerator = NULL; 	hres = pSvc->ExecQuery( 		bstr_t("WQL"),  		bstr_t("SELECT * FROM MSStorageDriver_ATAPISmartData"), 		WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,  		NULL, 		&pEnumerator);  	  	int nTemperature = 0; 	int nTotalTime = 0;  	IWbemClassObject *pclsObj; 	ULONG uReturn = 0;  	while (pEnumerator) 	{ 		HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,  			&pclsObj, &uReturn);  		if(0 == uReturn) 		{ 			break; 		}  		VARIANT vtProp; 		VariantInit(&vtProp);  		// Get the value of the VendorSpecific property 		hr = pclsObj->Get(L"VendorSpecific", 0, &vtProp, 0, 0);  		//if (vtProp.vt == VT_ARRAY|VT_UI1 ) 		{ 			SAFEARRAY *pIn; 			pIn = vtProp.parray; 			VARTYPE vt; 			UINT dim; 			SafeArrayGetVartype(pIn,&vt);    //获得数据类型 			dim = SafeArrayGetDim(pIn);    //获得维数 			long LBound;                           //下界 			long UBound;                           //上界 			SafeArrayGetLBound(pIn,1,&LBound);    //获得下界 			SafeArrayGetUBound(pIn,1,&UBound);   //获得上界 			BYTE *pdata = new BYTE[UBound-LBound+1]; 			ZeroMemory(pdata,UBound-LBound+1);  			BYTE *buf; 			SafeArrayAccessData(pIn, (void **)&buf); 			memcpy(pdata,buf,UBound-LBound+1); 			SafeArrayUnaccessData(pIn);  			BYTE* pTemp = pdata+2; 			for(int i=2;i<UBound-LBound+1;i+=12) 			{ 				pTemp = pdata+i; 				if (*pTemp == 0xc2) 				{ 					//Beep(1000,200); 					nTemperature = *(pTemp+5); 				}  				if (*pTemp == 0x09) 				{ 					//Beep(1000,200); 					nTotalTime = (*(pTemp+5)) + (*(pTemp+6)<<8); 				}  			} 		}  		//m_strTest.Format("硬盘已经使用了 %d 个小时 ， 现在的温度是 %d C",nTotalTime,nTemperature); 		 		wcout<<nTotalTime<<"硬盘现在的温度是"<<nTemperature<<"c";  		VariantClear(&vtProp); 	}      CoUninitialize(); getchar(); 	return 0; }

您好；您说的是linux系统，谢谢您，我想要windows的。谢谢。

它是个工具，你需要自行在线安装： Ubuntu #apt-get install lm-sensors Centos.Fedora:#yum install lm-sensors

sensors(1)  //传感器                  Linux User's Manual                   sensors(1)  NAME        sensors - print sensors information  SYNOPSIS        sensors [ options ] [ chips ]        sensors -s [ chips ]        sensors --bus-list  DESCRIPTION        sensors is used to show the current readings of all sensor chips.        sensors  -s        file.        sensors --bus-list   OPTIONS        -c config-file               Specify  a configuration file. If no file is specified, the lib‐               sensors default configuration file is used. Use  `-c  /dev/null'               to temporarily disable this default configuration file.         -h     Print a help text and exit.         -s     Evaluate  all  `set'  statements  in  the configuration file and               exit. You must be `root' to do this. If this  parameter  is  not               specified, no `set' statement is evaluated.         -A     Do not show the adapter for each chip.         -u     Raw output. This mode is only meant for debugging.         -v     Print the program version and exit.         -f     Print the temperatures in degrees Fahrenheit instead of Celsius.         --bus-list               Generate bus statements suitable for using in sensors.conf. Such               bus statements are only needed if you have several chips sharing               the  same  address  on  different buses of the same type. As bus               numbers are usually not guaranteed to be  stable  over  reboots,               these  statements  let  you refer to each bus by its name rather               than numbers.

可以写个shell脚本，程序中调用这个脚本，例如一个简单的脚本文件（linux下）  #!/bin/bash  #获取CPU温度 sensors | grep CPUTIN | awk '{print $2}' | cut -c 2-5 #获取系统温度 sensors | grep SYSTIN | awk '{print $2}' | cut -c 2-5

账号:zhao4zhong1昵称:zhao4zhong1已关注 博客空间 最新帖子: 1.C/C++论坛领取赠书需要发站内短... 2.个人意见：不检查scanf函数返回... 3.散分＋普及DOS命令行知识 更多 >>zhao4zhong1 zhao4zhong1 等级：Blank   更多勋章  #1 得分：0  回复于： 2013-10-10 16:32:54    WMI ？

wmi,使用c++或c写的

WMI ？


Question: C程序问题

没给a有效的地址！  int *a = (int *)malloc(sizeof(int));

你直接使用了未经初始化的野指针，在linux环境里必然段错误。

没有给指针a赋地址，也就是说：*a的内容是不确定的。指针使用前应赋值！

#include <stdio.h> #include <stdlib.h> #include <string.h>  int main() { int b = 2;  int *a = &b; printf("%d", *a); return 0; }这样也行。。。

a所指向的地址没有分配内存空间

int* a; int b; b赋给a的方式： 一、 *a = b； 二、 a = (int)malloc(sizeof(int)); memcpy(a, &b, sizeof(int)); //用完free(a);

#include <stdio.h> #include <stdlib.h> #include <string.h>  int main() { int *a = (int*)malloc(sizeof(int)); int b = 2; memcpy(a, &b, sizeof(int)); printf("%d", *a); free(a); return 0; }  引用 楼主 baoyuan24 的回复:#include <stdio.h> #include <stdlib.h> #include <string.h>  int main() { 	int *a; 	int b = 2; 	memcpy(&a, &b, 4); 	printf("%d", *a);  	return 0; } 为什么最后一句printf("%d", *a)会导致段错误？ 以我这样的思路，怎么样改才可以实现将b中的值赋给a的目的？


Question: 如何将多文件C程序创建为动态链接库？

引用 6 楼 lm_whales 的回复:1)IDE 直接 建一个DLL工程，添加那些 .c,和一个.def 用来导出函数， 编译即可  2）命令行 编译那些.c ，.def 生成 .obj 连接成 .dll 如果缺少DLLMain  定义一个就是。++

VS2010直接 建一个DLL工程

如果有源文件就容易

是多个c程序 还是多个源文件？

我Q空间日志，《写代码学习Windowns编程之动态链接库编程》自己写的，有详细过程及代码 Q:284941821

查MSDN是Windows程序员必须掌握的技能之一。

多个文件和单个文件是一回事，建立一个DLL工程，往里面添加C程序即可，参考http://www.vckbase.com/index.php/wv/1381.html  引用 楼主 u011637030 的回复:请问如何将多文件C程序创建为动态链接库？求相关资料！


Question: 白痴到了极点的问题，如何删除保存好的程序

引用 楼主 u012379764 的回复:新手一个，一个编译好的程序如何给删除掉，用的编程软件是Microsoft visual C++，因为里面全是英文的看不懂，找不到删除在哪。拜谢，这个问题纠结我一个月了已经。

点击：Build->Clean 然后重新生成就OK了

点鼠标右键，选删除？ 点鼠标左键，按Del键？

选中要删除的文件名，然后按DELETE键即可。  引用 楼主 u012379764 的回复:新手一个，一个编译好的程序如何给删除掉，用的编程软件是Microsoft visual C++，因为里面全是英文的看不懂，找不到删除在哪。


Question: 为什么18B20用共阴数码管显示为0而1602能显示

数码管 和 LCD 的控制方法一样吗？

数码管需分时扫描进行显示。  引用 楼主 dyb920719 的回复:用18B20做实验，18B20+HC573用共阴数码管显示一直为0，但是18B20一样的程序用1602就能显示温度，求解


Question: 指针强制转换问题 （int*)(char*)buffer

类型转换 只是对内存解释的方式改变了而已

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步对应汇编一行！  单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） //C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+

引用 10 楼 worldy 的回复:[quote=引用 8 楼 wenbei2006 的回复:] [quote=引用 1 楼 turingo 的回复:] 强制转换在于buffer本身的地址不变，但是其意义改变了。  [quote=引用 楼主 wenbei2006 的回复:] 刚刚在看opencv源代码的cvcanny的时候，看到这样一段代码： cv::AutoBuffer<char> buffer; int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer; 有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？[/quote] mag_buf[0] = (int*)(char*)buffer;这个为什么要先强制转换char* 然后再转换成int*，直接转到int*不行吗 [/quote]  对象怎么能直接转换成指针？（char*）应该是个重载运算[/quote]一语惊破梦中人，我再好好看下

引用 8 楼 wenbei2006 的回复:[quote=引用 1 楼 turingo 的回复:] 强制转换在于buffer本身的地址不变，但是其意义改变了。  [quote=引用 楼主 wenbei2006 的回复:] 刚刚在看opencv源代码的cvcanny的时候，看到这样一段代码： cv::AutoBuffer<char> buffer; int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer; 有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？[/quote] mag_buf[0] = (int*)(char*)buffer;这个为什么要先强制转换char* 然后再转换成int*，直接转到int*不行吗 [/quote]  对象怎么能直接转换成指针？（char*）应该是个重载运算

cv::AutoBuffer<char> buffer; 楼主看看这个

引用 1 楼 turingo 的回复:强制转换在于buffer本身的地址不变，但是其意义改变了。  [quote=引用 楼主 wenbei2006 的回复:] 刚刚在看opencv源代码的cvcanny的时候，看到这样一段代码： cv::AutoBuffer<char> buffer; int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer; 有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？[/quote] mag_buf[0] = (int*)(char*)buffer;这个为什么要先强制转换char* 然后再转换成int*，直接转到int*不行吗

引用 6 楼 worldy 的回复:cv::AutoBuffer<char> buffer;//char类型的模板类 int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer;//(char*)应该是一个模板类的运算符，用于将模板类对象转换为类型指针（char*），然后再讲char*转换为int*  有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？ 直接强制转换成int型指针和这样转换有什么区别呢？我的意思是 mag_buf[0] = (int*)(char*)buffer和 mag_buf[0] = (int*)buffer 的区别是什么？

引用 4 楼 AnYidan 的回复:[quote=引用 1 楼 turingo 的回复:] 强制转换在于buffer本身的地址不变，但是其意义改变了。  [quote=引用 楼主 wenbei2006 的回复:] 刚刚在看opencv源代码的cvcanny的时候，看到这样一段代码： cv::AutoBuffer<char> buffer; int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer; 有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？[/quote]  站在不同的角度看同样的object[/quote] 看了一下，果然是  引用 11 楼 wenbei2006 的回复:[quote=引用 10 楼 worldy 的回复:] [quote=引用 8 楼 wenbei2006 的回复:] [quote=引用 1 楼 turingo 的回复:] 强制转换在于buffer本身的地址不变，但是其意义改变了。  [quote=引用 楼主 wenbei2006 的回复:] 刚刚在看opencv源代码的cvcanny的时候，看到这样一段代码： cv::AutoBuffer<char> buffer; int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer; 有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？[/quote] mag_buf[0] = (int*)(char*)buffer;这个为什么要先强制转换char* 然后再转换成int*，直接转到int*不行吗 [/quote]  对象怎么能直接转换成指针？（char*）应该是个重载运算[/quote]一语惊破梦中人，我再好好看下[/quote]  我看了一下cv::AutoBuffer<char> 的源码，果然是对指针强制转换进行了重载，厉害厉害，这样就明白了，分给你了

强制转换的意义在于用一种不同的方法操作数据，前提是那个数据确实是可以那样操作的。 比如电视上有人能够吃玻璃，那就是因为他把玻璃强制转换成食物了，前提是他吃了不会有事。 这个比喻如何啊？

引用 1 楼 turingo 的回复:强制转换在于buffer本身的地址不变，但是其意义改变了。  [quote=引用 楼主 wenbei2006 的回复:] 刚刚在看opencv源代码的cvcanny的时候，看到这样一段代码： cv::AutoBuffer<char> buffer; int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer; 有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？[/quote]  站在不同的角度看同样的object

目测这个操作是将 buffer这个容器作为mag_buf这个指针数组的一个元素 首先要获取buffer这个容器地址，因为容器是char型的，所以先获取一个char*即(char*)buffer 又因为要把它赋给mag_buf这个int*的变量，所以在强制转换一下 最终即 mag_buf[0] = (int*)(char*)buffer; 错了勿喷！！！

未知类型 -> int* 不保证正确 未定义行为 还是 实现定义行为就记不清了  但是呢  任意类型 -> char* 有做保证 指向对象最低单元 另外  char* -> int* 依稀记得可能会造成 严格别名(Strict alias) 内存对齐 等问题 [就是说 如果能确保不会出现那些问题 那么 char* -> int* 就是安全的 ]

强制转换在于buffer本身的地址不变，但是其意义改变了。  引用 楼主 wenbei2006 的回复:刚刚在看opencv源代码的cvcanny的时候，看到这样一段代码： cv::AutoBuffer<char> buffer; int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer; 有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？


Question: 地铁次数问题

大神你好,请问c++版本,如果拆成三个class, 分别是Track,Station, SubwaySystem.   class Track { 	public: 		Track(); 		Track(char input_node_1,char input_node_2); //起始点,终结点 		~Track(); 	private: 		bool visited;  		char node_1; 		char node_2; };  class Station { 	public: 		Station(); 		Station(char Current_Station_ID,int Starting_ID,int Current_Size);//  		~Station();  	private: 		char station_name; //车站名称 		int track_starting_ID;// 		int track_size;  };  class SubwaySystem { 	public: 		SubwaySystem(); 		...                     //Recursive function递归方程 		void SearchRoute(int Current_Station_ID);  		...                      //其他方程      	private: 		Track my_track[34]; 		Station my_station[12]; 		int count_routes; };    在SubwaySystem.cpp里面  #include "subway_system.h"  SubwaySystem::SubwaySystem() { 	//Initialize tracks 	my_track[0] = Track('a','b'); 	my_track[1] = Track('b','a'); 	my_track[2] = Track('b','c'); 	my_track[3] = Track('b','d'); 	my_track[4] = Track('b','e'); 	my_track[5] = Track('b','f'); 	my_track[6] = Track('c','b'); 	my_track[7] = Track('c','e'); 	my_track[8] = Track('d','b'); 	my_track[9] = Track('d','e'); 	my_track[10] = Track('e','b'); 	my_track[11] = Track('e','c'); 	my_track[12] = Track('e','d'); 	my_track[13] = Track('e','g'); 	my_track[14] = Track('e','h'); 	my_track[15] = Track('f','b'); 	my_track[16] = Track('f','h'); 	my_track[17] = Track('g','e'); 	my_track[18] = Track('g','k'); 	my_track[19] = Track('h','e'); 	my_track[20] = Track('h','f'); 	my_track[21] = Track('h','i'); 	my_track[22] = Track('h','j'); 	my_track[23] = Track('h','k'); 	my_track[24] = Track('i','h'); 	my_track[25] = Track('i','k'); 	my_track[26] = Track('j','h'); 	my_track[27] = Track('j','k'); 	my_track[28] = Track('k','g'); 	my_track[29] = Track('k','h'); 	my_track[30] = Track('k','i'); 	my_track[31] = Track('k','j'); 	my_track[32] = Track('k','l'); 	my_track[33] = Track('l','k'); 	 	 	//Initialize stations 	my_station[0] = Station('a',0,1); 	my_station[1] = Station('b',1,5); 	my_station[2] = Station('c',6,2); 	my_station[3] = Station('d',8,2); 	my_station[4] = Station('e',10,5); 	my_station[5] = Station('f',15,2); 	my_station[6] = Station('g',17,2); 	my_station[7] = Station('h',19,5); 	my_station[8] = Station('i',24,2); 	my_station[9] = Station('j',26,2); 	my_station[10] = Station('k',28,5); 	my_station[11] = Station('l',33,1); 	 }  不好意思啊,写的有点乱,只要的一时能不能拆成三个class文件,老师很烦人,不教课,却教我们写作业, 正在恶补class,constructor,之类的东西. 如果有时间,希望大神能给予帮助和指导,谢谢

#include <stdio.h> #include <string.h> #include <stdlib.h>  typedef struct tagPATH { 	tagPATH(const char *Path); 	bool Enable; 	char Begin; 	char End; 	char Name[10]; 	char RevName[10]; } PATH;  PATH::tagPATH(const char *Path) { 	int Length = (int)strlen(Path); 	Enable = true; 	Begin = Path[0]; 	End = Path[Length - 1]; 	strcpy_s(Name, 10, Path); 	for (int i = 0; i < Length; i++) 	{ 		RevName[i] = Name[Length - 1 - i]; 	} 	RevName[Length] = '\0'; }  void SearchPath(char Begin, char End, char **List, int ListSize, PATH *Path, int PathSize) { 	static int _Count = 0; 	if (Begin == End) 	{ 		printf_s("%3d ", ++_Count); 		for (int i = 0; i < ListSize; i++) 		{ 			printf_s("%s ", List[i]); 		} 		printf_s("\n"); 	} 	else 	{ 		for (int i = 0; i < PathSize; i++) 		{ 			if (Path[i].Enable && (Path[i].Begin == Begin || Path[i].End == Begin)) 			{ 				List[ListSize] = Path[i].Begin == Begin ? Path[i].Name : Path[i].RevName; 				Path[i].Enable = false; 				SearchPath(Path[i].Begin == Begin ? Path[i].End : Path[i].Begin, End, List, ListSize + 1, Path, PathSize); 				Path[i].Enable = true; 			} 		} 	} }  int main(void) { 	const int PATH_SIZE = 11; 	char *List[PATH_SIZE]; 	PATH  Path[PATH_SIZE] = {PATH("AB"),PATH("BCE"),PATH("BE"),PATH("BDE"),PATH("BFH"),PATH("EGK"),PATH("EH"),PATH("HIK"),PATH("HK"),PATH("HJK"),PATH("KL")}; 	SearchPath('A', 'L', List, 0, Path, PATH_SIZE);  	system("pause"); 	return 0; }

引用 4 楼 amoyman 的回复:我算了一下，有640种。是这样吧  #include <iostream> #include <vector> using namespace std;  typedef struct tagPATH { 	tagPATH(const char *Path); 	char Begin; 	char End; 	char Name[10]; } PATH;  PATH::tagPATH(const char *Path) { 	int Length = (int)strlen(Path); 	Begin = Path[0]; 	End = Path[Length - 1]; 	strcpy_s(Name, 10, Path); }  void SearchPath(char Begin, char End, vector<int> &memPath, PATH *Path, int Size) { 	static int _Count = 0; 	if (Begin == End) 	{ 		printf_s("%3d ", ++_Count); 		for (vector<int>::iterator it = memPath.begin(); it != memPath.end(); it++) 		{ 			printf_s("%s ", Path[*it].Name); 		} 		printf_s("\n"); 		return; 	} 	bool *Enable = new bool[Size]; 	memset(Enable, true, Size); 	for (vector<int>::iterator it = memPath.begin(); it != memPath.end(); it++) 	{ 		Enable[*it] = false; 	} 	for (int i = 0; i < Size; i++) 	{ 		if (Enable[i]) 		{ 			if (Path[i].Begin == Begin) 			{ 				memPath.push_back(i); 				SearchPath(Path[i].End, End, memPath, Path, Size); 				memPath.pop_back(); 			} 			else if (Path[i].End == Begin) 			{ 				memPath.push_back(i); 				SearchPath(Path[i].Begin, End, memPath, Path, Size); 				memPath.pop_back(); 			} 		} 	} 	delete[] Enable; }  // 定义所有的线路  int main(void) { 	const int PATH_SIZE = 11; 	PATH Path[PATH_SIZE] = 	{ 		PATH("AB"), 		PATH("BCE"), 		PATH("BE"), 		PATH("BDE"), 		PATH("BFH"), 		PATH("EGK"), 		PATH("EH"), 		PATH("HIK"), 		PATH("HK"), 		PATH("HJK"), 		PATH("KL") 	}; 	vector<int> memPath; 	SearchPath('A', 'L', memPath, Path, PATH_SIZE);  	system("pause"); 	return 0; }   没事了,十分感谢,可以用,640种应该是对的; 请问您C的版本熟悉么

引用 4 楼 amoyman 的回复:我算了一下，有640种。是这样吧  #include <iostream> #include <vector> using namespace std;  typedef struct tagPATH { 	tagPATH(const char *Path); 	char Begin; 	char End; 	char Name[10]; } PATH;  PATH::tagPATH(const char *Path) { 	int Length = (int)strlen(Path); 	Begin = Path[0]; 	End = Path[Length - 1]; 	strcpy_s(Name, 10, Path); }  void SearchPath(char Begin, char End, vector<int> &memPath, PATH *Path, int Size) { 	static int _Count = 0; 	if (Begin == End) 	{ 		printf_s("%3d ", ++_Count); 		for (vector<int>::iterator it = memPath.begin(); it != memPath.end(); it++) 		{ 			printf_s("%s ", Path[*it].Name); 		} 		printf_s("\n"); 		return; 	} 	bool *Enable = new bool[Size]; 	memset(Enable, true, Size); 	for (vector<int>::iterator it = memPath.begin(); it != memPath.end(); it++) 	{ 		Enable[*it] = false; 	} 	for (int i = 0; i < Size; i++) 	{ 		if (Enable[i]) 		{ 			if (Path[i].Begin == Begin) 			{ 				memPath.push_back(i); 				SearchPath(Path[i].End, End, memPath, Path, Size); 				memPath.pop_back(); 			} 			else if (Path[i].End == Begin) 			{ 				memPath.push_back(i); 				SearchPath(Path[i].Begin, End, memPath, Path, Size); 				memPath.pop_back(); 			} 		} 	} 	delete[] Enable; }  // 定义所有的线路  int main(void) { 	const int PATH_SIZE = 11; 	PATH Path[PATH_SIZE] = 	{ 		PATH("AB"), 		PATH("BCE"), 		PATH("BE"), 		PATH("BDE"), 		PATH("BFH"), 		PATH("EGK"), 		PATH("EH"), 		PATH("HIK"), 		PATH("HK"), 		PATH("HJK"), 		PATH("KL") 	}; 	vector<int> memPath; 	SearchPath('A', 'L', memPath, Path, PATH_SIZE);  	system("pause"); 	return 0; }   刚才尝试用你给你的code 跑一下,发现Line 18的Strcpy_s 没有定义? Line26 print_s 好像也是同样的问题. 求大神答疑.

仅供参考//1 2 3 //4 5 6 求一笔划过所有9个键的所有方法 //7 8 9 #include <stdio.h> int g[10][9]={     {0,0,0,0,0,0,0,0,0},     {2,4,5,0,0,0,0,0,0},//1     {1,3,4,5,6,0,0,0,0},//2     {2,5,6,0,0,0,0,0,0},//3     {1,2,5,7,8,0,0,0,0},//4     {1,2,3,4,6,7,8,9,0},//5     {2,3,5,8,9,0,0,0,0},//6     {4,5,8,0,0,0,0,0,0},//7     {4,5,6,7,9,0,0,0,0},//8     {5,6,8,0,0,0,0,0,0},//9 }; int k,i,n; int h[10];//记录是否划过h[1..9],history int p[10];//记录划的顺序p[1..9],path void go(int f,int L) {     int j;      if (L==9) {         p[L]=f;         n++;         printf("%08d:",n);         for (i=1;i<=9;i++) printf(" %d",p[i]);         printf("\n");     } else {         p[L]=f;         h[f]=1;         j=0;         while (1) {             if (g[f][j]==0) break;             if (h[g[f][j]]==0) {                 go(g[f][j],L+1);                 h[g[f][j]]=0;             }             j++;         }     } } int main() {     n=0;     for (k=1;k<=9;k++) {         for (i=1;i<=9;i++) h[i]=0;         go(k,1);     }     return 0; } //00000001: 1 2 3 5 4 7 8 6 9 //00000002: 1 2 3 5 4 7 8 9 6 //00000003: 1 2 3 5 6 9 8 4 7 //00000004: 1 2 3 5 6 9 8 7 4 //00000005: 1 2 3 5 7 4 8 6 9 //00000006: 1 2 3 5 7 4 8 9 6 //00000007: 1 2 3 5 9 6 8 4 7 //00000008: 1 2 3 5 9 6 8 7 4 //00000009: 1 2 3 6 5 4 7 8 9 //00000010: 1 2 3 6 5 7 4 8 9 //00000011: 1 2 3 6 5 9 8 4 7 //00000012: 1 2 3 6 5 9 8 7 4 //00000013: 1 2 3 6 8 4 7 5 9 //00000014: 1 2 3 6 8 7 4 5 9 //00000015: 1 2 3 6 8 9 5 4 7 //00000016: 1 2 3 6 8 9 5 7 4 //00000017: 1 2 3 6 9 5 4 7 8 //00000018: 1 2 3 6 9 5 4 8 7 //00000019: 1 2 3 6 9 5 7 4 8 //00000020: 1 2 3 6 9 5 7 8 4 //00000021: 1 2 3 6 9 5 8 4 7 //00000022: 1 2 3 6 9 5 8 7 4 //00000023: 1 2 3 6 9 8 4 5 7 //00000024: 1 2 3 6 9 8 4 7 5 //00000025: 1 2 3 6 9 8 5 4 7 //00000026: 1 2 3 6 9 8 5 7 4 //00000027: 1 2 3 6 9 8 7 4 5 //00000028: 1 2 3 6 9 8 7 5 4 //00000029: 1 2 4 5 3 6 9 8 7 //00000030: 1 2 4 5 7 8 9 6 3 //00000031: 1 2 4 7 5 3 6 8 9 //00000032: 1 2 4 7 5 3 6 9 8 //00000033: 1 2 4 7 5 8 9 6 3 //00000034: 1 2 4 7 5 9 8 6 3 //00000035: 1 2 4 7 8 5 3 6 9 //00000036: 1 2 4 7 8 5 9 6 3 //00000037: 1 2 4 7 8 6 3 5 9 //00000038: 1 2 4 7 8 6 9 5 3 //00000039: 1 2 4 7 8 9 5 3 6 //00000040: 1 2 4 7 8 9 5 6 3 //00000041: 1 2 4 7 8 9 6 3 5 //00000042: 1 2 4 7 8 9 6 5 3 //00000043: 1 2 4 8 7 5 3 6 9 //00000044: 1 2 4 8 7 5 9 6 3 //00000045: 1 2 4 8 9 6 3 5 7 //00000046: 1 2 5 3 6 9 8 4 7 //00000047: 1 2 5 3 6 9 8 7 4 //00000048: 1 2 5 4 7 8 9 6 3 //00000049: 1 2 5 7 4 8 9 6 3 //00000050: 1 2 6 3 5 4 7 8 9 //00000051: 1 2 6 3 5 7 4 8 9 //00000052: 1 2 6 3 5 9 8 4 7 //00000053: 1 2 6 3 5 9 8 7 4 //00000054: 1 2 6 9 8 4 7 5 3 //00000055: 1 2 6 9 8 7 4 5 3 //00000056: 1 4 2 3 5 6 9 8 7 //... ... //00000776: 9 8 7 4 5 6 3 2 1 //00000777: 9 8 7 5 1 4 2 3 6 //00000778: 9 8 7 5 1 4 2 6 3 //00000779: 9 8 7 5 3 6 2 1 4 //00000780: 9 8 7 5 3 6 2 4 1 //00000781: 9 8 7 5 4 1 2 3 6 //00000782: 9 8 7 5 4 1 2 6 3 //00000783: 9 8 7 5 6 3 2 1 4 //00000784: 9 8 7 5 6 3 2 4 1

排列组合问题。  引用 楼主 geo24 的回复:如果从A站出发到L站,中间路径不可以重复,但是站台可以重复,请问有多少种做法?    希望能用C和C++各一种方法.  这是一个作业,希望可以有经验的前辈给予帮助 .  助教已经给力些帮助,没办法我的底子太差.  #include <stdio.h>    int a[12][12]={0,1,0,0,0,0,0,0,0,0,0,0, 			1,0,1,1,1,1,0,0,0,0,0,0, 			0,1,0,0,1,0,0,0,0,0,0,0,                         0,1,0,0,1,0,0,0,0,0,0,0, 		        0,1,1,1,0,0,1,1,0,0,0,0, 			0,1,0,0,0,0,0,1,0,0,0,0,                         0,0,0,0,1,0,0,0,0,0,1,0, 		        0,0,0,0,1,1,0,0,1,1,1,0, 		        0,0,0,0,0,0,0,1,0,0,1,0,                         0,0,0,0,0,0,1,1,0,0,1,0, 		        0,0,0,0,0,0,0,1,1,1,0,1, 		        0,0,0,0,0,0,0,0,0,0,1,0                 }; 	void SearchRoute(int row, int col) 	{ 		        if()            //find a succseful route to L 		{ 			...		//ADD 1 into varibale  			 			...		//print out this route 					 			return; 		} 		 		        else {  //Get into recursive Function Body 			 			      while(col < 12) // becuase "11" is the ending point L 			{ 				....  //Find one possible step (push stack) 				 				.... // save this step & make it used 				 				SearchRoute(col, 0); 				 				...		// Backtrack this step, 1-0-1 (pop stack) 				 				col++; 			} 			 		} 	}    void main ()  { 	   }

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


Question: 求i输入一个数，判断它的奇偶性，错误在哪里？

直接用p%2判断它余数为1则是奇数，余数为0则是偶数，干嘛要写那么复杂。

楼主看的啥教材？  函数返回值 竟然全是double？  换本书看看吧！

把double换成int  引用 楼主 u011688498 的回复:我写了代码，但是运行之后输入数字结果不准确，不知道哪里出错了！ 求真实的代码，需不需要把double换成int? 新手求教 #include<stdio.h> double main() { 	double shang(); 	double p; 	p=shang(); 	printf("结果，商是:%d\n",p); 	if(p>=0)       printf("这个数是基数\n"); 	 else       printf("这个数是偶数\n"); 	 return 0; }  double shang() { 	int x,y; 	scanf("%d",&x); 	printf("阁下输入的是：%d\n正在计算....................\n",x); 	y=x%2;     return (y); }

引用 4 楼 sruru 的回复:一点建议，为什么不把参数接手以后传递到函数呢？ int idEvenOdd(int num) {   int result = num /2;   return result; }怎么说？有没有详细的代码？

引用 2 楼 max_min_ 的回复:楼主看的啥教材？  函数返回值 竟然全是double？  换本书看看吧！没人教，都是自己胡打的

引用 3 楼 user-7 的回复:转换太乱套了 在你这个代码中 可以一律用 int可以的吗？？好像商有小数啊

引用 5 楼 yulitingfeng 的回复:#include<stdio.h>  double main()  {      double shang();      double p;      p=shang();      printf("结果，商是:%f\n",p);      if(p<=-0.000001||p>=0.000001) //double 的零值比较问题       printf("这个数是基数\n");       else       printf("这个数是偶数\n");       return 0;  }     double shang()  {      int x,y;      scanf("%d",&x);      printf("阁下输入的是：%d\n正在计算....................\n",x);      y=x%2;      return (y);  }  p 是double类型。与0 比较的方式不对。可以试下修改过的 ++

转换太乱套了 在你这个代码中 可以一律用 int


Question: 如何将线程中得到的buffer攒够20包后，再按顺序一起postmessage出去

仅供参考//循环向a函数每次发送200个字节长度（这个是固定的）的buffer, //a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理， //在处理的时候每次从新buffer中取两个字节打印 #ifdef WIN32     #pragma warning(disable:4996) #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef WIN32     #include <windows.h>     #include <process.h>     #include <io.h>     #define  MYVOID             void     #define  vsnprintf          _vsnprintf #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  MYVOID             void * #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); } void sleep_ms(int ms) {     Sleep(ms); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } void sleep_ms(int ms) {     usleep(ms*1000); } #endif void LogV(const char *pszFmt,va_list argp) {     struct tm *now;     struct timeb tb;      if (NULL==pszFmt||0==pszFmt[0]) return;     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} #define ASIZE    200 #define BSIZE    240 #define CSIZE      2 char Abuf[ASIZE]; char Cbuf[CSIZE]; CRITICAL_SECTION cs_HEX ; CRITICAL_SECTION cs_BBB ; struct FIFO_BUFFER {     int  head;     int  tail;     int  size;     char data[BSIZE]; } BBB; int No_Loop=0; void HexDump(int cn,char *buf,int len) {     int i,j,k;     char binstr[80];      Lock(&cs_HEX);     for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%03d %04x -",cn,i);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             Log("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         Log("%s\n",binstr);     }     Unlock(&cs_HEX); } int GetFromRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      lent=0;     Lock(cs);     if (fbuf->size>=len) {         lent=len;         if (fbuf->head+lent>BSIZE) {             len1=BSIZE-fbuf->head;             memcpy(buf     ,fbuf->data+fbuf->head,len1);             len2=lent-len1;             memcpy(buf+len1,fbuf->data           ,len2);             fbuf->head=len2;         } else {             memcpy(buf     ,fbuf->data+fbuf->head,lent);             fbuf->head+=lent;         }         fbuf->size-=lent;     }     Unlock(cs);     return lent; } MYVOID thdB(void *pcn) {     char        *recv_buf;     int          recv_nbytes;     int          cn;     int          wc;     int          pb;      cn=(int)pcn;     Log("%03d thdB              thread begin...\n",cn);     while (1) {         sleep_ms(10);         recv_buf=(char *)Cbuf;         recv_nbytes=CSIZE;         wc=0;         while (1) {             pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);             if (pb) {                 Log("%03d recv %d bytes\n",cn,pb);                 HexDump(cn,recv_buf,pb);                 sleep_ms(1);             } else {                 sleep_ms(1000);             }             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef WIN32     pthread_exit(NULL); #endif } int PutToRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      Lock(cs);     lent=len;     if (fbuf->size+lent>BSIZE) {         lent=BSIZE-fbuf->size;     }     if (fbuf->tail+lent>BSIZE) {         len1=BSIZE-fbuf->tail;         memcpy(fbuf->data+fbuf->tail,buf     ,len1);         len2=lent-len1;         memcpy(fbuf->data           ,buf+len1,len2);         fbuf->tail=len2;     } else {         memcpy(fbuf->data+fbuf->tail,buf     ,lent);         fbuf->tail+=lent;     }     fbuf->size+=lent;     Unlock(cs);     return lent; } MYVOID thdA(void *pcn) {     char        *send_buf;     int          send_nbytes;     int          cn;     int          wc;     int           a;     int          pa;      cn=(int)pcn;     Log("%03d thdA              thread begin...\n",cn);     a=0;     while (1) {         sleep_ms(100);         memset(Abuf,a,ASIZE);         a=(a+1)%256;         if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop         send_buf=(char *)Abuf;         send_nbytes=ASIZE;         Log("%03d sending %d bytes\n",cn,send_nbytes);         HexDump(cn,send_buf,send_nbytes);         wc=0;         while (1) {             pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);             Log("%03d sent %d bytes\n",cn,pa);             HexDump(cn,send_buf,pa);             send_buf+=pa;             send_nbytes-=pa;             if (send_nbytes<=0) break;//             sleep_ms(1000);             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef WIN32     pthread_exit(NULL); #endif } int main() { #ifdef WIN32     InitializeCriticalSection(&cs_log);     InitializeCriticalSection(&cs_HEX );     InitializeCriticalSection(&cs_BBB ); #else     pthread_t threads[2];     int threadsN;     int rc;     pthread_mutex_init(&cs_log,NULL);     pthread_mutex_init(&cs_HEX,NULL);     pthread_mutex_init(&cs_BBB,NULL); #endif     Log("Start===========================================================\n");      BBB.head=0;     BBB.tail=0;     BBB.size=0;  #ifdef WIN32     _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);     _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2); #else     threadsN=0;     rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);     rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1); #endif      if (!access("No_Loop",0)) {         remove("No_Loop");         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     while (1) {         sleep_ms(1000);         if (No_Loop) break;//         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     sleep_ms(3000);     Log("End=============================================================\n"); #ifdef WIN32     DeleteCriticalSection(&cs_BBB );     DeleteCriticalSection(&cs_HEX );     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_BBB);     pthread_mutex_destroy(&cs_HEX);     pthread_mutex_destroy(&cs_log); #endif     return 0; }


Question: gdb调试段错误具体方法

引用 楼主 u012378280 的回复:最让人头痛的是调试的时候出现段错误，要怎样才能找出来？求大神解答！ 段错误，你高清段错误的实质就知道怎么调了。  我用看都能看出来一般，看不出来用消息打印

使用帮助man，有样例，看下各命令

引用 21 楼 zhao4zhong1 的回复:[quote=引用 19 楼 u012378280 的回复:] [quote=引用 16 楼 zhao4zhong1 的回复:]    使用共享内存，编程实现一个进程往共享内存中写数据，另一个进程从共享内存中读取数据这要怎么写？ Linux下不知道。 Windows下参考Microsoft SDK\samples\winbase\SharedMem [/quote]   windows底下怎么操作？

引用 16 楼 zhao4zhong1 的回复:前提是你的源代码名字是string.cpp或string.c g++或gcc生成的可执行文件名是string   我知道了。。。。原来是gcc -o string string.c才行

core有时候不大好用，如果走到了某个无调试信息的lib中而导致了segmentfault 而这个调用层次软多时，会显示不出来在哪出问题。

引用 19 楼 u012378280 的回复:[quote=引用 16 楼 zhao4zhong1 的回复:]    使用共享内存，编程实现一个进程往共享内存中写数据，另一个进程从共享内存中读取数据这要怎么写？ Linux下不知道。 Windows下参考Microsoft SDK\samples\winbase\SharedMem

如果不指定名称的话，生成的就是那个a.out

这东西网上一搜大把。。。

楼上的这个提示不是很明显吗？ ./string都没有生成

引用 13 楼 zhao4zhong1 的回复:1. ulimit -c 100 2. ./string 这步会生成core文件 3. gdb string core 4. bt   这是怎么回事？

// 在当前目录生成core文件 echo "./core_$(date +%Y-%m-%d_%H-%M-%S)_%p.core" > /proc/sys/kernel/core_pattern // core文件大小不限制 ulimit -c unlimited  gdb 可执行文件名 core文件名 // 进入gdb后使用 bt bt full

引用 楼主 u012378280 的回复:最让人头痛的是调试的时候出现段错误，要怎样才能找出来？求大神解答！ 我想说的是，段错误最好找了，用眼睛看都行，代码多了用printf或者printk

ulimit  功能说明：控制shell程序的资源。  语　　法：ulimit [-aHS][-c <core文件上限>][-d <数据节区大小>][-f <文件大小>][-m <内存大小>][-n <文件数目>][-p <缓冲区大小>][-s <堆叠大小>][-t <CPU时间>][-u <程序数目>][-v <虚拟内存大小>]  补充说明：ulimit为shell内建指令，可用来控制shell执行程序的资源。  参　　数：   -a 　显示目前资源限制的设定。    -c <core文件上限> 　设定core文件的最大值，单位为区块。    -d <数据节区大小> 　程序数据节区的最大值，单位为KB。    -f <文件大小> 　shell所能建立的最大文件，单位为区块。    -H 　设定资源的硬性限制，也就是管理员所设下的限制。    -m <内存大小> 　指定可使用内存的上限，单位为KB。    -n <文件数目> 　指定同一时间最多可开启的文件数。    -p <缓冲区大小> 　指定管道缓冲区的大小，单位512字节。    -s <堆叠大小> 　指定堆叠的上限，单位为KB。    -S 　设定资源的弹性限制。    -t <CPU时间> 　指定CPU使用时间的上限，单位为秒。    -u <程序数目> 　用户最多可开启的程序数目。    -v <虚拟内存大小> 　指定可使用的虚拟内存上限，单位为KB。

引用 7 楼 u012378280 的回复:1. ulimit -c unlimited your_app_name 2. your_app_name and_its_parameters 这步会生成core文件 3. gdb core_file_name  这一般比较单步高试要快，尤其是对代码不是很熟的时候。 怎么调试的可以截图过来看下 your_app_name说的程序，不是源码。

引用 6 楼 user-8 的回复:[quote=引用 5 楼 u012378280 的回复:] ulimit -c core?????  1. ulimit -c unlimited your_app_name 2. your_app_name and_its_parameters 这步会生成core文件 3. gdb core_file_name  这一般比较单步高试要快，尤其是对代码不是很熟的时候。 [/quote]    麻烦调试界面截图过来看下好吗

引用 5 楼 u012378280 的回复:ulimit -c core?????  1. ulimit -c unlimited your_app_name 2. your_app_name and_its_parameters 这步会生成core文件 3. gdb core_file_name  这一般比较单步高试要快，尤其是对代码不是很熟的时候。


Question: c primer plus    习题12.6

++简化。。。。。。。。。晕。


Question: 怎样创建一个一bit的变量

多谢rocktyt。

请搜索位域.

unsigned int i; int flag = i >> 31; int id = (i >> 16) & 0x7fff; int i2 = i & 0xffff;


8155的操作时序很简单，都是硬件自己完成的，不需要认为去操作。

首先得弄清楚8155的接口和时序。  引用 楼主 happypdw0219 的回复:我使用P89V51RD2单片机驱动8155芯片，但是8155芯片驱动不起来，如果换成芯片就能驱动起来，此事一直困扰我好久，求大神指教？？？？

但是8155 芯片驱动不起来， 如果换成 芯片就能驱动起来

发到嵌入式版块看看


Question: 我用while来建立一个树，不成功，帮我看看。

输入得到的结果为

我修必了一下程序，成功显示了，不知这个树图是否正确，  程序如下：  #include "stdafx.h" #include "stdio.h" #include "stdlib.h"  typedef int Item;  typedef struct node  { 	Item item; 	struct node *left; 	struct node *right; 	 }Node;  typedef struct tree { 	Node *root; 	int size; }Tree;  void InitializeTree(Tree *ptree); void CreateTree(int *ar, int n, Item item, Tree *ptree); void CountTree(Tree *ptree); void PreShowTree(Tree *ptree); void MidShowTree(int m, int n, Tree *ptree);  int main(void) { 	 Tree data; 	Item number; 	int array[3]; 	array[0] = 0; 	array[1] = 0; 	array[2] = 0;  	InitializeTree(&data); 	puts("Please enter the first item:(enter 'q' to quit)"); 	while(scanf("%d", &number) == 1) 	{ 		while(getchar() != '\n') 		{ 			continue; 		} 		CreateTree(array, 3, number, &data); 		puts("Please enter another item:(enter 'q' to quit)"); 	} 	Tree copy; 	copy = data; 	printf("There are %d items on the tree.\n", array[0]); 	printf("There are %d items on the left tree.\n", array[1]); 	printf("There are %d items on the right tree.\n", array[2]); 	puts("先序显示："); 	PreShowTree(&data); 	puts("\n中序显示："); 	MidShowTree(array[1], array[2], ©); 	printf("\n");  	return 0; }  void InitializeTree(Tree *ptree) { 	ptree->root = NULL; 	ptree->size = 0; }  void CreateTree(int *ar, int n, Item item, Tree *ptree) { static	Node *current; 	current = ptree->root; 	Node *pnew; 	pnew = (Node *)malloc(sizeof(Node)); 	if(pnew == NULL) 	{ 		fprintf(stderr, "Failing to allocate memory.\n"); 	} 	else 	{ 		pnew->item = item; 		pnew->left = NULL; 		pnew->right = NULL; 		if(current == NULL) 		{ 			ptree->root = pnew; 		//	current = pnew; 		} 		else 		{			 			if(item > 10) 			{ 				while(1) 				{ 					 					if(current->left != NULL) 					{ 						current = current->left; 					} 					else 					{ 						break; 					} 				}				 				current->left = pnew; 				ar[1] = ar[1] + 1; 			} 			else 			{ 				while(1) 				{ 					if(current->right != NULL) 					{ 						current = current->right; 					} 					else 					{ 						break; 					}	 				}			 				current->right = pnew;	 				ar[2] = ar[2]+1; 			}			 		} 		ptree->size++; 		ar[0] = ptree->size; 	} }   void CountTree(Tree *ptree) { 	 ptree->size; } void PreShowTree(Tree *ptree) { 	Node *current; 	current = ptree->root; 	if(ptree->root != NULL) 	{ 		printf("%d ", ptree->root->item); 		while(ptree->root->left != NULL) 		{ 			printf("%d ", ptree->root->left->item);	 			ptree->root = ptree->root->left;		 			//printf("%d ", ptree->root->item); 		}  		while(current->right != NULL) 		{ 			printf("%d ", current->right->item);	 			current = current->right;		 			//printf("%d ", ptree->root->item); 		} 	 	}	 }  void MidShowTree(int m, int n, Tree *ptree) { 	int i = 0; 	  Node *current; 	current = ptree->root; //	printf("%d ", current->item); 	 	if(ptree->root != NULL) 	{							 		while(1) 		{ 			current = ptree->root; 			while (i<m && current->left != NULL) 			{ 			//	printf("%d ", ptree->root->left->item); 				current = current->left; 				i++;				 			} 			printf("%d ", current->item); 			i = 0; 			m = m-1; 			if(m == 0) 			{ 				break; 			} 		} 			printf("%d ",ptree->root->item);  		while(1) 		{ 			current = ptree->root; 			while (i<n && current->right != NULL) 			{ 			//	printf("%d ", ptree->root->left->item); 				current = current->right; 				i++;				 			} 			printf("%d ", current->item); 			i = 0; 			n = n-1; 			if(n == 0) 			{ 				break; 			} 		} 		   	} }

谢谢楼上，我根据您说的再改改程序。

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

step by step debug

我随便输入几个数，得到如下结果： Please enter the first item:(enter 'q' to qu 12 Please enter another item:(enter 'q' to quit 45 Please enter another item:(enter 'q' to quit 8 Please enter another item:(enter 'q' to quit 9 Please enter another item:(enter 'q' to quit 6 Please enter another item:(enter 'q' to quit 7 Please enter another item:(enter 'q' to quit q There are 6 items on the tree. 先序显示： 6 7 中序显示： 7 Press any key to continue


Question: 新手问题，指针变量作为参数

引用是这样写的吧。（源代码扩展名必须是cpp） void SplitList(Linklist *L,Linklist &*la,Linklist &*lb) {     //这里有处理代码，分离后la和lb不为空，是两个链表的表头，代码就不贴了，没问题 } void main() {     Linklist *L;//这里L不为空     Linklist *la=NULL;     Linklist *lb=NULL;     SplitList(L,la,lb); }

vc是传值的，传入的是指针的值拷贝到栈变量中，而不是指针的地址，因此，函数写回的就写到了了栈变量中，调用者是无法获得修改后的指针值

引用 4 楼 zhao4zhong1 的回复:void SplitList(Linklist *L,Linklist **pla,Linklist **plb) {     //将此函数中所有la替换为(*pla),lb替换为(*plb)     //这里有处理代码，分离后la和lb不为空，是两个链表的表头，代码就不贴了，没问题 } void main() {     Linklist *L;//这里L不为空     Linklist *la=NULL;     Linklist *lb=NULL;     SplitList(L,&la,&lb); }  请教个问题，la本身指向结构体，属于引用类型，怎么还需要传地址呢？

引用 4 楼 zhao4zhong1 的回复:void SplitList(Linklist *L,Linklist **pla,Linklist **plb) {     //将此函数中所有la替换为(*pla),lb替换为(*plb)     //这里有处理代码，分离后la和lb不为空，是两个链表的表头，代码就不贴了，没问题 } void main() {     Linklist *L;//这里L不为空     Linklist *la=NULL;     Linklist *lb=NULL;     SplitList(L,&la,&lb); } 正解！

应该将存放指针的单元的地址传给函数，而不是将指针值传给函数

SplitList 做了什么？ 看起来你是要L指针中输出两个指针，那么你这样做是有问题的，函数看起来应该这样定义： void SplitList(Linklist *L,Linklist **la,Linklist **lb)   {     //这里有处理代码，分离后la和lb不为空，是两个链表的表头，代码就不贴了，没问题 }

你的做法是值传递   实参 la 和 lb 没改变


Question: 修改系统sid后不能加入域怎么办？

大虾：讨教一下，我做了一个虚拟机，安装了一个“NEWSID"软件，修改完SID后，91VPN怎么也登录上，一直显示连接失败，请重试！我是这方面的低能儿，请大虾指点一二。

引用 4 楼 yangw150 的回复:wi7_32下调用sysprep.exe改完sid后会清空用户的设置，dns的设置也就被清空了，所以如果不调用sysprep.exe直接加入域是可以成功的，调用之后，重启起来后用户的dns就被设置成auto了，所以在修改sid之前先将dns保存到本地，等改完sid后将保存的dns的ip重新用代码设置回去，再进行加入域，这样就可以加入域了 人最宝贵的东西是生命.生命对人来说只有一次.因此,人的一生应当这样度过:当一个人回首往事时,不因虚度年华而悔恨,也不因碌碌无为而羞愧;这样,在他临死的时候,能够说,我把整个生命和全部精力都献给了人生最宝贵的事业——为人类的解放而奋斗。

分是次要的，公布解决方法是主要的。

白给都没人要啊

搞定结贴了，来着散分


Question: 请问t1和t2函数的哪个运行速度更快呢？？这个自己有点纠结

这个应该是 先计算B 的要快一些，因为A可以把B 的运算拿来套用。

引用 38 楼 lm_whales 的回复:[quote=引用 31 楼 unituniverse2 的回复:] [quote=引用 30 楼 lm_whales 的回复:] [quote=引用 27 楼 unituniverse2 的回复:] 这次是release模式，开了快速模式编译，同样关了动态超频，使用低频测试：  #define A 10000000 #define B 100 的时候 1891 2714  #define A 1000000 #define B 1000 的时候 1836 2540  #define A 10000000 #define B 1000 的时候 17245 26355 看来你只看了最后一贴。。。我说的是对于同样的代码，按快速模式优化的程序比按最小模式优化的代码执行起来反而更慢[/quote] #include<time.h> #include<stdio.h>  #define A 10000000  #define B 1000  int a[A],b[B];    void t1(){ int j; for(j=0;j<B;j++) {   b[j] += A; }   }  void t2(){ int i; for(i=0;i<A;i++) {   a[i] += B; } }    int main() { 	clock_t t =clock();     t1(); 	printf("t1= %d\n",clock()-t); 	t=clock(); 	t2(); 	printf("t2= %d\n",clock()-t); 	getchar();  return 0; } Debug: t1= 0 t2= 109 Release 速度最快: t1= 0 t2= 31 Release 代码最小: t1= 0 t2= 47 你的电脑该淘汰了，太慢了点。 速度最快，比代码最小要快一点，不明显。 另外clock();计时精度也太低了点。  [/quote]  你有看到我说了降频测试的么，别说没注意。而且还得关了动态超频测试。这个频率是多少我补充一下：1.1G 你这个例程我这里测试的结果： 最小模式优化： t1= 0 t2= 34 t3= 19489 t1= 0 t2= 20 t3= 19558 t1= 0 t2= 19 t3= 19662 t1= 0 t2= 19 t3= 19686 t1= 0 t2= 20 t3= 19501 t1= 0 t2= 19 t3= 19636 t1= 0 t2= 20 t3= 19702 t1= 0 t2= 19 t3= 19618  最快模式优化： t1= 0 t2= 34 t3= 19465 t1= 0 t2= 20 t3= 19334 t1= 0 t2= 19 t3= 19356 t1= 0 t2= 19 t3= 19461 t1= 0 t2= 20 t3= 19514 t1= 0 t2= 18 t3= 19251 t1= 0 t2= 19 t3= 19471 t1= 0 t2= 19 t3= 19386  还好意思说淘汰。别告诉我你的机器比这个频率还低。你还是用lz那个例子程序测吧，=0居然都给你报出来了。。。你这个例程就是故意做成有利于编译器优化的状态的，这样测当然能达到优化的预期目的，而且你这个0，完全不能证明你的处理器有多“快”。因为根据n你提供的t1函数，编译后得到如下汇编代码（我这里贴的是最小模式的）：  00EF1000  mov         eax,offset b (0EF3370h)   00EF1005  mov         ecx,dword ptr [eax]   00EF1007  add         ecx,989680h   00EF100D  mov         dword ptr [eax],ecx   00EF100F  add         eax,4   00EF1012  cmp         eax,offset a (0EF4310h)   00EF1017  jl          t1+5 (0EF1005h)   00EF1019  ret    989680h即是10000000，编译器并没有老实的做两层循环，而是直接把结果加到初始值上去了，因为你的程序里内层循环没有移动地址，编译器完全可以拆掉这个循环。真正执行的循环次数只有1000轮

引用 27 楼 unituniverse2 的回复:这次是release模式，开了快速模式编译，同样关了动态超频，使用低频测试：  #define A 10000000 #define B 100 的时候 1891 2714  #define A 1000000 #define B 1000 的时候 1836 2540  #define A 10000000 #define B 1000 的时候 17245 26355  我就不明白了，按快速模式优化的程序怎么跑起来还会更慢。。。不知道什么情况。。。  比较的条件，结果就不同，不知道你有啥好郁闷的。 循环优化本来就不是那么容易的，你以为开了优化，就会加快多少了。  要知道，编译器是按照一定模式，进行优化的； 虽然多数情况下，优化的程序要好，但是永远做不到最好。  因为编译器，是人编写的。 人没有想到的，编译器就没有办法做到。  你的两个数组大小完全不一样，他们造成的影响，掩盖了代码优化的影响。  B是个小数组，安排在同一页面是没有问题的 最多也就在两个页面内 t1() 这段程序，除了，每个页面第一次访问，需要调页以外，整个循环期间，页面可以始终在内存中，不需要换页 当然要快得多，不管循环优化没有。  t2() 这段程序 9K多的页面，无论怎样优化； 换页总是难以避免的，怎么优化也不可能快起来。  至于高速缓存命中问题，确实也会拖累这段程序，不过影响应该没有那么大。 因为即使很小一块内存，也难免会有，不命中的时候，虽然几率更小。  PS: 循环优化，是针对同一种情况，为了减少跳转的影响，而做的努力。  比起高速缓存命中问题，解决的根本就是不痛不痒的问题  比起换页的影响，就更是云泥之别。  这怎么能在一起比较呢。

#include<time.h> #include<stdio.h> #include<windows.h>  #define A 10000000  #define B 1000  int a[A],b[B];    void t1(){ int j; for(j=0;j<B;j++) {   b[j] += A; }   }  void t2(){ int i; for(i=0;i<A;i++) {   a[i] += B; } }   #define test(fun) {clock_t t =clock(); fun();	printf("%s= %d\n",#fun,clock()-t); }  #define Test() {test(t1);test(t2);}    	             int main(){ 	Test(); 	Test(); 	Test(); 	Test(); 	Test(); 	Test(); 	Test(); 	Test(); 	getchar();  return 0; } Debug  t1= 0 t2= 94 t1= 0 t2= 93 t1= 0 t2= 110 t1= 0 t2= 93 t1= 0 t2= 79 t1= 0 t2= 78 t1= 0 t2= 78 t1= 0 t2= 62 Release 使大小最小化 (/O1) t1= 0 t2= 63 t1= 0 t2= 16 t1= 0 t2= 31 t1= 0 t2= 62 t1= 0 t2= 16 t1= 0 t2= 31 t1= 0 t2= 47 t1= 0 t2= 15 Release 使速度最大化 (/O2) t1= 0 t2= 47 t1= 0 t2= 16 t1= 0 t2= 31 t1= 0 t2= 15 t1= 0 t2= 32 t1= 0 t2= 15 t1= 0 t2= 32 t1= 0 t2= 15  PS : 首先，clock() 计时精度不够，其次，每次执行时间不一致。 然后使速度最大化，总比使大小最小化略快。 然后小内存操作要快。Release 比Debug 快  #include<time.h> #include<stdio.h> #include<windows.h>  #define A 10000000  #define B 1000  int a[A],b[B];    void t1(){ int i,j; for(j=0;j<B;j++)for(i=0;i<A;i++) {   b[j] ++; }   }  void t2(){ int i,j; for(i=0;i<A;i++)for(j=0;j<B;j++) {   a[i] ++; } }  void t3(){ int i,j; for(j=0;j<B;j++)for(i=0;i<A;i++) {   a[i] ++; } }   #define test(fun) {clock_t t =clock(); fun();	printf("%s= %d\n",#fun,clock()-t); }  #define Test() {test(t1);test(t2);test(t3);}    	             int main(){ 	Test(); 	Test(); 	Test(); 	Test(); 	Test(); 	Test(); 	Test(); 	Test(); 	getchar();  return 0; } Release，使速度最大化 (/O2) t1= 0 t2= 47 t3= 29063 t1= 0 t2= 31 t3= 25484 t1= 0 t2= 31 t3= 25391 t1= 0 t2= 15 t3= 25375 t1= 0 t2= 32 t3= 25546 t1= 0 t2= 32 t3= 25765 t1= 0 t2= 32 t3= 25578 t1= 0 t2= 31 t3= 25531 Release，使速度最大化 (/O2) t1= 0 t2= 46 t3= 30969 t1= 0 t2= 31 t3= 28422 t1= 0 t2= 47 t3= 28266 t1= 0 t2= 47 t3= 28547 t1= 0 t2= 31 t3= 28641 t1= 0 t2= 47 t3= 28437 t1= 0 t2= 32 t3= 28281 t1= 0 t2= 31 t3= 28000

引用 31 楼 unituniverse2 的回复:[quote=引用 30 楼 lm_whales 的回复:] [quote=引用 27 楼 unituniverse2 的回复:] 这次是release模式，开了快速模式编译，同样关了动态超频，使用低频测试：  #define A 10000000 #define B 100 的时候 1891 2714  #define A 1000000 #define B 1000 的时候 1836 2540  #define A 10000000 #define B 1000 的时候 17245 26355 看来你只看了最后一贴。。。我说的是对于同样的代码，按快速模式优化的程序比按最小模式优化的代码执行起来反而更慢[/quote] #include<time.h> #include<stdio.h>  #define A 10000000  #define B 1000  int a[A],b[B];    void t1(){ int j; for(j=0;j<B;j++) {   b[j] += A; }   }  void t2(){ int i; for(i=0;i<A;i++) {   a[i] += B; } }    int main() { 	clock_t t =clock();     t1(); 	printf("t1= %d\n",clock()-t); 	t=clock(); 	t2(); 	printf("t2= %d\n",clock()-t); 	getchar();  return 0; } Debug: t1= 0 t2= 109 Release 速度最快: t1= 0 t2= 31 Release 代码最小: t1= 0 t2= 47 你的电脑该淘汰了，太慢了点。 速度最快，比代码最小要快一点，不明显。 另外clock();计时精度也太低了点。

因为编译器，是人编写的。 人没有想到的，编译器就没有办法做到。  有些因素，编译器，不一定会考虑到。  编译器优化，只是对通常的代码，是那个样子的。 通常，   选择快速优化的比较快，通常程序代码比较长。   选择短小优化的比较慢，但是代码更短。  这只是一种取舍而已，并不是必然会快。 虽然90%以上的时候，快速优化编译的代码更快。  但这不是绝对的。

引用 35 楼 unituniverse2 的回复:[quote=引用 33 楼 zhao4zhong1 的回复:] 使用电脑计时有时误差会很大，因为待测程序段的运行会影响电脑时钟。 将待测程序段循环足够多次，手动掐秒表计时可能更准确。 本来不想说的。。。受不了。。电脑时钟是由独立芯片控制的，即使死机这个时钟都照样继续走。一般程序的运行不会影响这个时钟的准确性 要说“有影响”倒是时钟取值函数本身的运行时开销。但是如果程序的计时算法设计到位的话（比如lz的程序，只是循环开始和结束各调用一次，纳秒级的调用开销和循环体秒级别的相比可以忽略不计了）。这个时间绝对比你手动掐表的更准[/quote] 两个M个N核CPU的机器，对准其时间，写一个while死循环程序，在一个机器上启动M×N个实例让CPU总负荷100%，持续1小时，观察两个机器的时钟差多少再说。

引用 33 楼 zhao4zhong1 的回复:使用电脑计时有时误差会很大，因为待测程序段的运行会影响电脑时钟。 将待测程序段循环足够多次，手动掐秒表计时可能更准确。 本来不想说的。。。受不了。。电脑时钟是由独立芯片控制的，即使死机这个时钟都照样继续走。一般程序的运行不会影响这个时钟的准确性 要说“有影响”倒是时钟取值函数本身的运行时开销。但是如果程序的计时算法设计到位的话（比如lz的程序，只是循环开始和结束各调用一次，纳秒级的调用开销和循环体秒级别的相比可以忽略不计了）。这个时间绝对比你手动掐表的更准

忍不住要说一句,闲的蛋疼

楼主自己运行一次不就得了，看每一个函数运行需要多少时间，原理的话我觉得30楼说的挺有道理的

引用 30 楼 lm_whales 的回复:[quote=引用 27 楼 unituniverse2 的回复:] 这次是release模式，开了快速模式编译，同样关了动态超频，使用低频测试：  #define A 10000000 #define B 100 的时候 1891 2714  #define A 1000000 #define B 1000 的时候 1836 2540  #define A 10000000 #define B 1000 的时候 17245 26355  我就不明白了，按快速模式优化的程序怎么跑起来还会更慢。。。不知道什么情况。。。  比较的条件，结果就不同，不知道你有啥好郁闷的。 循环优化本来就不是那么容易的，你以为开了优化，就会加快多少了。  要知道，编译器是按照一定模式，进行优化的； 虽然多数情况下，优化的程序要好，但是永远做不到最好。  因为编译器，是人编写的。 人没有想到的，编译器就没有办法做到。  你的两个数组大小完全不一样，他们造成的影响，掩盖了代码优化的影响。  B是个小数组，安排在同一页面是没有问题的 最多也就在两个页面内 t1() 这段程序，除了，每个页面第一次访问，需要调页以外，整个循环期间，页面可以始终在内存中，不需要换页 当然要快得多，不管循环优化没有。  t2() 这段程序 9K多的页面，无论怎样优化； 换页总是难以避免的，怎么优化也不可能快起来。  至于高速缓存命中问题，确实也会拖累这段程序，不过影响应该没有那么大。 因为即使很小一块内存，也难免会有，不命中的时候，虽然几率更小。  PS: 循环优化，是针对同一种情况，为了减少跳转的影响，而做的努力。  比起高速缓存命中问题，解决的根本就是不痛不痒的问题  比起换页的影响，就更是云泥之别。  这怎么能在一起比较呢。 [/quote] 看来你只看了最后一贴。。。我说的是对于同样的代码，按快速模式优化的程序比按最小模式优化的代码执行起来反而更慢

引用 15 楼 user-9 的回复:猜够了  发运行截图   试试关闭所有优化， 然单独运行t1,t2。 估计相差不大。

引用 13 楼 mujiok2003 的回复:等价代码， 显然t2更快（更少的工作，更好的局部性）。   #define A 10000000 #define B 1000 int a[A],b[B];  void t1(){ int j; for(j=0;j<B;j++) {   b[j]+ = A; }  } void t2(){ int i; for(i=0;i<A;i++) {   a[i] += B; } }  说反了， t1更快。

不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  使用电脑计时有时误差会很大，因为待测程序段的运行会影响电脑时钟。 将待测程序段循环足够多次，手动掐秒表计时可能更准确。

运行一万遍自己看时间。。。

引用 15 楼 user-9 的回复:猜够了  发运行截图  妙事上楼这位兄台更有说服力的赶脚。。。不过不同的机器运行时间应该不一样是吧？cpu处理时间不一样，不过应该不影响结果，也就是t1要快一点是吧。。

猜够了  发运行截图

引用 13 楼 mujiok2003 的回复:等价代码， 显然t2更快（更少的工作，更好的局部性）。   #define A 10000000 #define B 1000 int a[A],b[B];  void t1(){ int j; for(j=0;j<B;j++) {   b[j]+ = A; }  } void t2(){ int i; for(i=0;i<A;i++) {   a[i] += B; } }   忽略局部性。


Question: 简单代码分析！！

unsigned char result;  int a,b,c,d;  a=2;   0000 0010  b=4;   0000 0100  c=6;   0000 0110  d=8;   0000 1000   result=a & c; //按位与，1和1为1，其余都为0. 因此，a&c的结果就是0000 0010 也就是十进制的2了。  printf("result= %d\n",result);  result= b | d; //按位或，0和0为0，其余都为1. 因此，b|d的结果就是0000 1100 也就是12了。  printf("result= %d\n",result);  result =a ^ d;//按位异或，某个二进制位和0异或结果不变，某个二进制位和1异或取相反数.因此 a^d的结果就是，0000 1010，也就是十进制的10了。  printf("result= %d\n",result);  result = ~a; //按位取反，取每个二进制位的相反数。1111 1101 也就是253.  printf("result= %d\n",result);

路过学习知识的！！！对于二进制表示新手的我暂时不懂

~a	  11111111 11111111 11111111 11111111	11111101    =	(2^8-1)-2^1=253

int						unsigned char     a 	2 00000000 00000000 0000000 00000010     b 	4 00000000 00000000 0000000 00000100     c 	6 00000000 00000000 0000000 00000110     d 	8 00000000 00000000 0000000 00001000          a & c 00000000 00000000 00000000 00000010 	00000010    =	2^1 = 2     b | d 00000000 00000000 00000000 00001100   00001100    =	2^3+2^2=12     a ^ d 00000000 00000000 00000000 00001010	00001010    =	2^3+2^1=10     ~a	  11111111 11111111 11111111 11111101	11111101    =	(2^8-1)-2^1=253

转化成二进制，各个位进行运算就好了！拿画画就知道了 http://www.cnblogs.com/911/archive/2008/05/20/1203477.html 参考

先把各个数值转换成二进制，然后再进行相关的操作就ok了，按位进行相关操作。

注意一下无符号和有符号整数的运算不一样的。


定义动态数组吧，不然容易出现stack overflow错误

引用 15 楼 jasminesst 的回复:[quote=引用 14 楼 wenbei2006 的回复:] http://wenku.baidu.com/view/a3816b0d4a7302768e993972.html，看一下这个原理吧；如果要代码的话，这里有 http://download.csdn.net/detail/zjfly2008/1185942  这样可以不？？你看看！  #include <stdio.h> #include <iostream>  void main() { 	int i,j; 	float k1,k2; 	float c1,c2; 	int id,jd;  	float temp; 	float Data[128][128];         float Data1[300][300];  	FILE *q; 	q=fopen("atte_para_newC_1.img","rb");  	for (i=1;i<=128;i++) 	{ 		for(j=1;j<=128;j++) 		{ 			fread(&temp,sizeof(float),1,q); 			Data[i][j]=temp; 		} 	} 	fclose(q);  	k1=300/128; 	k2=300/128; 	c1=1/k1; 	c2=1/k2;  	for (i=1;i<=300;i++) 	{ 		for(j=1;j<=300;j++) 		{ 			id=ceil(c1*i); 			jd=ceil(c2*j); 			Data1[i][j]=Data[id][jd]; 		} 	}  	FILE *fp; 	fp=fopen("bm.img","wb"); 	fwrite(Data1,sizeof(float),128*128,fp); 	fclose; }[/quote]这个能够实现最基本的方法，还是建议楼主从最简单的nearest，bilinear方法看起，然后到cubic，spline样条插值，稍微复杂一些的lanczos插值等等

引用 14 楼 wenbei2006 的回复:http://wenku.baidu.com/view/a3816b0d4a7302768e993972.html，看一下这个原理吧；如果要代码的话，这里有 http://download.csdn.net/detail/zjfly2008/1185942  这样可以不？？你看看！  #include <stdio.h> #include <iostream>  void main() { 	int i,j; 	float k1,k2; 	float c1,c2; 	int id,jd;  	float temp; 	float Data[128][128];         float Data1[300][300];  	FILE *q; 	q=fopen("atte_para_newC_1.img","rb");  	for (i=1;i<=128;i++) 	{ 		for(j=1;j<=128;j++) 		{ 			fread(&temp,sizeof(float),1,q); 			Data[i][j]=temp; 		} 	} 	fclose(q);  	k1=300/128; 	k2=300/128; 	c1=1/k1; 	c2=1/k2;  	for (i=1;i<=300;i++) 	{ 		for(j=1;j<=300;j++) 		{ 			id=ceil(c1*i); 			jd=ceil(c2*j); 			Data1[i][j]=Data[id][jd]; 		} 	}  	FILE *fp; 	fp=fopen("bm.img","wb"); 	fwrite(Data1,sizeof(float),128*128,fp); 	fclose; }

应该是周围8个点的RGB平均值效果会好些吧

搜 NearestNeighbor Bilinear HighQualityBilinear Bicubic HighQualityBicubic

引用 5 楼 xiaohuh421 的回复:放大最重要的就是插值算法, 有线性插值,也有非线性插值, 当然, 非线性插值的放大效果会好一些.  大家说的有道理，如何扩大插值，求一个具体的方法详解下啊！！

Using Interpolation Mode to Control Image Quality During Scaling   --------------------------------------------------------------------------------  The interpolation mode of a Graphics object influences the way Microsoft Windows GDI+ scales (stretches and shrinks) images. The InterpolationMode enumeration in Gdiplusenums.h defines several interpolation modes, some of which are shown in the following list:   InterpolationModeNearestNeighbor  InterpolationModeBilinear  InterpolationModeHighQualityBilinear  InterpolationModeBicubic  InterpolationModeHighQualityBicubic  To stretch an image, each pixel in the original image must be mapped to a group of pixels in the larger image. To shrink an image, groups of pixels in the original image must be mapped to single pixels in the smaller image. The effectiveness of the algorithms that perform these mappings determines the quality of a scaled image. Algorithms that produce higher-quality scaled images tend to require more processing time. In the preceding list, InterpolationModeNearestNeighbor is the lowest-quality mode and InterpolationModeHighQualityBicubic is the highest-quality mode.  To set the interpolation mode, pass one of the members of the InterpolationMode enumeration to the SetInterpolationMode method of a Graphics object.  The following example draws an image and then shrinks the image with three different interpolation modes:  Show Example  Image image(L"GrapeBunch.bmp"); UINT width = image.GetWidth(); UINT height = image.GetHeight(); // Draw the image with no shrinking or stretching. graphics.DrawImage(    &image,    Rect(10, 10, width, height),  // destination rectangle      0, 0,        // upper-left corner of source rectangle    width,       // width of source rectangle    height,      // height of source rectangle    UnitPixel); // Shrink the image using low-quality interpolation.  graphics.SetInterpolationMode(InterpolationModeNearestNeighbor); graphics.DrawImage(    &image,    Rect(10, 250, 0.6*width, 0.6*height),  // destination rectangle     0, 0,        // upper-left corner of source rectangle    width,       // width of source rectangle    height,      // height of source rectangle    UnitPixel); // Shrink the image using medium-quality interpolation. graphics.SetInterpolationMode(InterpolationModeHighQualityBilinear); graphics.DrawImage(    &image,    Rect(150, 250, 0.6 * width, 0.6 * height),  // destination rectangle     0, 0,        // upper-left corner of source rectangle    width,       // width of source rectangle    height,      // height of source rectangle    UnitPixel); // Shrink the image using high-quality interpolation. graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic); graphics.DrawImage(    &image,    Rect(290, 250, 0.6 * width, 0.6 * height),  // destination rectangle     0, 0,        // upper-left corner of source rectangle    width,       // width of source rectangle    height,      // height of source rectangle    UnitPixel); The following illustration shows the original image and the three smaller images.     --------------------------------------------------------------------------------

引用 5 楼 xiaohuh421 的回复:放大最重要的就是插值算法, 有线性插值,也有非线性插值, 当然, 非线性插值的放大效果会好一些.  ++

同意5楼的做法，7楼的朋友，你的代码到是简单了，但是会出现断层现象。举个例子：1，2，放大之后应该是1，1.5，2.而不该是1,1,2，或者1,2,2。

最简单的：  void Zoom(unchar* pSrc[128], uchar* pDst[300]) {  for(int i=0;j<300;j++)  for(int j=0;i<300;i++) {  pDst[i][j]=pSrc[i*128/300][j*128/300]; } }

你投的算法工程师么？我数字信号处理都忘了

在纸上画画就清楚了。  引用 2 楼 jasminesst 的回复:[quote=引用 1 楼 turingo 的回复:] 最简单的做法就是有些像素点复制为2x2个点，而有些像素点复制为3x3个点，直到补满300x300个点。  [quote=引用 楼主 jasminesst 的回复:] C语言实现128*128到300*300的图像放大 函数定义为void Zoom(unchar* pSrc[128], uchar* pDst[300]);  求各位大神~！[/quote]  请您详解之，谢谢！！！[/quote]

引用 1 楼 turingo 的回复:最简单的做法就是有些像素点复制为2x2个点，而有些像素点复制为3x3个点，直到补满300x300个点。  [quote=引用 楼主 jasminesst 的回复:] C语言实现128*128到300*300的图像放大 函数定义为void Zoom(unchar* pSrc[128], uchar* pDst[300]);  求各位大神~！[/quote]  请您详解之，谢谢！！！

最简单的做法就是有些像素点复制为2x2个点，而有些像素点复制为3x3个点，直到补满300x300个点。  引用 楼主 jasminesst 的回复:C语言实现128*128到300*300的图像放大 函数定义为void Zoom(unchar* pSrc[128], uchar* pDst[300]);  求各位大神~！


Question: 求改进：计算一个词在文件中出现的次数的代码

引用 12 楼 AnYidan 的回复:[quote=引用 10 楼 mcmay 的回复:] [quote=引用 8 楼 AnYidan 的回复:]   [quote=引用 7 楼 mcmay 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 建议每次查找时，可以把文件打开使用上次使用的文件描述符。一次打开多次使用，只是每次都要把文件设置成开始位置。可以使用fseek的哦。 引用 4 楼 max_min_ 的回复:1 用strcasecmp函数比较会好！对大小写不敏感（无视大小写） 2 不建议频繁的对文件打开关闭操作，可以移动文件描述符操作！  频繁打开关闭文件操作的问题我想过，我这里这样做的目的是想给程序使用者一个机会每次都输入不同词在不同文件中查找。另外，我想请教一下，频繁打开关闭文件有何弊端。[/quote]  浪费资源[/quote] 在一个循环周期之内打开和关闭，重复这个过程，应该也不会怎么浪费资源吧？[/quote]  当你close 文件，memory 中的内容写回disk, 再open 要从disk 中读取，disk 的读取速度与memory相差多少lz应该清楚吧 [/quote] 有道理！如果是大数量的读写，像大型网站上那种，效率就显得比什么都重要了！谢谢！

引用 11 楼 zhao4zhong1 的回复:[quote=引用 5 楼 mcmay 的回复:] [quote=引用 1 楼 zhao4zhong1 的回复:] 用德文、法文、……试试？！、 这个还真没试过......那个isalpha()函数只能识别英语字母的吗？[/quote] Locale Use the setlocale function to change or query some or all of the current program locale information. “Locale” refers to the locality (the country and language) for which you can customize certain aspects of your program. Some locale-dependent categories include the formatting of dates and the display format for monetary values. For more information, see Locale Categories.   Locale-Dependent Routines   Routine  Use setlocale Category  Setting Dependence  atof, atoi, atol Convert character to floating-point, integer, or long integer value, respectively LC_NUMERIC  is Routines Test given integer for particular condition. LC_CTYPE  isleadbyte Test for lead byte () LC_CTYPE  localeconv Read appropriate values for formatting numeric quantities LC_MONETARY, LC_NUMERIC  MB_CUR_MAX Maximum length in bytes of any multibyte character in current locale (macro defined in STDLIB.H) LC_CTYPE  _mbccpy Copy one multibyte character LC_CTYPE  _mbclen Return length, in bytes, of given multibyte character LC_CTYPE  mblen Validate and return number of bytes in multibyte character LC_CTYPE  _mbstrlen For multibyte-character strings: validate each character in string; return string length  LC_CTYPE  mbstowcs Convert sequence of multibyte characters to corresponding sequence of wide characters LC_CTYPE  mbtowc Convert multibyte character to corresponding wide character LC_CTYPE  printf functions Write formatted output LC_NUMERIC (determines radix character output)  scanf functions Read formatted input LC_NUMERIC (determines radix character recognition)  setlocale, _wsetlocale Select locale for program Not applicable  strcoll, wcscoll Compare characters of two strings LC_COLLATE  _stricoll, _wcsicoll Compare characters of two strings (case insensitive) LC_COLLATE  _strncoll, _wcsncoll Compare first n characters of two strings  LC_COLLATE  _strnicoll, _wcsnicoll Compare first n characters of two strings (case insensitive) LC_COLLATE  strftime, wcsftime Format date and time value according to supplied format argument LC_TIME  _strlwr Convert, in place, each uppercase letter in given string to lowercase LC_CTYPE  strtod, wcstod, strtol, wcstol, strtoul, wcstoul Convert character string to double, long, or unsigned long value LC_NUMERIC (determines radix character recognition)  _strupr Convert, in place, each lowercase letter in string to uppercase LC_CTYPE  strxfrm, wcsxfrm Transform string into collated form according to locale LC_COLLATE  tolower, towlower Convert given character to corresponding lowercase character LC_CTYPE  toupper, towupper Convert given character to corresponding uppercase letter LC_CTYPE  wcstombs Convert sequence of wide characters to corresponding sequence of multibyte characters LC_CTYPE  wctomb Convert wide character to corresponding multibyte character LC_CTYPE  _wtoi, _wtol Convert wide-character string to int or long LC_NUMERIC   [/quote] 呵呵，把标准搬出来了！谢谢指点，我还真没有好好看过关于标准的书籍呢！

引用 5 楼 mcmay 的回复:[quote=引用 1 楼 zhao4zhong1 的回复:] 用德文、法文、……试试？！、 这个还真没试过......那个isalpha()函数只能识别英语字母的吗？[/quote] Locale Use the setlocale function to change or query some or all of the current program locale information. “Locale” refers to the locality (the country and language) for which you can customize certain aspects of your program. Some locale-dependent categories include the formatting of dates and the display format for monetary values. For more information, see Locale Categories.   Locale-Dependent Routines   Routine  Use setlocale Category  Setting Dependence  atof, atoi, atol Convert character to floating-point, integer, or long integer value, respectively LC_NUMERIC  is Routines Test given integer for particular condition. LC_CTYPE  isleadbyte Test for lead byte () LC_CTYPE  localeconv Read appropriate values for formatting numeric quantities LC_MONETARY, LC_NUMERIC  MB_CUR_MAX Maximum length in bytes of any multibyte character in current locale (macro defined in STDLIB.H) LC_CTYPE  _mbccpy Copy one multibyte character LC_CTYPE  _mbclen Return length, in bytes, of given multibyte character LC_CTYPE  mblen Validate and return number of bytes in multibyte character LC_CTYPE  _mbstrlen For multibyte-character strings: validate each character in string; return string length  LC_CTYPE  mbstowcs Convert sequence of multibyte characters to corresponding sequence of wide characters LC_CTYPE  mbtowc Convert multibyte character to corresponding wide character LC_CTYPE  printf functions Write formatted output LC_NUMERIC (determines radix character output)  scanf functions Read formatted input LC_NUMERIC (determines radix character recognition)  setlocale, _wsetlocale Select locale for program Not applicable  strcoll, wcscoll Compare characters of two strings LC_COLLATE  _stricoll, _wcsicoll Compare characters of two strings (case insensitive) LC_COLLATE  _strncoll, _wcsncoll Compare first n characters of two strings  LC_COLLATE  _strnicoll, _wcsnicoll Compare first n characters of two strings (case insensitive) LC_COLLATE  strftime, wcsftime Format date and time value according to supplied format argument LC_TIME  _strlwr Convert, in place, each uppercase letter in given string to lowercase LC_CTYPE  strtod, wcstod, strtol, wcstol, strtoul, wcstoul Convert character string to double, long, or unsigned long value LC_NUMERIC (determines radix character recognition)  _strupr Convert, in place, each lowercase letter in string to uppercase LC_CTYPE  strxfrm, wcsxfrm Transform string into collated form according to locale LC_COLLATE  tolower, towlower Convert given character to corresponding lowercase character LC_CTYPE  toupper, towupper Convert given character to corresponding uppercase letter LC_CTYPE  wcstombs Convert sequence of wide characters to corresponding sequence of multibyte characters LC_CTYPE  wctomb Convert wide character to corresponding multibyte character LC_CTYPE  _wtoi, _wtol Convert wide-character string to int or long LC_NUMERIC

引用 10 楼 mcmay 的回复:[quote=引用 8 楼 AnYidan 的回复:]   [quote=引用 7 楼 mcmay 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 建议每次查找时，可以把文件打开使用上次使用的文件描述符。一次打开多次使用，只是每次都要把文件设置成开始位置。可以使用fseek的哦。 引用 4 楼 max_min_ 的回复:1 用strcasecmp函数比较会好！对大小写不敏感（无视大小写） 2 不建议频繁的对文件打开关闭操作，可以移动文件描述符操作！  频繁打开关闭文件操作的问题我想过，我这里这样做的目的是想给程序使用者一个机会每次都输入不同词在不同文件中查找。另外，我想请教一下，频繁打开关闭文件有何弊端。[/quote]  浪费资源[/quote] 在一个循环周期之内打开和关闭，重复这个过程，应该也不会怎么浪费资源吧？[/quote]  当你close 文件，memory 中的内容写回disk, 再open 要从disk 中读取，disk 的读取速度与memory相差多少lz应该清楚吧

用德文、法文、……试试？！

引用 8 楼 AnYidan 的回复:[quote=引用 7 楼 mcmay 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 建议每次查找时，可以把文件打开使用上次使用的文件描述符。一次打开多次使用，只是每次都要把文件设置成开始位置。可以使用fseek的哦。 引用 4 楼 max_min_ 的回复:1 用strcasecmp函数比较会好！对大小写不敏感（无视大小写） 2 不建议频繁的对文件打开关闭操作，可以移动文件描述符操作！  频繁打开关闭文件操作的问题我想过，我这里这样做的目的是想给程序使用者一个机会每次都输入不同词在不同文件中查找。另外，我想请教一下，频繁打开关闭文件有何弊端。[/quote]  浪费资源[/quote] 在一个循环周期之内打开和关闭，重复这个过程，应该也不会怎么浪费资源吧？

引用 4 楼 max_min_ 的回复:1 用strcasecmp函数比较会好！对大小写不敏感（无视大小写）  我区别大小写以及首字母大写，主要是想将一个词可能在文本中出现的形态都顾及到，例如，cat一词，在一般文本中有可能的形式主要是cat，Cat和CAT，那么这三种情况都要查找。

引用 7 楼 mcmay 的回复:[quote=引用 3 楼 cfjtaishan 的回复:] 建议每次查找时，可以把文件打开使用上次使用的文件描述符。一次打开多次使用，只是每次都要把文件设置成开始位置。可以使用fseek的哦。 引用 4 楼 max_min_ 的回复:1 用strcasecmp函数比较会好！对大小写不敏感（无视大小写） 2 不建议频繁的对文件打开关闭操作，可以移动文件描述符操作！  频繁打开关闭文件操作的问题我想过，我这里这样做的目的是想给程序使用者一个机会每次都输入不同词在不同文件中查找。另外，我想请教一下，频繁打开关闭文件有何弊端。[/quote]  浪费资源

引用 3 楼 cfjtaishan 的回复:建议每次查找时，可以把文件打开使用上次使用的文件描述符。一次打开多次使用，只是每次都要把文件设置成开始位置。可以使用fseek的哦。 引用 4 楼 max_min_ 的回复:1 用strcasecmp函数比较会好！对大小写不敏感（无视大小写） 2 不建议频繁的对文件打开关闭操作，可以移动文件描述符操作！  频繁打开关闭文件操作的问题我想过，我这里这样做的目的是想给程序使用者一个机会每次都输入不同词在不同文件中查找。另外，我想请教一下，频繁打开关闭文件有何弊端。

引用 2 楼 N_sev7 的回复:该成动态申请内存的，不要限制数组大小 你这里限制大小了，如果你读入的文件大于你数组的边界呢？ 这个有理！现在有些文件加上目录还真有可能超出256个字符了。

引用 1 楼 zhao4zhong1 的回复:用德文、法文、……试试？！、 这个还真没试过......那个isalpha()函数只能识别英语字母的吗？


Question: 求助：有关线程的一些共享操作问题

引用 3 楼 qq120848369 的回复:通过pthread_create最后一个参数传进去。 我想明白为什么不可以通过共享资源这样来理解，求解释。。

引用 1 楼 luckyjungle 的回复:全局变量和局部变量。共享栈，表示没听说过。 我的意思是进程栈里面有了a变量，那么这个进程创建了一个线程，线程就应该共享了进程里面的资源，包括a变量了，那么线程就有了a变量了，但是线程使用a变量的时候却说没有定义，求回复。。

//循环向a函数每次发送200个字节长度（这个是固定的）的buffer, //a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理， //在处理的时候每次从新buffer中取两个字节打印 #ifdef WIN32     #pragma warning(disable:4996) #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef WIN32     #include <windows.h>     #include <process.h>     #include <io.h>     #define  MYVOID             void     #define  vsnprintf          _vsnprintf #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  MYVOID             void * #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); } void sleep_ms(int ms) {     Sleep(ms); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } void sleep_ms(int ms) {     usleep(ms*1000); } #endif void LogV(const char *pszFmt,va_list argp) {     struct tm *now;     struct timeb tb;      if (NULL==pszFmt||0==pszFmt[0]) return;     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} #define ASIZE    200 #define BSIZE    240 #define CSIZE      2 char Abuf[ASIZE]; char Cbuf[CSIZE]; CRITICAL_SECTION cs_HEX ; CRITICAL_SECTION cs_BBB ; struct FIFO_BUFFER {     int  head;     int  tail;     int  size;     char data[BSIZE]; } BBB; int No_Loop=0; void HexDump(int cn,char *buf,int len) {     int i,j,k;     char binstr[80];      Lock(&cs_HEX);     for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%03d %04x -",cn,i);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             Log("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         Log("%s\n",binstr);     }     Unlock(&cs_HEX); } int GetFromRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      lent=0;     Lock(cs);     if (fbuf->size>=len) {         lent=len;         if (fbuf->head+lent>BSIZE) {             len1=BSIZE-fbuf->head;             memcpy(buf     ,fbuf->data+fbuf->head,len1);             len2=lent-len1;             memcpy(buf+len1,fbuf->data           ,len2);             fbuf->head=len2;         } else {             memcpy(buf     ,fbuf->data+fbuf->head,lent);             fbuf->head+=lent;         }         fbuf->size-=lent;     }     Unlock(cs);     return lent; } MYVOID thdB(void *pcn) {     char        *recv_buf;     int          recv_nbytes;     int          cn;     int          wc;     int          pb;      cn=(int)pcn;     Log("%03d thdB              thread begin...\n",cn);     while (1) {         sleep_ms(10);         recv_buf=(char *)Cbuf;         recv_nbytes=CSIZE;         wc=0;         while (1) {             pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);             if (pb) {                 Log("%03d recv %d bytes\n",cn,pb);                 HexDump(cn,recv_buf,pb);                 sleep_ms(1);             } else {                 sleep_ms(1000);             }             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef WIN32     pthread_exit(NULL); #endif } int PutToRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      Lock(cs);     lent=len;     if (fbuf->size+lent>BSIZE) {         lent=BSIZE-fbuf->size;     }     if (fbuf->tail+lent>BSIZE) {         len1=BSIZE-fbuf->tail;         memcpy(fbuf->data+fbuf->tail,buf     ,len1);         len2=lent-len1;         memcpy(fbuf->data           ,buf+len1,len2);         fbuf->tail=len2;     } else {         memcpy(fbuf->data+fbuf->tail,buf     ,lent);         fbuf->tail+=lent;     }     fbuf->size+=lent;     Unlock(cs);     return lent; } MYVOID thdA(void *pcn) {     char        *send_buf;     int          send_nbytes;     int          cn;     int          wc;     int           a;     int          pa;      cn=(int)pcn;     Log("%03d thdA              thread begin...\n",cn);     a=0;     while (1) {         sleep_ms(100);         memset(Abuf,a,ASIZE);         a=(a+1)%256;         if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop         send_buf=(char *)Abuf;         send_nbytes=ASIZE;         Log("%03d sending %d bytes\n",cn,send_nbytes);         HexDump(cn,send_buf,send_nbytes);         wc=0;         while (1) {             pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);             Log("%03d sent %d bytes\n",cn,pa);             HexDump(cn,send_buf,pa);             send_buf+=pa;             send_nbytes-=pa;             if (send_nbytes<=0) break;//             sleep_ms(1000);             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef WIN32     pthread_exit(NULL); #endif } int main() { #ifdef WIN32     InitializeCriticalSection(&cs_log);     InitializeCriticalSection(&cs_HEX );     InitializeCriticalSection(&cs_BBB ); #else     pthread_t threads[2];     int threadsN;     int rc;     pthread_mutex_init(&cs_log,NULL);     pthread_mutex_init(&cs_HEX,NULL);     pthread_mutex_init(&cs_BBB,NULL); #endif     Log("Start===========================================================\n");      BBB.head=0;     BBB.tail=0;     BBB.size=0;  #ifdef WIN32     _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);     _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2); #else     threadsN=0;     rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);     rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1); #endif      if (!access("No_Loop",0)) {         remove("No_Loop");         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     while (1) {         sleep_ms(1000);         if (No_Loop) break;//         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     sleep_ms(3000);     Log("End=============================================================\n"); #ifdef WIN32     DeleteCriticalSection(&cs_BBB );     DeleteCriticalSection(&cs_HEX );     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_BBB);     pthread_mutex_destroy(&cs_HEX);     pthread_mutex_destroy(&cs_log); #endif     return 0; }

全局变量和局部变量。共享栈，表示没听说过。

变量所占用的内存可共享，不过需要同步才不会出错。 变量本身，不一定共享，由变量的定义所在作用域决定。 自动变量，寄存器变量，作用域在函数内部，是不共享的。 即便两个线程，使用同一函数，也是不共享的。  自动变量，寄存器变量，在函数调用期间定义，不是编译期其定义的。 函数内部的变量定义其实是声明，只能决定函数调用时，各变量的相对位置。 每次函数调用这些变量的地址才会确定下来。  不同线程，栈是不同的，寄存器，是不一定相同的时间片，不一定相同的CPU， 不一定相同的内核的，不一定同名的寄存器，  而且时间片，CPU内核，寄存器组合，必定是不会重合的。  所以不同线程的自动变量，寄存器变量是不共享的。

共享地址空间 堆可共享，栈不可以共享。  自动变量，寄存器变量，不是自动共享的。  共享的变量使全局变量，或者某些局部静态变量，包括匿名名空间的。  共享的内存，可以是任何变量的内存，前提是线程可以访问的。  实质是，我们编写的线程，不过是编写个函数；  这个函数的代码，运行在线程自己的栈空间，和某一CPU的某个内核的某些时间片上， 其他资源都是共享的。  线程运行时某一时刻，某一CPU的某一内核（超线程则是其中的某些寄存器），线程是独占的。 线程的栈空间，和和CPU内核，时间片这一类线程资源是系统分配的。  栈空间，一般是一次性分配的； CPU内核，时间片是动态分配的。  栈空间，不能随意共享，否则会发生访问冲突。 一般栈空间，对于线程都是独立的，不共享的。

引用 4 楼 eeeeelin 的回复:[quote=引用 1 楼 luckyjungle 的回复:] 全局变量和局部变量。共享栈，表示没听说过。 我的意思是进程栈里面有了a变量，那么这个进程创建了一个线程，线程就应该共享了进程里面的资源，包括a变量了，那么线程就有了a变量了，但是线程使用a变量的时候却说没有定义，求回复。。[/quote]  不能共享变量。


y = 3000ui64 * 24000000ui64 / 1000ui64; C/C++语言整数常量语法（参考3楼）不过关。

楼上都是专家啊，学习了，谢谢！

y = (uint64_t)3000 * (uint64_t)24000000 / 1000;  C语言基础不过关。

常量也有类型！ C++ Integer Constants Integer constants are constant data elements that have no fractional parts or exponents. They always begin with a digit. You can specify integer constants in decimal, octal, or hexadecimal form. They can specify signed or unsigned types and long or short types.  Syntax  integer-constant :  decimal-constant integer-suffixopt octal-constant integer-suffixopt hexadecimal-constant integer-suffixopt 'c-char-sequence'  decimal-constant :  nonzero-digit decimal-constant digit  octal-constant :  0 octal-constant octal-digit  hexadecimal-constant :  0x hexadecimal-digit 0X hexadecimal-digit hexadecimal-constant hexadecimal-digit  nonzero-digit : one of  1 2 3 4 5 6 7 8 9  octal-digit : one of  0 1 2 3 4 5 6 7  hexadecimal-digit : one of  0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F  integer-suffix :  unsigned-suffix long-suffixopt long-suffix unsigned-suffixopt  unsigned-suffix : one of  u U  long-suffix : one of  l L  64-bit integer-suffix :  i64  To specify integer constants using octal or hexadecimal notation, use a prefix that denotes the base. To specify an integer constant of a given integral type, use a suffix that denotes the type.  To specify a decimal constant, begin the specification with a nonzero digit. For example:  int i = 157;   // Decimal constant int j = 0198;  // Not a decimal number; erroneous octal constant int k = 0365;  // Leading zero specifies octal constant, not decimal  To specify an octal constant, begin the specification with 0, followed by a sequence of digits in the range 0 through 7. The digits 8 and 9 are errors in specifying an octal constant. For example:  int i = 0377;   // Octal constant int j = 0397;   // Error: 9 is not an octal digit  To specify a hexadecimal constant, begin the specification with 0x or 0X (the case of the “x” does not matter), followed by a sequence of digits in the range 0 through 9 and a (or A) through f (or F). Hexadecimal digits a (or A) through f (or F) represent values in the range 10 through 15. For example:  int i = 0x3fff;   // Hexadecimal constant int j = 0X3FFF;   // Equal to i  To specify an unsigned type, use either the u or U suffix. To specify a long type, use either the l or L suffix. For example:  unsigned uVal = 328u;             // Unsigned value long lVal = 0x7FFFFFL;            // Long value specified                                    //  as hex constant unsigned long ulVal = 0776745ul;  // Unsigned long value

引用 1 楼 turingo 的回复:y = 3000 * 24000000 / 1000; 溢出了。  y的定义是uint64_t y; 64位的，怎么就溢出了？

y = 3000 * 24000000 / 1000; 溢出了。  引用 楼主 syrchina 的回复:各位大神请看下面的程序，我的问题在注释里  //编译环境：codeblocks+gcc  #include <stdio.h> #include <stdint.h> int Fun() { 	uint64_t y; 	uint32_t x1, x2;      y = 3000 * 24000000 / 1000; 	printf("0x%llX\n", y);//输出错误结果：0xFFFFFFFFFFF08554 ，Why??? int64位不能正确运算吗？  	x1 = (uint32_t)(y & 0xFFFFFFFF);     x2 = (uint32_t)(y >> 32);     printf("0x%X,0x%X \n", x1, x2);//输出错误结果：0xFFF08554, 0xFFFFFFFF 	     y = 3000 * (24000000 / 1000); 	printf("0x%llX\n", y);//输出正确结果： 0x44AA200 	x1 = (uint32_t)(y & 0xFFFFFFFF);     x2 = (uint32_t)(y >> 32);     printf("0x%X,0x%X \n", x1, x2);//正确结果 ：0x44AA200， 0x0  } int main() { 	Fun(); }


Question: 请大家看看我的这个问题，帮我解答一下！！

编译器常用的命令行参数还是要掌握一些的。

你的.cpp中引用的头文件用全路径试试 既然有 应该能引到

引用 2 楼 max_min_ 的回复: //试试这样呢 g++ -o main example1.cpp -I./../src　 +1

引用 2 楼 max_min_ 的回复: //试试这样呢 g++ -o main example1.cpp -I./../src　-I参数可以指定查找的路径

执行 $PATH,看看你的h在不在path里面,不在就加进来.

.cpp文件，应该需要g++编译器来编译的吧。gcc默认是去C语言的头文件路径里查找该头文件，g++去对应的C++里查找。 所以，你用g++试着编译一下！


Question: 请教关于union的问题

他们读取数据的方式不一样  一个是从高地址开始 一个从低地址开始

256 == 0x100  5楼正确，2楼错误

union是共用体，即共享一段内存， student.arr[0] = 0; student.arr[1] = 1; 将共享的内存置为 00 01 x是一个整型变量，占4个字节，所以x的值在内存中的表示就是00 01 00 00(小顶端) 也就是 0x00000100 = 256

引用 2 楼 N_sev7 的回复:char型占一个字节 整个联合占四个字节 内存如下 0X0005654:00 01 00 00 此时的x的值为十六进制的01 00 00 == 256  correct

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

断点，查看变量！

arr[0] = 0; arr[1] = 1;  => x = 0x1000,0000;        arr[1],arr[0]

引用 6 楼 booirror 的回复:256 == 0x100  5楼正确，2楼错误 表述错误  当时想抢个SF的，我的意思和5楼的一样


Question: 求指点。。。。妹纸老师说我错了。。。

这个问题。太蛋疼了，，这题让我着急。。

题目是让你写出b的逻辑表达式。而你的错误是 不符合题目要求。 b=a-a; a=b;

引用 21 楼 zyc13701469860 的回复:b = a & 0   我想答案应该是这样的。和妹纸不是一个学校。她也没记老师的联系方式。没办法了。

引用 18 楼 z542858367 的回复:老师肯定是要考察你某个知识点，而不是只要你输出结果就好的，你这样写虽然能实现，但是你学到了什么？你有什么提高？    妹纸跟我说就是我掉了if语句。我读了几遍都没读懂老师的题意。小生不才。语文课一直都是体育老师上的。

哈哈。我只想说这老师语文是不是体育老师教的。

妹子老师要晚上约你，所以找叉，验证完毕

a = 0 ; b = 0;

不懂，看答案吧，感觉这题有歧义......

看不懂题，理解不了

笑死了，哈哈哈

出题的是脑残。鉴定完毕

老师要求结果 a=0,b=0，这个应该是说内存中的实际结果，不是说打印一个 a=0 b=0来 才上四节课，这个题目的目题是让只上过四节课编程课大学学生练习一下定义变量，修改变量的值。 说老师脑残的我不得不说“同学你刚开始学四节课时你老师就让你去和GNU合作修改liunx内核模块了是吧？”

我想看看老师给什么答案

引用 22 楼 zyc13701469860 的回复:  	bool b = (a = 0);   括号多余

引用 21 楼 zyc13701469860 的回复:b = a & 0 想太简单了 试试下面这个  #include <stdio.h> int main() {     int a;     printf("\n\n\n请输入a的值");     scanf("%d",&a); 	bool b = (a = 0);     printf("最终反馈结果a=%d,b=%d\n",a,b); }

b = a & 0

引用 16 楼 abc594986308 的回复:[quote=引用 1 楼 XinRuZhiShui196 的回复:]  还有张图。 我似乎懂了，我来解释一下。 首先题目的意思因该是这样。 首先是你输入任意a。 然后又一个逻辑表达式，其表现形式是b。 好了 我便一个程序看看，对不？ #include <stdio.h> int main(void) {    int a , b = 5;     printf("Input the value of a\n");     scanf("%d",&a);     if(b == 5)     printf("a = 0 , b = 0\n");     return 0; }[/quote]     这个还真的有可能是这样。 是老师的智商太高还是我们的智商太低。

引用 1 楼 XinRuZhiShui196 的回复: 还有张图。 我似乎懂了，我来解释一下。 首先题目的意思因该是这样。 首先是你输入任意a。 然后又一个逻辑表达式，其表现形式是b。 好了 我便一个程序看看，对不？ #include <stdio.h> int main(void) {    int a , b = 5;     printf("Input the value of a\n");     scanf("%d",&a);     if(b == 5)     printf("a = 0 , b = 0\n");     return 0; }


Question: 关于单链表的问题。

r 是一个单独的指针，不是链表中的结点

r=s;执行这一句之后r就已经赋了另外的值，自己画个图好理解一些

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步对应汇编一行！  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “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

在纸上画关系图是最直接有效的方法。

画一下图，就出来了，靠看代码不容易理解。

引用 2 楼 zdnexus 的回复:我好想懂了。。  r->next=s; r=s//就是r=r->next;读取下一个节点。 r->next=null.  是不是哦？ OK了

r->next=s; s->next=r->next;  //r->next已经是s了，再将s赋给s->next不就循环了吗 s->next=null;  如果按照楼主的思路应该是： r->next=s; s->next=null; 上面两步只是将s结到最后，题目还要求r需要指向最后一个节点，于是还需要r = s;