Question: 散分＋“加括号改变运算顺序的所有方案”终极代码PK和征集

自顶！

唉，想不出来，只能围观赵老师，围观大神了

上面给的结果好像都多了1, 我用 wc -l 数输出文件的行数了...

后缀表达式转中缀表达式啊...   后缀表达式总是前2个是 数字, 最后一个是运算符, 中间是各 n-2 个数字和运算符, 程序里用一个bit表示后缀表达式中是出现数字还是运算符, 1表示数字, 0表示运算符, 放 check里检查是否是合法的表达式... output 里把后缀表达式转成中缀表达式输出...  中缀表达式好像除了给人看也没啥用, 如果是具体计算就完全不用转中缀表达式了...

引用 16 楼 mujiok2003 的回复: 都可以发空的， ，只能说csdn很傻

引用 13 楼 u013163178 的回复:[quote=引用 12 楼 zhao4zhong1 的回复:] 自顶！ 为什么你输3个字也能发布，不是至少要5个字吗[/quote]  因为是【color=#000000]自顶！[/color】

引用 13 楼 u013163178 的回复:[quote=引用 12 楼 zhao4zhong1 的回复:] 自顶！ 为什么你输3个字也能发布，不是至少要5个字吗[/quote] 因为你才3裤衩，人家都一个砖了。。

不错，楼上的比我的快多了。求简单介绍一下思路。

带上格式吧...  #include <stdio.h> #include <stdlib.h> #include <string.h>  int b1c( unsigned x ) { 	x = (x&0x55555555) + ((x&0xaaaaaaaa)>>1); 	x = (x&0x33333333) + ((x&0xcccccccc)>>2); 	x = (x&0x0f0f0f0f) + ((x&0xf0f0f0f0)>>4); 	x = (x&0x00ff00ff) + ((x&0xff00ff00)>>8); 	x = (x&0x0000ffff) + ((x&0xffff0000)>>16);  	return x; }  int check(int n, int v) { 	int c = 1;  	n-=2; 	while(n--) 	{ 		if(v & (1<<(2*n + 1))) 			++c; 		else if(--c < 0) 			return 0;  		if(v & (1<<2*n)) 			++c; 		else if(--c < 0) 			return 0; 	}  	return 1; }  void output(int idx, int n, int v) { 	char s_expr[16][80], expr_r[80], expr[80], *pi, *po; 	int  stack[16], ne = 1, ns = 2;  	strcpy(s_expr[0], "."); 	stack[0] = stack[1] = 0;  	n = 2 * (n-2); 	while(n--) 	{ 		if(v & (1<<n)) 		{ 			stack[ns++] = 0; 		} 		else 		{	 			--ns; 			sprintf(s_expr[ne], "(%s+%s)", s_expr[stack[ns-1]], s_expr[stack[ns]]); 			stack[ns-1] = ne++; 		} 	}  	sprintf(expr_r, "(%s+%s)", s_expr[stack[0]], s_expr[stack[1]]); 	for(n = 0, pi = expr_r, po = expr; *pi; ++pi, ++po) 	{ 		if('.' == *pi) 		{ 			++n; 			if(n < 10) 			{ 				*po = '0' + n; 			} 			else 			{ 				*po++ = '1'; 				*po   = '0' + n - 10; 			}	 		} 		else 		{ 			*po = *pi; 		} 	} 	*po = 0; 	printf("%8d: %s\n", idx, expr); }  int main(int argc, char* argv[]) { 	int n = 8, nmx, i, idx = 0;  	if(argc == 2) 		n = atoi(argv[1]);  	if(n < 2 || n > 16) 		n = 8;  	nmx = 1 << 2 * (n-2);  	for(i = 0; i < nmx; ++i) 	{ 		if(b1c(i) == n - 2 && check(n, i)) 			output(idx++, n, i); 	}	  return 0; }

贴个慢的,  16个数的在我机器上运行时间 42秒,  9694845 个结果, 输出文件 740M ,  12个数就不测了, 好像0.3秒左右, 58786 个结果... 写个好的输出函数应该能处理 16 个数在 20多秒..  #include <stdio.h> #include <stdlib.h> #include <string.h>  int b1c( unsigned x ) { 	x = (x&0x55555555) + ((x&0xaaaaaaaa)>>1); 	x = (x&0x33333333) + ((x&0xcccccccc)>>2); 	x = (x&0x0f0f0f0f) + ((x&0xf0f0f0f0)>>4); 	x = (x&0x00ff00ff) + ((x&0xff00ff00)>>8); 	x = (x&0x0000ffff) + ((x&0xffff0000)>>16);  	return x; }  int check(int n, int v) { 	int c = 1;  	n-=2; 	while(n--) 	{ 		if(v & (1<<(2*n + 1))) 			++c; 		else if(--c < 0) 			return 0;  		if(v & (1<<2*n)) 			++c; 		else if(--c < 0) 			return 0; 	}  	return 1; }  void output(int idx, int n, int v) { 	char s_expr[16][80], expr_r[80], expr[80], *pi, *po; 	int  stack[16], ne = 1, ns = 2;  	strcpy(s_expr[0], "."); 	stack[0] = stack[1] = 0;  	n = 2 * (n-2); 	while(n--) 	{ 		if(v & (1<<n)) 		{ 			stack[ns++] = 0; 		} 		else 		{	 			--ns; 			sprintf(s_expr[ne], "(%s+%s)", s_expr[stack[ns-1]], s_expr[stack[ns]]); 			stack[ns-1] = ne++; 		} 	}  	sprintf(expr_r, "(%s+%s)", s_expr[stack[0]], s_expr[stack[1]]); 	for(n = 0, pi = expr_r, po = expr; *pi; ++pi, ++po) 	{ 		if('.' == *pi) 		{ 			++n; 			if(n < 10) 			{ 				*po = '0' + n; 			} 			else 			{ 				*po++ = '1'; 				*po   = '0' + n - 10; 			}	 		} 		else 		{ 			*po = *pi; 		} 	} 	*po = 0; 	printf("%8d: %s\n", idx, expr); }  int main(int argc, char* argv[]) { 	int n = 8, nmx, i, idx = 0;  	if(argc == 2) 		n = atoi(argv[1]);  	if(n < 2 || n > 16) 		n = 8;  	nmx = 1 << 2 * (n-2);  	for(i = 0; i < nmx; ++i) 	{ 		if(b1c(i) == n - 2 && check(n, i)) 			output(idx++, n, i); 	}	  return 0; }

引用 23 楼 slx_391987 的回复:[quote=引用 21 楼 zhao4zhong1 的回复:] [quote=引用 20 楼 slx_391987 的回复:] 还要考虑 运算符 优先级吧。 比如全是加法，加了括号也没用。 此处的＋泛指所有双目运算符，而非算数加法。[/quote] 所以我说了 “比如”。  我的意思是，加括号的时候，需要考虑运算符的优先级，如果全是+或者-或者* 等，加了括号也不能改变运算结果。[/quote] 此题不关注运算结果是否相等，只关注给出所有加括号改变运算顺序的可能。

引用 21 楼 zhao4zhong1 的回复:[quote=引用 20 楼 slx_391987 的回复:] 还要考虑 运算符 优先级吧。 比如全是加法，加了括号也没用。 此处的＋泛指所有双目运算符，而非算数加法。[/quote] 所以我说了 “比如”。  我的意思是，加括号的时候，需要考虑运算符的优先级，如果全是+或者-或者* 等，加了括号也不能改变运算结果。

泛指所有双目运算符

引用 20 楼 slx_391987 的回复:还要考虑 运算符 优先级吧。 比如全是加法，加了括号也没用。 此处的＋泛指所有双目运算符，而非算数加法。

还要考虑 运算符 优先级吧。 比如全是加法，加了括号也没用。

哦，嗦嘎！

引用 12 楼 zhao4zhong1 的回复:自顶！ 为什么你输3个字也能发布，不是至少要5个字吗

自顶！

想了半天，还是不懂，我投降


Question: 新手问个问题，关于判断栈是否溢出的

Pointer Arithmetic Additive operations involving a pointer and an integer give meaningful results only if the pointer operand addresses an array member and the integer value produces an offset within the bounds of the same array. When the integer value is converted to an address offset, the compiler assumes that only memory positions of the same size lie between the original address and the address plus the offset.  This assumption is valid for array members. By definition, an array is a series of values of the same type; its elements reside in contiguous memory locations. However, storage for any types except array elements is not guaranteed to be filled by the same type of identifiers. That is, blanks can appear between memory positions, even positions of the same type. Therefore, the results of adding to or subtracting from the addresses of any values but array elements are undefined.  Similarly, when two pointer values are subtracted, the conversion assumes that only values of the same type, with no blanks, lie between the addresses given by the operands.

顺序存储实现栈，意味着这栈空间是连续分配出来的，top-base就等于栈的目前实际使用容量。  实际使用容量跟栈最大容量相等，不就是栈满了吗？

引用 1 楼 lovesmiles 的回复:top和base又不一定是指针。  比如top=10,base=0; 栈的大小是stacksize=10; 那top-base自然就知道是不是满了。  top可能就是一个说明栈顶在第几个位置。所以无须连接空间也可以我的意思就是指针，不是整型计数器

引用 2 楼 zhao4zhong1 的回复:因为top总是每次加1的。那指针相减到底是什么相减，还是不太明白，希望老师能详细解释一下，谢谢老师

因为top总是每次加1的。


Question: 用C语言实现串口通信

那么我有了这些代码，具体要怎么实现，就是要下载VC的软件吗？用wintc不行吗

STDAFX.CPP, STDAFX.H  These files are used to build a precompiled header file PROJNAME.PCH and a precompiled types file STDAFX.OBJ. It is important that you neither define nor undefine any of the _AFX_NO_XXX macros in stdafx.h. See the Knowledge Base article "PRB: Problems Occur When Defining _AFX_NO_XXX". You can find Knowledge Base articles on the MSDN Library CD, or at http://www.microsoft.com/kb/.

看第一个头文件可知是用vc或vs编译的

不是所有的代码都用wintc编译的

引用 7 楼 zhao4zhong1 的回复:VS 是Microsoft Visual Studio吗

VS

引用 5 楼 zhao4zhong1 的回复:[quote=引用 4 楼 z530650681 的回复:] 那么我有了这些代码，具体要怎么实现，就是要下载VC的软件吗？用wintc不行吗 不行。 [/quote] 那要用什么样的软件，是不是串口通信的软件呢？试了一下，不太会，该用什么软件？

引用 4 楼 z530650681 的回复:那么我有了这些代码，具体要怎么实现，就是要下载VC的软件吗？用wintc不行吗 不行。


Question: 新手求大神帮忙

参考MSDN98\SAMPLES\VC98\SDK\SDKTOOLS\IMAGE\DRWATSON\DISASM.C

一种汇编语言，不懂这个 楼主可以先把内容输出的程序先写出来，然后从网上找这个汇编的一些资料

不就是个反汇编器。


Question: C语言的一点小问题

可以使用malloc函数啊

二维动态数组？  int **p; p = new int*[10];    //注意，int*[10]表示一个有10个元素的指针数组 for (int i = 0; i != 10; ++i) {     p[i] = new int[5]; } //当数组使用完毕，释放空间的代码是： for(int i = 0; i != 5; i++) {     delete[] p[i]; }  delete[] p;

用calloc函数。 calloc （待分配内存大小，要分多少块）  这里 第一个参数 你可以用strlen 算出来    第二个参数你用n 表示  下面为其赋值

可以尝试用链表

用链表。。。

http://bbs.csdn.net/topics/340075990 参考这个帖子吧

LONGLONG正好是八个BYTE 读到一个LONGLONG数组中(LONGLONG *pLL 然后 BYTE* = (BYTE*)(&pLL[x])

最好能给一个具体点的代码


Question: 截取两个特定字符串之间的内容

非常感谢几位热心帮助。

给你说下strstr这个函数的用法 函数原型： char *strstr( char *str, char * substr );   函数的作用也就是，返回在str里搜索 substr 第一次出现的位置， 并返回该位置。。  举个例子吧。  #include<stdio.h>  #include<string.h>  int main() {  char *str = "bbs.csdn.net/";   char *substr = "csdn";  char *s = strstr(str, substr);  printf("%s\n", s); return 0; } 那么输出结果就是 ： csdn.net/

用strstr进行子串的查找。看看strstr的使用说明，不难

使用strstr， 参考一下

C++的 用string类型存放整串  string str = “........select distinct guiydh from bgydl a,pdsdl b  where faredm = :FRDM_BGYDL and jiaoym='7301'..........;”; string::size_type Pos_From = str.find( "from",0 ); string::size_type Pos_Where = str.find( "where",0 ); string strDis = str.substr( Pos_From,Pos_Where );  C的话就用指针遍历字符串，记住找到“from” Pos1 和“where”的位置Pos2 memcpy( );size为Pos2 - Pos1

#include <stdio.h> #include <string.h>  int main() {   char *src = "........select distinct guiydh from bgydl a,pdsdl b  where faredm = :FRDM_BGYDL and jiaoym='7301'..........;";   char dest[100] = {0};   char *p1, *p2;   p1 = strstr(src, "from ");   p2 = strstr(src, " where");   if (p1 == NULL || p2 == NULL || p1 > p2) {     printf("Not found\n");   } else {     p1 += strlen("from ");     memcpy(dest, p1, p2 - p1);     printf("%s\n", dest);   }   return 0; }


Question: 数组和指针问题

引用 6 楼 u012421456 的回复:#include <stdio.h> #include <string.h>> #include <ctype.h>  void ToLowerCase(char *s) {  	for(int i=0; i<strlen(s); i++)     	s[i] = tolower(s[i]);/////////// } int main() {         char s[] = "HELLOWORLD";         ToLowerCase(s);         printf("%s\n", s);         return 0; } ++i效率会更好点， 恩核心还是字符串常量不允许修改，修改就是未定义啦， 但指向字符串常量的指针可以修改

引用 7 楼 u012421456 的回复:其实这样的问题百度谷歌可以找到的，楼主要善于利用搜索啊 恩  知道了 ：）

其实这样的问题百度谷歌可以找到的，楼主要善于利用搜索啊

引用 4 楼 xigangcpp 的回复:[quote=引用 1 楼 brookmill 的回复:] char *s = "HELLOWORLD"; // 这是常量字符串，不允许修改的 改成 char s[] = "HELLOWORLD";  恩 那么如何将request请求转换成小写呢[/quote]         while(*s){                 *s  = tolower(*s);                 s++;         } *s  = tolower(*s++); 这种写法有调戏编译器之嫌，参考置顶帖“C,C++表达式求值顺序 ” http://bbs.csdn.net/topics/370153775

引用 1 楼 brookmill 的回复:char *s = "HELLOWORLD"; // 这是常量字符串，不允许修改的 改成 char s[] = "HELLOWORLD";  恩 那么如何将request请求转换成小写呢

那么怎么把request请求的字符串转换成小写呢？

char *s = "HELLOWORLD";字符串常量不允许修改，你可以改成char s[] = "HELLOWORLD";


Question: 软件工程的问题，画了一通宵用例图，求我下面的用例图有没问题，谢谢谢

用例图已经N年没有画过了。不过，刚才百度了一下  空心三角形箭头应该是一个泛化(Inheritance)的关系。 就是父类和子类的关系。  但是你图中的空心三角形箭头好像不是这个意思。  各种箭头是不能够乱用的。

谢谢谢谢谢谢！！

不知道楼主是什么基础的，好像用况图的基本概念都没弄清楚  下面有一个简单的例子，仅供参考： 如有一个自动饮料销售系统，功能如下，用户可以自动购买饮料，供货员负责增加饮料，收银员负责收钱，而供货员和收钱人员都可以打开和关闭系统，画出该用况图。（下图没考虑用况包含与扩展关系）

华师大? 这张图画一通宵？。。 哎，楼主，装个roseration或者vs的那什么在里头画吧


Question: 跪求各位大神关于netbios的问题

我如果编一个基于netbios的网络通信程序，应该用什么软件运行啊？谢谢啊

你发错了论坛


Question: PROC 编译出错问题

是不是makefile的单条命令太长了。

顶一下，盼复

这样的问题很难帮你，你去其它的板块问问吧。

现在报错为： INTERNAL ERROR: Failed assertion [PGE Code=90105]  网上查询说是没有oracle用户权限，我已经将我测试用户加入oracle组了，怎么还是不行

引用 2 楼 yzg001212 的回复:[quote=引用 1 楼 zlloct 的回复:] [quote=引用 楼主 yzg001212 的回复:] 采用oracle proc 编译的时候报错： PCC-F-02044, CMD-LINE:  Illegal or out of range value for option  这种问题是Makefile文件问题吗？暂时没有找到头绪，忘指点，谢谢！  命令行超出可接受范围 PCC-02044: CMD-LINE: Illegal or out of range value for option: option string  Cause: A value specified for a command-line option was not within the accepted range. For example, the range for the MAXOPENCURSORS option is 5 to 256. If a value outside this range is specified, this message is triggered.   Action: See the Programmer's Guide to the Oracle Precompilers for the ranges that option values can take.[/quote]  这个错误解释我也查了，但是应该不是它所描述的问题，代码段本身是没有问题的，应该还是编译配置问题[/quote] 这个放在这个版块不是很合适，帮你挪一下

引用 1 楼 zlloct 的回复:[quote=引用 楼主 yzg001212 的回复:] 采用oracle proc 编译的时候报错： PCC-F-02044, CMD-LINE:  Illegal or out of range value for option  这种问题是Makefile文件问题吗？暂时没有找到头绪，忘指点，谢谢！  命令行超出可接受范围 PCC-02044: CMD-LINE: Illegal or out of range value for option: option string  Cause: A value specified for a command-line option was not within the accepted range. For example, the range for the MAXOPENCURSORS option is 5 to 256. If a value outside this range is specified, this message is triggered.   Action: See the Programmer's Guide to the Oracle Precompilers for the ranges that option values can take.[/quote]  这个错误解释我也查了，但是应该不是它所描述的问题，代码段本身是没有问题的，应该还是编译配置问题

引用 楼主 yzg001212 的回复:采用oracle proc 编译的时候报错： PCC-F-02044, CMD-LINE:  Illegal or out of range value for option  这种问题是Makefile文件问题吗？暂时没有找到头绪，忘指点，谢谢！  命令行超出可接受范围 PCC-02044: CMD-LINE: Illegal or out of range value for option: option string  Cause: A value specified for a command-line option was not within the accepted range. For example, the range for the MAXOPENCURSORS option is 5 to 256. If a value outside this range is specified, this message is triggered.   Action: See the Programmer's Guide to the Oracle Precompilers for the ranges that option values can take.


Question: 怎么把 指针b的指向的地址作为值 放到指针a指向的地址里？

好像是这个意思，1楼的答案不错，谢谢哈

中间加上：              long lbPos = (long)&(*b); 	unsigned short wRemain; 	a[0] = '0'; 	a[1] = 'x'; 	for(unsigned short wTemp = 0; wTemp < 8; wTemp++) 	{ 		wRemain = lbPos % 16; 		lbPos = lbPos / 16; 		if (wRemain < 10) 		{ 			a[9 - wTemp] = '0' + wRemain; 		} 		else 		{ 			a[9 - wTemp] = 'a' + wRemain - 10; 		} 	} 不知道楼主是不是这个意思？

char* a=(char*)malloc(10);  char* b="ddd";  *(int*)a=(int)b;  printf("0x%x\n", *(int*)a);//能打印出b的地址


Question: 求答案，求大神

围观。。。。

如果m，n，k都很大的话，由于 m^n%k的余数肯定会循环，因此空间换时间即可 按x从1到k-1计算m^x%k,如果之前这个余数已经存在则记录循环数目和余数，最后用%求下即可

支持1楼

支持1楼 ！！

是m xor n吗?还是pow(m,n)?

#include<stdio.h>  int main() { 	int m,n,k; 	scanf("%d%d%d",&m,&n,&k); 	printf("%d\n",((m^n)%k));  	return 0;	 }    输入你的数值，，就可以得到答案 ，这样快吗？

一个表达式，还最快速度？

m^n%k==(m%k)^n%k


Question: 求大神指教。。。。。

引用 3 楼 cs290473786 的回复:[quote=引用 1 楼 u012421456 的回复:] 你想问什么？ int mian (void) 这句是不是错了？？！ 哈哈。眼神不错，楼主想mian（面）吃了。[/quote]   确实是这里。多谢各位。。哥们眼神真好。。赞一个。

引用 1 楼 u012421456 的回复:你想问什么？ int mian (void) 这句是不是错了？？！ 哈哈。眼神不错，楼主想mian（面）吃了。

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

你想问什么？ int mian (void) 这句是不是错了？？！


Question: 这段程序有什么问题

2楼很有道理啊

顶二楼，二楼正解，还是自己亲自调试

二楼是对的...

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

if(c==*y*)  标点符号错了。 我都不明白你的程序能编译通过？

你會單步調試嗎? 不然告你你答案學不會那麼快


Question: 求大神解惑

如果可以的话，能帮我写下可以完成我这个例子的代码吗，主要是我不知道lc3汇编语言是啥...所以完全没头绪

这个要会汇编

试试debug

反汇编原理吧，我记得有一本书c++反汇编与逆向分析技术揭秘 这本书的前面有讲到如何实现的，只是一个翻译，挺 简单

用c读取一个文件中的4位16进制数字，然后输出相应的LC3汇编语言 后面还有示例 完全没有头绪？？？


Question: 为什么用vc++6.0写程序时出现找不到

#include <system.h> 是linux的东西吧？ 你在window上面编程自然找不到了。

#include <stdio.h> #include <conio.h> //#include <system.h> # include <stdlib.h> # include <windows.h>  int main(void) { 	while(!kbhit()) { 	    int i,j,k,l; 		for(k=0;k<20;k++) { 			printf("\n"); 		   	printf(" "); 		} 		printf("Press any key to return:"); //		delay(60000); 		Sleep(60000); 		printf("."); //		delay(60000); 		Sleep(60000); 		k++; 		if(k=6) { 			k=0; 			system("cls"); //		   	clrscr(); 		} 	} 	 	return 0; } ——http://zhidao.baidu.com/link?url=HvU6sjoj2vEsK18lPiBtRURMzsDarnoRmkXrxrWOZa51em00Bh88h_qgAlufqJiyhYyUExhWN39cZdo8tV_SlK


Question: 关于函数传址调用的问题

引用 3 楼 relaxisland 的回复:因为你要返回的是地址， 不是结构体 所以， 你的函数声明要是 fun(STU a[],STU **s) *s = &t[j] m的声明则必须指针 STU *m = null；   如果只是为了得到结构体 fun(STU a[],STU *s) *s = t[j] 嗯，输出没问题了！我再看看结果

更simple的描述方式会加速你的解答过程

#include<stdio.h> #include<string.h> #define N 10 typedef struct ss { 	char num[10]; 	int s; }STU; fun(STU a[],STU *s) { 	int i,j; 	STU *t; 	t=a; 	for(i=0;i<N;i++) 		for(j=i+1;j<N;j++) 			if(t[i].s>t[j].s) s=&t[j]; 	return s->s; } main() { 	STU a[N]={ 		{"A01",81}, 		{"A02",89}, 		{"A03",66}, 		{"A04",87}, 		{"A05",77}, 		{"A06",90}, 		{"A07",79}, 		{"A08",61}, 		{"A09",80}, 		{"A10",71} 	},m; 	int i; 	printf("***** The original data ***** \n"); 	for(i=0;i<N;i++) 		printf("NO=%s  Mark=%d\n",a[i].num,a[i].s); 	fun(a,&m); 	printf("***** The Result ***** \n"); 	printf("The lowest:  %s  ,  %d\n",m.num,m.s); 	getchar(); }


Question: GetWindowLong与SetWindowLong 函数问题

英语也是一门计算机语言的说。

要是我英文好我早就去看MSDN了,关键是翻译软件翻译出来的也不好用~!

1楼纯属胡扯！ SetWindowLong The SetWindowLong function changes an attribute of the specified window. The function also sets a 32-bit (long) value at the specified offset into the extra window memory of a window.   LONG SetWindowLong(   HWND hWnd,       // handle of window   int nIndex,      // offset of value to set   LONG dwNewLong   // new value );   Parameters hWnd  Handle to the window and, indirectly, the class to which the window belongs.  nIndex  Specifies the zero-based offset to the value to be set. Valid values are in the range zero through the number of bytes of extra window memory, minus 4; for example, if you specified 12 or more bytes of extra memory, a value of 8 would be an index to the third 32-bit integer. To set any other value, specify one of the following values: Value Action  GWL_EXSTYLE Sets a new extended window style.  GWL_STYLE Sets a new window style.  GWL_WNDPROC Sets a new address for the window procedure.  GWL_HINSTANCE Sets a new application instance handle.  GWL_ID Sets a new identifier of the window.  GWL_USERDATA Sets the 32-bit value associated with the window. Each window has a corresponding 32-bit value intended for use by the application that created the window.    The following values are also available when the hWnd parameter identifies a dialog box: Value Action  DWL_DLGPROC Sets the new address of the dialog box procedure.  DWL_MSGRESULT Sets the return value of a message processed in the dialog box procedure.  DWL_USER Sets new extra information that is private to the application, such as handles or pointers.     dwNewLong  Specifies the replacement value.  Return Values If the function succeeds, the return value is the previous value of the specified 32-bit integer.  If the function fails, the return value is zero. To get extended error information, callGetLastError.   If the previous value of the specified 32-bit integer is zero, and the function succeeds, the return value is zero, but the function does not clear the last error information. This makes it difficult to determine success or failure. To deal with this, you should clear the last error information by callingSetLastError(0) before calling SetWindowLong. Then, function failure will be indicated by a return value of zero and a GetLastError result that is nonzero.  Remarks The SetWindowLong function fails if the window specified by the hWnd parameter does not belong to the same process as the calling thread.  Certain window data is cached, so changes you make using SetWindowLong will not take effect until you call the SetWindowPos function.  If you use SetWindowLong with the GWL_WNDPROC index to replace the window procedure, the window procedure must conform to the guidelines specified in the description of the WindowProc callback function.   If you use SetWindowLong with the DWL_MSGRESULT index to set the return value for a message processed by a dialog procedure, you should return TRUE directly afterwards. Otherwise, if you call any function that results in your dialog procedure receiving a window message, the nested window message could overwrite the return value you set using DWL_MSGRESULT.   Calling SetWindowLong with the GWL_WNDPROC index creates a subclass of the window class used to create the window. An application can subclass a system class, but should not subclass a window class created by another process. The SetWindowLong function creates the window subclass by changing the window procedure associated with a particular window class, causing the system to call the new window procedure instead of the previous one. An application must pass any messages not processed by the new window procedure to the previous window procedure by calling CallWindowProc. This allows the application to create a chain of window procedures.   Reserve extra window memory by specifying a nonzero value in the cbWndExtra member of the WNDCLASSEX structure used with the RegisterClassEx function.   You must not call SetWindowLong with the GWL_HWNDPARENT index to change the parent of a child window. Instead, use the SetParent function.   Windows CE: The nIndex parameter must be a multiple of 4 bytes.   Unaligned access is not supported.   The following nIndex parameter values are not supported:   GWL_HINSTANCE   GWL_HWNDPARENT   GWL_USERDATA   Windows CE versions 2.0 and later support the DWL_DLGPROC value in the nIndex parameter, but Windows CE 1.0 does not.  QuickInfo   Windows NT: Requires version 3.1 or later.   Windows: Requires Windows 95 or later.   Windows CE: Requires version 1.0 or later.   Header: Declared in winuser.h.   Import Library: Use user32.lib.   Unicode: Implemented as Unicode and ANSI versions on Windows NT.  See Also Window Classes Overview, Window Class Functions, CallWindowProc, GetWindowLong, RegisterClassEx, SetParent, WindowProc, WNDCLASSEX     File: "C:\Program Files\Microsoft Visual Studio\VC98\Include\WINUSER.H"    7810: /*    7811:  * Get/SetWindowWord/Long offsets for use with WC_DIALOG windows    7812:  */    7813: #define DWL_MSGRESULT   0    7814: #define DWL_DLGPROC     4    7815: #define DWL_USER        8

^异或 |或

SetWindowLong是一个Windows API函数。该函数用来改变指定窗口的属性．函数也将指定的一个32位值设置在窗口的额外存储空间的指定偏移位置。  SetWindowLong(hwnd, 0, 0);//这个函数的目的是什么？  这里就是将窗口的所有属性设置为0.  SetWindowLong(hwnd, 0, 1 ^ GetWindowLong(hwnd, 0));//还有这个函数我也不懂他的意思？  先获得窗口原来的属性，然后在这基础上做或运算，即加上一个1的属性，然后再将运算结果设置回原窗口。


Question: CSDN在线编程挑战 F(x)~C  提交出错

输入输出有问题啊，是一次性输入，一次性输出。不是分开的

你输入个稍微大点的数看看，比如111

多组数据，每组第一行有一个整数n, 0 < n <= 10^11。    while(scanf("%d",&m))     {         if((m<=0)||(m>110))         {             return 0;         }


Question: opencv  openmp  人脸检测

引用 1 楼 zhao4zhong1 的回复:崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  从调试状态进入，崩溃之后像上面那张图，没办法进入调试。

选中断试试看。


Question: 函数指针的参数问题

引用 4 楼 u012986806 的回复:[quote=引用 2 楼 lovesmiles 的回复:] p_fnct 是一个函数指针      (*OS_TMR_CALLBACK_PTR)(void *p_tmr, void *p_arg);  这个定义已经说明p_fnct 它是接受二个参数的。  假如你说的p_tmr->CallbackPtr这个函数指针只接受一个参数，那么  p_fnct = p_tmr->CallbackPtr;  这个赋值肯定会出错的，不可能将一参数的函数指针赋值给二个参数的函数指针.  所以，你先确定你没有看错说明？  p_tmr一个是形参一个是实际存在的，两者我不是说得很清楚，不是同一个，只不过用的名字相同而已，麻烦你再帮忙看下帖子看我的问题怎么理解？谢谢[/quote] 这个是a,那个是a,这个又是a，到底是哪个a？你理解的了么？直接上代码不是更好么？你这样断章取义，谁能知道你到时又跑出个啥东西来……

引用 1 楼 u010030181 的回复:[quote=引用 楼主 u012986806 的回复:]  2.获取回调函数并执行。有两个参数，一个是我们回调函数的参数，另一个是p_tmr。 先获取p_fnct = p_tmr->CallbackPtr;这句话有问题吧？ 应该是p_arg = p_tmr->CallbackPtr吧？[/quote] 看4楼

引用 3 楼 zhao4zhong1 的回复:仅供参考#include <stdio.h> double A[300][100]; double valuex[300]; double valuey[300]; int i; double fun00(double x,double y) {return x  +   y  ;}; double fun01(double x,double y) {return x*x+ 3*y  ;}; double fun02(double x,double y) {return x  + 2*y*x;}; //...  fun03(double x,double y) {return ...+...   ;}; //... //...  fun98(double x,double y) {return ...+...   ;}; double fun99(double x,double y) {return x/2+20*y  ;}; double (*funNN[100])(double,double)={     fun00,     fun01,     fun02, //  fun03, //  ... //  fun98,     fun99, }; int main() {     double x,y;     int f,FN;      for (i=0;i<300;i++) {         valuex[i]=(double)i;         valuey[i]=(double)i;     }     FN=3;     for (i=0;i<300;i++) {          x=valuex[i];          y=valuey[i];          for (f=0;f<FN;f++) A[i][f]=funNN[f](x,y);     }     for (i=0;i<3;i++) {         for (f=0;f<FN;f++) printf("%lg ",A[i][f]);         printf("\n");     }     return 0; } //0 0 0 //2 4 3 //4 10 10 不懂，可以直接教我下吗？

引用 2 楼 lovesmiles 的回复:p_fnct 是一个函数指针      (*OS_TMR_CALLBACK_PTR)(void *p_tmr, void *p_arg);  这个定义已经说明p_fnct 它是接受二个参数的。  假如你说的p_tmr->CallbackPtr这个函数指针只接受一个参数，那么  p_fnct = p_tmr->CallbackPtr;  这个赋值肯定会出错的，不可能将一参数的函数指针赋值给二个参数的函数指针.  所以，你先确定你没有看错说明？  p_tmr一个是形参一个是实际存在的，两者我不是说得很清楚，不是同一个，只不过用的名字相同而已，麻烦你再帮忙看下帖子看我的问题怎么理解？谢谢

引用 楼主 u012986806 的回复:2.获取回调函数并执行。有两个参数，一个是我们回调函数的参数，另一个是p_tmr。 先获取p_fnct = p_tmr->CallbackPtr;这句话有问题吧？ 应该是p_arg = p_tmr->CallbackPtr吧？


Question: C语言遍历文件夹中的文件

int AddFileIntoStream(char *basePath,struct *st) { 	DIR *dir; 	struct dirent *ptr; 	char base[1000];  	if ((dir=opendir(basePath)) == NULL){ 		return -1; 	}  	while ((ptr=readdir(dir)) != NULL){ 		if(strcmp(ptr->d_name,".")==0 || strcmp(ptr->d_name,"..")==0)	 ///current dir OR parrent dir 			continue; 		else if(ptr->d_type == 8)	 /*file*/ 		{	 		   // 当前目录文件 		} 		else if(ptr->d_type == 10)	  /*link file*/ 		{ 	 		}  		else if(ptr->d_type == 4)	 /*dir*/ 		{ 			memset(base,'\0',sizeof(base)); 			strcpy(base,basePath); 			strcat(base,"/"); 			strcat(base,ptr->d_name); 			AddFileIntoStream(base , st); 		} 	} 	closedir(dir); 	return 1; }

system("dir /b /a-d c:\\*.* >d:\\allfiles.txt"); //读文件d:\\allfiles.txt的内容即C:\\下所有文件的名字 system("dir /b /a-d /s c:\\*.* >d:\\allfilesinsub.txt"); //读文件d:\\allfilesinsub.txt的内容即C:\\下所有文件的名字包含子目录 system("dir /b /ad  c:\\*.* >d:\\alldirs.txt"); //读文件d:\\alldirs.txt的内容即C:\\下所有子目录的名字 请记住，能用shell命令获取文件、文件夹信息或者操作文件、文件夹最好用shell命令获取或者操作，而不要用各种API获取或者操作，因为当遇到非法文件夹名或非法文件名或非法文件长度、非法文件日期、压缩文件、链接文件、稀疏文件……等各种意料之外的情况时，API会处理的不全面或陷入死循环，而shell命令不会。

Windows下用dir Linux下用ls

引用 4 楼 slx_391987 的回复:linux下可以使用readdir函数。参考代码如下：  int travelDir(const char *pcDirName) {     struct dirent *pstDirent = NULL;     DIR* pDir = NULL;           if (NULL == pcDirName)     {         return -1;     }      pDir = opendir(pcDirName);     if (NULL == pDir)     {         return -1;     }      while (NULL != (pstDirent=readdir(pDir)))     {         printf("%s\n", pstDirent->d_name);     }      return 0; }   忘记 closedir 了，呵呵

C语言标准库里面没有关于文件夹的操作的函数，所以只能使用系统本身提供的操作函数。Windows和Linux提供的文件夹函数差别很大，不能稍微修改就能在Linux上使用。

1. 可以用findfirst findnext http://bbs.csdn.net/topics/10288987 2. 没有linux和windows通用的方法吧？两个不同的系统，各有其接口，应该不能通用的。如果有的话，我也很想知道。 linux里面用opendir readdir之类的


Question: fflush(stdin)问题？

linux下使用 setbuf(stdin, NULL);

那就再读一次，把没有回车的扔掉。不要钻牛角尖

麻烦你看认真看下我的问题行么？   char cmdbuf[1024]; fgets(cmdbuf,sizeof(cmdbuf),stdin);  //就算按照你说的，定义cmdbuf[1024]大小，如果输入超过1024个字符，那么输入缓冲区里依然有没有读完的数据。 我的问题是如何清空没读完的数据。。。。。

引用 3 楼 xpdavis 的回复:char cmdbuf[1024]; fgets(cmdbuf,sizeof(cmdbuf),stdin); 它不是说非要读满1024个字节才返回的，它是碰到回车就返回，如果输入超过四个字符，就可以直接取前四个，剩下的都在缓冲区里面，不用就是了+1

问题是如何清空没读完的数据。

你多读一些，只取前四个字符就可以了啊


Question: 一个C语言链表编写的投票系统，还请各位大神为我解惑。

楼主怎么解决的这一道题啊？

引用 5 楼 learner66 的回复:[quote=引用 4 楼 u012421456 的回复:] char n; [u]n=getchar();  是n=getchar();就是接受一个字符，看和哪一位的序号相同，一开始我使用数组的，就是让数组中的数和竞选人的序号相比较，相同册p->account增1.您看看这个到底为什么只能输出第一个竞选人的结果。[/quote] 那n前边的[u]什么意思，我本以为楼主写错了，没想到楼主不提它

Node *calculate(Node *po) { Node *head=po; Node *p=head; char n; [u]n=getchar(); while(p->next!=NULL)  { while(n!='0')  {    if(n==p->flag)   p->account++;   n=getchar(); } p++;  //这不能有p++，链表分配的空间不是连续的，改成if( p->next!=NULL ) p=p->next;  }

引用 4 楼 u012421456 的回复:char n; [u]n=getchar();  是n=getchar();就是接受一个字符，看和哪一位的序号相同，一开始我使用数组的，就是让数组中的数和竞选人的序号相比较，相同册p->account增1.您看看这个到底为什么只能输出第一个竞选人的结果。

[quote=引用 6 楼 xionggch 的回复:] 一语中的，谢谢你的解答。以后多加交流

[quote=引用 7 楼 u012421456 的回复:] [quote=引用 5 楼 learner66 的回复:] [quote=引用 4 楼 u012421456 的回复:] 已经解决了，谢谢您的解答，

[quote=引用 6 楼 xionggch 的回复:]    [quote=引用 7 楼 u012421456 的回复:] [quote=引用 5 楼 learner66 的回复:] [quote=引用 4 楼 u012421456 的回复:] #include<stdio.h> #include<stdlib.h> #include<string.h> #define LEN sizeof(struct Position) typedef struct Position //竞选人的结构体 {         char name[20];         int  flag; int account;         struct Position *next; }Node; Node* inlist();//建立动态结构链表 void print(Node *po);//输入结果 void vote(); Node *calculate(Node *po,int str[]);//投票处理  Node* inlist() { Node *q,*p; Node *head; int n=0; p=q=(Node*)malloc(LEN); p->account=0; scanf("%s%d",p->name,&p->flag);  head=NULL;  while(p->flag!=0)   {  n=n+1;            if(n==1)            head=p;             else            q->next=p;          q=p;             p=(Node*)malloc(LEN); p->account=0;   scanf("%s%d",p->name,&p->flag);    }    q->next=NULL;    return head; } Node *calculate(Node *po,int str[]) { Node *p=po;  int i; for(;p->next!=NULL;p=p->next) { 	for(i=0;str[i]!=0;i++) 	if(str[i]==p->flag) 		p->account++; }  return po; }   void print(Node *po) { Node *p=po; for(;p->next!=NULL;p++) printf("%s %d %d\n",p->name,p->flag,p->account); }   void  vote() { char m; Node *head; int i; char position[20]; int str[1000]; printf("请输入要竞选的职位:"); gets(position); printf("请输入要参加该职位竞选的人员名字:\n"); head=inlist(); printf("请输入投票情况:"); for(i=0;;i++) {scanf("%d",&str[i]); if(str[i]==0)break; } head=calculate(head,str); printf("得到的结果是:"); print(head); }  int main() { printf("	 欢迎使用本系统！\n"); vote(); } 这次我重新改了一下，就是您只能显示我，而不能显示后边两位的选票数。

char n; [u]n=getchar();

谢谢您的解答，不过我的程序是一个投票系统，就是把竞选人给他们都标上号，然后根据号来进行投票。问题是我只能输出第一个人的票数，而不能输出后面的。

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

错了，是只能输出第一个人的信息，而不能输出后面的。


引用 3 楼 zxh707wk 的回复:#include <stdio.h>  int function() {     int i;     int temp=1;     for(i=0;i<100;i++)         temp=(temp*2)%100;     return temp; }  int main() {     printf("%d\n",function());     return 0; } 仅供参考   可是答案是i对的， 不知道为什么啊。 我刚学C。  能把具体思路给我说一下吗 详细一点 谢谢！

引用 3 楼 zxh707wk 的回复:#include <stdio.h>  int function() {     int i;     int temp=1;     for(i=0;i<100;i++)         temp=(temp*2)%100;     return temp; }  int main() {     printf("%d\n",function());     return 0; } 仅供参考   这个是不是 错了啊？   在循环第5次时候   temp = 2^6 = 64   第六次： temp = （2^7）%100 = 28 第七次： temp = （28*2）%100=56  到这儿就错了啊。 没有保证 括号里直接叠加到 2^100 次方 。

引用 8 楼 DelphiGuy 的回复:2^100=16^25=16^12*16^13 所以：2^100%100=(16^12%100 * 16^13%100)%100，int64可以直接计算。

引用 13 楼 shizhong_q 的回复:[quote=引用 3 楼 zxh707wk 的回复:] #include <stdio.h>  int function() {     int i;     int temp=1;     for(i=0;i<100;i++)         temp=(temp*2)%100;     return temp; }  int main() {     printf("%d\n",function());     return 0; } 仅供参考   可是答案是i对的， 不知道为什么啊。 我刚学C。  能把具体思路给我说一下吗 详细一点 谢谢！[/quote]只是要个位和十位的数，所以只保留这两位的数就行了

2^100%100 = (2^10^10)%100 = 1024^10^100 = 24^10 % 100 = 24^2^5^100=76^5%100=76

100本身就不大，根本用不到快速幂取模，还可以简化下：2^100=1024^10,顺序循环求24^10就是了

引用 2 楼 u012061345 的回复:快速幂取模，可以在对数时间解决。很基本的算法。 Mark下， 学习了！

？你就没次乘以2都对100取余，高位是多少不用关心

本帖子已过去太久远了，不再提供回复功能。

快速幂取模，可以在对数时间解决。很基本的算法。

这个可以用递归，或者你直接用math头文件，里面有幂函数。


Question: C语言列出素数求解

[quote=引用 5 楼 zxh707wk 的回复:] [quote=引用 3 楼 learner66 的回复:] 可以啊，但是这个小程序不需要用调用函数了吧

引用if(b=a-1)  if (b == a -1)

引用 3 楼 learner66 的回复:#include<stdio.h> int main() { int i,n,count; for(n=1;n<=100;n++) { count=0; for(i=2;i<n;i++) {if(n%i==0)count++;} if(count==0)  printf("%3d\n",n); } return 0; } 我也编写了一个，和你的不一样，供你发散思维。方法不止一种，希望共同学习做成函数然后调用不好吗，虽然运行要多花一些时间

引用 2 楼 u010030181 的回复:根据你的例子稍微改写的，仅供参考！记住for循环怎么循环，if绝大多数是用来判断的，不是用来赋值的…… #include<stdio.h> int main() {         int a,b,c,d,e,f;          c=2;          for(a=3;a<100;a++)     {     	for(b=2;b<a;b++)        	{         	if(a%b==0) 		  	{ 		  		break; 		  	} 			if(b==a-1)     			printf("\n%d",a);   		  			           	}                     	       	}    getchar();    return 0; }+1

你想完成什么功能？getch()最好改成getchar()


Question: 怎样把结构的大小扩大到一定的尺寸？

引用 15 楼 wangjun403 的回复:[quote=引用 14 楼 wgmhj328 的回复:] [quote=引用 11 楼 SXJIAKE 的回复:] // 大小固定為128字節，可隨時擴充。 typedef union {     struct {         int a;         int b;         int c;     };     BYTE dummy[128]; } ABCSTRUCT;  ABCSTRUCT abc; abc.a = 1; abc.b = 2; abc.c = 3;   正解[/quote] 万一a，b，c的大小超过了128byte呢[/quote] 支持，一切皆有可能。

引用 14 楼 wgmhj328 的回复:[quote=引用 11 楼 SXJIAKE 的回复:] // 大小固定為128字節，可隨時擴充。 typedef union {     struct {         int a;         int b;         int c;     };     BYTE dummy[128]; } ABCSTRUCT;  ABCSTRUCT abc; abc.a = 1; abc.b = 2; abc.c = 3;   正解[/quote] 万一a，b，c的大小超过了128byte呢

引用 11 楼 SXJIAKE 的回复:// 大小固定為128字節，可隨時擴充。 typedef union {     struct {         int a;         int b;         int c;     };     BYTE dummy[128]; } ABCSTRUCT;  ABCSTRUCT abc; abc.a = 1; abc.b = 2; abc.c = 3;   正解

在这个结构的开始添加一个 cbSize 成员。 根据这个成员就可以判断 结构的版本了。

楼主不会用realloc

typedef struct abc_t abc;; abc* ctor();  use(abc* p); dtor(abc*);   只需要修改函数实现就是可以做到随意扩展，这就是抽象。

引用 7 楼 derekrose 的回复:[quote=引用 6 楼 screen12 的回复:] [quote=引用 3 楼 derekrose 的回复:]  struct ABC { int a; int b; int c; void* extra; };  这个只是在最后添加一个指针变量，能把结构的大小扩大到128字节吗？ [/quote] 如果你只是要结构体所占大小扩大到128字节，那么办不到  但是在逻辑层面上，这做法不仅能扩大到128  而且扩大到逻辑上的任何size[/quote]+1

引用 1 楼 user-11 的回复:我一般是在最后加一个变量 char reserve[128-16];  支持。 还可以使用union以方便访问。

引用 6 楼 screen12 的回复:[quote=引用 3 楼 derekrose 的回复:]  struct ABC { int a; int b; int c; void* extra; };  这个只是在最后添加一个指针变量，能把结构的大小扩大到128字节吗？ [/quote] 如果你只是要结构体所占大小扩大到128字节，那么办不到  但是在逻辑层面上，这做法不仅能扩大到128  而且扩大到逻辑上的任何size

引用 3 楼 derekrose 的回复: struct ABC { int a; int b; int c; void* extra; };  这个只是在最后添加一个指针变量，能把结构的大小扩大到128字节吗？

引用 2 楼 u010030181 的回复:这个不懂啥意思，干嘛要呢去分配结构体的大小？你加减成员，自动就会相应的变化啊…… 这个很有用的。比如一个结构，里面的数据很复杂，而且将来你可能会添加新的变量。但是，如果你的软件已经发布出去了，用户已经使用你这个结构了，并且已经把他的数据保存到硬盘上了，结果你新程序中添了一个变量，结构大小不同了。结果从硬盘中读取数据来初始化你这个结构，就一塌胡涂了。

引用 1 楼 user-11 的回复:我一般是在最后加一个变量 char reserve[128-16]; 最后加变量有个缺点，就是你添加一个新变量的时候，你最后加的这个变量就要减去相应的值，稍不注意，就使得结构大小与原来不同。

我一般是在最后加一个变量 char reserve[128-16];


Question: 关于gets函数的一个小问题

C语言里不要用gets函数，请用fgets

[quote=引用 7 楼 k91191 的回复:] #include "stdio.h" #include <stdlib.h> int main(void) {     while (getchar()=='\n')     {         printf("Good\n");     }     printf("hello world\n");     return 0; }  不知道你要的是不是这样的输出，不过在输出hello world 时，你需要先用一个键跳出循环，再按enter 输出helloworld ，你可以试一下，多加交流

引用 5 楼 zhao4zhong1 的回复:Enter,Ctrl+Z,Enter 按下Enter会直接打印good,并且每按一次都是打印一次good，而不是表示被判定为空，而打印hello world

引用 3 楼 learner66 的回复:#include "stdio.h" #include <stdlib.h> #define SIZE 45 char input [SIZE]; int main(void) {     while ( gets(input )==NULL)     {         printf("Good\n");     }     printf("hello world\n");     return 0; } 不知道楼主是不是要这样的结构，把不等改成等号就行了 不是，我是希望按下Enter则表示输入为空，然后打印hello world

Enter,Ctrl+Z,Enter

引用 3 楼 learner66 的回复:#include "stdio.h" #include <stdlib.h> #define SIZE 45 char input [SIZE]; int main(void) {     while ( gets(input )==NULL)     {         printf("Good\n");     }     printf("hello world\n");     return 0; } 不知道楼主是不是要这样的结构，把不等改成等号就行了+1

你定义的input完全没意义啊，那还不如用getchar（）来检测输入

键盘上  不是 不能输入  null 吧 一般大家都是用 eof 来判断  可以用CTRL+z来结束输入


Question: 【参考算法】从N个数字中选出K个数字构成一组组合

仅供参考#include <stdio.h> #include <stdlib.h> #define MAX_NUM 26 int comb[MAX_NUM]; int c1,c2; void combination(int m,int n) {     int i,j;      for (i=m;i>=n;i--) {         comb[n]=i; /* 选择当前的“头”元素 */         if (n>1) {             combination(i-1,n-1); /* 进入下一次更小的组合问题 */         } else { /* 满了需要的组合数，输出 */             for (j=comb[0];j>0;j--) printf("%c",'A'+c1-comb[j]);             printf("\n");         }     }     return; } int main(int argc,char **argv) {     if (argc<3) {         printf("%s 组合下标 组合上标\n",argv[0]);         return 1;     }     c1=atoi(argv[1]);     if (c1<1 || MAX_NUM<c1) {         printf("1<=组合下标<=%d\n",MAX_NUM);         return 2;     }     c2=atoi(argv[2]);     if (c2<1 || c1<c2) {         printf("1<=组合上标<=组合下标\n");         return 3;     }     comb[0]=c2;     combination(c1,c2);     return 0; }


Question: 急！大家帮忙看看代码哪里出了错；

引用 1 楼 u012421456 的回复:你看一下s的值是多少，是0 因为1/2的值取整以后就是0 s=1/2*(x+y+z);这一句中程序先计算1/2，因为1和2都是整型的，所以1/2的结果等于0，0接着作为乘数，0乘任何数得0，于是s=0。s又作为乘数参与area值的运算（area=sqrt(s*(s-x)*(s-y)*(s-z));），故area的值等于0.

自己调试一下不就知道为啥是0了

对了，楼主代码格式看起来挺不方便的，最后return 0比较好

你看一下s的值是多少，是0 因为1/2的值取整以后就是0


Question: 如何用qsort对二维字符数组存的若干字符串排序？

谢谢兄弟们，尤其是赵哥。 本来想问一下char t[5][100] 不能用于qsort的解决办法，没想到额外收获了赵哥的简洁高效程序。 我用了80万行的倚天屠龙记切分语料来统计无重复词，朝歌的程序跑得非常OK。

#include <stdio.h>  #include <stdlib.h>   #include <string.h>    /*---------------------------------------------------------------------     字符指针数组的4个字符串排序函数：升序或降序 and 是否忽略大小写     调用方法： 	    char *s[5]=     {"caTtle","caR","banana","cabet","cap"};           qsort((void*)s, 5, sizeof(char *), 下面所列的4个函数名之一); ---------------------------------------------------------------------*/ int qsort_compare_pstr_asc(const void *a, const void *b);   int qsort_compare_pstr_asc_ignorecase(const void *a, const void *b);   int qsort_compare_pstr_desc(const void *a, const void *b);   int qsort_compare_pstr_desc_ignorecase(const void *a, const void *b);    /*---------------------------------------------------------------------     二位字符数组的4个字符串排序函数：升序或降序 and 是否忽略大小写     调用方法： 	    char t[5][100]= {"caTtle","caR","banana","cabet","cap"};           qsort(t, 5, 100*sizeof(char), 下面所列的4个函数名之一); ---------------------------------------------------------------------*/ int qsort_compare_chararray_asc(const void *arg1, const void *arg2); int qsort_compare_chararray_asc_ignorecase(const void *arg1, const void *arg2); int qsort_compare_chararray_desc(const void *arg1, const void *arg2); int qsort_compare_chararray_desc_ignorecase(const void *arg1, const void *arg2);   /*---------------------------------------------------------------------     8个字符串排序函数的具体定义     按如下三个标准分成8个函数：（1）字符指针数组 or 二维字符数组 	                           （2）升序 or 降序 	                           （3）是否忽略英文字母的大小写 ---------------------------------------------------------------------*/ int qsort_compare_pstr_asc(const void *a, const void *b)                 /* 字符指针数组、升序、区分大小写 */ {       return strcmp(*(char**)a, *(char**)b);  }    int qsort_compare_pstr_asc_ignorecase(const void *a, const void *b)      /* 字符指针数组、升序、忽略大小写 */ {       return stricmp(*(char**)a, *(char**)b);  }    int qsort_compare_pstr_desc(const void *a, const void *b)                /* 字符指针数组、降序、区分大小写 */  {       return -strcmp(*(char**)a, *(char**)b);  }    int qsort_compare_pstr_desc_ignorecase(const void *a, const void *b)     /* 字符指针数组、降序、忽略大小写 */  {       return -stricmp(*(char**)a, *(char**)b);  }  int qsort_compare_chararray_asc(const void *arg1, const void *arg2)               /* 二维字符数组、升序、区分大小写 */ {     return strcmp((char *)arg1, (char *)arg2);  }  int qsort_compare_chararray_asc_ignorecase(const void *arg1, const void *arg2)    /* 二维字符数组、升序、忽略大小写 */ {     return stricmp((char *)arg1, (char *)arg2);  }  int qsort_compare_chararray_desc(const void *arg1, const void *arg2)              /* 二维字符数组、降序、区分大小写 */ {     return -strcmp((char *)arg1, (char *)arg2);  }  int qsort_compare_chararray_desc_ignorecase(const void *arg1, const void *arg2)   /* 二维字符数组、降序、忽略大小写 */ {     return -stricmp((char *)arg1, (char *)arg2);  }      char *s[5]=     {"caTtle","caR","banana","cabet","cap"};   char t[5][100]= {"caTtle","caR","banana","cabet","cap"};   int main()   {      int i;      printf("\ns降序排列：\n");      qsort((void*)s, 5, sizeof(char *), qsort_compare_pstr_desc);      for(i=0; i<5; i++)          printf("%s\n",s[i]);      printf("\ns降序排列（忽略大小写）：\n");      qsort((void*)s, 5, sizeof(char *), qsort_compare_pstr_desc_ignorecase);      for(i=0; i<5; i++)          printf("%s\n",s[i]);   	printf("\ns升序排列：\n");      qsort((void*)s, 5, sizeof(char *), qsort_compare_pstr_asc);      for(i=0; i<5; i++)          printf("%s\n",s[i]);   	printf("\ns升序排列（忽略大小写）：\n");      qsort((void*)s, 5, sizeof(char *), qsort_compare_pstr_asc_ignorecase);      for(i=0; i<5; i++)          printf("%s\n",s[i]);         printf("\nt降序排列：\n");      qsort(t, 5, 100*sizeof(char), qsort_compare_chararray_desc);      for(i=0; i<5; i++)          printf("%s\n",t[i]);         printf("\nt降序排列（忽略大小写）：\n");      qsort(t, 5, 100*sizeof(char), qsort_compare_chararray_desc_ignorecase);      for(i=0; i<5; i++)          printf("%s\n",t[i]);         printf("\nt升序排列：\n");      qsort(t, 5, 100*sizeof(char), qsort_compare_chararray_asc);      for(i=0; i<5; i++)          printf("%s\n",t[i]);         printf("\nt升序排列（忽略大小写）：\n");      qsort(t, 5, 100*sizeof(char), qsort_compare_chararray_asc_ignorecase);      for(i=0; i<5; i++)          printf("%s\n",t[i]);         return 0;  }

如果数据量很大的话，那一般在读取的时候不会用指针常量存的。而且数据量大的时候内存都会出问题，一般采用外部排序。

数据量大的话可以做归并排序 将数据按10万分段做排序，结果存储到文件中，然后作多路归并就可以了

仅供参考//文件1中的内容排序并去重,结果保存到文件2中 #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAXCHARS 128      //能处理的最大行宽,包括行尾的\n和字符串尾的\0 int MAXLINES=10000,MAXLINES2; char *buf,*buf2; int c,n,hh,i,L; FILE *f; char ln[MAXCHARS]; int ignore_case=0; int icompare(const void *arg1,const void *arg2) {    return stricmp((char *)arg1,(char *)arg2); } int compare(const void *arg1,const void *arg2) {    return strcmp((char *)arg1,(char *)arg2); } int main(int argc,char **argv) {     if (argc<3) {         printf("Unique line. Designed by zhao4zhong1@163.com. 2012-08-20\n");         printf("Usage: %s src.txt uniqued.txt [-i]\n",argv[0]);         return 1;     }     if (argc>3) ignore_case=1;//若存在命令行参数3，忽略大小写     f=fopen(argv[1],"r");     if (NULL==f) {         printf("Can not find file %s!\n",argv[1]);         return 1;     }     buf=(char *)malloc(MAXLINES*MAXCHARS);     if (NULL==buf) {         fclose(f);         printf("Can not malloc(%d LINES*%d CHARS)!\n",MAXLINES,MAXCHARS);         return 2;     }     n=0;     hh=0;     i=0;     while (1) {         if (NULL==fgets(ln,MAXCHARS,f)) break;//         hh++;         L=strlen(ln)-1;         if ('\n'!=ln[L]) {//超长行忽略后面内容             printf("%s Line %d too long(>%d),spilth ignored.\n",argv[1],hh,MAXCHARS);             while (1) {                 c=fgetc(f);                 if ('\n'==c || EOF==c) break;//             }         }         while (1) {//去掉行尾的'\n'和空格             if ('\n'==ln[L] || ' '==ln[L]) {                 ln[L]=0;                 L--;                 if (L<0) break;//             } else break;//         }         if (L>=0) {             strcpy(buf+i,ln);i+=MAXCHARS;             n++;             if (n>=MAXLINES) {                 MAXLINES2=MAXLINES*2;                 if (MAXLINES2==1280000) MAXLINES2=2500000;                 buf2=(char *)realloc(buf,MAXLINES2*MAXCHARS);                 if (NULL==buf2) {                     printf("Can not malloc(%d LINES*%d CHARS)!\n",MAXLINES2,MAXCHARS);                     printf("WARNING: Lines >%d ignored.\n",MAXLINES);                     break;//                 }                 buf=buf2;                 MAXLINES=MAXLINES2;             }         }     }     fclose(f);     if (n>1) {         if (ignore_case) qsort(buf,n,MAXCHARS,icompare);         else qsort(buf,n,MAXCHARS,compare);     }     f=fopen(argv[2],"w");     if (NULL==f) {         free(buf);         printf("Can not create file %s!\n",argv[2]);         return 2;     }     fprintf(f,"%s\n",buf);     if (n>1) {         if (ignore_case) {             hh=0;             L=MAXCHARS;             for (i=1;i<n;i++) {                 if (stricmp((const char *)buf+hh,(const char *)buf+L)) {                     fprintf(f,"%s\n",buf+L);                 }                 hh=L;                 L+=MAXCHARS;             }         } else {             hh=0;             L=MAXCHARS;             for (i=1;i<n;i++) {                 if ( strcmp((const char *)buf+hh,(const char *)buf+L)) {                     fprintf(f,"%s\n",buf+L);                 }                 hh=L;                 L+=MAXCHARS;             }         }     }     fclose(f);     free(buf);     return 0; }

引用 2 楼 woshihuzi 的回复:我可以另外设一个字符指针数组char *pt[5] = {t[0],t[1],t[2],t[3],t[4]} 下面只需要用qsort对pt排序，最后pt[0]、pt[1]、……指向的字符串就是有序的。 现在带来一个问题： 如果数据量很大，比如100万个字符串，额外加400万字节的指针，会不会消耗内存很厉害？ 如果我想在pt排序完之后再写段代码让t有序，会不会是多此一举？ 100万个字符串，明显会内存消耗很利害，要考虑其它 的方法了。比如hash. 是多此一举。

t[i]是指针常量，不能作为左值。所以会在qsort交换数组元素位置时出错。  要qsort排序的话，可以把t的每个元素赋给一个字符指针数组，就像s。


Question: int i = 1；i = i ++ > 0 ? i++： i;  为什么i等于2而不是3？

引用 30 楼 unituniverse2 的回复:[quote=引用 29 楼 unituniverse2 的回复:] 其实这问题全出在i=i++>0上 这个式子其实是 i=(i++>0) i++>0为true，所以相当于i=true 结果i=1，然后才是执行问号后面的内容 居然没看清楚。。结果作废好了 i = i ++ > 0 ? i++： i; 相当于 i = (i ++ > 0 ? i++ : i); 按标准?:的副作用在过？时就结束，结果应该为i=i++。问题是这个式子本身是未定义的（即使按最新的标准，i=++i是已定义的表达式，而后置型的i=i++则仍属于未定义的情况）。[/quote]  谢

引用 21 楼 FancyMouse 的回复:[quote=引用 11 楼 u012526168 的回复:] [quote=引用 5 楼 FancyMouse 的回复:] [quote=引用 2 楼 u012526168 的回复:] [quote=引用 1 楼 FancyMouse 的回复:] >这时i = 2 并作赋值给i，然后遇到序列点；i再自增 这里没有序列点 五点58，蛮拼的 分号不是序列点？[/quote] 分号是分整个statement的，不是分?:的。分号序列点发生在整个i = i++ > 0 ? i++ : i之后。[/quote] 这个我知道啊，先赋值嘛，之后不是应该还自增的[/quote] 那你就应该知道你这写法等价于i++; i=i++;而这是未定义行为。[/quote]  谢谢，有眼不识泰山，你是对的。

初看这个标题还以为是简单问题呢，没想到这么复杂。受教了

引用 33 楼 u012526168 的回复:[quote=引用 30 楼 unituniverse2 的回复:] [quote=引用 29 楼 unituniverse2 的回复:] 其实这问题全出在i=i++>0上 这个式子其实是 i=(i++>0) i++>0为true，所以相当于i=true 结果i=1，然后才是执行问号后面的内容 居然没看清楚。。结果作废好了 i = i ++ > 0 ? i++： i; 相当于 i = (i ++ > 0 ? i++ : i); 按标准?:的副作用在过？时就结束，结果应该为i=i++。问题是这个式子本身是未定义的（即使按最新的标准，i=++i是已定义的表达式，而后置型的i=i++则仍属于未定义的情况）。[/quote]  谢[/quote]  引用 31 楼 u012526168 的回复:[quote=引用 30 楼 unituniverse2 的回复:] [quote=引用 29 楼 unituniverse2 的回复:] 其实这问题全出在i=i++>0上 这个式子其实是 i=(i++>0) i++>0为true，所以相当于i=true 结果i=1，然后才是执行问号后面的内容 居然没看清楚。。结果作废好了 i = i ++ > 0 ? i++： i; 相当于 i = (i ++ > 0 ? i++ : i); 按标准?:的副作用在过？时就结束，结果应该为i=i++。问题是这个式子本身是未定义的（即使按最新的标准，i=++i是已定义的表达式，而后置型的i=i++则仍属于未定义的情况）。[/quote]  不懂，可不可以说的详细点[/quote]  引用 30 楼 unituniverse2 的回复:[quote=引用 29 楼 unituniverse2 的回复:] 其实这问题全出在i=i++>0上 这个式子其实是 i=(i++>0) i++>0为true，所以相当于i=true 结果i=1，然后才是执行问号后面的内容 居然没看清楚。。结果作废好了 i = i ++ > 0 ? i++： i; 相当于 i = (i ++ > 0 ? i++ : i); 按标准?:的副作用在过？时就结束，结果应该为i=i++。问题是这个式子本身是未定义的（即使按最新的标准，i=++i是已定义的表达式，而后置型的i=i++则仍属于未定义的情况）。[/quote]  引用 30 楼 unituniverse2 的回复:[quote=引用 29 楼 unituniverse2 的回复:] 其实这问题全出在i=i++>0上 这个式子其实是 i=(i++>0) i++>0为true，所以相当于i=true 结果i=1，然后才是执行问号后面的内容 居然没看清楚。。结果作废好了 i = i ++ > 0 ? i++： i; 相当于 i = (i ++ > 0 ? i++ : i); 按标准?:的副作用在过？时就结束，结果应该为i=i++。问题是这个式子本身是未定义的（即使按最新的标准，i=++i是已定义的表达式，而后置型的i=i++则仍属于未定义的情况）。[/quote] 按这样理解的话，i=i++>0?++i:i;是否就等价于i=++i 呢？

引用 17 楼 xpdavis 的回复:i=i++?i++:i;  1 i++ ----- i=2  2 i++:i; ----- 表达式求值 结果为2  3 i++  ----- i =3  4 i=表达式赋值 i=2  看汇编确实是这么执行的，但是总感觉给我之前理解的序列点有出入， 1.为什么第二个后自增操作没有对赋值之后的 i 起作用？ 2.这与 int i = 1; if (i++ > 0){ 	i = i++; } else{ 	i = i; } 有什么不同？ 3.可否把序列点在底层的实现给梳理一下？

引用 16 楼 u013163178 的回复:我觉得讨论这个没意思啊，谁会写可读性这么差的代码，加个括号几u不至于这样啊 嗯，我也觉得。

我觉得讨论这个没意思啊，谁会写可读性这么差的代码，加个括号几u不至于这样啊

引用 6 楼 xpdavis 的回复:这种问题知道它的利害关系就行了，没必要花太多时间去研究它。写程序最好要知道自己要的是什么，或者是看到代码知道它想干什么，如果这两点不能做到的话，要么面壁思过，要么把代码废了。如果我看到这样的代码，就是把它废了 理是这个理，但是不知道在程序底层干了些什么导致这样，心里难受怎么办？

引用 7 楼 r_Jimy 的回复:从现象上看，i=i++?i++:i;这里前面的i++没起作用  i=i++>0?i+10:i+20; 这样子用DEVC++，i++有起作用，i的值是12 首先谢谢你， 其次 ”从现象上看，i=i++?i++:i;这里前面的i++没起作用，“ 从汇编代码看，你说的是错误的。 012613B4  mov         dword ptr [i],ecx    012613B7  cmp         dword ptr [ebp-0D0h],0    012613BE  jle         main+54h (012613D4h)    012613C0  mov         edx,dword ptr [i]    012613C3  mov         dword ptr [ebp-0D4h],edx    012613C9  mov         eax,dword ptr [i]    012613CC  add         eax,1    012613CF  mov         dword ptr [i],eax   最后 你举得例子，好像给我问的问题没关系。

引用 12 楼 u012526168 的回复:[quote=引用 9 楼 yongqingling 的回复:] 第二个i++，先返回i,返回了i就不执行了（gcc），你换成++i就是3了  ++i是这样，那i++呢。[/quote]i++是2啊

引用 9 楼 yongqingling 的回复:第二个i++，先返回i,返回了i就不执行了（gcc），你换成++i就是3了  ++i是这样，那i++呢。

引用 5 楼 FancyMouse 的回复:[quote=引用 2 楼 u012526168 的回复:] [quote=引用 1 楼 FancyMouse 的回复:] >这时i = 2 并作赋值给i，然后遇到序列点；i再自增 这里没有序列点 五点58，蛮拼的 分号不是序列点？[/quote] 分号是分整个statement的，不是分?:的。分号序列点发生在整个i = i++ > 0 ? i++ : i之后。[/quote] 这个我知道啊，先赋值嘛，之后不是应该还自增的

引用 30 楼 unituniverse2 的回复:[quote=引用 29 楼 unituniverse2 的回复:] 其实这问题全出在i=i++>0上 这个式子其实是 i=(i++>0) i++>0为true，所以相当于i=true 结果i=1，然后才是执行问号后面的内容 居然没看清楚。。结果作废好了 i = i ++ > 0 ? i++： i; 相当于 i = (i ++ > 0 ? i++ : i); 按标准?:的副作用在过？时就结束，结果应该为i=i++。问题是这个式子本身是未定义的（即使按最新的标准，i=++i是已定义的表达式，而后置型的i=i++则仍属于未定义的情况）。[/quote] 不懂，可不可以说的详细点

引用 6 楼 xpdavis 的回复:这种问题知道它的利害关系就行了，没必要花太多时间去研究它。写程序最好要知道自己要的是什么，或者是看到代码知道它想干什么，如果这两点不能做到的话，要么面壁思过，要么把代码废了。如果我看到这样的代码，就是把它废了+1

引用 29 楼 unituniverse2 的回复:其实这问题全出在i=i++>0上 这个式子其实是 i=(i++>0) i++>0为true，所以相当于i=true 结果i=1，然后才是执行问号后面的内容 居然没看清楚。。结果作废好了 i = i ++ > 0 ? i++： i; 相当于 i = (i ++ > 0 ? i++ : i); 按标准?:的副作用在过？时就结束，结果应该为i=i++。问题是这个式子本身是未定义的（即使按最新的标准，i=++i是已定义的表达式，而后置型的i=i++则仍属于未定义的情况）。

第二个i++，先返回i,返回了i就不执行了（gcc），你换成++i就是3了

引用 6 楼 xpdavis 的回复:这种问题知道它的利害关系就行了，没必要花太多时间去研究它。写程序最好要知道自己要的是什么，或者是看到代码知道它想干什么，如果这两点不能做到的话，要么面壁思过，要么把代码废了。如果我看到这样的代码，就是把它废了 灰常同意，这么奇怪的代码实在不该写出来


Question: C语言新手求解

scanf("%s")是错的，应该是%c，另外如果能说出这个程序解决什么问题，可能更好讨论出错的地方。

为啥我运行会崩溃 求解。。题目在下面 是英文的

你想问什么？


Question: 如何用高效的代码提取格式化字符串中的信息

LEX+YACC Flex+Bison

引用 13 楼 ForestDB 的回复:我最近在看一本书，叫《叫flex和bison》，当然我也看不太懂，但是可以推荐给你。 挺好，中英文版的pdf在csdn上都找到了，有空好好读读。

引用 6 楼 ForestDB 的回复:最高效的就是状态机。 请问ForestDB兄，状态机用程序实现起来能否数据与程序分离。 也就算是，我负责设计状态机，按程序员要求的格式将状态机描述出来，程序员负责编程运行状态机。 当我的状态机变换的时候，程序不用任何修改就能运行另一个符合格式要求的状态机。

赵哥 给的程序不错，开了眼界。我见过有一种有限状态转移网络，跟有限状态机很像，那是只转移状态不输出的，能识别字符串，但不能提取字符串中的信息。

引用 5 楼 zhao4zhong1 的回复:提醒坛友们：      在字符串扫描处理这个问题域内，正则表达式不是万能的；而有限状态自动机是万能的。   我对有限状态自动机稍懂一点，我觉得它只能识别一个字符串是否符合给定的格式，不知道它是不是还有从字符串中提取需要数据的功能？

引用 4 楼 zhao4zhong1 的回复:建议楼主节省下以后思考此类问题的时间，潜心研究《编译原理》中的词法分析和有限状态自动机。 谢谢赵哥的代码。编译原理的有限状态自动机稍微懂一点，但词法分析没学过。

引用 2 楼 xpdavis 的回复:http://www.cnblogs.com/hjslovewcl/articles/2314311.html http://blog.sina.com.cn/s/blog_5357c0af0100hfua.html 好资料，以后好好学习学习。

引用 9 楼 woshihuzi 的回复:[quote=引用 5 楼 zhao4zhong1 的回复:] 提醒坛友们：      在字符串扫描处理这个问题域内，正则表达式不是万能的；而有限状态自动机是万能的。   我对有限状态自动机稍懂一点，我觉得它只能识别一个字符串是否符合给定的格式，不知道它是不是还有从字符串中提取需要数据的功能？[/quote] 有限状态机，（英语：finite-state machine, FSM），又称有限状态自动机，简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。 参考下面：//有字符串 //1_22_333,,4444__55555,_666666 //需要解析为 //1 //22 //333 //_ //4444 //55555 //666666 #include <stdio.h> char s[]="1_22_333,,4444__55555,_666666"; char c,*p,*p1; int st; void main() {     st=0;     p=s;     while (1) {         c=*p;         if (0==c) {             switch (st) {             case 1:printf("_\n");    break;             case 2:printf("%s\n",p1);break;             }             break;//         }         switch (st) {         case 0:                  if ('_'==c) {                            st=0;}             else if (','==c) {                            st=1;}             else             {p1=p;                       st=2;}         break;         case 1:                  if ('_'==c) {                            st=1;}             else if (','==c) {printf("_\n");              st=1;}             else             {p1=p;                       st=2;}         break;         case 2:                  if ('_'==c) {*p=0;printf("%s\n",p1);*p=c;st=0;}             else if (','==c) {*p=0;printf("%s\n",p1);*p=c;st=1;}             else             {                            st=2;}         break;         }         p++;     } } //1 //22 //333 //_ //4444 //55555 //666666

最高效的就是状态机。

//in.txt //f(a  bc,甲)=丙 //f(a,乙)=戊/222    //123 //f(48,丙)=戊 //f(2aaaaaaa   ,丙)=戊//aaa //f(48,张三)=戊 //f(阿3,丁)=乙    //子丑寅卯 //f(48,)=李四  //子鼠丑牛 #include <stdio.h> #include <stdlib.h> #include <string.h> FILE *f; char ln[80]; char s1[40]; char s2[40]; char s34[80]; char *p; char s3[40]; char s4[40]; int i,k; int main() {     f=fopen("in.txt","r");     if (NULL==f) {         printf("Can not open file in.txt!\n");         return 1;     }     i=0;     while (fgets(ln,80,f)) {         if (3==sscanf(ln,"f(%39[^,],%39[^)])=%79[^\n]",s1,s2,s34)) {             p=strstr(s34,"//");             if (p) {                 k=__min(39,p-s34);                 strncpy(s3,s34,k);s3[k]=0;                 k=__min(39,strlen(p+2));                 strncpy(s4,p+2,k);s4[k]=0;             } else {                 strncpy(s3,s34,39);s3[39]=0;                 s4[0]=0;             }             printf("[%s],[%s],[%s],[%s]\n",s1,s2,s3,s4);         } else {             printf("in.txt line %d format error:%s",i+1,ln);         }         i++;     }     fclose(f);     return 0; } //[a  bc],[甲],[丙],[] //[a],[乙],[戊/222    ],[123] //[48],[丙],[戊],[] //[2aaaaaaa   ],[丙],[戊],[aaa] //[48],[张三],[戊],[] //[阿3],[丁],[乙    ],[子丑寅卯] //in.txt line 7 format error:f(48,)=李四  //子鼠丑牛 //

这个已经超越scanf的阉割正则语法的能力了。请自行处理或使用正规正则库。


Question: 急急急   C/C++字符串与整型异或运算

1.第一步： c^a = 1110 ^ 0011 = 1101 = 13; 2. 第二步：~（c^a）= 1111 1111 1111 0010; 因为补码是负数。对应的原码为为补码取反+1<符号位不动>。结果为：1000 0000 0000 1110，为-14； 3. 第三步：~（c^a）<<4 = 1000 0000 1110 0000; 结果-224

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

楼主应该是打算写char a=14;的吧？char a='14';会编译出错。  详细解答过程：

引用 3 楼 xpdavis 的回复:[quote=引用 2 楼 u012421456 的回复:] 又见到这种写法了 char a='14'; 这算是单个字符吗 这样写，首个字符有效，就是'1'[/quote] 哦，谢谢啊  楼主清楚这几个运算符的含义吗

引用 2 楼 u012421456 的回复:又见到这种写法了 char a='14'; 这算是单个字符吗 这样写，首个字符有效，就是'1'

又见到这种写法了 char a='14'; 这算是单个字符吗


Question: 字符串转换为二进制？？？

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

所有数据在内存中存储的时候都是二进制的（可以从一些计算精度问题看出），在输出的时候会根据输出函数的参数和类型选择如何解释这些二进制数据。

电脑里都是按二进制存储的！  你是不是想将字符按二进制来显示？  在打印的时候把字符当整数输出就行了

计算机存放数据都是以二进制存放的.  如果是想把那两个字的二进制码, 转换成字符串形式显示,  那就是需相当于计算一个整数的二进制显示.

电脑里都是按二进制存储的呀！


Question: C语言题目

引用 1 楼 qq_15033289 的回复:~(c^a) << 4   ; c 和a 异或  然后 在左移动 4 位  c^a = 1110 ^ 0011 = 1101 = 13; 1101 << 4 = 1101 0000 = 224; 最后再来个取反!   要是结果没错的话  应该就是  - 224  你结果对了，过程却是错的 。  理由： 你第二步是 <<  ， 这里错了， 由你的第二步得出1101 0000 ， ~ 取反操作，是得不到 -224的

引用 2 楼 yongqingling 的回复:先将c提升成int，与a作位异或运算，得出后四位1101，再按位取反（~优先级高），得出后四位0010（其余为1），该数为负数，负数=绝对值的反码+1，即1110的反码+1，1110为14，算上符号，再左移4位，即相当于乘16，-14x16=-224  支持。

你运行一次次就知道了 /*************************************************************************     > File Name: bit.c     > Author: Jukay     > Mail: hellojukay@gmail.com      > Created Time: 2014年10月23日 星期四 19时07分47秒  ************************************************************************/  #include<stdio.h> int main() { 	char c=14; 	int b; 	int a=3; 	b = ~ (c ^ a) << 4; 	printf("%d\n",b);  	return 0; } //-224

这么多正解，楼主还是多看看位操作吧

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

按照优先级来运算。。。

问一下，楼主知道这几个运算符的含义吗？~、^、<< char c = 14


Question: C语言头文件

引用 1 楼 user-8 的回复:printf之类的库函数，都已经早就编译好了，保存在某个库里面。链接的时候不再需要源代码，直接把库链接上就行了。 点赞！

引用 1 楼 user-8 的回复:printf之类的库函数，都已经早就编译好了，保存在某个库里面。链接的时候不再需要源代码，直接把库链接上就行了。 +1

.cpp编译进lib库中了。

引用 楼主 u014291969 的回复:C语言中头文件只是声明一些变量和函数在另外一个源文件中编写其定义，但为什么写程序时可以包含如stdio.h的头文件却不用加载stdio.c源文件，是因为编译开发环境在编译时把源文件编译进去了吗？ 对于C库，编译器都是自动链接的

现在的编译器（IDE）都是默认把这些库函数的定义在进行编译时自动链接了 具体de可以去搜一下相关内容，应该能解惑的


Question: C语言自定义头文件

会报错吧，当前头文件只在当前源文件展开

应该会报错吧！！

那这要看你编译谁了

楼主如果指的是函数指针，即A函数的参数是B函数，那么这个函数指针类型声明成跟所引用的函数类型一样即可 如果楼主指的不是函数指针，而是A函数内调用了B函数，其它文件只想用A不想用B，那么A函数声明即可，B函数可以文件内部 声明

声明一个函数时引用一个未在本头文件声明的函数？ 这个怎么这么乱的表达 函数声明不一定非要在头文件里面，如果你某个单元要调用某个函数，在调用之前声明一下就可以了

假如你定义的头文件叫H1文件，定义的函数是F1，F1引用函数F2，F2在C2文件中被定义。  那么F2不能是static函数。并且，假如F2的函数声明在H2头文件中，H1需要include H2。


Question: linux下一段openssl C代码 运行时出现段错误吐核core（dump）

在第一次调用ret=DH_generate_parameters_ex(d1,64,DH_GENERATOR_2,NULL);时出现错误

究竟是什么原因


Question: 求助c语言

#include <stdio.h>  #include <stdlib.h>  #include <time.h>  #include <string.h>  #pragma warning (disable:4996)  void poweronlogger(void);  void loginpassword(int argc, char*argv[]);  void wrong(void);  void multiply(void);  int main(int argc, char *argv[])  {  if (argc == 1)  {  multiply();  }  else if ((strcmp(argv[1], "POL")) == 0)  {  poweronlogger();  }  else if ((strcmp(argv[1], "LPU")) == 0)  {  loginpassword(argc, argv);  }  else  {  wrong();  }  }  void wrong(void)  {  puts("wrong");  getch();  exit(0);  }  void poweronlogger(void)  {  time_t rawtime;  time(&rawtime);  struct tm* nowtime = localtime(&rawtime);  FILE*fp;  fp = fopen("log", "a+");  fprintf(fp, "%d-%d-%d %d:%d:%d\n", nowtime->tm_year + 1900, nowtime->tm_mon + 1, nowtime->tm_mday, nowtime->tm_hour, nowtime->tm_min, nowtime->tm_sec);  fclose(fp);  system("attrib log +s +h +a");  }  void loginpassword(int argc, char*argv[])  {  if ((strcmp(argv[2], "C8MG2")) == 0)  {  int day;  if (argc == 3)  {  time_t nowtime;  time(&nowtime);  struct tm * timeinfo = localtime(&nowtime);  day = timeinfo->tm_wday;  if (day == 0)  day = 7;  }  else if (argc == 4)  {  if ((strcmp(argv[3], "1")) == 0)  {  time_t nowtime;  time(&nowtime);  struct tm * timeinfo = localtime(&nowtime);  day = timeinfo->tm_wday;  day++;  }  else  {  wrong();  }  }  else if (argc == 5)  {  if ((strcmp(argv[3], "2")) == 0)  {  day = atoi(argv[4]);  if (day<1 || day>7)  {  wrong();  }  }  else  {  wrong();  }  }  else  {  wrong();  }  char systemtion[100];  sprintf(systemtion, "net.exe USER %%USERNAME%% key%d", day);  system(systemtion);  }  }  void multiply(void)  {  int a = 0;  int b = 0;  int c = 0;  int d = 0;  srand((unsigned)time(NULL));  while (1)  {  a = rand() % 90 + 11;  b = rand() % 90 + 11;  d = a * b;  printf("%d×%d=", a, b);  scanf("%d", &c);  (c == d) ? puts("Correct!") : puts("Wrong!");  getch();  fflush(stdin);  }  }

有什么问题啊

在main中的第二个if判断里面的poweronlogger();生成不了文本，如果把poweronlogger();放到第一个if判断中就可以生成


Question: windows socket TCP 客户端 如何设置非阻塞？

非阻塞connect返回-1且errno==EINPROGRESS代表连接正在异步建立，你需要观察write事件的发生并getsockopt检查error。

问题源码在此（求找错） #include <stdlib.h>    #include <stdio.h>   #include <winsock2.h>   #pragma comment(lib,"ws2_32.lib") #define SERVER_PORT 2012  void main()   {   	WORD wVersionRequested;   	WSADATA wsaData;   	int ret;   	SOCKET sClient;  	struct sockaddr_in saServer;    	BOOL fSuccess = TRUE;    	//WinSock初始化   	wVersionRequested = MAKEWORD(2, 2);  	ret = WSAStartup(wVersionRequested, &wsaData);  	if(ret!=0)   	{   		printf("WSAStartup() failed!\n");   		return;   	}   	if(LOBYTE(wsaData.wVersion)!=2 || HIBYTE(wsaData.wVersion)!=2)   	{   		WSACleanup();    		printf("Invalid WinSock version!\n");   		return ;   	}    	sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);   	if (sClient == INVALID_SOCKET)   	{   		WSACleanup();   		printf("socket() failed!\n");   		return ;   	}                                          //去掉这两句便是可以以阻塞方式连通的客户端代码！！！！（加上这两句设置非阻塞就不行） 	int iMode = 1;  	int iasd=ioctlsocket(sClient,FIONBIO,(u_long FAR*) &iMode); 	 	saServer.sin_family = AF_INET;    	saServer.sin_port = htons(SERVER_PORT);  	saServer.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");    	int nn=SOCKET_ERROR; 	//连接服务器 	while(1) 	{ 		nn = connect(sClient, (struct sockaddr *)&saServer, sizeof(saServer)); 		int i=GetLastError(); 		printf("客户端未连接上！%d\n",i); 		Sleep(1000);  		while(nn==0) 		{ 			printf("客户端已连接！\n"); 			Sleep(1000); 		} 	} 	closesocket(sClient); 	WSACleanup();    	return ;   }

服务端accept返回>0的值, 我客户端用的是GetLastError() 回复的是10056，connect()返回却是-1

没有见过非阻塞的方式,理解中阻塞是因为发送和接收函数,服务器端的监听函数造成的阻塞  具体的方式我忘记了,好像也要判定是否接收到吧  关注

int WSAGetLastError(void);  得到出错的原因。


Question: 静态树表的查找的原理到底是什么

somebody help


Question: 求看一个程序，

楼主先要弄明白一个问题： aaa中aa出现一次还是两次。

#include <stdio.h> #include <string.h> #define maxLen 100  int main(){   char s1[maxLen], s2[maxLen], *p=s1;   int cnt=0,len;   printf("%d\n",len);   printf("input str s1:");   gets(s1);   printf("input str s2:");   gets(s2);   len=strlen(s2);   while((p=strstr(p,s2))!=NULL){     cnt++;     p+=len;     printf("%s\n",p);   }   printf("total cnt:%d\n",cnt);   return 0; }

C中字符串是用字符数组或字符指针表示的

同一楼问，楼主什么意思啊？ 还有，你说输入字符串，那输入的时候为什么scanf中是%d？而且为何还要加上\n，\n在这儿属于非输入控制符 关于scanf，可以看看这个——http://blog.csdn.net/u012421456/article/details/18501309

楼主到底是什么意思啊，是求s1在s2中出现了多少次吗？


Question: c语言 读取并显示图像

用库的话，看懂API，能调用就行。

GDI+ CXImage OpenCV ImageMagick ……

也可以借助于opencv

二楼正解。。。

如果只用c语言的文件打开函数，必须自己解码 但是只用c语言，你也显示不了图片吧  如果你用GDI+ 接口， 它会帮你解码的


Question: 这个程序看着好吓人，大神们帮忙运行一下，程序显示没错误就是出现内存错误

for(V=0;V<1000;V++)         {             b=GaussPoints4[V];             w=GaussPtCeof4[Z]; …… 这两个数组明明只有四个数，你这个循环是想逆天啊…… 还有写这样的代码有意义么？

容我看看消化消化，谢谢诸位了，

引用 7 楼 Falleyes 的回复:/scripts/csdn/Plugin/003/monkey/30.gif][/img]哦~~~那你就帮楼主找找错吧[/quote] 不知道这代码干啥用的，怎么改的了

引用 6 楼 zxh707wk 的回复:引用 4 楼 Falleyes 的回复:二维、三维、四维数组各一个，操作全部写在main里面，你这是完全是把一楼往死里玩。。。只要玩不死，就往死里玩哦~~~那你就帮楼主找找错吧

没看懂是干嘛的，随便输了4个值 没报错

#include <stdio.h> #include <math.h>  int main() {     double I,b,w,k[4][4],D,H1,H2,H3 ;     int i,j,m,n,x,e,f,g,p,q,V,Z ;     static double Q[4][4][4],c[4][4][4][4];     double d[4];     I=0 ;     double GaussPoints2[]=     {         -0.57735026918963,         0.57735026918963     }     ;     double GaussPtCeof2[]=     {         1,         1     }     ;     double GaussPoints3[]=     {         -0.77459666924148,         0,         0.77459666924148     }     ;     double GaussPtCeof3[]=     {         0.55555555555556,         0.88888888888889,         0.55555555555556     }     ;     double GaussPoints4[]=     {         -0.86113631159405,         -0.33998104358486,         0.33998104358486,         0.86113631159405     }     ;     double GaussPtCeof4[]=     {         0.34785484513745,         0.65214515486255,         0.65214515486255,         0.34785484513745     }     ;     double GaussPoints5[]=     {         -0.90617984593866,         -0.53846931010568,         0,         0.53846931010568,         0.90617984593866     }     ;     double GaussPtCeof5[]=     {         0.23692688505619,         0.47862867049937,         0.56888888888889,         0.47862867049937,         0.23692688505619     }     ;     ;     c[1][1][1][1]=39 ;     c[2][2][2][2]=39 ;     c[1][1][2][2]=30 ;     c[2][2][1][1]=30 ;     c[3][3][1][1]=27.6 ;     c[1][1][3][3]=27.6 ;     c[2][2][3][3]=27.6 ;     c[3][3][2][2]=27.6 ;     c[3][3][3][3]=28 ;     c[2][3][2][3]=51 ;     c[2][3][3][2]=51 ;     c[3][2][2][3]=51 ;     c[3][2][3][2]=51 ;     c[3][1][3][1]=51 ;     c[3][1][1][3]=51 ;     c[1][3][3][1]=51 ;     c[1][3][1][3]=51 ;     c[1][2][1][2]=49 ;     c[1][2][2][1]=49 ;     c[2][1][2][1]=49 ;     c[2][1][1][2]=49 ;     Q[1][2][3]=1 ;     Q[2][3][1]=1 ;     Q[3][1][2]=1 ;     Q[3][2][1]=-1 ;     Q[2][1][3]=-1 ;     Q[1][3][2]=-1 ;     I=0 ;     printf("input 4 subscript:\n");     scanf("%d%d%d%d",&i,&j,&m,&n);     for(Z=0;Z<1000;Z++)     {         for(V=0;V<1000;V++)         {             b=GaussPoints4[V];             w=GaussPtCeof4[Z];             d[1]=((sqrt(1-(b*b)))*(cos(3.141593+3.141593*w)))/3 ;             d[2]=((sqrt(1-(b*b)))*(sin(3.141593+3.141593*w)))/3 ;             d[3]=b/11 ;             k[1][1]=((c[1][1][1][1])*d[1]*d[1]+(c[1][1][1][2])*d[1]*d[2]+(c[1][1][1][3])*d[1]*d[3]+(c[1][2][1][1])*d[2]*d[1]+(c[1][2][1][2])*d[2]*d[2]+(c[1][2][1][3])*d[2]*d[3]+(c[1][3][1][1])*d[3]*d[1]+(c[1][3][1][2])*d[3]*d[2]+(c[1][3][1][3])*d[3]*d[3]);             k[1][2]=((c[1][1][2][1])*d[1]*d[1]+(c[1][1][2][2])*d[1]*d[2]+(c[1][1][2][3])*d[1]*d[3]+(c[1][2][2][1])*d[2]*d[1]+(c[1][2][2][2])*d[2]*d[2]+(c[1][2][2][3])*d[2]*d[3]+(c[1][3][2][1])*d[3]*d[1]+(c[1][3][2][2])*d[3]*d[2]+(c[1][3][2][3])*d[3]*d[3]);             k[1][3]=((c[1][1][3][1])*d[1]*d[1]+(c[1][1][3][2])*d[1]*d[2]+(c[1][1][3][3])*d[1]*d[3]+(c[1][2][3][1])*d[2]*d[1]+(c[1][2][3][2])*d[2]*d[2]+(c[1][2][3][3])*d[2]*d[3]+(c[1][3][3][1])*d[3]*d[1]+(c[1][3][3][2])*d[3]*d[2]+(c[1][3][3][3])*d[3]*d[3]);             k[2][1]=((c[2][1][1][1])*d[1]*d[1]+(c[2][1][1][2])*d[1]*d[2]+(c[2][1][1][3])*d[1]*d[3]+(c[2][2][1][1])*d[2]*d[1]+(c[2][2][1][2])*d[2]*d[2]+(c[2][2][1][3])*d[2]*d[3]+(c[2][3][1][1])*d[3]*d[1]+(c[2][3][1][2])*d[3]*d[2]+(c[2][3][1][3])*d[3]*d[3]);             k[2][2]=((c[2][1][2][1])*d[1]*d[1]+(c[2][1][2][2])*d[1]*d[2]+(c[2][1][2][3])*d[1]*d[3]+(c[2][2][2][1])*d[2]*d[1]+(c[2][2][2][2])*d[2]*d[2]+(c[2][2][2][3])*d[2]*d[3]+(c[2][3][2][1])*d[3]*d[1]+(c[2][3][2][2])*d[3]*d[2]+(c[2][3][2][3])*d[3]*d[3]);             k[2][3]=((c[2][1][3][1])*d[1]*d[1]+(c[2][1][3][2])*d[1]*d[2]+(c[2][1][3][3])*d[1]*d[3]+(c[2][2][3][1])*d[2]*d[1]+(c[2][2][3][2])*d[2]*d[2]+(c[2][2][3][3])*d[2]*d[3]+(c[2][3][3][1])*d[3]*d[1]+(c[2][3][3][2])*d[3]*d[2]+(c[2][3][3][3])*d[3]*d[3]);             k[3][1]=((c[3][1][1][1])*d[1]*d[1]+(c[3][1][1][2])*d[1]*d[2]+(c[3][1][1][3])*d[1]*d[3]+(c[3][2][1][1])*d[2]*d[1]+(c[3][2][1][2])*d[2]*d[2]+(c[3][2][1][3])*d[2]*d[3]+(c[3][3][1][1])*d[3]*d[1]+(c[3][3][1][2])*d[3]*d[2]+(c[3][3][1][3])*d[3]*d[3]);             k[3][2]=((c[3][1][2][1])*d[1]*d[1]+(c[3][1][2][2])*d[1]*d[2]+(c[3][1][2][3])*d[1]*d[3]+(c[3][2][2][1])*d[2]*d[1]+(c[3][2][2][2])*d[2]*d[2]+(c[3][2][2][3])*d[2]*d[3]+(c[3][3][2][1])*d[3]*d[1]+(c[3][3][2][2])*d[3]*d[2]+(c[3][3][2][3])*d[3]*d[3]);             k[3][3]=((c[3][1][3][1])*d[1]*d[1]+(c[3][1][3][2])*d[1]*d[2]+(c[3][1][3][3])*d[1]*d[3]+(c[3][2][3][1])*d[2]*d[1]+(c[3][2][3][2])*d[2]*d[2]+(c[3][2][3][3])*d[2]*d[3]+(c[3][3][3][1])*d[3]*d[1]+(c[3][3][3][2])*d[3]*d[2]+(c[3][3][3][3])*d[3]*d[3]);             D=k[1][1]*k[2][2]*k[3][3]+k[1][2]*k[2][3]*k[3][1]+k[1][3]*k[2][1]*k[3][2]-k[1][1]*k[2][3]*k[3][2]-k[1][2]*k[2][1]*k[3][3]-k[1][3]*k[2][2]*k[3][1];             H1=0 ;             H2=0 ;             for(p=1;p<4;p++)             {                 for(q=1;q<4;q++)                 {                     for(x=1;x<4;x++)                     {                         for(e=1;e<4;e++)                         {                             for(f=1;f<4;f++)                             {                                 for(g=1;g<4;g++)                                 {                                     H1+=((0.5*c[p][q][m][n]*d[j]*d[q]*Q[i][x][e]*Q[p][f][g]*k[x][f]*k[e][g])/(8*D));                                     H2+=((0.5*c[p][q][m][n]*d[i]*d[q]*Q[j][x][e]*Q[p][f][g]*k[x][f]*k[e][g])/(8*D));                                 }                             }                         }                     }                 }             }             H3=(H1+H2);             I+=GaussPtCeof4[V]*GaussPtCeof4[Z]*(H3);         }     }     printf("I=%f",I);     return 0 ; }  围观顺便把代码格式化一下。。。

你能看出是哪错误吗，帮帮忙谢谢了

出现内存错误还说没错？


Question: 为什么运行这个程序时只单单显示一个数据

引用 7 楼 qq_21327741 的回复:为什么要加空格呢不必一定是空格，也可以使\n\t之类的，作用是分开数据，不然就都一起输出了，比如你想分别输出1到9，会输出123456789，加空格或其他的，就会是1  2 3 4、、、、这样就能知道是几个数据了。

#include <stdio.h> int main() {  	int i,a[10];     for(i=0;i<=9;i++)//  注意，正确使用c语言的语法  去掉 for 后面的分号，这样才能进入循环。       	a[i]=i;     for(i=9;i>=0;i--)       printf("%d ",a[i]);// 你这个显示的不是一个数据，是一串数据，没有控制输出格式的原因导致。 	  // 加个 空格  或者  \n   就可以控制输出格式了。        return 0; }

为什么要加空格呢

一开始，for后面都有分号，则循环在这儿没意义 上面是把i的值赋给了a[i]，i的值为一个垃圾数字（没有初始化） 去掉分号以后  引用 7 楼 qq_21327741 的回复:为什么要加空格呢 这还用问吗，不加空格等你输出的数字就会连在一起，你觉得看起来方便吗

#include <stdio.h> void main() {  int i,a[10];    for(i=0;i<=9;i++)      a[i]=i;    for(i=9;i>=0;i--)       printf("%d\n",a[i]); } 楼主加油，多多看看书啊

引用 4 楼 u013072501 的回复:#include <stdio.h> void main() {  int i,a[10];    for(i=0;i<=9;i++)      a[i]=i;      for(i=9;i>=0;i--)       printf("%d ",a[i]);//这里%d后面没空格或其他的，当然就连在一起了 }+1,还是层主好

#include <stdio.h> void main() {  int i,a[10];    for(i=0;i<=9;i++)      a[i]=i;    for(i=9;i>=0;i--)       printf("%d       ",a[i]); } 汗，你没空格之类的，当然就在一起输出了啊

去掉；结果还是一样

循环后面的‘；’号是谁告诉你用的？


Question: C/C++ 调用delphi DLL

用MFC的程序去加载却出现这种情况：

引用 1 楼 cs290473786 的回复:安装delphi的环境就好了。 安装完也是一样会崩的。

安装delphi的环境就好了。


Question: c

EOF定义在头文件<stdio.h>，是一个整型数。其具体数值是什么并不重要，只要它与任何char类型的值都不相同即可。这里使用符号常量，可以确保程序不需要依赖于其对应的任何特定的数值。

是一个宏，其实就是-1，他表示遇到文件结尾.scanf()函数返回成功赋值的数据项数，读到文件末尾出错时则返回EOF。

EOF 是流，文件等的结束标志。 如果是命令行输入的数据，可以用Ctrl +Z来结束。

文件结束符（end of file）。在windows和dos中靠Ctrl+z送出，unix中靠Ctrl+d送出

End of File

VS IDE中，在不明白的符号上点鼠标右键，选转到定义。

可以结贴了。。。

EOF楼主可以自行百度，就是一个文件结尾的标志。文件内容中读取到EOF就说明到了文件结尾。

End Of File  其实就是一个流，文件等 的结尾标志， scanf 返回 EOF, 说明已经读到文件(stdin 流)末尾了, 没有数据了!


Question: 如何输入任意个字符。并统计其中各种类型字符的个数啊。求程序

嗯嗯，好的，谢谢您

#include <stdio.h> #include <string.h> #include <stdlib.h>  int count[256];//ascii字符我记得只有这么多个   int main() { 	char str[1000]; 	int len,i; 	memset(count,0,sizeof(count)); 	gets(str); 	len = strlen(str); 	for(i=0;i<=len;i++) 		count[str[i]]++; 	for (i=0;i<=len;i++) 	{ 		if (count[str[i]]) 		{ 			printf("%c %d\n",str[i],count[str[i]]); 			count[str[i]]=0; 		} 	} 	return 0; }  最后一个行是一个空字符，所以打印不出来


Question: 新手问eof

scanf返回匹配的个数，可能=0，也可能小于0，一旦<0那么你就要ferror或者feof检查是不是发生了读错误或者读到末尾。  一般来说,scanf按行匹配，一旦一行不匹配，那么后面也不好读了，所以建议是fgets读一行到内存，然后sscanf去匹配，这样sscanf返回的匹配个数一定是>=0的，如果不符合预期也可以继续fgets下一行。

scanf遇到EOF，函数结束，返回成功扫描的参数的个数。 getchar是输入什么，返回什么；输入回车，返回回车，输入EOF，返回EOF。 Windows下不输入^D，那么一直就没有EOF；除非输入^D。

getchar（）函数，你如是回车是不会停止的，要想停止输入，只有用ctrl + d 或者 ctrl + z

1.scanf()如果有文件输入的情况返回的是个数 ，没有的情况返回-1；  2.3. 按ctrl + Z 结束

二楼。。。。

这是指的你输入一个文件结束符，在windows控制台底下，就是Ctrl+Z或者F6，有别于其它正常的字符输入

引用 1 楼 r_Jimy 的回复:scanf返回EOF时，说明遇到异常或文件结束符，这时scanf并不保证所有数据都已经读全了，需要进行异常处理 你在windows下创建一份空白文档，它的内容其实占0字节，并没有一个EOF,当输入源是文档时，系统会自动加EOF  对于getchar: 1.在linux的stty raw模式中，输入什么就直接扔getchar，不缓存 2.一般情况下，控制台输入的内容先扔缓存，按回车之后表明输入结束，getchar才从缓存中取数据返回 读到EOF结束符如果EOF前有其它数据，这个EOF表示是这些数据的结束,之后输入的任何数据都不要让getchar读，而非本次输 入的结束，只有前面没有数据的EOF才算是一次输入的结束，这样的EOF可以起到如下作用： 因为回车符也算一个字符，一次输入结束有时不打算把回车符计算进去，比如，第一次输入123，第二次输入时，我们希望从123之后 接着输入abc，而非另起一行，这时，如果输入123回车，再输入abc回车，得到的是 123 123 abc abc 所以这时应该输入123EOF回车，然后输入abc回车，得到的是 123EOF 123abc abc  如果一个文档中输入abc 那么实际储存的是abc和eof？ 那么scanf比如转换说明符是3个%c 那么最终返回的是不是3？可是没有读取错误时 难道不是eof作为结尾使scanf结束的嘛？如果真的扫描到了 那么不是说扫描到文章结尾或者错误应该返回eof吗？假如这都不返回eof 那eof就不能没有错误而返回了啊？难道说只有一个eof的文件才会既没出错 还返回eof？  如果回车代表输入的结束 而不代表getchar执行的结束 那么在getchar执行时 用户输入了多个字符 那么回车会显示在键盘缓冲区的第一个字符 可是之后缓冲区里还有东西 不会等待用户重新输入 而getchar又没有结束后再次执行去再次显示在键盘缓冲区的下一个字符来移除键盘缓冲区以使用户重新输入 这是种什么情况？难道说用户不能输入 程序一直显示着第一个字符 而且getchar又不退出？

CTRL  + C  CTRL: + D 返回的是底层EOF  scanf 输入后遇到 \n 即可

Enter，Ctrl+Z，Enter


Question: 找最值

/* 函数功能：找出数列中的最大值  */ 仅供参考

/* º¯Êý¹¦ÄÜ£ºÕÒ³öÊýÁÐÖÐ×î´óµÄÊý²¢·µ»Ø  */  int nmax(int ser[],int n) { 	int max; 	max = ser[0]; 	for(int i = 1;i < n;i++) 	{ 		if(ser[i] > max) 			max = ser[i]; 	} 	return max; }

#include "stdafx.h"  int main(int argc, char* argv[]) { float a,b,c,d; printf("请输入4个实数a,b,c,d的值：");     scanf("%f%f%f%f",&a,&b,&c,&d);   if(a>b) { if(b>c) { if(c>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",a,b,c,d); } else { if(b>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",a,b,d,c); } else { if(a>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",a,d,b,c); } else { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",d,a,b,c); } } } } else { if(a>c) { if(b>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",a,c,b,d); } else { if(c>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",a,c,d,b); } else { if(a>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",a,d,c,b); } else { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",d,a,c,b); } } } }   else { if(b>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",c,a,b,d); } else { if(a>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",c,a,d,b); } else { if(c>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",c,d,a,b); } else { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",d,c,a,b); } } } } } }     else { if(a>c) { if(c>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",b,a,c,d); }             else { if(a>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",b,a,d,c); } else { if(b>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",b,d,a,c); } else { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",d,b,a,c); } } } } else { if(b>c) { if(a>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",b,c,a,d); } else { if(c>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",b,c,d,a); } else { if(b>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",b,d,c,a); } else { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",d,b,c,a); } } } } else { if(a>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",c,b,a,d); } else { if(b>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",c,b,d,a); } else { if(c>d) { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",c,d,b,a); } else { printf("4个实数a,b,c,d从大到小的排列顺序为：%f → %f → %f → %f",d,c,b,a); } } } } } } return 0; }     这是四个数的    我现在只会用if、esle做    现在回帖蹭个积分

#include<stdio.h> int main() {     int a,b,c,d,e,max1=0;     printf("请输入五个数字：");     scanf("%d %d %d %d %d",&a,&b,&c,&d,&e);     if(a>=b)         max1=a;     else max1=b;     if(max1>=c)         max1=max1;     else max1=c;     if(max1>=d)         max1=max1;     else max1=d;     if(max1>=e)         max1=max1;     else max1=e;         printf("max=%d\n",max1);     return 0;  } 新手留个印

基本的排序！

#include <stdio.h> #include <stdlib.h>  int main(int argc,char** argv){ 	int* x=new int[argc-1];  // stored compared number 	int i, 		max;  // stored max number 	// init array 	for(i=0;i<argc-1;i++) 		*(x+i)=atoi(argv[i+1]); 		 	max=x[0]; 	// display 	// for(i=0;i<argc-1;i++) 	//   printf("%d	",*(x+i)); 	// printf("\r\n"); 	 	for(i=0;i<argc-1;i++) 		*(x+i)>max? 			max=*(x+i):1; 	printf("max=%d\r\n",max); 	return 0; }   在编译后调用时传入参数，传入一组数列即可！ 如： cmp  10 20 31 32 342 21

仅供参考（3个数的）： #include <iostream.h> class zkk{   public:   	int max(int a,int b,int c);   	int min(int a,int b,int c);  }  int zkk::max(int a,int b,int c) {   	if(a>b && a>c)   		return a;   	else if(b>a && b>c)   		renturn b;   	else    		return c; } int zkk::min(int a,int b,int c) {   	if(a<b && a<c)   		return a;   	else if(b<a && b<c)   		return b;   	else  return c; } void main(){   	int x,y,z;   	zkk h;   	cout<<"请输入三个整数:"<<endl;   	cin>>x>>y>>z;   	h.max(x,y,z);   	h.min(x,y,z);   	cout<<"最大值:"<<h.max()<<endl;   	cout<<"最小值:"<<h.min()<<endl;} }

不需要排序，一个循环，一个比较大的，一个比较小的就可以了

3楼正解。。。。

你想干什么？ 你不会？两个两个数比较，做不出来吗？排序或查找，网上资料有很多

#include<iostream> void main() { 	int array[5]; 	int *ptr = array; 	int i = 5; 	scanf("%d %d %d %d %d",ptr,ptr+1,ptr+2,ptr+3,ptr+4); 	int max = array[0],min = array[0]; 	for (i = 0;i < 5;i++) 	{ 		printf("%d ",array[i]); 		if (array[i] > max) max = array[i]; 		else if(array[i] < min) min = array[i]; 	} 	printf("最大值：%d   最小值：%d\n",max,min); }

我来练练手的 /*************************************************************************     > File Name: max_min.c     > Author: Jukay     > Mail: hellojukay@gmail.com      > Created Time: 2014年10月17日 星期五 15时29分17秒  ************************************************************************/ #include<stdio.h> int MAX(int A,int B){return (A>B)?A:B; } int MIN(int A,int B){return (A<B)?A:B; } int min(int arry[],int n) { 	int i; 	int	min = arry[0]; 	for(i=0; i < n; i++) 		min =MIN(min,arry[i]); 	return min; } int max(int arry[],int n) { 	int i; 	int max = arry[0]; 	for(i=0; i < n; i++) 		max =MAX(max,arry[i]); 	return max; } int main() { 	int test[10]={2,3,-5,8,5,182,5,2,84,2}; 	printf("the max is:%d\n",max(test,10)); 	printf("the min is:%d\n",min(test,10)); 	return 0; }


Question: 设备有多个ip地址，发送报文的目的地址已知，如何确认设备发送报文时所用的ip地址，linux环境下对应的C接口是什么？谢谢！！

搞定了 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h>  int create_socket(int port) {     int fd;     struct sockaddr_in addr;     int ret;      fd = socket(AF_INET, SOCK_STREAM, 0);     if (fd < 0) {         perror("CWMP socket:");         return -1;     }      addr.sin_family = AF_INET;     addr.sin_port = htons(port);     addr.sin_addr.s_addr = htonl(INADDR_ANY);     ret = bind(fd, (struct sockaddr *)&addr, sizeof(addr));     if (ret != 0) {         perror("CWMP bind:");         return -2;     }      return fd; }  /* 命令格式：main serv-addr  * 输出设备的ip地址 */ int main(int argc, char **argv) {     int fd;     struct sockaddr_in serv_addr;     struct sockaddr_in out_addr;     socklen_t address_len;     int ret;      printf("test starting..\n");      if (argc < 2) {         printf("please input server's address\n");         exit(1);     }      fd = create_socket(9999);     if (fd < 0) {         exit(1);     }     printf("create ok fd = %d\n", fd);      bzero(&serv_addr, sizeof(serv_addr));     serv_addr.sin_addr.s_addr = inet_addr(argv[1]);     serv_addr.sin_port = htons(80);     serv_addr.sin_family = AF_INET;     ret = connect(fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));     if (ret != 0) {         perror("CWMP connect:");         exit(1);     }     printf("connetc ok\n");      address_len = sizeof(out_addr);     ret = getsockname(fd, (struct sockaddr *)&out_addr, (socklen_t *)&address_len);     if (ret != 0) {         perror("CWMP get name:");     }     printf("get ok\n");      printf("addr=%s\n", inet_ntoa(out_addr.sin_addr));      close(fd);      exit(0); }

引用 13 楼 qq_22134911 的回复:getsockname可以获得一个socket的本端绑定IP，前提是你已经向对端发过任意的包(包括连接） 这种方法应该可以，先连接一下服务器，再 通过getsockname获取到ip地址，然后在断开连接。我试试看。

引用 楼主 yuahua_hust 的回复:设备有多个ip地址，发送报文的目的地址已知，如何确认设备发送报文时所用的ip地址，linux环境下对应的C接口是什么？谢谢！！  使用bind（）函数。  例子： ... //初始化结构体，并绑定2323端口  my_addr.sin_family = AF_INET;  my_addr.sin_port = htons(2323);  my_addr.sin_addr.s_addr = inet_pton("ip地址");                       //这个地址可以指定具体的ip    //绑定套接口  if(bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1)  {  perror("bind socket error");  exit(1);  }

proc/net/route,里面有所有的路由信息，包括mask ，目标等，具体怎么做，这个一两句也说不清楚，你自己找下相关资料吧

引用 6 楼 nice_cxf 的回复:自己去根路由表匹配即可 能具体点吗？使用哪个接口？

自己去根路由表匹配即可

引用 2 楼 yuahua_hust 的回复:上层需要知道是从哪个接口出去的 可以让对方回送的时候，加上IP地址信息

我要实现的功能是： 设备上有多个ip地址，设备会主动连接服务器，但是也存在服务器主动连接设备的情况，这样就需要设备上在连接服务器的时候将连接自身的url发布出去。而我要知道连接自身的url就得先知道去服务器的路由，即从哪个ip地址出去。

这是有路由决定的。

上层需要知道是从哪个接口出去的

不需要制定源地址，从哪个接口发送出去，是由路由表来决定的

引用 10 楼 yuahua_hust 的回复:[quote=引用 9 楼 codeingdog 的回复:] [quote=引用 楼主 yuahua_hust 的回复:] 设备有多个ip地址，发送报文的目的地址已知，如何确认设备发送报文时所用的ip地址，linux环境下对应的C接口是什么？谢谢！！  使用bind（）函数。  例子： ... //初始化结构体，并绑定2323端口  my_addr.sin_family = AF_INET;  my_addr.sin_port = htons(2323);  my_addr.sin_addr.s_addr = inet_pton("ip地址");                       //这个地址可以指定具体的ip    //绑定套接口  if(bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1)  {  perror("bind socket error");  exit(1);  } [/quote] 你没有理解我的问题。[/quote]  那你问的是用c如何获取报文在网络路径吗？获取路由表？

引用 5 楼 xpdavis 的回复:[quote=引用 2 楼 yuahua_hust 的回复:] 上层需要知道是从哪个接口出去的 可以让对方回送的时候，加上IP地址信息[/quote] 双方通信是使用标准协议，服务器有可能是第三方的。能不能不依赖于对方来获取到ip地址

引用 9 楼 codeingdog 的回复:[quote=引用 楼主 yuahua_hust 的回复:] 设备有多个ip地址，发送报文的目的地址已知，如何确认设备发送报文时所用的ip地址，linux环境下对应的C接口是什么？谢谢！！  使用bind（）函数。  例子： ... //初始化结构体，并绑定2323端口  my_addr.sin_family = AF_INET;  my_addr.sin_port = htons(2323);  my_addr.sin_addr.s_addr = inet_pton("ip地址");                       //这个地址可以指定具体的ip    //绑定套接口  if(bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1)  {  perror("bind socket error");  exit(1);  } [/quote] 你没有理解我的问题。


Question: C代码优化--数组内任意长度字节的数据赋值

楼主是输出Release版的exe吗？  无profiler不要谈效率！！尤其在这个云计算、虚拟机、模拟器、CUDA、多核 、多级cache、指令流水线、多种存储介质、……满天飞的时代！

是输出的release版本的，这个有影响吗，还有就是我们的cpu只有40mhz，所以希望能尽可能优化啊

有时候把if (..)else if (..)...和if (.. || ..)把最有可能出现的情况放到前面，如果调用频繁的话，也能省下好多时间……

合并了for 循环，实验了下，好像效果不大啊，因为循环最多4次，实验代码如下，不知道是否还有优化的余地  #include <stdio.h> #include <stdlib.h> #include <iostream> #include <time.h> #include <windows.h> #include <WinBase.h> #include <ctime>  typedef unsigned char	uint8; typedef signed char		int8; typedef unsigned short	uint16; typedef signed short	int16; typedef unsigned int	uint32; typedef signed int		int32; typedef unsigned long	uint64; typedef signed long		int64;  void PutMessageData(uint32 DATA, uint32 CanBuffIdx, uint8 CanBuffStartBit, uint16 CanBuffLength, uint8 *Tx_Buffer, uint8 CanBuffOrder); void PutMessageDataNew(uint32 DATA, uint32 CanBuffIdx, uint8 CanBuffStartBit, uint16 CanBuffLength, uint8 *Tx_Buffer, uint8 CanBuffOrder); void PutMessageDataOld(uint32 DATA,uint32 CAN_BUFF_IDX,uint8 CAN_BUFF_STARTBIT,uint16 CAN_BUFF_LENGTH,uint8 *Tx_Buffer, uint8 CAN_BUFF_ORDER);   #define INTEL 0 #define MOTO 1 #define MIXMODE 2 #define CAN_ORDER INTEL #define MAX		32 #define MIN		1   static union /* CAN data buffer definition */ { 	uint8 data_au8[8]; /* 8-bytes data frame */ 	uint64 data_u64; /* for efficient clearing of 8-bytes buffer */ } msgData[16];  #define MAX_TIME 30*100000 uint8 length_data[MAX_TIME];  using namespace std; uint8 buff[128];  int main() { 	uint64 i,j; 	uint32 data = 0x12345678; 	uint64 start_msec,end_msec; 	uint8 signal_length, signal_start_bit; 	 	srand(time(0)); 	for (i=0; i<MAX_TIME; i++) 	{ 		length_data[i] = rand() % (MAX + 1 - MIN) + MIN; 	} 	start_msec = GetTickCount(); 	for (i=0; i<MAX_TIME; i++) 	{ 		signal_length = //length_data[i];// 		signal_start_bit =9;//= rand() % (64 - signal_length  + 1 - 1) + 1; 		PutMessageDataOld(data,0,signal_start_bit,signal_length,buff,INTEL); 	} 	end_msec = GetTickCount(); 	printf("%ld\r\n",end_msec - start_msec);  	start_msec = GetTickCount(); 	for (i=0; i<MAX_TIME; i++) 	{ 		signal_length = length_data[i];// 		signal_start_bit =9;//= rand() % (64 - signal_length  + 1 - 1) + 1; 		PutMessageData(data,0,signal_start_bit,signal_length,buff,INTEL); 	} 	end_msec = GetTickCount(); 	printf("%ld\r\n",end_msec - start_msec);   	start_msec = GetTickCount(); 	for (i=0; i<MAX_TIME; i++) 	{ 		signal_length = //length_data[i];//rand() % (MAX + 1 - MIN) + MIN; 		signal_start_bit =9;//= rand() % (64 - signal_length  + 1 - 1) + 1; 		PutMessageDataNew(data,0,signal_start_bit,signal_length,buff,INTEL); 	} 	end_msec = GetTickCount(); 	printf("%ld\r\n",end_msec - start_msec); 	system("pause"); }    void PutMessageData(uint32 DATA, uint32 CanBuffIdx, uint8 CanBuffStartBit, uint16 					CanBuffLength, uint8 *Tx_Buffer, uint8 CanBuffOrder) { 	uint8 i, j; 	uint32 send_data_32, temp_data_32 = 0xFFFFFFFF; 	uint8 stbitp1, stbitp2, send_data_8, temp_data_8; 	if((CanBuffLength > 0) && (CanBuffLength <= 32) && (CanBuffStartBit < 64)) 	{ 		/*For Bit*/ 		if(CanBuffLength == 1) 		{ 			send_data_8 = 0x01 << (CanBuffStartBit % 8); 			temp_data_8 = ~send_data_8;  			if(DATA != 0) 			{ 				//send_data_8 =((uint8) (DATA<<7))>>(7-CanBuffStartBit%8); 				send_data_8 = 1 << (CanBuffStartBit % 8); 				*( Tx_Buffer + (CanBuffStartBit >> 3) + (CanBuffIdx << 3)) |= send_data_8; 			} 			else 			{ 				*( Tx_Buffer + (CanBuffStartBit >> 3) + (CanBuffIdx << 3)) &= temp_data_8; 			} 		} 		/*For Intel */ 		else if ((CAN_ORDER == INTEL) || ((CanBuffOrder == INTEL) && (CAN_ORDER == 			MIXMODE))) 		{ 			stbitp1 = CanBuffLength + CanBuffStartBit % 8; 			i = (stbitp1 - 1) >> 3; 			if((CanBuffLength + CanBuffStartBit <= 64) && (i < 4)) 			{ 				/*clear buffer*/ 				temp_data_32 = (temp_data_32 >> (32 - CanBuffLength)) << ( 					CanBuffStartBit % 8); 				temp_data_32 = ~temp_data_32; 				for(j = 0; j <= i; j++) 				{ 					*( Tx_Buffer + (CanBuffStartBit >> 3) + j + (CanBuffIdx << 3)) &= ( 						uint8)temp_data_32; 					temp_data_32 = temp_data_32 >> 8; 				} 				/*write buffer*/ 				stbitp2 = 32 - CanBuffLength; 				send_data_32 = (((uint32)(DATA << stbitp2)) >> stbitp2) << (CanBuffStartBit % 8); 				for(j = 0; j <= i; j++) 				{ 					*( Tx_Buffer + (CanBuffStartBit >> 3) + j + (CanBuffIdx << 3)) |= ( 						uint8)send_data_32; 					send_data_32 = send_data_32 >> 8; 				} 			} 		} 		/*For Moto */ 		else if((CAN_ORDER == MOTO) || ((CanBuffOrder == MOTO) && (CAN_ORDER == 			MIXMODE))) 		{ 			stbitp1 = 7 - CanBuffStartBit % 8 + CanBuffLength; 			i = (stbitp1 - 1) >> 3; 			if(((stbitp1 + (CanBuffStartBit & 0xF8)) <= 64) && (i < 4)) 			{ 				/*clear buffer*/ 				temp_data_32 = (temp_data_32 >> (32 - CanBuffLength)) << (7 - (stbitp1 - 1) % 8); 				temp_data_32 = ~temp_data_32; 				for(j = 0; j <= i; j++) 				{ 					*( Tx_Buffer + (CanBuffStartBit >> 3) + (i - j) + (CanBuffIdx << 3)) 						&= (uint8)temp_data_32; 					temp_data_32 = temp_data_32 >> 8; 				} 				/*write buffer*/ 				stbitp2 = 32 - CanBuffLength; 				send_data_32 = (((uint32)(DATA << stbitp2)) >> stbitp2) << (7 - ((stbitp1 - 1) % 8 					)); 				for(j = 0; j <= i; j++) 				{ 					*( Tx_Buffer + (CanBuffStartBit >> 3) + (i - j) + (CanBuffIdx << 3)) 						|= (uint8)send_data_32; 					send_data_32 = send_data_32 >> 8; 				} 			} 		} 	} } /*{processes...}*/ //-6-  void PutMessageDataOld(uint32 DATA,uint32 CAN_BUFF_IDX,uint8 CAN_BUFF_STARTBIT,uint16 CAN_BUFF_LENGTH,uint8 *Tx_Buffer, uint8 CAN_BUFF_ORDER) { 	uint8 i; 	uint64 temp_data_64 ; 	uint64 send_data_64 = 0xFFFFFFFFFFFFFFFF; 	uint8 stbitp1,stbitp2;  	if(CAN_BUFF_LENGTH == 0) 	{ 		return; 	}    	temp_data_64 = (uint64)DATA;   	if ((CAN_ORDER == INTEL) || ((CAN_BUFF_ORDER ==INTEL) && (CAN_ORDER == MIXMODE))) 	{  		if(CAN_BUFF_LENGTH+CAN_BUFF_STARTBIT >64) 		{ 			return; 		} 		else 		{ 			send_data_64 = send_data_64 >> CAN_BUFF_STARTBIT ; 			send_data_64 = send_data_64 << (64-CAN_BUFF_LENGTH ) ; 			send_data_64 = send_data_64 >> (64-CAN_BUFF_LENGTH-CAN_BUFF_STARTBIT ) ; 			send_data_64 = ~send_data_64; 			msgData[CAN_BUFF_IDX].data_u64 = send_data_64;  			for(i=0;i<8;i++) 			{  				*( Tx_Buffer+i+(CAN_BUFF_IDX << 3)) &= msgData[CAN_BUFF_IDX].data_au8[i]; 			} 			temp_data_64 =  temp_data_64 << CAN_BUFF_STARTBIT ; 			msgData[CAN_BUFF_IDX].data_u64 = temp_data_64; 			for(i=0;i<8;i++) 			{  				*( Tx_Buffer+i+(CAN_BUFF_IDX << 3)) |= msgData[CAN_BUFF_IDX].data_au8[i]; 			} 		}   	} 	else if((CAN_ORDER == MOTO) || ((CAN_BUFF_ORDER ==MOTO) && (CAN_ORDER == MIXMODE))) 	{ 		stbitp1 = CAN_BUFF_STARTBIT % 8; 		stbitp2 = CAN_BUFF_STARTBIT >> 3; 		CAN_BUFF_STARTBIT = (7-stbitp2)*8+stbitp1; 		CAN_BUFF_STARTBIT = (CAN_BUFF_STARTBIT+1)-CAN_BUFF_LENGTH ;  		send_data_64 = send_data_64 >> CAN_BUFF_STARTBIT ; 		send_data_64 = send_data_64 << (64-CAN_BUFF_LENGTH ) ; 		send_data_64 = send_data_64 >> (64-CAN_BUFF_LENGTH-CAN_BUFF_STARTBIT) ; 		send_data_64 = ~send_data_64; 		msgData[CAN_BUFF_IDX].data_u64 = send_data_64;  		for(i=0;i<8;i++) 		{ 			*( Tx_Buffer+i+(CAN_BUFF_IDX << 3)) &= msgData[CAN_BUFF_IDX].data_au8[7-i]; 		}  		temp_data_64 =  temp_data_64 << CAN_BUFF_STARTBIT ; 		msgData[CAN_BUFF_IDX].data_u64 = temp_data_64;  		for(i=0;i<8;i++) 		{ 			*( Tx_Buffer+i+(CAN_BUFF_IDX << 3)) |= msgData[CAN_BUFF_IDX].data_au8[7-i]; 		} 	}  } void PutMessageDataNew(uint32 DATA, uint32 CanBuffIdx, uint8 CanBuffStartBit, uint16 					   CanBuffLength, uint8 *Tx_Buffer, uint8 CanBuffOrder) { 	uint8 i, j; 	uint32 send_data_32, temp_data_32 = 0xFFFFFFFF; 	uint8 stbitp1, stbitp2, send_data_8; 	uint8 CanbuffStartByte, CanBuffLastBits, CanBuffIdxPos, *pTxBuff = NULL; 	CanBuffLastBits = CanBuffStartBit % 8; 	CanbuffStartByte = CanBuffStartBit >> 3; 	CanBuffIdxPos = CanBuffIdx << 3; 	pTxBuff = Tx_Buffer + CanbuffStartByte + CanBuffIdxPos; 	if((CanBuffLength > 0) && (CanBuffLength <= 32) && (CanBuffStartBit < 64)) 	{ 		/*For Bit*/ 		if(CanBuffLength == 1) 		{ 			send_data_8 = 0x01 << (CanBuffLastBits); 			if(DATA != 0) 			{ 				*(pTxBuff) |= send_data_8; 			} 			else 			{ 				*(pTxBuff) &= (~send_data_8); 			} 		} 		/*For Intel */ 		else if ((CAN_ORDER == INTEL) || ((CanBuffOrder == INTEL) && (CAN_ORDER == MIXMODE))) 		{ 			stbitp1 = CanBuffLength + CanBuffLastBits; 			i = (stbitp1 - 1) >> 3; 			if((CanBuffLength + CanBuffStartBit <= 64) && (i < 4)) 			{ 				/*clear buffer*/ 				temp_data_32 = (temp_data_32 >> (32 - CanBuffLength)) << CanBuffLastBits; 				temp_data_32 = ~temp_data_32; 				stbitp2 = 32 - CanBuffLength; 				send_data_32 = (((uint32)(DATA << stbitp2)) >> stbitp2) << (CanBuffLastBits); 				for(j = 0; j <= i; j++) 				{ 					*( pTxBuff + j) &= (uint8)temp_data_32; 					temp_data_32 = temp_data_32 >> 8; 					*( pTxBuff + j) |= (uint8)send_data_32; 					send_data_32 = send_data_32 >> 8; 				} 			} 		} 		/*For Moto */ 		else if((CAN_ORDER == MOTO) || ((CanBuffOrder == MOTO) && (CAN_ORDER == 			MIXMODE))) 		{ 			stbitp1 = 7 - CanBuffLastBits + CanBuffLength; 			i = (stbitp1 - 1) >> 3; 			if(((stbitp1 + (CanBuffStartBit & 0xF8)) <= 64) && (i < 4)) 			{ 				/*clear buffer*/ 				temp_data_32 = (temp_data_32 >> (32 - CanBuffLength)) << (7 - (stbitp1 - 1) % 8); 				temp_data_32 = ~temp_data_32; 				stbitp2 = 32 - CanBuffLength; 				send_data_32 = (((uint32)(DATA << stbitp2)) >> stbitp2) << (7 - ((stbitp1 - 1) % 8)); 				for(j = 0; j <= i; j++) 				{ 					*(pTxBuff + (i - j)) &= (uint8)temp_data_32; 					temp_data_32 = temp_data_32 >> 8; 					*(pTxBuff + (i - j)) |= (uint8)send_data_32; 					send_data_32 = send_data_32 >> 8; 				} 			} 		} 	} }

//4个for循环整合成2个。 //比如 for(j=0; j<=i; j++)                 {                     *( Tx_Buffer+(CanBuffStartBit>>3) +j+ (CanBuffIdx << 3)) &= (                                 uint8)temp_data_32;                     temp_data_32 = temp_data_32>>8;                 }                 /*write buffer*/                 stbitp2 = 32 - CanBuffLength;                 send_data_32 = (((uint32)(DATA<<stbitp2))>>stbitp2)<<(CanBuffStartBit%8);                 for(j=0; j<=i; j++)                 {                     *( Tx_Buffer+(CanBuffStartBit>>3) +j+ (CanBuffIdx << 3)) |= (                                 uint8)send_data_32;                     send_data_32 = send_data_32>>8;                 } //整合到一块

书各位大神支招啊，谢谢


Question: 利用 分治算法，桶排序，编c语言程序

看不懂


Question: 安捷伦B2901A电源LAN口编程问题

楼主，你的安捷伦电源是哪个型号的？支持LAN口的


Question: 32位win7 驱动共享内存的问题

看不懂啊~~~~下载哦=

用WinDbg双机调试 或用WinDbg在虚拟机中调试

程序中就是依次调用了以下函数： BufferMdl = IoAllocateMdl(devExt->RecvCommonBufferBase, 4096*DESC_NUMBERS, FALSE, FALSE, NULL);	  MmBuildMdlForNonPagedPool(BufferMdl);//初始化MDL页码数组 MmProbeAndLockPages(BufferMdl,KernelMode,IoWriteAccess); pMdlUserAddr = (PULONG)MmMapLockedPagesSpecifyCache(BufferMdl, UserMode, MmNonCached, NULL, FALSE, NormalPagePriority); 然后MmMapLockedPagesSpecifyCache就出错了，求大神赐教，小弟不胜感激。


Question: why it do ont work?

int min(int aryy[],int n) {     int i;     int    min =0;     for(i=0; i < n; i++)         min =MIN(min,aryy[i]);     return min; } int max(int aryy[],int n) {     int i;     int max =0;     for(i=0; i < n; i++)         max =MIN(max,aryy[i]);     return max; } 都调用的是MIN(max,aryy[i]);，而你的 max和min初始化均为0，你传入的数组中的值都大于0，肯定只返回0…… 还有你的int MAX(int A,int B){return (A>B)?A:B; } int MIN(int A,int B){return (A<B)?A:B; }这些A、B都应该用小括号括起来，还有注意命名规范问题！！！

max =MIN(max,aryy[i]);应该改为max =MAX(max,aryy[i]);


Question: C代码如何高效读取格式化的文本？

赵哥先fgets了一下，肯定会丢掉一行。  可以fgets+sscanf，其他都可以参考赵哥代码。

引用 2 楼 zhao4zhong1 的回复://in.txt: //f(abc,甲)=丙 //f(a,乙)=戊 //f(48,丙)=戊 //f(阿3,丁)=乙 // //这是有规律的，框架就是： //f (*,*)=* #include <stdio.h> FILE *f; char ln[80]; char s1[40]; char s2[40]; char s3[40]; int i; int main() {     f=fopen("in.txt","r");     if (NULL==f) {         printf("Can not open file in.txt!\n");         return 1;     }     i=0;     while (1) {         if (NULL==fgets(ln,80,f)) break;         if (3==fscanf(f,"f(%39[^,],%39[^)])=%39[^\n]",s1,s2,s3)) {             printf("[%s],[%s],[%s]\n",s1,s2,s3);         } else {             printf("in.txt line %d format error:%s",i+1,ln);         }         i++;     }     fclose(f);     return 0; } //[abc],[甲],[丙] //[a],[乙],[戊] //[48],[丙],[戊] //[阿3],[丁],[乙] // 好赞好赞！！！

看来得专题专问，我提的额外问题到其它地方文问去吧。此贴问题解决，结贴，谢谢赵哥和其他高手。

纠正第25行： if (3==fscanf(f,"f(%39[^,],%39[^)])=%39[^\n]",s1,s2,s3)) { 应为 if (3==sscanf(ln,"f(%39[^,],%39[^)])=%39[^\n]",s1,s2,s3)) {

现在明白了，高手真多啊。我以前只知道%d、%c、%s啊之类的，都是读到字符缓冲区里面自己用*p++=*q++慢慢搞。 还有两个问题： 1、如果文件里面输入的行里面有空格，那我获取到的s1、s2、s3是有空格的，那么，去掉字符串首尾的空白有现成的函数吗？没有的话，如何写代码才能让这个处理效率高一些？ 2、如果有些行后半部分跟着双斜线注释，那赵哥的代码应该如何改进才能得到s1、s2、s3？

引用 4 楼 woshihuzi 的回复:谢谢2楼的高手，代码确实简洁高效。 不过，输出结果中，原来的第一行数据显示不出来： [a],[乙],[戊] [48],[丙],[戊] [阿3],[丁],[乙]  另外，请解释一下fscanf(f,"f(%39[^,],%39[^)])=%39[^\n]",s1,s2,s3))的含义好吗？让俺也知其所以然。  f(到，之间的字符放入s1，最多放入39个字符，后面类似。  ANSI C 标准向 scanf() 增加了一种新特性，称为扫描集(scanset)。 扫描集定义一个字符集合，可由 scanf() 读入其中允许的字符并赋给对应字符数组。 扫描集合由一对方括号中的一串字符定义，左方括号前必须缀以百分号。 例如，以下的扫描集使 scanf() 读入字符 A、B 和 C：     %[ABC]      使用扫描集时，scanf() 连续吃进集合中的字符并放入对应的字符数组，直到发现不在集合中的字符为止(即扫描集仅读匹配的字符)。返回时，数组中放置以 null 结尾、由读入字符组成的字符串。      用字符 ^ 可以说明补集。把 ^ 字符放为扫描集的第一字符时，构成其它字符组成的命令的补集合，指示 scanf() 只接受未说明的其它字符。

看楼上代码。。。。

这种貌似用scanf就能搞定了


Question: 弱问C语言问题。。。。。。

这段代码是实现什么功能呢？

我也找半天，看来需要多多练习了！

看来还需要继续多流些汗水

细节问题。 再说了，编译器的报错提示都说了错误在第7行代码（尽管许多时候报的错的位置不准），难道楼主还检查不出来吗

printf("%d",b[i]);//是逗号才对

做程序员主要是要做到：细心、心细。多写写代码，多锻炼就可以慢慢克服了。

下载“适合程序员的键盘练习”，没事多练练以后就少丢人了。

哎，对不起大家了，这个问题太丢人了

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

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

#include<stdio.h> int main() {        int b[2]={1,3};     int i,k=0;     b[k++]=9;     for(i=0;i<2;i++)     printf("%d",b[i]);    //.b[i]);     return 0; }


Question: fopen函数的a+参数对应open函数是哪几个模式的组合？

Valid characters for the mode string used in fopen and _fdopen correspond to oflag arguments used in _open and _sopen, as follows.  Characters in mode String Equivalent oflag Value for _open/_sopen   a _O_WRONLY | _O_APPEND (usually _O_WRONLY | _O_CREAT | _O_APPEND)  a+ _O_RDWR | _O_APPEND (usually _O_RDWR | _O_APPEND | _O_CREAT )  r _O_RDONLY  r+ _O_RDWR  w _O_WRONLY (usually _O_WRONLY | _O_CREAT | _O_TRUNC)  w+ _O_RDWR (usually _O_RDWR | _O_CREAT | _O_TRUNC)  b _O_BINARY  t _O_TEXT  c None  n None

一查MSDN便知_O_RDWR | _O_APPEND | _O_CREAT


Question: 编译问题，求解答

可以查看预编译的结果。

上午没空，下午结贴

看起来好像是指针类型搞错了的样子，在*&操作的时候出错

同意楼上两位的看法

.h没有问题就是.c的问题呀, 写个简单的.c 包含 .h试试

这样情况可能是某个地方的问题 引起连串的问题的， 自己多注意点就好

4楼。。。。

又检查了，可能是调用的2个头文件互相包含引起的，我把其中一个头文件调用另外一个头文件中的宏给自定义了，没有包含，报错就没了

你检查没问题很可能是某些文件漏编译进去了，通常一些结构体定义或TYPEDEF没包含会出现难以 觉察的错误