Question: VS2010 这是什么意思，求解答，如何解决

枚举不常用，也不要这么用

如果你确认自己没错，把源文件的后缀，由.cpp改为.c试试。

++符号不能用于枚举类型 对策 1 写一个++重载函数 支持枚举 -估计比较难  2 把枚举转换成int 后在处理


Question: 循环 计算圆周率 新手求帮忙

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

Bigint ?  Python for the task.  Perl for the task.  OpenSSL for the task.  GNU MP (multi-precision) library

楼主要问什么？程序编译不过?运行结果不对？

楼主想问什么

#include<stdio.h> int main() { 	double a[50]; 	double f(int, double *); 	double x,pi; 	int n = 0; 	pi = 0.0; 	scanf("%f",&x); 	do 	{ 		n++; 		a[n] = f(n,a); 		pi = pi +a[n]; 	}while(a[n] > x); 	printf("%f", 2 * pi); }  double f(int n, double * a) { 	if(n == 1) return 1.0; 	return a[n -1] * ( n - 1) / (2 * n - 1); } 谁来调试这个烂摊子


Question: 循环二分法求多项式单根新手求会的指出问题，谢谢！

围观。。。。


Question: 这个链表程序对吗？新手求帮助

在这堆代码中有示例 http://yun.baidu.com/s/17yIcQ


Question: 严&&吴《数据结构 C语言版》例2-4 中算法2-23 一元多项式加法问题

自己的问题 自己解决吧  代码写的太乱，决定重新规范下代码，没想到，规范了下代码，找到问题了，先贴代码，polynomial AddPolyn(polynomial *p,polynomial *q) { 	polynomial k,ka,pa,qa; 	pa=(*p)->pNext; 	qa=(*q)->pNext; 	ka=k=*p; 	double sum;  	while(pa && qa) 	{ 		switch(comp(pa->data.expn, qa->data.expn)) 		{ 		case -1: 			ka->pNext=pa; 			ka=pa; 			pa=pa->pNext; 			break; 		case 0: 			sum=pa->data.coef+qa->data.coef; 			if(sum != 0.0) 			{			 				ka->pNext=pa; 				pa->data.coef=pa->data.coef + qa->data.coef; 				ka=pa; 				pa=pa->pNext; //				qa=qa->pNext; 			}else{ 				polynomial pb=pa; 				ka->pNext=pa->pNext; 				pa=pa->pNext; 				free(pb); 				pb=NULL; //				qa=qa->pNext; 			} 			qa=qa->pNext; 			break; 		case 1: 			ka->pNext=qa; 			ka=qa; 			qa=qa->pNext; 			break; 		} 		ka->pNext = pa ? pa : qa;   	}  	return k; }  问题出在  原来的代码case -1:                  p1=p0->pNext;                  (p0)=(p0)->pNext; 这样p1并没有连接到p0，而是直接指向了p0->pNext;  从而导致了最后的结果只有  一元多项式的最后一项，前面的项根本就没有连接上


Question: HDOJ 2010水仙花数求解释，哪里错了。

引用 2 楼 user-2 的回复:int reNo = 0;     //判断是否输出no     int reSp = 0;    //判断输出空格  要放在while循环里面哦非常感谢~

围观....

求回答啊～～


Question: 关于codeblocks

非法字符，就是有些汉字，日文，等等C，C++语言不能识别的字符.... 这些字符， 放在双引号内部作为C，C++字符串，通常没问题 如果作为代码 ，标识符用，通常会出错  出现这种情况，往往都是，从网上复制代码造成的 仔细加查一下，就能找到 找不到，可以查编译后，出错信息所在行号 实在没办法的话，还有最后一招：代码全部手动输入。

建议你不要安装太多的输入法

肯定是字符  每行注释查

我重新换了，还是这个错误，怎么搞的

切换到英文编码是什么意思

还是全角或者中文之类的啦， 比如; %等等， 要么就细心的调， 要么找个编辑器切换到英文编码看看


Question: 蓝桥杯——李白打酒

//李白街上走，提壶去买酒，遇店加一倍，遇花喝一斗，遇到店5次，遇到花10次，酒壶原来有两斗，最后一滴不剩，且最后遇到的是花，问遇店和花的顺序和有多少可能性   //本题是菜鸟做法，大神慎入 #include <stdio.h> void main() { 	int a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,r,s[15],sum,w,t,z=0,v;//定义路上的15次遇到店和花 	 	for(a=1;a<=2;a++) 	for(b=1;b<=2;b++) 	for(c=1;c<=2;c++) 	for(d=1;d<=2;d++) 	for(e=1;e<=2;e++) 	for(f=1;f<=2;f++) 	for(g=1;g<=2;g++)               //每次都有两种可能性共有十五次，2代表遇到店，1代表遇到花 	for(h=1;h<=2;h++) 	for(i=1;i<=2;i++) 	for(j=1;j<=2;j++) 	for(k=1;k<=2;k++) 	for(l=1;l<=2;l++) 	for(m=1;m<=2;m++) 	for(n=1;n<=2;n++)    	{ 		s[0]=a; 		s[1]=b; 		s[2]=c; 		s[3]=d; 		s[4]=e; 		s[5]=f; 		s[6]=g; 		s[7]=h; 		s[8]=i;                //将每一种可能性都先放在s[]里 		s[9]=j; 		s[10]=k; 		s[11]=l; 		s[12]=m; 		s[13]=n; 		s[14]=1;            		 		sum=0; //每次循环初始化 		for(v=0;v<15;v++) 			sum=sum+s[v];		//求和  		 		if(sum==20)//筛选出遇到5次店面和10次花，恒等于20  		{ 			 			r=2;//每次循环酒壶里的酒初始化 			for(w=0;w<15;w++) 			{ 				t=s[w]; 				{if(t==2) 					r=2*r;        //利用循环判断，如果s[]为2，则表示遇到店，否则，则是为1，遇到花；遇到店加倍，遇到花喝一斗 				else 					r--; 			} 				 				 		} 			 		if(r==0)//如果酒壶里的酒一滴不剩，则把这种情况输出 		{ 			z++; 			for(t=0;t<15;t++) 				printf("%d  ",s[t]); 			printf("\n"); 		} 		} 	} 	printf("\nz=%d\n",z);//最后输出总的种数 }

这题目明显用递归容易解决些。。。

引用 1 楼 user-4 的回复:这就是个最简单的动态规划吧。假定先遇到店，然后递归计算剩下的可能；再假定先遇到花，然后递归计算剩下的可能。遇到满足要求的组合就加1. #include<iostream> using namespace std; int sum=0; int f(int a,int b,int c){  // a:店的总数 b:花的总数减1 c:酒的初值 // 任何初始状况，都有两个可能：先遇到店，或者先遇到花    if(a>0)      f(a-1,b,c*2); // 逢店加一倍    if(b>0)      f(a,b-1,c-1); // 遇花喝一斗    if(a==0&&b==0&&c==1) //这个是满足要求的终止条件。没有店剩下，还剩一朵花和一斗酒      sum=sum+1;     return sum; } int main() {     f(5,9,2);     cout<<sum<<endl; }赞一个！传参的时候花只传9，说明还有一斗酒是留给最后一朵花的。哎，递归好神奇……


Question: 在fedora上系统调用内存分配的问题

淡定。。。 。

最麻烦的是，A模块越界访问，修改了B模块分配的内存，这时候B模块会出现一些莫名其妙的现象，QA会找到B模块的程序员，于是就悲剧了……

内存越界访问错误，未必会马上导致问题，特别是这种小程序。如果是大系统，有很多人都在用堆内存，那就不好说了。


Question: 关于函数指针数组

看书或百度。。。

指针数组 与二级指针在同类型下的内存分配 相同字节 可用相同的读取方法 与写入方法

指針和數組其實很像，但是有些地方是不一樣的 你可以上http://imil.au.edu.tw/~hsichcl/TurboC/C_Unit10.htm看看


Question: 新手求助啊，求两数之间的较小数

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

#include <iostream>？？？怎么都用这个？

#include<iostream> int main() { using namespace std; int a,b; cin>>a>>b; cout<<(a>b)?b:a<<endl; exit(0); }

要不你也可以这样，a>b?b:a;

楼上都回答的很好了（。。分。。）

C做的  啊哈 #include<stdio.h> int mian(void) { int a,b;  printf("输入要比较的俩个数\n"); scanf_s("%d%d",&a,&b); printf("%d比较小\n",a>b?b:a); system("pause"); return 0; }

仅供参考 #include <iostream> using namespace std; int main() {     int a,b,c;     cin>>a>>b;     c=a;     if(a>b)c=b;     cout<<c<<endl;     return 0; }

楼主要认真看书哦

我是来蹭分的。 #include <iostream> using namespace std; int main() { 	int a,b,c; 	cin>>a>>b; 	//其实加个{}会好看很多的，相信我，不要偷懒 	if(a>b) 	{  		c=b; 	}else //if    else if ? if 什么？你是想说 要不然就把a赋值给c这样的吧 如果这样，if就没必要了。 	{ 		c=a; 	} 	cout<<c<<endl; 	return 0;//你的;不是英文状态下的符号，可能是拼音？又或是五笔？ } //example 1： // 1 2 // 1 //请按任意键继续... //example 2: //4 6 //4 //请按任意键继续...

楼主需要认真看书

1、else c=a;去掉if 2、return 0;中文符号


Question: volatile修饰指针是在什么情况下出现及原因？

楼主自己不是有例子了吗！

补一下《计算机组成原理》中断相关知识点。

buffer指向一个地址被A线程使用，B线程修改了buffer所指的地址，同时希望A线程使用新地址，设置volatile。

指针指向的内存也需要设置成volatile类型

你能理解某个int为什么是volatile吗？如果可以的话，int*为什么是volatile也是同样的道理。至于例子，你不是已经说了嘛。

不清楚，查了下http://blog.csdn.net/tigerjibo/article/details/7427366


Question: c语言分支-12. 计算火车运行时间(15)找不出错误。新手

非常感谢哈。没想到取余，还有一个问题如果一个浮点型变量我想取他的整数舍去所有小数该怎么转换。

你好算法不是很好理解，也有些问题，修改如下： #include <stdio.h> int main() {  	int t,a,b,d; int c; int m1=0; int m2=0; scanf("%d %d",&a,&b); c=(b-a)/100.0; m1=a%100; m2=b%100; //t=b-(int)(c)*100; //printf("%d\n",t); if(m2 >= m1) { d = m2 - m1; printf("%02d:%02d\n",c,d); } else{ d = m2 + 60 - m1; printf("%02d:%02d\n",c,d); }     return 0; }


Question: linux C下载软件的问题

使用wget命令试试看

经过调试发现，网络上有数据传递到本地，但是无法将数据写入硬盘。但是我下载其他网站的东西没问题呀。

楼下正解。。。


Question: 应该用哪种公式？？

镜像似乎是不错的思路，但是处理起来不简单吧。 小球碰到盒子的四个边，运动方向变化时不同的，分段处理，算出反弹位置和方向，然后递归即可。  #include <stdio.h> #include <math.h>  /**   * @brief 小球与盒子  *   * @param x1 盒子左下角 x 坐标  * @param y1 盒子左下角 y 坐标  * @param x2 盒子右上角 x 坐标  * @param y2 盒子右上角 y 坐标  * @param x0 小球 x 坐标  * @param y0 小球 y 坐标  * @param d0 小球方向角 [-pi,+pi)  * @param n 计数器  */  /*  *                        (x2,y2)  *   -----------------------  *   |\                   /|  *   | \                 / |  *   |  \               /  |  *   |   d4           d3   |  *   |    \           /    |  *   |     \         /     |  *   |      \       /      |  *   |       \     /       |  *   |        \   /        |  *   |         \ /         |  *   |          + (x0,y0)  |  *   |         / \         |  *   |        /   \        |  *   |       /     \       |  *   |      /       \      |  *   |     /         \     |  *   |   d1           d2   |  *   |   /             \   |  *   |  /               \  |  *   | /                 \ |  *   |/                   \|  *   ----------------------  * (x1,y1)  */   void ball_box(         double x1, double y1, double x2, double y2,         double x0, double y0, double d0, int n) {     double d1, d2, d3, d4;     double xn, yn, dn;      if (n == 1) {         printf("%02d O: x0=%f,y0=%f\n", 0, x0, y0);     }      d1 = atan2(y1 - y0, x1 - x0);     d2 = atan2(y1 - y0, x2 - x0);     d3 = atan2(y2 - y0, x2 - x0);     d4 = atan2(y2 - y0, x1 - x0);      if (0) {         ;     } else if (d0 >= d1 && d0 < d2) {         /* 小球方向 d0 在 [d1,d2) 区间 */         /* 在底边反弹 */         yn = y1;         xn = x0 + (y1 - y0) / tan(d0);         dn = -d0;         printf("%02d B: xn=%f,yn=%f\n", n, xn, yn);     } else if (d0 >= d2 && d0 < d3) {         /* 小球方向 d0 在 [d2,d3) 区间 */         /* 在右边反弹 */         xn = x2;         yn = y0 + (x2 - x0) * tan(d0);         if (d0 > 0) {             dn = M_PI - d0;         } else {             dn = -M_PI - d0;         }         printf("%02d R: xn=%f,yn=%f\n", n, xn, yn);     } else if (d0 >= d3 && d0 < d4) {         /* 小球方向 d0 在 [d3,d4) 区间 */         /* 在顶边反弹 */         yn = y2;         xn = x0 + (y2 - y0) / tan(d0);         dn = -d0;         printf("%02d T: xn=%f,yn=%f\n", n, xn, yn);     } else if (d0 >= d4 || d0 < d1) {         /* 小球方向 d0 在 [d4,+pi) 和 [-pi,d1) 区间 */         /* 在左边反弹 */         xn = y1;         yn = y0 + (x1 - x0) * tan(d0);         if (d0 > 0) {             dn = M_PI - d0;         } else {             dn = -M_PI - d0;         }         printf("%02d L: xn=%f,yn=%f\n", n, xn, yn);     }      if (n < 20) {         ball_box(x1, y1, x2, y2, xn, yn, dn, n + 1);     } }  int main(int argc, char *argv[]) {      ball_box(0, 0, 2, 2, 1, 0, M_PI / 4.0, 1);     ball_box(0, 0, 2, 100, 1, 1, +M_PI * (1.0/4.0), 1);     ball_box(0, 0, 2, 100, 1, 1, atan2(1, 2), 1);     ball_box(0, 0, 4, 6, 2, 1, M_PI / 4.0, 1);      return 0; }

这个思路有意思。 求触点的时候，扩展的盒子的翻转可以这样： 纵向：距离为奇数时上下翻转，偶数不变 横向：距离为奇数时左右翻转，偶数不变  变换后，就是反算到原盒子的坐标了

其实lz应该先写一下大概思路，找出规律

不知道。。。

可以給完整代碼嗎? 我這樣看這裡有問題 int i; for(i=0; i<0;i++){ printf("(%f, %f)\n)", x,y);  i 你用整數 迴圈就有問題了

没人会吗？？？？？？


Question: c语言中有关字符型指针输出字符串的一个问题

没有内存，指针什么也不是，你要保存字符串，首先你要申请内存啊

一楼说得对。  第一个代码，楼主可能正好碰巧没出错。多运行几次，或者scanf那里多输入点肯定会内存错误。

lz你这两个程序都有问题，并且都是一种错误 原因就是没有分配内存  所以指针a指向了一个不确定的位置，向该位置进行写操作可能会导致崩溃 可以这么改   #include<stdio.h> #include<stdlib.h> int main() {     char *a,*b;     printf("%d\n",&b);      a=(char*)malloc(6*sizeof(char));//分配内存     scanf("%s",a);     puts(a);  	free(a);//释放     return 0; }


Question: 咳，代码写得少，问题就多了，我请教来了。

引用 7 楼 zhaozhaohelu 的回复:引用 6 楼 zxh707wk 的回复:引用 3 楼 zhao4zhong1 的回复:+1，我只是围观的。。。没事没事，见者有份！ 有没有我的嘞？

引用 3 楼 zhao4zhong1 的回复:+1，我只是围观的。。。

今天下午的时候一直被卡在最高位进位的问题没法解决，后面尝试了一下手动给高位赋值，不知道这种做行可不可行。效果是有了。目前程序还有漏洞，就是输入进制之后，接下来没有检查加数与被加数是否合法，比较进制N=6，加数=653，被加数=172。这显然不科学。不过我想这几天看一看多线程部分，把知识夯一夯。这样吧，我再等一个有效回复，好把分数分成4份，每人10分。赵老师您老见谅哦。很显然我的代码不够简洁，回头研究研究您老的代码。 /*现在和外星人打交道，发现外星人使用的并非10进制或者16进制等，有些星球居然使用N进制（N在2-35之间）， 以下的1001个题目中我们将首先给你一个数字表示N进制，然后给出两个数字的字符串。请算出其求和结束并输出。 数字的字符串其中包括0-9和a-z（表示10-35） 详细描述如下： 	int Calc(int n,const char* num1,const char * num2,char * result) 	输入参数： 	n:		n进制 	num1：	加号左边的数字 	num2：	加号右边的数字 	result：得数 返回值： 	int:	如果计算成功返回0，否则返回-1 	约定：所有输入和输出都是数字或者小写字母，不存在其他字符 		result内存外部申请和释放 	实现：如果任何一个字符串为空或者空串都非法，不用再计算result */ #include <iostream> #include <cstring> using namespace std; ///////////////////////////////////////////////////////////////// //1.对传入的加数与被加数进行倒置 //2.加数与被加数同位相加 //3.进位处理 //4.再次倒置 //  问题描述：实现A+B=C   其中A、B位数超过100位  //  算法思想：大数使用字符串存储，每一个单元存储操作数的每一位，之后执行位相加。 // //  基本思路：字符串反转、字符变数字、位运算、反序输出 // ////////////////////////////////////////////////////////////////// int Calc(int n,const char* num1,const char * num2,char * result) { 	if (num1 == NULL ||num2 == NULL) 	{ 		return -1; 	} ////////////////////////////////////////////////////////////////////////////////////////////////////////////// 	//反转字符串 字符变数字  	int c = 0; 	char n1[256] = {0}; 	char n2[256] = {0}; 	memset(result,0,256*sizeof(char)); 	int lenA = strlen(num1); 	int lenB = strlen(num2); 	for (int i=0;i<lenA;i++) 	{ 		n1[i] = num1[lenA -i-1]-'0'; 	} 	for(int i=0;i<lenB;i++) 	{ 		n2[i] = num2[lenB -i-1]-'0'; 	} //////////////////////////////////////////////////////////////////////////////////////////////////////////// 	//同位相加 数字串转换成字符串 	for (int i=0;i<lenA||i<lenB;i++) 	{ 		//result[i] = (n1[i]+n2[i]+c)%n+'0';//未位处理 		//进制是2-35的，所以每个位数都有可能超过10，用a-z表示10-34 		if (((n1[i]+n2[i]+c)%n) >= 10) 		{ 			result[i] = (n1[i]+n2[i]+c)%n-10 + 'a'; 		}else 		{ 			result[i] = (n1[i]+n2[i]+c)%n+'0'; 		} 		c = (n1[i] + n2[i] +c)/n;//获取进位信息  	} 	if (c>0)//如果有进位，自己试图手动给字符串进位。 	{ 		int k = lenA>lenB?lenA:lenB; 		result[k] = c +'0'; 	} 	int len =strlen(result); 	int i =0; 	int j=0; 	for (i=len -1;result[i]==0;i--) 	{ 		; 	} 	cout<<"结果是:"; 	for (j=i;j>=0;j--) 	{ 		cout<<result[j]; 	} 	cout<<endl; 	return 0; } int main() { 	char num1[256]; 	char num2[256]; 	int n; 	char resul[256]; 	cout<<"输入进制："; 	cin>>n; 	cout<<endl; 	cout<<"加数："; 	cin>>num1; 	cout<<endl; 	cout<<"被加数:"; 	cin>>num2; 	cout<<endl; 	Calc(n,num1,num2,resul); 	return 0; }

引用 3 楼 zhao4zhong1 的回复:仅供参考#include <stdio.h> #include <string.h> #define MAXLEN 1000 char a1[MAXLEN]; char a2[MAXLEN]; static int v1[MAXLEN]; static int v2[MAXLEN]; static int v3[MAXLEN]; int i,j,n,L,z; void main(void) {     scanf("%d",&n);     for (j=0;j<n;j++) {         scanf("%s%s",a1,a2);          L=strlen(a1);         for (i=0;i<L;i++) v1[i]=a1[L-1-i]-'0';          L=strlen(a2);         for (i=0;i<L;i++) v2[i]=a2[L-1-i]-'0';          for (i=0;i<MAXLEN;i++) v3[i]=v1[i]+v2[i];          for (i=0;i<MAXLEN;i++) {             if (v3[i]>=10) {                 v3[i+1]+=v3[i]/10;                 v3[i]=v3[i]%10;             }         }          printf("Case %d:\n", j+1);         printf("%s + %s = ", a1, a2);          z=0;         for (i=MAXLEN-1;i>=0;i--) {             if (z==0) {                 if (v3[i]!=0) {                     printf("%d",v3[i]);                     z=1;                 }             } else {                 printf("%d",v3[i]);             }         }         if (z==0) printf("0");          printf("\n");     } } //Sample Input //3 //0 0 //1 2 //112233445566778899 998877665544332211 // //Sample Output //Case 1: //0 + 0 = 0 //Case 2: //1 + 2 = 3 //Case 3: //112233445566778899 + 998877665544332211 = 1111111111111111110 赵4老师，等了你好久了。哇哈哈！

大数加法，注意好进位，尤其是最高位上的进位，有可能会buffer（或者数组）大小不足，申请内存时应该+1

其实就是大数相加，明白了加法器的工作原理，这种题怎么作都不怕


Question: 为什么printf函数中以%d形式输出8.0/5.0  值为负数

《计算机组成原理》

因为浮点数与整数的编码方式是不同的

这个应该很清楚了

#include <iostream> using namespace std; void print(double x) { 	int y = *(int*)&x; //printf中就是一个强制类型转换 	std::cout << y << std::endl;  } int main() { 	print(8.0/5.0); 	return 0; }

#include <stdio.h> void main() { 	printf("%f\n", 8.0 / 5.0);  //%f 浮点数 	printf("%d", (int)(8.0 / 5.0));  //%d 十进制有符号整数 }

你百度下：浮点数 二进制表示 看完就懂了。


Question: 关于char **p和char *p[]问题的疑惑

都是二级指针

数组用作函数参数的时候，退化为指针。 int *p 和 int p[] 也是含义不同，但是，如果作为函数的参数，f(int p[])就等价于f(int *p)，在函数f里面p就是个指针。


Question: 求密码学基础术语解释？

关于加密的算法直接百度google就行，不必深入了解

引用 1 楼 zxhuser-1 的回复:百度。。。。 百度，谷歌都试过了。都是按“关键字”搜索，没搜到，才来发帖问的。真的是第一次接触密码学这些东西，如果知道一些，谢谢分享下嘛。

百度。。。。


Question: 宏定义min(x, y)中(void)(&x==&y)含义？

引用 3 楼 user-1 的回复:[quote=引用 2 楼 bx__8840668 的回复:] [quote=引用 1 楼 user-1 的回复:] 这个应该可以说明问题了 看完您给的链接，我的理解是在编译选项加上-Wunused-value时&_min1 == &_min2会给出warning，加上void来避免这个warning，请问是这个意思吗？[/quote] 是的。  更重要的是比较两个地址后扔掉比较结果的意义。 [/quote] 明白了，谢谢您了~

引用 2 楼 bx__8840668 的回复:[quote=引用 1 楼 user-1 的回复:] 这个应该可以说明问题了 看完您给的链接，我的理解是在编译选项加上-Wunused-value时&_min1 == &_min2会给出warning，加上void来避免这个warning，请问是这个意思吗？[/quote] 是的。  更重要的是比较两个地址后扔掉比较结果的意义。

引用 1 楼 user-1 的回复:这个应该可以说明问题了 看完您给的链接，我的理解是在编译选项加上-Wunused-value时&_min1 == &_min2会给出warning，加上void来避免这个warning，请问是这个意思吗？

这个应该可以说明问题了


Question: 如何扩展linux shell的参数长度？

为何太长？


Question: 求助，关于c指针的字面量

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

引用 1 楼 cs290473786 的回复:char* p = "Hello world!"，字符串常量所谓的字面值是指该字符串在常量区，不能够修改。 char ch[] = “Hello world!”，这里的字符串在栈区，可以通过指针修改。

2楼的回复正解

似都有道理

推荐你看一本书《深入理解计算机系统》，在里面会讲到内存的分布图，现在基本上是使用ELF文件形式构建内存的，在这个文件里面，其中有一块是放data区。 首先字符串"Hello word"是常量，它会被放在data里面，并且不可改变。第二，字符指针p只是指向这个字符串"Hello word"的首地址。你现在用指针指向的地址去修改常量，那是不可以的，相当于这么修改： 2 = 4 这样肯定是不可以的，因为常量不可在赋值语句中作为左值。

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

该说的都说了，那我就来拿积分吧

你说的字面量是什么意思？  char *p="Hello word";这一句其实在编译器看来等价于 const char *p="Hello word"; const是常量，是不能改变的，所以你的代码会报错


Question: 求一个易懂的思路

不知道排在前面的那几个代码长什么样，有两个执行时占内存为0，代码又短 我写了一个hello world测试了下内存用了196K，代码178 B

其实这种题目说明应该详细一些，再贴了我自己的测试用例，注意纯负数与正解在中间的情况： 4 5 6 -1 5 4 -7 7 0 6 -1 1 -6 7 -5 3 -5 -3 -1 8 -6 3 2 -7 1 3 2 -5 输出： Case 1: 14 1 4  Case 2: 7 1 6  Case 3: -1 3 3  Case 4: 6 5 7

贴上我通过的代码，楼主的代码很接近了，有两个问题注意下： 1.你的begin =i;应改为begin =i+1; 2.输出格式很坑，应注意第二个Case前有换行，最后一个Case不要再换行 Case 1: 14 1 4  Case 2: 7 1 6  Case 3: -1 3 3  #include<stdio.h>  typedef struct {     int maxSum;     int startIndex;     int endIndex; }MAX_SUM_T;  int main(void) {     int i = 0;     int j = 0;     int l = 0;     int tmpSum = 0;     int lineNum = 0;     int inputNum = 0;     int addNum = 0;     MAX_SUM_T t_results[20] = {0};     int startIndex = 1;     int mark =0;      if (1!=scanf("%d",&lineNum))         return 1;      for (l=0;l<lineNum;l++)     {         if (1!=scanf("%d",&inputNum))             return 1;         tmpSum = 0;          startIndex = 1;                  for (i=0;i<inputNum;i++)         {             if (1!=scanf("%d",&addNum))                 return 1;              tmpSum+=addNum;              if (tmpSum<0)             {                 mark = 1;             }                          if (tmpSum>t_results[l].maxSum||0==i)             {                 t_results[l].maxSum = tmpSum;                 t_results[l].startIndex = startIndex;                 t_results[l].endIndex = i+1;             }              if (mark)             {                 mark=0;                 tmpSum = 0;                 startIndex = i+2;             }         }      }      for (i=0;i<lineNum;i++)     {         if (i>0)             printf("\n");         printf("Case %d:\n",i+1);         printf("%d %d %d\n",t_results[i].maxSum,t_results[i].startIndex,t_results[i].endIndex);     }      return 0; }

引用 3 楼 u010622287 的回复:虽然...我看不懂这个，不过真的很想问一下   这个网站是多少啊？ 搜索杭电ACM

引用 3 楼 u010622287 的回复:虽然...我看不懂这个，不过真的很想问一下   这个网站是多少啊？acm.hdu.edu.cn

虽然...我看不懂这个，不过真的很想问一下   这个网站是多少啊？

对于这种问题我只能围观了。。。

楼主这是杭电上一个经典的DP问题，这个问题是一定要搞懂的，直接百度最大字序列吧，上面有详细的解释。


Question: 相同时间复杂度的算法，其时间复杂度之差

这是要算 E 的节奏吗

引用 2 楼 dianyancao 的回复:使用大O符号，那么O(n^2)=c*n^2，c是不依赖于n的常数 那么可设这两算法的时间复杂度分别为a*n^2和b*n^2 其差的绝对值为|a-b|n^2，其阶数视|a-b|的值而定 时间复杂度之差一般是用倍数关系来比较的，比如算法A和算法B的时间复杂度相差100倍这样的说法。  之差应该是上述的a/b的倍值。而不应该再是O（***）这类的写法了。

三个都有可能。具体没法算，因为都有可能。

引用 3 楼 lovesmiles 的回复:之差应该是上述的a/b的倍值。而不应该再是O（***）这类的写法了。 嗯，应该使用复杂度的比值  O(n^2)是等于c*n^2加上比O(n^2)低阶的复杂度


Question: 大神们，帮小弟调试一下这个链表，我快疯了，是遍历那的问题HELP！（新人）

我明白了谢谢

大哥，我的问题出在哪？我没看懂

仅供参考# include <stdio.h> # include <malloc.h>  struct list { 	int sore;//序号 	int data;//数据 	list * pvod;//下一个变量指针  };  list* create(void) { 	list* head=NULL; 	list* late=NULL; 	head=(list*)malloc(sizeof(list)); 	late=head; 	if(head==NULL) 	{ 		printf("内存节点申请失败！"); 		return NULL; 	} 	list* Element; 	int sor,dat; 	printf("请输入初始长度："); 	int i; 	scanf("%d",&i); 	for(int j=0;j<i;j++) 	{ 		printf("请输入序号和成绩："); 		scanf("%d %d",&sor,&dat); 		Element=(list*)malloc(sizeof(list)); 		if(Element==NULL) 		{ 			printf("内存节点申请失败！"); 			return NULL; 		} 		Element->data =dat; 		Element->sore =sor; 		head->pvod =Element; 		head=Element; 	} 	Element->pvod = NULL;	//防止后面的指针乱指，赋值为NULL，确保最后为NULL  //	Element=late; //	late=head; //	head=Element->pvod; 	return late; } void  traverse(list*head) { 	printf("-------------\n"); 	head = head->pvod;//表头没赋值，跳过  	while(head != NULL) 	{ 		printf("成绩是：%d序号是%d\n",head->data,head->sore); 		head=head->pvod; 	} 	 	printf("------------\n"); }  int main(void) { 	list* head=create(); 	traverse(head); 	return 0; }


Question: 关于连续最长的字符串问题，自己摆弄了一天，没弄明白。求教。

引用 2 楼 user-4 的回复:原理弄懂了没泥？你只要画个表格你就懂了，只要原理 懂了。。代码就好懂好写了我现在是想利用一个int的中间变量和一个中间buff来记录遍历时碰到的连续数字的长度和字符串内容，MaxLen 和 szMax来保存最长的连续数字的长度和字符串内容。我现在是在保存字符串的时间碰到了坎，心绪乱了。睡觉起来再弄，再过1个半小时就应该生病了吧，哎。

你的程序有明显的问题：                line 47和line 49:    你新new出来两段内存，然后却将szCru和szMax指向了空字符串。注意你这里不是赋值，是改变指针指向！！此后的一切操作都肯定非法。                line 24 和 25， nI和nNum定义后根本没有使用过；                你的程序的算法我稍微研究了下，没看下去。你应该再多写一些注释，把思路写上去，这样更明晰  给你我的答案：   1  /*step 1) 找到下一个数字序列的起始位置   2  *         2) 根据升或者降一直找到这个序列的符合要求的最后一个数字，然后获得这个序列的长度   3  *         3) 如果这个序列比之前得到的最长序列还要长，把这个序列的起始位置和长度记录下来，顶替上一个最长序列   4  */   5    6 #include <ctype.h>   7 #include <string.h>   8 #include <stdio.h>   9 const int EndReached = 0;  10 const int MAXLENGTH = 128;  11 int getNextNumberSequence(const char*, unsigned int*);  12   13 int main()  14 {  15         char input_str[MAXLENGTH];  16         printf("please input the string\n");  17         scanf("%s",input_str);  18         unsigned int cur_pos = 0, end_pos;  19         /*cur_pos is the current positon in the input string, end_pos is the end position of the next number sequence\  20          * in the input string*/  21         unsigned int maxseq_len = 0, maxseq_beg, maxseq_end;  22         /*seq_len is the length of the longest number sequence, maxseq_beg and maxseq_end are its positions\               in the input string*/  23         while (1)  24         {  25                 end_pos = getNextNumberSequence(input_str,&cur_pos);  26                 if (end_pos != EndReached)  27                 {  28                         unsigned int seq_length = end_pos - cur_pos + 1;  29                         if (seq_length > maxseq_len)  30                         {  31                                 /*find a longer sequence, mark it*/  32                                 maxseq_len = seq_length; 3                                    maxseq_beg = cur_pos;  34                                 maxseq_end = end_pos;  35                         }  36                         cur_pos = end_pos;  37                         /*next time, we start search from end_pos*/  38                         if (end_pos == strlen(input_str) - 1)  39                                 /*the string has been scanned to the last character, time to stop*/  40                                 break;  41                 }  42                 else break;  43         }  44         printf("max number sequence length is %d\n",maxseq_len);  45         int i;  46         for (i = maxseq_beg; i <= maxseq_end; i++)  47                 printf("%c",input_str[i]);  48         return 0;  49 }  50   51 /*this function gets the next number sequence.   52  * It returns the end position of number sequence in the string,   53  * and parameter 'pos' is set to be the start position.  54  * If it returns -1(namely EndReached), end of string is reached*/  55 int getNextNumberSequence(const char* str, unsigned int *pos)  56 {  57         unsigned int str_len = strlen(str);  58         /*locate the first digit character*/  59         while ( (*pos) < str_len && !isdigit( str[*pos]) )  60                 (*pos)++; 61         if ((*pos) == str_len)  62         /*end of string reached*/  63                 return EndReached;  64         unsigned int end_pos = (*pos) + 1;  65         if (end_pos == str_len)  66         /*we haven arrived at the last character in the string, so this number sequence contains only one digit.*/  67                 return (*pos);  68         else  69         {  70                 int diff;  71                 /*if diff == 1,it's ascending; -1, descending*/  72                 if ( isdigit(str[end_pos]) )  73                         diff = str[end_pos] - str[(*pos)];  74                 if (diff == 1 || diff == -1)  75                         while ((++end_pos) < str_len && isdigit(str[end_pos])\  76                                         && (str[end_pos] - str[end_pos -1] == diff) );  77                                                 /*make sure it's uniformly ascending or descending*/  78         }  79         return end_pos - 1;  80 }

引用 6 楼 cs290473786 的回复: #include <stdio.h>  unsigned int Continumax(char ** pOutputstr,char * intputstr) { 	char* pMaxStr = ""; 	char* pValue = intputstr; 	int maxLen = 0; 	while(*pValue != '\0') 	{ 		if (*pValue >= '0' && *pValue <= '9') 		{ 			unsigned int tempLen = 0; 			char* pTempPtr = pValue; 			while(*pValue >= '0' && *pValue <= '9' ) 			{ 				tempLen++; 				pValue++; 			} 			if (tempLen >= maxLen) 			{ 				pMaxStr = pTempPtr; 				maxLen = tempLen; 			} 		} 		pValue++; 	}  	for (int i = 0; i <= maxLen; i++) 		(*pOutputstr)[i] = pMaxStr[i]; 	 	return maxLen; } int _tmain(int argc, _TCHAR* argv[]) { 	char *pInputStr = "abcd12345ss54321";/*abcd12345ed1255ss123456789*/ 	char OutputStr[256] = {0}; 	char* pOutputStr = OutputStr; 	Continumax(&pOutputStr, pInputStr); 	printf("%s\n", pOutputStr); 	return 0; }主要是递增，递减这个功能实现起来麻烦。不过你的方法我先试一试。

感谢各位大大，8楼给了我很大的帮助。我分就给他了。最后，我把我自己写的代码附上。/* 	在一个字符串中找出连续最长的字符串，并把这个最长的字符串返回。如果存在长度相同的连续字符串，返回最后一个字符串 	注意，数字不光要连着，还需要是连续的，比如1234，而不是1245，如果没有数字，则返回空字符串“” 而不是NULL！ 	样例输入 		abcd12345ed1255ss123456789  		abcd12345ss54321 	样例输出 		123456789,函数返回值9 		54321，函数返回值5 	接口说明 		函数原型： 		unsigned int Continumax(char ** pOutputstr,char * intputstr) 		输入参数： 		char * intputstr 输入字符串 		输出参数: 		char ** pOutputstr 连续最长的数字串，如果连续最长数字串长度为0，应该返回空字符串，如果输入空字符串也应该返回空字符串 		返回值：连续最长的数字串的长度 */ #include <iostream> #include <Cstring> using namespace std;   //1.大体动作：遍历整个字符串，寻找连续递增或递减的，最长的数字字符串 //2.记录连续递增或递减数列的起始位置和结束位置 //3.保存最长的数列的起始位置和结束位置 //4.把最长数列的内容保存到一个字符串中，然后输出。 bool ascending(char * inputstr,int nLen) { 	int temp = nLen; 	if (temp>=3) 	{ 		if ((*inputstr)>(*(inputstr-1))) 		{ 			return ((*inputstr)==*(inputstr-2)+2)?true:false; 		}else 		{ 			return ((*inputstr)==*(inputstr-2)-2)?true:false; 		} 	}else if (temp==2) 	{ 		if ((*inputstr)>(*(inputstr-1))) 		{ 			return ((*inputstr)==*(inputstr-1)+1)?true:false; 		}else 		{ 			return ((*inputstr)==*(inputstr-1)-1)?true:false; 		} 	}else { 			return true; 	}  } unsigned int Continumax(char ** pOutputstr,char * intputstr) { 	int MAxLen = 0; 	//pos_begin和pos_end记录连续数列的起始位置和结束位置  	int pos_begin = 0; 	int pos_end = 0; 	//tempLen记录当前数列的长度 	int tempLen = 0; 	//i用来记录遍历时指针偏移量 	int i=0; 	char * pTemp = intputstr; 	while (*pTemp !='\0')//遍历 	{ 		//找到连续递增或递减的数列 		if (*pTemp >='0'&&*pTemp<='9') 		{ 			tempLen++; 			//判断是否连续增或者连续减 			if (!ascending(pTemp,tempLen)) 			{ 				tempLen = 0; 			} 			//记录位置 			if (tempLen>MAxLen) 			{ 				pos_end = i; 				pos_begin = pos_end-tempLen+1; 				MAxLen = tempLen; 			} 		}else 		{ 			tempLen=0; 		} 		i++; 		pTemp++; 	} 	//把pos_begin 到ppos_end之间的内容传送给pOutputstr带出 	*pOutputstr = &intputstr[pos_begin]; 	return MAxLen; } int main() { 	char * inputstr=new char[256]; 	cin.getline(inputstr,256); 	char *pOutputstr = new char[256]; 	int Max_Len = Continumax(&pOutputstr,inputstr); 	int i=0; 	//因为当时传回来的只是连续数字长度的首个元素地址，所以要考虑长度。 	while (i<Max_Len) 	{ 		cout<<*pOutputstr; 		*pOutputstr++; 		i++; 	} 	cout<<","; 	cout<<Max_Len<<endl; 	//if (pOutputstr) 	//{ 	//	delete [] pOutputstr; 	//} 	return 0; } 如果最后delete[]不注释的话DOS窗口不回收。。。这个问题不明白。不过也是从29号晚上开始做这个题了，现在终于做出来了，8楼的思想是先找有效数据的位置，最后再考虑输出的问题。这个是我之前没有想透的。

函数返回找到的串长

unsigned int Continumax(char ** pOutputstr,char * intputstr) *pOutputstr 直接指向intputstr的某个位置，除非1）没找到，2）intputstr=NULL，3）intputstr=“”； 函数返回找到的串 这个问题，不需要 new 新的字符串，只需要纪录指针，和串长

原理弄懂了没泥？你只要画个表格你就懂了，只要原理 懂了。。代码就好懂好写了

默默地顶一下，顺便去吃个饭，回来再试试。


Question: 求解释设计到 指针数组， 指针常量，指针的指针的这个程序

引用 7 楼 czjacke 的回复:也就是可以这么理解吗： 把argv理解为指向argv[]指针数组中的argv[0],而把argv当做是一个指向指针的指针变量！！  以前浅显地学过c语言，现在导师项目要求编程，现在来重新学习C，指针都快被弄晕了！！！ 对，是这样的。 《C和指针》，找来看看吧。

函数参数里的数组，其实是指针

引用 8 楼 brookmill 的回复:[quote=引用 7 楼 czjacke 的回复:] 也就是可以这么理解吗： 把argv理解为指向argv[]指针数组中的argv[0],而把argv当做是一个指向指针的指针变量！！  以前浅显地学过c语言，现在导师项目要求编程，现在来重新学习C，指针都快被弄晕了！！！ 对，是这样的。 《C和指针》，找来看看吧。[/quote]谢谢！！！！！

引用 5 楼 brookmill 的回复:楼主可以搜一下“参数 数组 退化 指针” 对于局部变量或者全局变量的数组名，确实不允许修改。但是，数组名作为参数的时候，编译器是把它按照指针来处理的，所以，函数里面他就是个指针。这和什么类型的数组没关系。 比如 int f(int a[])  // 这个完全等价于 int f(int *a) { a++; // 这个是允许的。 } 楼主的例子，char * argv[]就等于char **argv，也确实有人这么写。也就是可以这么理解吗： 把argv理解为指向argv[]指针数组中的argv[0],而把argv当做是一个指向指针的指针变量！！   以前浅显地学过c语言，现在导师项目要求编程，现在来重新学习C，指针都快被弄晕了！！！

引用 5 楼 brookmill 的回复:楼主可以搜一下“参数 数组 退化 指针” 对于局部变量或者全局变量的数组名，确实不允许修改。但是，数组名作为参数的时候，编译器是把它按照指针来处理的，所以，函数里面他就是个指针。这和什么类型的数组没关系。 比如 int f(int a[])  // 这个完全等价于 int f(int *a) { a++; // 这个是允许的。 } 楼主的例子，char * argv[]就等于char **argv，也确实有人这么写。  楼上说的对，呵呵

其实这是一个 “步长”  问题 ++argv;就是将argv往下移动一个“步长” 地址，在这里是往下移动一列值； 列值： argv[0][0].......[n]              argv[1][0]......[n]  ++argv,指针从argv[0]移到argv[1]

既然是指针地址，肯定就可以进行++操作的，但是这个++不一定是+1； 例如：int *argv[]中argv++地址会后移四个字节，这个和申明的类型有关系。

你说的没错，argv是字符串数组的第一个地址，按理说也是指针常量。 但是，这个数组是char * 的，比较特殊，argv可以作为左值。

char* argv[]是指针数组。argv[0]存储的是指针。++argv，就是下一个指针argv[1]


Question: ? snmp中trap消息的源端口有限制吗？

必须是161还是没有限制？


Question: 数据结构-基础编程求debug

已经解决^_^

还有一点： main函数退出前，最好手动把malloc的内存free掉。 虽然main函数退出后，操作系统会回收内存，但是作为C/C++程序员，最好自己手动回收内存。

错误有下面几个： 1、21行 应该是 scanf("%s", p->name);   scanf 注意格式，前面是类型，后面是地址。 你写的&p->name[10] 已经数组越界了。 2、22行  应该是scanf("%d", &p->score);  3、malloc内存后，要判断下p是否为空，这是一个好的编程习惯 4、39行 改成LinkList L;  LinkList 已经是指针了。 5、48行 改成 PrintList(L); 6、另外一些 printf的格式很不美观，自己调整下。

仅供参考//带表头结点的单向链表 #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-> //


Question: 菜鸟求教，忘各位大神指教。。。

a=b=c; 这种连等号a和b都必须是左值，等价与 b=c; a=b; 你的代码里中间那个表达式显然不是。把它展开 (unsigned int)(lati-p1.y)*(p2.x-p1.x)/(unsigned int)(p2.y-p1.y) =p1.x;  //显然错误 unsigned int jx = (unsigned int)(lati-p1.y)*(p2.x-p1.x)/(unsigned int)(p2.y-p1.y);

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

楼主写这个表达式想完成什么功能？。。


Question: 深度遍历顶点vi是否存在到顶点vj的路径(以邻接表形式存储)

Decide递归调用后，看下p是否为空指针。


Question: 新手入門,找不出的bug

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

for (i=0;i<65;i++) { bit[i]=0; } 越界了


Question: 下面这个多项式相加相乘的程序问题出在哪里了？

第46行    scanf("%d", &high_power); 改成 ： scanf("%d", &pol->HighPower); 理由。。一眼就能看出来了吧== 还有你没考虑常数项是X的0次方。直接从X的1次方考虑的。


Question: 求教C语言，我要怎样把它的名次变成这样

看三楼。。。

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

可以給我Scores.txt 的內容嗎? 我能直接寫給你

引用 3 楼 zhao4zhong1 的回复://Score.txt: //甲 70 60 65 //乙 80 76 90 //丙 75 65 90 //丁 56 80 70 #include <stdio.h> struct ST {     char name[20];     int gw;     int yw;     int sx;     int zf;     int pj;     int mc; } st[4]; struct ZFS {     int no;     int zf; } zfs[4],zft; int main() {     FILE *fp;     int i,j;      fp=fopen("Scores.txt","r");     if (fp==NULL) return -1;     for (i=0;i<4;i++) {         fscanf(fp,"%19s%d%d%d",             st[i].name,            &st[i].gw,            &st[i].yw,            &st[i].sx);         st[i].zf=st[i].gw+st[i].yw+st[i].sx;         st[i].pj=(int)(st[i].zf/3.0+0.5);         zfs[i].no=i;//记住该总分对应的人         zfs[i].zf=st[i].zf;     }     fclose(fp);     //对总分排序     for (i=0;i<4-1;i++) {         for (j=i+1; j<4;j++) {             if (zfs[j].zf>zfs[i].zf) {                 zft=zfs[i];zfs[i]=zfs[j];zfs[j]=zft;             }         }     }     for (i=0;i<4;i++) st[zfs[i].no].mc=i+1;//填写每个人的名次     printf("姓名\t國文\t英文\t數學\t總分\t平均\t名次\r\n");      for (i=0;i<4;i++) {         printf("%s\t%2d\t%2d\t%2d\t%3d\t%2d\t%2d\n",             st[i].name,             st[i].gw,             st[i].yw,             st[i].sx,             st[i].zf,             st[i].pj,             st[i].mc);     }     return 0; } //姓名    國文    英文    數學    總分    平均    名次 //甲      70      60      65      195     65       4 //乙      80      76      90      246     82       1 //丙      75      65      90      230     77       2 //丁      56      80      70      206     69       3 //   我修改后这样运行的结果，不知怎么回事 //#include<stdafx.h>  #include<stdio.h> #include<stdlib.h> #include<memory.h> int main(int argc, char* argv[]) { 	int StudentScores[10][6]; 	char StudentName[10][20]; 	int temp; 	int Cur=0,Cur1=0; 	int Index=0; 	FILE *fp=NULL; 	fp = fopen("Scores.txt","rb");  		if (fp==NULL) 			return -1; 			 		for(Cur=0; Cur<4;Cur++) 		{	 			fscanf(fp,"%s\t%d\t%d\t%d\t%d", 				StudentName[Cur], 				&StudentScores[Cur][0], 				&StudentScores[Cur][1], 				&StudentScores[Cur][2], 				&StudentScores[Cur][3], 				&StudentScores[Cur][4]); 				StudentScores[Cur][5]=Cur; 				StudentScores[Cur][4]=StudentScores[Cur1][4]; 		} 	 		fclose(fp);	 		for(Cur=0; Cur<4-1;Cur++){ 		for(Cur1=Cur+1;Cur1<4;Cur1++) 		{ 			if(StudentScores[Cur][3]>StudentScores[Cur1][3]) 			{	 				temp=StudentScores[Cur][5]; 				StudentScores[Cur][5]=StudentScores[Cur1][5]; 				StudentScores[Cur1][5]=temp; 			} 		} 		} 		for(Cur=0; Cur<4;Cur++) 			StudentScores[Cur][5]=Cur+1; 		printf("姓名\t國文\t英文\t數學\t總分\t平均\t名次\r\n"); 		 		for(Cur=0;Cur<4;Cur++) 		{ 		 			StudentScores[Cur][3]=StudentScores[Cur][0]+StudentScores[Cur][1]+StudentScores[Cur][2]; 			StudentScores[Cur][4]=(StudentScores[Cur][0]+StudentScores[Cur][1]+StudentScores[Cur][2])/3; 			printf("%s\t%2d\t%2d\t%2d\t%d\t%d\t%d \r\n",  				StudentName[Cur], 				StudentScores[Cur][0], 				StudentScores[Cur][1], 				StudentScores[Cur][2], 				StudentScores[Cur][3], 				StudentScores[Cur][4]); 		} 		//排序 		int temp_Scores[6]; 		char temp_Name[20]; 		int i=0,j=0; 		int value=0; 		for(i=0; i<4;i++) 		{ 			for(j=i+1; j<4;j++) 			{ 				if(StudentScores[j][3]>StudentScores[i][3]) 				{ 					memcpy(temp_Scores,StudentScores[j],sizeof(temp_Scores)); 					memcpy(StudentScores[j],StudentScores[i],sizeof(temp_Scores)); 					memcpy(StudentScores[i],temp_Scores,sizeof(temp_Scores)); 					 					memcpy(temp_Name,StudentName[j],sizeof(temp_Name)); 					memcpy(StudentName[j],StudentName[i],sizeof(temp_Name)); 					memcpy(StudentName[i],temp_Name,sizeof(temp_Name)); 				} 			} 		} 		printf("姓名\t國文\t英文\t數學\t總分\t平均\t名次\r\n"); 		 		for(Cur=0;Cur<4;Cur++) 		{ 			printf("%s\t%2d\t%2d\t%2d\t%2d\t%2d\t%2d \r\n",  				StudentName[Cur], 				StudentScores[Cur][0], 				StudentScores[Cur][1], 				StudentScores[Cur][2], 				StudentScores[Cur][3], 				StudentScores[Cur][4], 				Cur+1); 		} 		return 0; } //姓名    國文    英文    數學    總分    平均    名次 //甲        70        60        65      195       65      0 //乙        80        76        90       246      82      0 //丙        75        65        90       230      76      0 //丁        56        80        70       206      68      0  //姓名    國文    英文    數學    總分    平均    名次 //乙        80       76        90       246     82       1 //丙        75       65        90       230     76       2 //丁        56       80        70       206     68       3 //甲        70       60        65       195     65       4

引用 1 楼 user-3 的回复:可以給我Scores.txt 的內容嗎? 我能直接寫給你


Question: 关于《C,C++表达式求值顺序 裘老的解释。》的疑问

解惑了，参考：http://bbs.csdn.net/topics/380213111 operator<<(operator<<(operator<<(cout, a), a++), endl) 具体说来是红色的那一层operator<<的两个参数operator<<(cout, a)和a++的求值顺序由编译器自行决定。如果先求出前者输出就是44，如果先求出后者输出就是54。而45在正常情况下是不可能的。 后一个指针的例子，则还有编译器的乱序优化小聪明。 至于究竟什么才是“定义了的行为”，请自行网上搜索C++顺序点。

引用 2 楼 zhao4zhong1 的回复:我的回帖中已经解释的很清楚了。 将置顶中的所有贴子看了一遍，赵老师的回复主要讲两点： 1.根据自己的编译器看汇编，找结果，不迷信书本、文字等 2.提了下各运算符优先级  我的问题在于，根据某一汇编，cout<<a++<<a<<endl;它的顺序是明确的，但是如果同一段代码用不同的编译器 编译得到的汇编执行结果不同，这是不能容忍的，我想知道的这些汇编生成的规则，如果只知其然，不知其所以 然，掉坑是必然的。  抛开裘老的解释，我的问题在于，对于cout<<a++<<a;这种语句，编译器要遵循什么规则来编译，哪个顺序是未 定义的？  根据目前的结果，要么它输出4，4，要么它输出4，5  输出4，4，则该命令相当于： cout<<a cout<<a a++; 输出4，5，该命令相当于： cout<<a a++; cout<<a 如果只迷信这样的结果，很容易做出，第一步肯定是cout<<a是没问题的，问题在于a++对于后一个输出是否起作用，这样的论 断有问题，接下来的例子是这样的： a=4; cout<<a<<a++; 1个可能的输出的结果是5,4 那么这又相当于是 tmp = a; a++; cout<<a; cout<<tmp;  对于上面这两个例子，编译系统是根据什么原则来编译的，表示不理解

我的回帖中已经解释的很清楚了。

没人吗，顶顶


Question: 醉了，为什么我调用的函数不执行呢？

引用 1 楼 yangyangsnr 的回复:没走是什么意思？程序能正常执行的啊。 不过你这样写的意义何在？传了两个参数，一个都没用到，有一个返回值，返回值也没用到我VC犯2了，我调函数没反映，这个用来测试，我后面重启了VC就好了，哎。


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

引用 1 楼 aa5566f4 的回复:先看fgets函數 stdio.h 中的 fgets() 從檔案一行一行的讀取資料，共需三個參數，第一個參數為儲存輸入資料的陣列，第二個參數為該行最多幾個字元，第三個參數為指向結構 FILE 的指標。    以下程式用 fgets() 取得一行文字便列印到螢幕上  int main(void) {     FILE *fPtr;     char s[50];            fPtr = fopen("oldname.txt", "r");     if (!fPtr) {         printf("檔案開啟失敗...\n");         exit(1);     }           while (fgets(s, 50, fPtr) != NULL) {         printf(s);     }     printf("\n");       fclose(fPtr);           return 0; }   再看strcmp函數 string.h 的函數 strcmp() ，需要兩個字串當作參數，比較兩個字串是否相等，相等就回傳 0，第一個字串大於第二個字串回傳正值，反之回傳負值。     以下程式比較字串 s 與字串 t 是否相等  #include <stdio.h> #include <string.h>   int main(void) {     char s[] = "Hello, world!";     char t[] = "Hello, my friend!";     int test = strcmp(s, t);           if (test == 0) {         printf("All right!\n");     }     else {         if (test > 0) {             printf("%s\n", s);         }         else {             printf("%s\n", t);         }     }            return 0;     }    這樣懂了嗎? 如果不懂你要把完整代碼再貼上來我一行一行解釋了   多谢这位好心的大神，不知大神有QQ没，方便的话给下，以后小弟有不懂的地方还请大神多多指教。。。

引用 2 楼 slx_391987 的回复:这个代码可以分解成两步： fgets(buffer, BUFFERSIZE, stdin); 从标准输入中读取最多BUFFERSIZE个字符到buffer中，fgets返回值是一个指针，指向buffer  if(!strcmp(buffer, endstr)) 判断buffer中的内容是否跟endstr相同。  综合起来，if(!strcmp(fgets(buffer, BUFFERSIZE, stdin), endstr)) 意思就是从标准输入中读最多BUFFERSIZE字符，然后判断读到的字符是否是endstr。 引用 2 楼 slx_391987 的回复:这个代码可以分解成两步： fgets(buffer, BUFFERSIZE, stdin); 从标准输入中读取最多BUFFERSIZE个字符到buffer中，fgets返回值是一个指针，指向buffer  if(!strcmp(buffer, endstr)) 判断buffer中的内容是否跟endstr相同。  综合起来，if(!strcmp(fgets(buffer, BUFFERSIZE, stdin), endstr)) 意思就是从标准输入中读最多BUFFERSIZE字符，然后判断读到的字符是否是endstr。 引用 2 楼 slx_391987 的回复:这个代码可以分解成两步： fgets(buffer, BUFFERSIZE, stdin); 从标准输入中读取最多BUFFERSIZE个字符到buffer中，fgets返回值是一个指针，指向buffer  if(!strcmp(buffer, endstr)) 判断buffer中的内容是否跟endstr相同。  综合起来，if(!strcmp(fgets(buffer, BUFFERSIZE, stdin), endstr)) 意思就是从标准输入中读最多BUFFERSIZE字符，然后判断读到的字符是否是endstr。   多谢大神。。。非常感谢呀。


Question: 求助：刚学C语言，题目：从键盘输入一个小于1000的正数，要求输出它的平方根，如果平方根不是整数，则输出其整数，运行结果是负数

从键盘任意输入一个键。如果是正数求平方根，如果是负数，求相反数后求平方根,。。。。       刚学，求解

删除了else之后可以了，谢谢！

前面输入大于1000，直接执行if语句 else跳过去了，没有执行，所以看起来怪数字，实际是因为b没有初始化。 你要把开放放在else的外面。不要放在else里面。


Question: u32等类型是在哪个头文件中定义？

补充下，  struct fw_data {     short offset：8; };  占两个字节  struct fw_data {     short offset：8;     int:0; }; 变成占4个字节 struct fw_data {     short offset;     int:0; };  还是两个字节 综上，int:0的作用是在当前一个结构体成员只使用几位的时候，int:0会将这个成员所占空间填为int所占的4个字节，然后 下一个成员在4个字节后开始计算

struct fw_data {     u32 offset : 8;     u32 : 0;     u32 val; };  占8个字节  struct fw_data {     int offset : 8;     int c:8;     int : 0;     int val; };  还是占8个字节  struct fw_data {     int offset : 8;     int : 0;     int c:8;     int val; };  占了12个字节 综上, int:0将前一个int的剩余位数占用 U32的话还可以在当前文件自己再定义一个U32,编译冲突时会告诉原来你在哪定义的

从下一个字节或int开始新的位域？

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

自顶一个~~


Question: 刚接触C语言，这是我的问题以及总结，求教

所以会产生数据不精确问题

计算机中浮点数是以 （-1）s * m * 2^f表示的   m表示小数位 f小数位数

关于格式化输出， 好好记住这个  对于printf， %f可以输出double,  float会自动转为double， 不需要%lf. 但是要输出long double就要用%Lf。   还有， 浮点数规格化（10进制转2进制）是有误差的。

楼主可以去了解一下float和double的精度，以及计算机中浮点数的存储问题 建议最好下载一个帮助文档看看，如——

刚学C，有点不懂，谢谢大家回答


Question: 今天早上起床发现有人说用C语言做了.apk真的可以么？

可以完全不用Java写。甚至可以不用NDK（直接使用NDK打包的standalone toolchain和Android SDK）。 不过生成的.apk里还是有Java代码的默认实现。

看看有没有.so后缀的文件名就知道了。

应该说的是jni吧。 底层主要逻辑是用c写的。  接口还是要java转一下。

LZ可以把解包后的文件名列出来啊。你自己看得不一定准。 Java可以JNI调用的LZ还知道？


Question: linux C/C++ proc 连接oracle 求教

引用 2 楼 zhao4zhong1 的回复:进程意外退出会在当前目录下产生‘core’文件或形如‘core.数字’的文件比如‘core.1234’ 使用命令 gdb 运行程序名 core或core.数字 进入gdb然后使用bt命令 可以查看进程意外退出前函数调用的堆栈，内容为从上到下列出对应从里层到外层的函数调用历史。 如果进程意外退出不产生core文件，参考“ulimit -c core文件最大块大小”命令 #0  0x007256c6 in __strlen_sse2_bsf () from /lib/i686/nosegneg/libc.so.6 #1  0x08048c97 in tolower (s=0x4e <Address 0x4e out of bounds>) at mtest.pc:117 #2  0x41994696 in nlpatolower () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #3  0x41995954 in nlpagtcase () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #4  0x4199581a in nlpaputval () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #5  0x4199568a in nlpainzert () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #6  0x4042f007 in nlpaparse () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #7  0x4042ed43 in nlpardfile () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #8  0x4042e856 in nlpains () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #9  0x4042e695 in nlpainso () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #10 0x402e1dca in nlstdlp_load_psource () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #11 0x4197e875 in nlstdggo () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #12 0x4197e67b in nlstdgg () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #13 0x40398562 in nigini2 () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #14 0x40754f9c in kpeDbgGetNPDGlobal () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #15 0x40754ec8 in kpeDbgTLSInit () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #16 0x41a5898f in kpummTLSGET1 () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #17 0x4075503a in kpeDbgProcessInit () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #18 0x40753590 in kpummpin () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #19 0x40293f88 in kpupin () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #20 0x40262f28 in OCIInitialize () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #21 0x4023b1c5 in sqgctx () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #22 0x41954344 in sqgrct () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #23 0x419527b1 in sqlcmex () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #24 0x419525cc in sqlcxt () from /home/oracle/product/11.2/lib/libclntsh.so.11.1 #25 0x08048b9c in db_connect () at mtest.pc:109 #26 0x0804903a in main () at mtest.pc:222  我不debug 怎么知道在哪里core的勒。上面说的109行 我已经修改！~ 反正就是EXEC SQL  connect :sql_userid IDENTIFIED BY :sql_passwd using :sql_dbname; core

我也是刚接触proc链接oracle，主要参考这个网页里的资料，楼主看一下有没有帮助 http://bbs.chinaunix.net/thread-9155-1-1.html


Question: 万能的C板块，哥又来了！有大问题，快进！

引用 16 楼 nadleeh123 的回复:[quote=引用 12 楼 u014497038 的回复:] IOS的文档里面肯定有啊！ 其实我只需要看到有硬件中断仲裁器 就ok了  没心情去翻，被sdk的代码搞烦了[/quote] 你也没说问题是什么？鬼畜的是啥？

引用 12 楼 u014497038 的回复:IOS的文档里面肯定有啊！ 其实我只需要看到有硬件中断仲裁器 就ok了  没心情去翻，被sdk的代码搞烦了

不会耶，帮顶一个

帮顶一下吧，不懂哎

引用 2 楼 osoon 的回复:找不到资源, 你觉得可能吗? 耐心一点.  w3.myexception.cn/software-architecture-design/1593861.html  等的就是这样的高人阿

呵呵，没有接触过，友情帮你顶贴

IOS的文档里面肯定有啊！

鬼畜。。。lz肯定看里番

百度都玩不好？

说的都是些什么

引用 6 楼 truelance 的回复:4.13. Generic Interrupt Controller, GIC - ARM Information Center http://infocenter.arm.com/help/topic/com.arm.doc.../Cacgfedh.html 是这个么?  差不多了


Question: 请问c语言头文件.h中函数的参数怎嘛申明

@mymtom 如你所说，问题解决！ @lovesmiles   我开始的想法是在.h文件中重新定义一个变量，来解决函数参数没有申明问题，但是我查了下资料，都说在头文件中定义变量会出现占用内存问题。这个变量，应该是只能在被引用文件范围内使用，这算是局部变量？ 关于用extern申明变量，然后再定义使用，这个我待会试试。

引用 6 楼 shenwansan_gz 的回复:@cs290473786，貌似是我想错了  在头文件中定义局部变量，如果有多个文件引用，可能出现的是冗余变量，  你说的局部变量是什么意思？你可以用extern来声明，然后只在一个地方定义这个变量变可以了

原因是结构体没有声明就使用呀 #include <pcap/pcap.h> 即可！  #include <sys/types.h> #include <stdio.h>  #ifdef USE_PCAP #include <pcap/pcap.h> #endif  typedef void (*wifi_pcap_callback)(u_char *, const struct pcap_pkthdr *,const u_char *);  int main(int argc, char *argv[]) {     ;      return 0; }   $ gcc -o demo015 demo015.c            demo015.c:8: warning: 'struct pcap_pkthdr' declared inside parameter list demo015.c:8: warning: its scope is only this definition or declaration, which is probably not what you want $ gcc -DUSE_PCAP -o demo015 demo015.c $

@user-4 因为其他两个都是基本类型，第二个是自己定义的结构体，这个可以编译过去，但是有waring，现在要解决这个waring

楼主申明和定义概念貌似不是满清晰。申明为局部类型，还是定义局部类型的变量啊。怎么会重定义呢

你想想，三个参数的声明其实都是一样的，编译器为什么不喜欢第二个，而对两外两个都没有意见？

这个好像不是声明变量的问题，我觉得编译器是说找不到struct pcap_pkthdr这个类型。楼主看看struct pcap_pkthdr是在哪里定义的？


Question: 请问高手关于调用16位的dll的问题？

32位的.exe不能直接调用16位的.dll，要通过中间DLL做thunk，这样说你能懂了吧。

什么乱七八糟 人家要问的是， 首先如何把16位dll调用起来。  我也想很好奇。

引用 4 楼 DelphiGuy 的回复:win32中确实可以16-bit DLL和32-bit DLL互相调用，ms称之为thunk，你要从32-bit DLL调用16-bit DLL，你首先要写一个脚本.thk文件，里面包括被调用的16-bit DLL中的函数描述（C风格），然后用thunk编译器编译成两个.obj文件，分别连接到32-bit和16-bit DLLs中，每个DLL的入口部分要调用一个特定函数做初始化，具体怎么写我忘记了，你搜索一下msdn。注意，如果是没做过thunk的16-bit DLL，你也没有源码，是调用不了的（至少我印象如此）。请问阁下，我的问题是一个win下调用api 的32位的.exe文件调用16位的.dll文件？，你看懂了吗？至于你说的这些，我会认真研究的，不过没有这方面的实例的话，我做起来好像很迷茫啊！

是这样的，如果编写一个调用win32 api的32位应用程序，调用16位的dll话，好像是有点空难的。请教下高手，我好麻烦啊！

引用 1 楼 zhao4zhong1 的回复:不要做A语言代码修改为B语言代码的无用功。 也不要做用A语言代码直接调用B语言代码库这样复杂、这样容易出错的傻事。 只需让A、B语言代码的输入输出重定向到文本文件，或修改A、B语言代码让其通过文本文件输入输出。 即可很方便地让A、B两种语言之间协调工作。 比如： A将请求数据写到文件a.txt，写完后改名为aa.txt B发现aa.txt存在时，读取其内容，调用相应功能，将结果写到文件b.txt，写完后删除aa.txt，改名为bb.txt A发现bb.txt存在时，读取其内容，读完后删除bb.txt 以上A可以替换为任何一种开发语言或开发环境，B可以替换为任何一种与A不同的开发语言或开发环境。 除非A或B不支持判断文件是否存在、文件读写和文件更名。 但是谁又能举出不支持判断文件是否存在、文件读写和文件更名的开发语言或开发环境呢？  共享临时文本文件这种进程之间的通讯方法相比其它方法的优点有很多，下面仅列出我现在能想到的： ·进程之间松耦合 ·进程可在同一台机器上，也可跨机，跨操作系统，跨硬件平台，甚至跨国。 ·方便调试和监视，只需让第三方或人工查看该临时文本文件即可。 ·方便在线开关服务，只需删除或创建该临时文本文件即可。 ·方便实现分布式和负载均衡。 ·方便队列化提供服务，而且几乎不可能发生队列满的情况（除非硬盘空间满） ·……  请自行将上面的“A语言”替换为“32位APP和32位DLL”，“B语言”替换为“16位APP和16位DLL”你说的这些只是两种编程语言之间数据交换的一种编写方式，也可以用xml这种方式。你跟我说的问题，不是一回事。

噗。。。。。

什么年代了，还有16位的dll ...  我好像在哪里看到过说16位的dll是可以直接在32位的进程空间里用的。但是32位与64位是不能在同一个进程的。


Question: 请教，printf()可以用宏来定义吗？

多谢各位高人的热心指点！ 我是做嵌入式开发的，在ARM Cortex-M0 的编译器上试验过了，是可行的。  我用下面的形式： #define LOGPRINT(...) printf(__VA_ARGS__)

c99、c++11支持 __VA_ARGS__ #define dprint(X, ... ) printf( X, __VA_ARGS__ )  注意X和...之间有逗号  或者用 ##即可。。。  #define dprint(X,args... ) printf( X, ##args)  注意args和...之间没逗号

多谢回复！我学习一下。

ms-help://MS.VSCC.v90/MS.MSDNQTR.v90.chs/dv_vclang/html/51e757dc-0134-4bb2-bb74-64ea5ad75134.htm  Collapse AllExpand All      Code: All Code: Multiple Code: Visual Basic Code: C# Code: Visual C++ Code: J# Code: JScript   Visual Basic C# Visual C++ J# JScript Visual C++ Language Reference  Variadic Macros  Example  See Also  Send Feedback     Variadic macros are function-like macros that contain a variable number of arguments.  Remarks To use variadic macros, the ellipsis may be specified as the final formal argument in a macro definition, and the replacement identifier __VA_ARGS__ may be used in the definition to insert the extra arguments. __VA_ARGS__ is replaced by all of the arguments that match the ellipsis, including commas between them.  The C Standard specifies that at least one argument must be passed to the ellipsis, to ensure that the macro does not resolve to an expression with a trailing comma. The Visual C++ implementation will suppress a trailing comma if no arguments are passed to the ellipsis.  Support for variadic macros was introduced in Visual C++ 2005.  Example   Copy Code  // variadic_macros.cpp #include <stdio.h> #define EMPTY  #define CHECK1(x, ...) if (!(x)) { printf(__VA_ARGS__); } #define CHECK2(x, ...) if ((x)) { printf(__VA_ARGS__); } #define CHECK3(...) { printf(__VA_ARGS__); } #define MACRO(s, ...) printf(s, __VA_ARGS__)  int main() {    CHECK1(0, "here %s %s %s", "are", "some", "varargs1(1)\n");    CHECK1(1, "here %s %s %s", "are", "some", "varargs1(2)\n");   // won't print     CHECK2(0, "here %s %s %s", "are", "some", "varargs2(3)\n");   // won't print    CHECK2(1, "here %s %s %s", "are", "some", "varargs2(4)\n");     // always invokes printf in the macro    CHECK3("here %s %s %s", "are", "some", "varargs3(5)\n");     MACRO("hello, world\n");    // MACRO("error\n", EMPTY);   would cause C2059 }     Copy Code  here are some varargs1(1) here are some varargs2(4) here are some varargs3(5) hello, world    See Also Concepts Macros (C/C++) Send feedback on this topic to Microsoft.

// 有的编译器支持 "##__VA_ARGS__"，"..." 可以为空： #define LOGPRINT(fmt, ...) printf(fmt, ##__VA_ARGS__) // 有的编译器不支持 "##__VA_ARGS__"，只能写成这样： #define LOGPRINT(...) printf(__VA_ARGS__)

引用 6 楼 mymtom 的回复:可变参数宏，C99支持的  #include <stdio.h>  #define debug(fmt, ...) \     printf("%s:%d " fmt "\n", __FILE__, __LINE__, __VA_ARGS__)  int main(int argc, char *argv[]) {      debug("argc=%d", argc);     return 0; }  /* output: hello.c:10 argc=1 */

可以！  比如 #define LOG(format, ...) printf(format, ##__VA_ARGS__)   给你一个我用来调试代码用的  #ifdef DEBUG #define LOG_DEBUG(log_name, format, ...) \     fprintf(log_name, "\033[32m%s %s:%d %s()\033[0m DEBUG| "format"\n", __DATE__, __FILE__, __LINE__,  __func__, ##__VA_ARGS__) #else #define LOG_DEUGG(log_name, format, ...) #endif

可变参数宏，C99支持的

引用 1 楼 user-6 的回复:variadic  maco maco --> macro

variadic  maco


Question: 字符串问题请教

找到问题了，乌龙。

因为 Mcu_Mode==1

这是用IAR编译的。  刚刚换成WINTC就正常了。  是不是写法一不够严谨？


Question: 求助：关于ShellExecuteEx函数调用cmd并输入一条指令的应用

将要执行的命令放在一个tmp.bat文件中，open这个tmp.bat

还有没有人来帮忙看下  还是没有成功调用   在cmd输入相同的指令是可以执行的

引用 3 楼 zhao4zhong1 的回复:if (0 != CallEXE(_T(""), _T("open"),_T("cmd.exe /c cd /d D:\\bios&w32_flashrom0.9.7.exe -p internal -r bios_read.ROM"), _T("D:\\bios"))) 谢谢了  刚试了下  还是没有执行   &连接符是并执行的意思吗？

引用 2 楼 user-2 的回复:看看那个w32_flashrom0.9.7.exe 的工作路径有问题没 路径肯定是对的   没有问题

看看那个w32_flashrom0.9.7.exe 的工作路径有问题没

目的是调用cmd  并且输入一条指令执行     看了msdn的关于lpParameters和lpDirectory参数的说明   不是很明白  不知道到底为题在哪    谢谢大家了


Question: 模板函数干嘛不支持 template  RET_T pri

引用 9 楼 mujiok2003 的回复:[quote=引用 8 楼 FrankHB1989 的回复:] [quote=引用 5 楼 mujiok2003 的回复:] [quote=引用 4 楼 soso101 的回复:] 三个类型都显式调用，比如double v = prifunc＜double，int，int>(1, 1); c++ 11以前， 需要这样。  C++ 11 已经完美解决这个问题了。  #include <iostream> using namespace std; template<class Lhs, class Rhs>   auto adding_func(const Lhs &lhs, const Rhs &rhs) -> decltype(lhs+rhs) {return lhs + rhs;}    int main() { 	auto x = adding_func(5, 6.45); 	std::cout << x << std::endl;  //11.45 	return 0; }[/quote] 完美？return塞个有capture的lambda进去看你怎么写trailing-return-type。 [/quote] 这里的问题是lamda吗？[/quote]  5楼之后就看不懂了，前面的都对我很有用啊！谢谢各位。

引用 10 楼 FrankHB1989 的回复:LZ说“网上找出来的例子都是只声明一种类型”于是有“感觉这样的用法太不方便了吧，模板到底怎么用的”的疑问。 因此“这里”的问题实质上是指怎么在调用处省略返回类型——并不强调返回类型具体是什么。 closure type不是LZ给的例子，但顺着你的解法是可以遇到这个坑的，所以在说“完美”之前，有必要提个醒。 如果对你的说法信以为真，看到C++14省略trailing-return-type以后感觉可能就是被你玩了一样。 引用auto x = adding_func(5, 6.45);  std::cout << x << std::endl;  //11.45  这就解决使用不方便及怎么使用的问题的，不多不少：函数调用的时候<...>不见了， 配合auto x的类型也编译器自行推导。完美解决lz的问题， 不是说 trailing-return-type完美。

引用 9 楼 mujiok2003 的回复:[quote=引用 8 楼 FrankHB1989 的回复:] [quote=引用 5 楼 mujiok2003 的回复:] [quote=引用 4 楼 soso101 的回复:] 三个类型都显式调用，比如double v = prifunc＜double，int，int>(1, 1); c++ 11以前， 需要这样。  C++ 11 已经完美解决这个问题了。  #include <iostream> using namespace std; template<class Lhs, class Rhs>   auto adding_func(const Lhs &lhs, const Rhs &rhs) -> decltype(lhs+rhs) {return lhs + rhs;}    int main() { 	auto x = adding_func(5, 6.45); 	std::cout << x << std::endl;  //11.45 	return 0; }[/quote] 完美？return塞个有capture的lambda进去看你怎么写trailing-return-type。 [/quote] 这里的问题是lamda吗？[/quote] LZ说“网上找出来的例子都是只声明一种类型”于是有“感觉这样的用法太不方便了吧，模板到底怎么用的”的疑问。 因此“这里”的问题实质上是指怎么在调用处省略返回类型——并不强调返回类型具体是什么。 closure type不是LZ给的例子，但顺着你的解法是可以遇到这个坑的，所以在说“完美”之前，有必要提个醒。 如果对你的说法信以为真，看到C++14省略trailing-return-type以后感觉可能就是被你玩了一样。

引用 8 楼 FrankHB1989 的回复:[quote=引用 5 楼 mujiok2003 的回复:] [quote=引用 4 楼 soso101 的回复:] 三个类型都显式调用，比如double v = prifunc＜double，int，int>(1, 1); c++ 11以前， 需要这样。  C++ 11 已经完美解决这个问题了。  #include <iostream> using namespace std; template<class Lhs, class Rhs>   auto adding_func(const Lhs &lhs, const Rhs &rhs) -> decltype(lhs+rhs) {return lhs + rhs;}    int main() { 	auto x = adding_func(5, 6.45); 	std::cout << x << std::endl;  //11.45 	return 0; }[/quote] 完美？return塞个有capture的lambda进去看你怎么写trailing-return-type。 [/quote] 这里的问题是lamda吗？

引用 5 楼 mujiok2003 的回复:[quote=引用 4 楼 soso101 的回复:] 三个类型都显式调用，比如double v = prifunc＜double，int，int>(1, 1); c++ 11以前， 需要这样。  C++ 11 已经完美解决这个问题了。  #include <iostream> using namespace std; template<class Lhs, class Rhs>   auto adding_func(const Lhs &lhs, const Rhs &rhs) -> decltype(lhs+rhs) {return lhs + rhs;}    int main() { 	auto x = adding_func(5, 6.45); 	std::cout << x << std::endl;  //11.45 	return 0; }[/quote] 完美？return塞个有capture的lambda进去看你怎么写trailing-return-type。

但是记得模板声明时的顺序即你的模板RET_T要放到第一位，要不然你还需要把RET_T之前的模板同样进行显示的实例化

模板支持返回参数为模板参数，比如常调用的的函数make_share就会让你显示的指定返回类型(c++11)，因为在函数调用时无法直接推断返回类型，所以可以显示的提供模板实参，比如你的函数调用的方式可以修改为 prifunc<int> 代表返回int类型，而剩余的参数则按常规方式利用形参进行推断。  int tmp; tmp = prifunc<int>(3,5);  后面的两个模板参数被实例化为int类型

引用 4 楼 soso101 的回复:三个类型都显式调用，比如double v = prifunc＜double，int，int>(1, 1); c++ 11以前， 需要这样。  C++ 11 已经完美解决这个问题了。  #include <iostream> using namespace std; template<class Lhs, class Rhs>   auto adding_func(const Lhs &lhs, const Rhs &rhs) -> decltype(lhs+rhs) {return lhs + rhs;}    int main() { 	auto x = adding_func(5, 6.45); 	std::cout << x << std::endl;  //11.45 	return 0; }

当函数返回值为模板参数时，编译器无法推断出该参数具体类型。需要向2楼那样调用才行

模板定义是正确的

擦，不是模板不对，是你不会调用吧。 int v = prifunc<int>(1, 1);


Question: 二进制位运算和大小端题目，达人分析下

The order of allocation of bit-fields within a unit (high-order to low-order or low-order to high-order) is implementation-defined.

struct   bit      {        unsigned int   a:3;         unsigned int   b:2;          unsigned int   c:3;    };

引用 3 楼 yejie1111 的回复:[quote=引用 2 楼 user-3 的回复:] aix输出比较奇怪，按说应该是-4，-1，1 aix下，a占高3位，最高位为1，应该是-4，b占中间2位11，应该-1，C占低三位，结果1 x86下相反，应该是1 ， -1 ，-4   赵老师的就没看懂了。。。你说的这个-1 我能理解 是11，，，-4是怎么看的100怎么会解析为-4？[/quote] 最高位符号位，因此是负数，取的补码，还是100，因此是-4，不清楚为什么aix下边这里都不一样

引用 2 楼 user-3 的回复:aix输出比较奇怪，按说应该是-4，-1，1 aix下，a占高3位，最高位为1，应该是-4，b占中间2位11，应该-1，C占低三位，结果1 x86下相反，应该是1 ， -1 ，-4   赵老师的就没看懂了。。。你说的这个-1 我能理解 是11，，，-4是怎么看的100怎么会解析为-4？

#include <stdio.h> #include <stdlib.h> char buf[17]; union U {   unsigned short int aa;   struct {     unsigned int bb:7;//(bit 0-6)     unsigned int cc:6;//(bit 7-12)     unsigned int dd:3;//(bit 13-15)   }; } u; void main() {                 //bbbbbbbbbbbbbbbb                 //iiiiiiiiiiiiiiii                 //tttttttttttttttt                 //111111                 //5432109876543210                 //::::::::::::::::     u.aa=0xE07F;//1110000001111111     printf("bb==%d,cc==%d,dd==%d\n",u.bb,u.cc,u.dd);     u.bb=0x41;     u.cc=0x21;//dddccccccbbbbbbb     u.dd=5;   //1011000011000001     printf("aa==0x%04X==%016s(2)\n",u.aa,itoa(u.aa,buf,2)); } //bb==127,cc==0,dd==7 //aa==0xB0C1==1011000011000001(2)


Question: ffmpeg教程的编译问题

楼主   什么环境变量？ 我也遇到了相同问题

应该不是这个原因，我编译安装成功了，用gcc -o tutorial01 tutorial01.c -lavutil -lavformat -lavcodec -lz -lavutil -lz执行教程的时候找不到头文件，所以您在回答我的问题的时候请慎重

./configure         make         su         输入root用户的密码         make install

在此谢谢的各位，虽然没有让我解决直接问题，但是给了我提示，我的是环境变量没有设好的原因。

不是很了解，关注，学习。

libavcodec下面有相应的头文件就是找不到阿，

tutorial01.c是ffmpeg提供的一个基于命令行的视频播放器 如果是要使用库的话，编译生成已经成功了，不需理会这个问题。 如果是为了验证代码的话，估计是路径不对

我前段时间刚好用过，不过只是限于命令，你可以先用ffmpeg的命令转码一个视频格式试试，ffmpeg -iout1.mp4 -s 1920*1080 -vcodec mpeg4 video.avi，看看你的av编解码库能不能用。另外库的环境变量你要看一下有没有导入

libavcodec 到这目录下看看有木有头文件，路径不对？

这不是忽悠人吗，那么在意积分，随便回帖不会招举报吗，我个人觉得信誉很重要，不懂不会帖就好了


Question: 定义一个宏，连接字符串用的

#define MADE_WORD(word) TEXT("ABCDEFG") TEXT(#word)

我不知道lz想要什么我写了这个 #include<stdio.h> #define STRING_HEAD "StringHead_" #define TEXT(x) STRING_HEAD#x #define JONNE(x) TEXT(Head_##x)  int main() { 	printf("%s\n",JONNE(aaa)); 	return 0; }

引用 1 楼 user-3 的回复:试试这个 #define MADE_WORD(word)        TEXT("ABCDEFG"#word) MADE_WORD( abc )  就能得到：  TEXT("ABCDEFG""abc");  和楼主的要求不是很一样，不过编译器应该会把这两个字符串合并成一个  谢谢！

再试试这个 #define MADE_TMP(word)         TEXT(#word) #define MADE_WORD(word)        MADE_TMP(ABCDEFG##word)


Question: 求指教！关于malloc函数，以及指针的问题（我想是的）

引用 15 楼 zhao4zhong1 的回复:printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。  在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 谢谢您的指教！！我稍微理解了道理，而且我觉得scanf跟输入的是“%c”还是“%d”有很大的关系，当输入“%c”的时候，就要以习性全部输入，当是“%d”的时候可以用循环每按一次换行就输入一个数！！太谢谢您了！！

Format Specification Fields: scanf and wscanf Functions A format specification has the following form:  % [width] [{h | l | I64 | L}]type  The format argument specifies the interpretation of the input and can contain one or more of the following:   White-space characters: blank (' '); tab ('\t'); or newline ('\n'). A white-space character causes scanf to read, but not store, all consecutive white-space characters in the input up to the next non–white-space character. One white-space character in the format matches any number (including 0) and combination of white-space characters in the input.   Non–white-space characters, except for the percent sign (%). A non–white-space character causes scanf to read, but not store, a matching non–white-space character. If the next character in stdin does not match, scanf terminates.   Format specifications, introduced by the percent sign (%). A format specification causes scanf to read and convert characters in the input into values of a specified type. The value is assigned to an argument in the argument list.  The format is read from left to right. Characters outside format specifications are expected to match the sequence of characters in stdin; the matching characters in stdin are scanned but not stored. If a character in stdin conflicts with the format specification, scanf terminates, and the character is left in stdin as if it had not been read.  When the first format specification is encountered, the value of the first input field is converted according to this specification and stored in the location that is specified by the first argument. The second format specification causes the second input field to be converted and stored in the second argument, and so on through the end of the format string.  An input field is defined as all characters up to the first white-space character (space, tab, or newline), or up to the first character that cannot be converted according to the format specification, or until the field width (if specified) is reached. If there are too many arguments for the given specifications, the extra arguments are evaluated but ignored. The results are unpredictable if there are not enough arguments for the format specification.  Each field of the format specification is a single character or a number signifying a particular format option. The type character, which appears after the last optional format field, determines whether the input field is interpreted as a character, a string, or a number.   The simplest format specification contains only the percent sign and a type character (for example, %s). If a percent sign (%) is followed by a character that has no meaning as a format-control character, that character and the following characters (up to the next percent sign) are treated as an ordinary sequence of characters, that is, a sequence of characters that must match the input. For example, to specify that a percent-sign character is to be input, use %%.  An asterisk (*) following the percent sign suppresses assignment of the next input field, which is interpreted as a field of the specified type. The field is scanned but not stored.

引用 12 楼 mujiok2003 的回复:[quote=引用 7 楼 u012686177 的回复:] [quote=引用 3 楼 user-4 的回复:] 输入q之后敲了个回车，被第二个scanf读到了。如果你用%d来输出*p，你会看到13 敲回车之前多输入几个字符就好了。 如果，我想循环输入多个字符，就不能像数组那样一个一个去接收吗？有没有改进的办法？[/quote] [/quote]  int n = 120; char* p = (char*)malloc(n) char fmt[64]; if(p) {   snprintf(fmt, 64, "%%%us", n-1); //%119s   scanf(fmt, p);  }

引用 12 楼 mujiok2003 的回复:[quote=引用 7 楼 u012686177 的回复:] [quote=引用 3 楼 user-4 的回复:] 输入q之后敲了个回车，被第二个scanf读到了。如果你用%d来输出*p，你会看到13 敲回车之前多输入几个字符就好了。 如果，我想循环输入多个字符，就不能像数组那样一个一个去接收吗？有没有改进的办法？[/quote]  int n = 120; char* p = (char*)malloc(n) char fmt[64]; if(p) {   snprintf(fmt, 64, "%%%u", n-1); //%119s   scan(fmt, p);  } [/quote]  scan --> scanf

引用 7 楼 u012686177 的回复:[quote=引用 3 楼 user-4 的回复:] 输入q之后敲了个回车，被第二个scanf读到了。如果你用%d来输出*p，你会看到13 敲回车之前多输入几个字符就好了。 如果，我想循环输入多个字符，就不能像数组那样一个一个去接收吗？有没有改进的办法？[/quote]  int n = 120; char* p = (char*)malloc(n) char fmt[64]; if(p) {   snprintf(fmt, 64, "%%%u", n-1); //%119s   scan(fmt, p);  }

引用 8 楼 u012686177 的回复:[quote=引用 5 楼 lovesmiles 的回复:] 应该是第一次输入时按多了一次回车引起的 如果，我想循环输入多个字符，就不能像数组那样一个一个去接收吗？有没有好的改进办法？请多多指教！[/quote] for(int i=0;i<6;i++) scanf("%c",&p[i]); 这样你就可以一次性输入6个字符了。就像数组一样

scanf("%s", p); 是读取一个字符串，直到输入空格或回车。 但是要小心，如果输入的字符个数超过了p的长度，会导致数组越界。

引用 7 楼 u012686177 的回复:[quote=引用 3 楼 user-4 的回复:] 输入q之后敲了个回车，被第二个scanf读到了。如果你用%d来输出*p，你会看到13 敲回车之前多输入几个字符就好了。 如果，我想循环输入多个字符，就不能像数组那样一个一个去接收吗？有没有改进的办法？[/quote] scanf("%s", p);

引用 5 楼 lovesmiles 的回复:应该是第一次输入时按多了一次回车引起的 如果，我想循环输入多个字符，就不能像数组那样一个一个去接收吗？有没有好的改进办法？请多多指教！

引用 3 楼 user-4 的回复:输入q之后敲了个回车，被第二个scanf读到了。如果你用%d来输出*p，你会看到13 敲回车之前多输入几个字符就好了。 如果，我想循环输入多个字符，就不能像数组那样一个一个去接收吗？有没有改进的办法？

引用 4 楼 user-4 的回复:[quote=引用 3 楼 user-4 的回复:] 输入q之后敲了个回车，被第二个scanf读到了。如果你用%d来输出*p，你会看到13 也可能是10，\r和\n的ascii码我总是分不清。 [/quote]告诉我，你们怎么可以这么厉害。。。我以为是4字节指针和char类型的一字节有什么冲突呢 。。。关键是，我发的帖子，你都回啊！！好感动啊，大神！虽然我只发了两个帖子。。。

应该是第一次输入时按多了一次回车引起的

引用 3 楼 user-4 的回复:输入q之后敲了个回车，被第二个scanf读到了。如果你用%d来输出*p，你会看到13 也可能是10，\r和\n的ascii码我总是分不清。

为什么我的第二次的scanf函数，在程序输入的时候，直接给我忽略了？？？

malloc/free要成对使用，分配了内存就要记得释放


Question: 求助各位大神。。。。。。。。

……这个，大小写转换函数只要百度一下就可以找到

# include <stdio.h> # include <ctype.h>   int main(void) { 	char buffer[20]; 	int i = 0;  	printf("请任意输入20个字符:\n"); 	gets(buffer);  	while(buffer[i] != '\0') 	{ 		buffer[i] = toupper(buffer[i]); 	    i++; 	}  	puts(buffer);  	return 0; }  哈哈，终于搞定了。。加油！！！


Question: Linux系统下关于环境变量的问题

环境变量每个进行都有，可能会改变。想一直改变要修改一个文件。

getenv()返回的指针指向的地方被strtok改了，strtok 不安全，建议楼主换成strtok_r，如果期望getenv()不被改，需要另外 给strtok_r提供两个buffer来分割，一个是目标buffer存拷贝的env，另外一个buffer给strok_r内部使用

对函数getenv()的调用一直在一个进程中呀

环境变量在每个进程数据中都保存一份。


Question: 我要排出这个成绩表的名次，但是为什么会这样？

引用 9 楼 lovesmiles 的回复:你的文件里面有没有名次这个数据，如果有，在输入时应该加上 fscanf(fp,"%s\t%d\t%d\t%d\t%d\t%d\t%d",StudentName[Cur],&StudentScores[Cur][0],&StudentScores[Cur][1], &StudentScores[Cur][2],&StudentScores[Cur][3],&StudentScores[Cur][4],&StudentScores[Cur][5]);  打印时也加上 printf("%s\t%2d\t%2d\t%2d\t%d\t%d\t%d \r\n", StudentName[Cur],StudentScores[Cur][0],StudentScores[Cur][1], StudentScores[Cur][2],StudentScores[Cur][3],StudentScores[Cur][4],StudentScores[Cur][5]); 如果没有就只有这样可以得出正确名次吗？ 这是刚才的第一段表名次好像不行

引用 7 楼 lovesmiles 的回复:那就加1，自己改一下都不会？ printf("%s\t%2d\t%2d\t%2d\t%d\t%d\t%d \r\n", StudentName[Cur],StudentScores[Cur][0],StudentScores[Cur][1], StudentScores[Cur][2],StudentScores[Cur][3],StudentScores[Cur][4],Cu+1r); 不是，这两段表是一样的，上面一段是乱序同时把名称打出来；下面一段是把上面的排了名次和分数！！现在是要把下面的表顺序还原，名次也要正确的意思

引用 4 楼 lovesmiles 的回复:printf("%s\t%2d\t%2d\t%2d\t%d\t%d\t%d \r\n", StudentName[Cur],StudentScores[Cur][0],StudentScores[Cur][1], StudentScores[Cur][2],StudentScores[Cur][3],StudentScores[Cur][4],Cur);   打印时少了一个参数 名次变这样也不对

引用 2 楼 slx_391987 的回复:麻烦楼主详细说下遇到的问题。 我觉得排序结果是正确的，没什么问题。 但是名次好像有点问题啊

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

麻烦楼主详细说下遇到的问题。 我觉得排序结果是正确的，没什么问题。


Question: bios build 报错，希望高手指点，谢谢

@zhao4zhong1 请问你是在帮我翻译错误信息吗？

谢谢。我是有一个从外设读data的函数，主函数会从那取值，我有点混乱，在bios的C程序中，函数调用到底怎么用？是不是在主函数里，还是要去定义一个相似的变量，或者可以直接拿来用？

有一个链接错误，某变量没有被找到，你确实变量定义的文件已经加入编译项里了吗？

项目、属性、链接器、常规、附加库目录：填写附加依赖库所在目录 分号间隔多项 项目、属性、链接器、输入、附加依赖项：填写附加依赖库的名字.lib 空格或分号间隔多项


Question: 关于暴力破解XLS文件加密密码

引用 楼主 u012735433 的回复:excel中有一个功能是加密文件，需输入密码才能进行文件的修改等操作，需要用C语言编程实现破解EXCEL的密码，采用的是暴力解密的思想，有哪位大神能帮忙分析一下 似乎不用暴力破解，改一下文件中的某一处就好了。 xls里面的VBA源码加密就是这样的。 真正文件里面倒是不知道。。。

这要看加密使用的是什么算法了，对于AES或者 3DES之类的著名加密算法的话，只要密钥足够复杂，你就破解不了。 当然，如果密码比较弱，正好在你暴力破解所使用的字典里的话，还是能破解的。

搜搜看，有现成的破解软件。


Question: SHRD高精度移位如何转换成C语言?

#include <stdio.h> int main () {     int v=0x12345678;     __asm {         mov eax,v         mov eax,0x12345678         rol eax,16         mov v,eax     }     printf("0x%08x\n",v);//0x56781234     return 0; }

int main (int argc, char argv[]) { int dest = 0x12345678; int src = 0x13572468; 	__asm { 		pushad 			mov eax,dest 			mov edx,src		 			shrd eax,edx,16 			mov dest,eax 			popad 	} 	printf("%d",dest); }


Question: 关于宏定义和位段的一个题，前几天笔试时遇到的，智商捉急！百度上没搜到

引用 7 楼 zhao4zhong1 的回复:仅供参考#include <stdio.h>  #define WIRTE_UINT(des ,x ,pos ,len)  (                                   \     (des)                                                                 \     &                                                                     \        ~(                                /* 除要修改的位为0，其余都为1 */ \             (                                                             \                 (1<<(len))-1             /* 长度为len位的1             */ \             )                                                             \             <<(32-(pos)-(len))           /* 左移32-(pos)-(len)位       */ \         )                                                                 \     |                                                                     \         (                                                                 \             (x)                                                           \             <<(32-(pos)-(len))                                            \         )                                                                 \ ) #define READ_UINT(src ,pos ,len)      (                                   \     (                                                                     \         (                                                                 \             (unsigned)(src)                                               \         )                                                                 \         >>(32-(pos)-(len))               /* 逻辑右移32-(pos)-(len)位   */ \     )                                                                     \     &                                                                     \     (                                                                     \         (1<<(len))-1                     /* 长度为len位的1             */ \     )                                                                     \ )  int main()                              //                1111111111222222222233 {                                       //bit   01234567890123456789012345678901     unsigned int des = 0x661;           //      00000000000000000000011001100001     unsigned int r;      des = WIRTE_UINT(des ,3 ,28 ,2);    //      00000000000000000000011001101101     printf("des==0x%08X\n",des);     r = READ_UINT(des ,28 ,2);     printf("r==%d\n",r);     return 0; } //des==0x0000066D //r==3 这代码看着真蛋疼。。。

似乎没人考虑过要将十进制表示的v转成2进制表示的v?

#define msb_cn( x,n)  (((x) >>(n)) <<(n))           //后 n bits清零，保留前 sizeof (x) -n bits #define lsb_cn( x,n)  (((x) <<(n)) >>(n))           // 前 n后 n bits清零,保留后 sizeof (x) - n bits #define msb_n(x,n)   msb_cn((x),sizeof(x)*8 -(n))   //保留前 n bits，前 sizeof (x) -n bits 清零 #define lsb_n( x,n)  lsb_cn((x),sizeof(x)*8 -(n))   //保留后 n bits, 前 sizeof (x) - n bits 清零  #define replace_mn(a,v,m,n) (msb_cn((a),(m))       \                              | ((m) > (n)? lsb_n((a),((m)-(n))):0)  \                              | (lsb_n ((v),(n))<<((m)-(n))))

说错了，还是用了一个加法。。。。。。。。。

在这里我没改变那4个参数，而是把replace当成一个函数，它的返回值就是你需要的。

#define replace(a,v,m,n) (((~((~0)<<n))&v)<<m)|((~((~((~0)<<(m+n))>>m)<<m))&a)  我不用减法，全部用位运算来实现。基本思想是一样的，只是操作起来不同。

基本思路就是先用一个&把a的对应n位清0，再用一个|把v填到对应n位里面。 以n=4为例，1<<4得到10000，再减1得到1111，这就得到了一个4位的mask。把这个mask左移m位再取反，和a与一下就把a里面从m开始的n位都清0了。v和这个mask与一下再左移m位，就把v移到了需要的位置，和a或一下就填到a的对应位里面了。

#define replace(a,v,m,n) a = (a & ~(((1<<(n))-1)<<(m))) | (((v)&((1<<(n))-1))<<(m))


Question: 有关大小端问题

把内存想象成楼房，每层有八间房（一个字节）每四位一个十六进制数 存储顺序是这样的（上面的地址大）： 7  8                            对应的2进制    0111  1000 5  6                                                      0101  0110 3  4                                                      0011  0100 1  2                                                      0001  0010

计算机组成原理→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对应的汇编并单步执行观察相应内存和寄存器变化。）

在联合体中，各元素共用同一块内存，这些元素的地址是一样的，都是整个联合体的低地址（联合体的起始位置）。 如果是小端，那么a/b的内存如下： 低地址-------->高地址 78     56     34     12 |<-------a------------>| |<---b--->| 如果是大端，那么a/b的内存如下： 低地址-------->高地址 12     34     56     78 |<-------a------------>| |<---b--->|  所以，可以根据给a赋值后看b的值是多少，就可以看出大小端。

因为short也是小端    int 0x12345678 存储为： 地址：11       12     13     14 存储 ：0x78  0x56 0x34 0x12  short取低2位  11和12 地址：11       12      存储 ：0x78  0x56  这不就是 0x5678的存储吗

在纸上画画内存分布。自己再写个程序调试下。

数据的高/低位 与 内存的高/低地址。 0x12345678 小端下的内存存储模式是 78|56|34|12 , 取低位2个字节变为数据模式为0x5678

规定。。。。

大小端只是电脑记录方式而已，它表达出来的东西还是按正常的思路去想的。  5678存到电脑里面，不管它是大端还是小端，你叫电脑输出给我们看时，它永远是输出5678。它内部怎么表示没影响。


Question: 关于链表的问题，问题很简单，只是我搞不掂，所以来送分啦！

你的head不是一个指针，而是一个变量，看清楚没有？不存在野指针的问题，因为你声明它时都没有加上*号，它是一个变量

引用 6 楼 zhaozhaohelu 的回复:[quote=引用 4 楼 lovesmiles 的回复:] CreatNodeList  That is not Right, you can remove it.是因为我NODE head={0};了之后就没必要再开空间给他的缘故么？可是我不给他赋值的话又在担心野指针。[/quote] 你这个操作已经是给它赋值了。让它的num和next的值都为0了。你的ctreat函数完全不起作用。因为参数只能改变指针指的值，不能改变指针本身。 这个函数运行结束后反而引起了内存泄漏。head还是指向了原来的{0}。 好好思考一下你的代码吧。

引用 4 楼 lovesmiles 的回复:CreatNodeList  That is not Right, you can remove it.是因为我NODE head={0};了之后就没必要再开空间给他的缘故么？可是我不给他赋值的话又在担心野指针。

引用 2 楼 Evankaka 的回复:/创建链表的数据结构 typedef struct NODE { int num; NODE * pNext; }; //生成表头 void CreatNodeList(NODE * head) { if (NULL != head) return; head = (NODE *)malloc(sizeof(NODE)); head->pNext = NULL; }  //插入节点 void InsertNodeList(NODE * head) { NODE * InserNode = (NODE *)malloc(sizeof(NODE)); if (InserNode == NULL) { return ; } InserNode->num = rand()%11; InserNode->pNext = head->pNext; head->pNext = InserNode;  } //显示节点信息 void ShowNodeList(NODE * head) { while (head->pNext != NULL) { head = head->pNext;////你的头节点NUM没赋值，为0,所以你每次都会输出0.,把这句提前就可以了 cout<<head->num<<" ";  } cout<<endl; } int main() { srand(time(0)); NODE head={0}; CreatNodeList(&head); for (int i=0;i<10;i++) { InsertNodeList(&head); } ShowNodeList(&head); return 0; }我这应该算是找到了问题，找不到方法吧，呵呵。

引用 1 楼 orangeholic 的回复:head节点被打印出来了   而且还漏掉一个节点  用下面这个  //显示节点信息 void ShowNodeList(NODE * head) { 	head=head->pNext; 	while (head) 	{ 		cout<<head->num<<" "; 		head = head->pNext; 	} 	cout<<endl; }NICE。


Question: C语言操作数据库文件

引用 2 楼 lovesmiles 的回复:XLS文件转为.DBF文件之后，格式根本就不是数据库的格式  这一步你是怎么做的？你确定转换了？ 可能当时是不太了解数据库文件格式，不好意思，现已成功转换。格式应该是正确的，不过还没有实际去读取。希望能告知C语言读写access数据库方法？谢谢！

引用 5 楼 zhao4zhong1 的回复:建议楼主学习ADO和SQL Server 你好！我想使用access数据库，如果使用C语言操作ACCESS数据库的话，具体需要向哪方面了解？

建议楼主学习ADO和SQL Server

使用COM读写.xls文件， 使用visual fox的ODBC/ADO/Ado.net等来操作.dbf文件  不要企图理解xls.dbf格式。

我不想开帖，求ODBC API封装的数据库类，最近工作要用这个东西。百度的东西我都看过了，不要COPY啊。

是否可以使用EPPLUS插件来操作 xls,


Question: 函数指针疑问

不要纠结是书上的哪些，写代码时，函数直接调用，或者是使用指向函数的指针直接调用就行，加不加*都一样，记住这一点即可。      最后，结贴吧！

不太明白你意思。按照猜测，你可能是觉得1.书本上讲会对指针进行解引用（编译器去做），2. 帖子上讲不需要解引用，编译器需要的是指针。1和2矛盾 是这样的吗？  没看出来前后矛盾啊。 编译器拿函数指针去做解引用的工作，你需要做的只是使用函数指针直接调用就可以了。 这不是很合情合理吗？

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

把下面代码跑一遍你就明白了： #include <iostream>  void func()  { 	 printf("func\n");  } int main() { 	func();    (*func)();    (**func)();    (***func)();    getchar();     return 0; }  在vc2008测试通过。对函数指针做* 操作,做100 次也没有意义，完全没有意义.....

不明白你想要解释什么啊 你的前后表述没有矛盾啊  函数指针， 可以跟别的指针一样 取地址或者解引用 但是也可以不需要，  因为函数不同于别的变量， 他本身就可以是一个地址


Question: 函数形参定义和初始化是否是在第一次被调用时进行的？

围观。。。。

函数参数。 在函数调用时，初始化（这就是参数传递） 函数调用结束的时候，参数结束生命周期。  函数执行过程大概如下  函数每次调用，先对参数初始化（完成参数传递）， 然后（把下一条指令的地址存入堆栈，这个地址就是函数的返回地址），跳入函数内部执行， 执行完毕，函数返回调用处，  ret 指令 通过堆栈中保存的函数返回地址， 跳回调用函数的地方， 继续执行---执行地址被保存到的那条指令。  此时函数参数，结束历史使命，他的生命周期，也就结束了。 函数 int fun(int a,int b,int c，int d);  fun(x,y,z,w) 【 push w push z push y push x   call  fun           //== push nextcode                            //       jump fun nextcode: sub esp, 8        】  fun  【  ret // <===> jump esp 【nextcode_addr】 <===>jum nextcode 】  C 调用约定 : 调用者清栈， 清栈语句是 sub  esp,n;  返回语句是 ret ;  标准调用约定:  被调函数清栈， 清栈和返回语句是 ret  n;

看下反汇编就知道了，就是一个push

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！  单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  指针即地址 引用即别名

同意楼上的回答

应该说是“每次”调用的时候吧。 函数的参数，只在这个函数运行的时候有效，函数返回之后就失效了，每次进入这个函数都要从头再来一遍。 int a = 9; test( a);   /*   函数是在这时被调用的，才给b赋值 */ int c = 90; test( c);   /*   再次给b赋值 */


Question: 定义的位数   在结构体中  unit32_t a:5  这样a是32位还是5位？

引用 5 楼 slx_391987 的回复:回答4楼问题：  假如再来一个unsigned int ee， 是隔16位再算32位。 因为是32位，4字节对齐，int(unsigned int) 的开始地址是4字节的倍数。  再请教一下。如果我定义成 short ee； 如果short是16位。 他会占用32位剩下的16位，还是为了字节对齐重新在一个32位中使用16位？  我的理解应该是后者。 因为字节对齐对系统操作比较简单一些。

假设int是32位。 假如再来一个unsigned int ee; 这个ee会接着dd 再算32位吗，还是隔16位再算32位。 （之所以说隔16位是因为bb cc dd加起来是16位，如果为了int对齐的话，就要再隔16位）  引用 3 楼 zhao4zhong1 的回复:#include <stdio.h> #include <stdlib.h> char buf[17]; union U {   unsigned short int aa;   struct {     unsigned int bb:7;//(bit 0-6)     unsigned int cc:6;//(bit 7-12)     unsigned int dd:3;//(bit 13-15)   }; } u; void main() {                 //bbbbbbbbbbbbbbbb                 //iiiiiiiiiiiiiiii                 //tttttttttttttttt                 //111111                 //5432109876543210                 //::::::::::::::::     u.aa=0xE07F;//1110000001111111     printf("bb==%d,cc==%d,dd==%d\n",u.bb,u.cc,u.dd);     u.bb=0x41;     u.cc=0x21;//dddccccccbbbbbbb     u.dd=5;   //1011000011000001     printf("aa==0x%04X==%016s(2)\n",u.aa,itoa(u.aa,buf,2)); } //bb==127,cc==0,dd==7 //aa==0xB0C1==1011000011000001(2)

short 会占用32位剩下的16位.

二楼正解，我就不多说了

1 a是5位， 但是内存分配了32位， 他后面的类似变量可以 使用32位中的后续内存  2 根据成员的定义顺序 从一个int的低位开始使用  3 节省内存， 比如你有 32个开关， 只需要一个int，不需要32个int  4 非结构体 应该不能用吧 关键是 用了也没意义啊， 不能达到多个变量共用一个 int内存的 目的


Question: 结构体菜鸟问题

Typedef 定义的是一个指针类型    Link是指针。在main函数中，Link link定义了一个指针，这是一个野指针，它没有指向有效的内存区域（没有定义结构体变量，分配内存空间），对  link->i  赋值时会出现段错误。

typedef struct PNode{     int i;     struct PNode * next; }*Link; Link是指针类型  Link link;你声明了一个指针变量，需要你给它分配内存。

仅供参考//带表头结点的单向链表 #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-> //

#include<stdio.h> #include<stdlib.h>  typedef struct PNode{ 	int i; 	struct PNode * next; }*Link;  int main() { 	//这里这是定义Link结构体的类型的一个变量而已，并没有指向真正的物理地址 	Link link = (Link )malloc(sizeof(Link));  	link->i=10; 	printf("%d\n",link->i); 	 	return 0; }

引用 4 楼 brookmill 的回复:c语言要用malloc/free，c++用new/delete #include <stdlib.h> int main() {     Link link = (Link)malloc(sizeof(*link));     link->i=10;     printf("%d",link->i);     free(link);     return 0; }啊哈哈，malloc+free是个好习惯 我下次注意。

#include <iostream> using namespace std; typedef struct PNode{ 	int i; 	struct PNode * next; };  int main() { 	PNode * link = (PNode *)malloc(sizeof(PNode)); 	link->next = NULL; 	link->i=10; 	printf("%d\n",link->i);  	return 0; }  我是这么写的。

你为嘛不给你的结构体开内存呢？

首先你要明白typedef的意思，它是给一个数据类型取别名。还有后面main里面，你要明白自己定义的是指针还是变量，指针访问要用——>，一般变量用的是‘.’。

å#include<stdio.h>       typedef struct PNode{     int i;     struct PNode * next; }Link;   ／／这处修改   int main() {         Link link;  ／／这样这里不在是指针，实际分配了内存空间       link.i=10;  ／／这里修改     printf("%d",link.i);  ／／这里修改           return 0; }  指针没有理解好。推荐看一下《c和c指针》。

引用 3 楼 younkerjqb 的回复:#include<stdio.h>    typedef struct PNode{ 	int i; 	struct PNode * next; }Link;  int main() {   	Link link;  	link->i=10; 	printf("%d",link->i); 	 	return 0; } 把那个*去掉就可以了 *去掉，link->i 就出错了！

编译错去提示是什么？ turbo C 编译没错误。 另外你确实需要给link分配存储空间，否则会踩了别人的内存。

编译不通过啊

#include<stdio.h>  typedef struct PNode{ 	int i; 	struct PNode * next; }*Link;  int main() { 	 	 	Link link = new PNode; 	 	link->i=10; 	printf("%d",link->i); 	 	return 0; }  要对 link 开辟空间，才能存储数据。


Question: 《计算机组成原理》----对内存对齐的理解

引用 2 楼 truelance 的回复:LZ你的问题是什么?求帮忙找错

引用 2 楼 truelance 的回复:LZ你的问题是什么?求帮忙找错

引用 2 楼 truelance 的回复:LZ你的问题是什么?求帮忙找错

引用 7 楼 misskissC 的回复:[quote=引用 6 楼 truelance 的回复:] 4个这样的存储器，要么4位地址线32位数据线，要么16位地址线8位数据线。没法支持16位地址线32位数据线。  是的。4 x (2^4  x 8 )  !=  2^16 x 32[/quote] 将其M改为4地址线32位数据线。

引用 6 楼 truelance 的回复:4个这样的存储器，要么4位地址线32位数据线，要么16位地址线8位数据线。没法支持16位地址线32位数据线。  是的。4 x (2^4  x 8 )  !=  2^16 x 32

引用 9 楼 lovesmiles 的回复:[quote=引用 6 楼 truelance 的回复:] 4个这样的存储器，要么4位地址线32位数据线，要么16位地址线8位数据线。没法支持16位地址线32位数据线。  应该也没有到16位地址线，4片内存块只需要加2条线就可以确那片被选中了。 所以应该是6条位地址线就可以确定8位的数据。   如果是要一次读出32位的数据，地址线不用增加，片选中默认打开，只要4条就可以了。   观察存储器M的结构（第一行地址为0），只要将变量的地址分配到此变量所占内存大小（以字节为单位）的整数倍上  这句也有点问题，应该是分配到以字为单位(32bit)的地址上才合理。  [/quote] 1. 应该也没有到16位地址线，4片内存块只需要加2条线就可以确那片被选中了。 所以应该是6条位地址线就可以确定8位，16位，32位的数据。  2. 观察存储器M的结构（第一行地址为0），只要将变量的地址分配到此变量所占内存大小（以字节为单位）的整数倍上  这句也有点问题，应该是分配到以字为单位(32bit)的地址上才合理。  如占16位的变量只需要分配到以半字（16位）的地址上即可。

引用 6 楼 truelance 的回复:4个这样的存储器，要么4位地址线32位数据线，要么16位地址线8位数据线。没法支持16位地址线32位数据线。  应该也没有到16位地址线，4片内存块只需要加2条线就可以确那片被选中了。 所以应该是6条位地址线就可以确定8位的数据。   如果是要一次读出32位的数据，地址线不用增加，片选中默认打开，只要4条就可以了。   观察存储器M的结构（第一行地址为0），只要将变量的地址分配到此变量所占内存大小（以字节为单位）的整数倍上  这句也有点问题，应该是分配到以字为单位(32bit)的地址上才合理。

LZ你的问题是什么?

从物理结构上理解对齐。


Question: 思维程序化了，肿么办？

人类一思考，上帝就发笑。

多看书，多向大家请教，多跟身边人交流，跨领域交流！

引用 2 楼 lovesmiles 的回复:后来，写多了，看多了别人的代码，  我不太认同你的这些说话，记得有句话说的，“如果你觉得自己是因为看的书太多而变得肤浅，那是因为你看的书还不够多。”   王国维说到的为学的三种境界是:  1.昨夜西风凋碧树,独上高楼,望尽天涯路  2.衣带渐宽终不悔,为伊人消得人憔悴  3.众里寻她千百度,莫然回首,那人却在灯火阑珊处.   一个人如果真正到了独上高楼，望尽天下路（掌握自己领域内的所有知识）的境界时，应该是很孤独的感觉的。  别浮燥，多看点书，再深入一点，你就会得到莫大的快乐。

我觉得交个女朋友，可以解决这个问题。


Question: 求大家帮我看看13整除的代码哪里错了

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

引用 4 楼 brookmill 的回复:s=abs(atoi(b)-atoi(c));  这里的b只比a短3位而已，a最长到80的情况下b同样也是超出了atoi的范围。 我随便写了一段，不知道对不对，我自己试了一些数好像还行： 128396511965064616  // Yes 128396511965064613  // No 16049382683950649382683945  // Yes 16049382683950649382683946  // No #include<stdio.h> int main() {     char a[128];     int T, s;     char *p;     scanf("%d",&T);     while(T-- > 0)     {         s = 0;         scanf("%s", a);         for (p = a; *p != '\0'; p++)         {             s = (*p - '0' + s * 10) % 13;         }         if(s%13==0) printf("Yes\n");         else printf("No\n");     }     return 0; }  可行，这题目就是要求用字符串操作来处理运算操作，不能转换成数字(会内存溢出的)来操作，

数据这么大，必须用大数才行啊

其实也可以不用大数，直接算1%13 10%13,100%13.....13次方内必然可以循环，因为80不大，直接开一个数组记录模13的余数也可以

验差可以偷个小懒， 位数>n位的不用验算,例如n=4，n=8  对于int 为 4Bits 的系统 可以在小于9，8 位十位数的时候，直接转换成 int 类型，验算(直接用除法计算) 对于int 为 4Bits 的系统 可以在小于4位十位数的时候，直接转换成 int 类型，验算 (直接用除法计算)

1 ）用大数除法 2）用截尾法 不论如何都是大数运算 被13整除：  若一个整数的个位数字截去，再从余下的数中，加上个位数的4倍，如果差是13的倍数，则原数能被13整除。如果差太大或心算不易看出是否13的倍数，就需要继续上述「截尾、倍大、相加、验差」的过程，直到能清楚判断为止。

for(i=0;i<l-3;i++) b[i]=a[i]; b[i+1]='\0'; for(j=0;i<l;i++)     c[j]=a[i]; c[i+1]='\0';  首先i+1都改i。其次你l=80的时候l-3是77，这itoa不是一样会爆？

引用 1 楼 brookmill 的回复:if(i/*这应该是l吧*/<=3) 是错了但是改了后还是不对啊。。。应该是字符串长度有问题吧


Question: 有关共用体的内容，通过一个程序来确定长变量的存储顺序

2. char类型是有符号的8位，0x88是负数，符号位为1，按%p输出是扩展为32位，按符号位扩展，前面全都填充符号位 5. 现在的主流编译器，int都是4个字节了。

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

引用 5 楼 hustcyb 的回复:大哥，%p是用来输入指针地址的，你后面三个输出相当于将联合体的内容转成指针了，对目前大多数机器（32位机）而言，指定是占四个字节的  基础太差了，感谢指教

引用 4 楼 zhao4zhong1 的回复:#include <stdio.h> #include <stdlib.h> char buf[17]; union U {   unsigned short int aa;   struct S {     unsigned int bb:7;//(bit 0-6)     unsigned int cc:6;//(bit 7-12)     unsigned int dd:3;//(bit 13-15)   } s; } u; void main() {                 //bbbbbbbbbbbbbbbb                 //iiiiiiiiiiiiiiii                 //tttttttttttttttt                 //111111                 //5432109876543210                 //::::::::::::::::     u.aa=0xE07F;//1110000001111111     printf("bb==%d,cc==%d,dd==%d\n",u.s.bb,u.s.cc,u.s.dd);     u.s.bb=0x41;     u.s.cc=0x21;//dddccccccbbbbbbb     u.s.dd=5;   //1011000011000001     printf("aa==0x%04X==%016s(2)\n",u.aa,itoa(u.aa,buf,2)); } //bb==127,cc==0,dd==7 //aa==0xB0C1==1011000011000001(2)   姜是老的辣！受教了！感谢赵老师的参考代码

引用 3 楼 user-4 的回复:关于第3，4点，你可以搜下什么是大端（big-endian）/小端(little-endian), 这个取决于你的机器  嗯，仔细看过存储顺序的有关资料，我的机器是intel i3，所以是小端存储，也就是低位字节存入低地址，其实我是不确定我这个程序是否能满足题目的要求，有些不明白这个题目到底想表达什么


Question: 我做的是ArcGis的shape文件导入到MDB库,出现Access文件共享锁数溢出的情况

引用 1 楼 zhao4zhong1 的回复:先导出到纯文本.csv文件，再从.csv文件导出到.mdb   谢谢谢你的帮助，问题已经解决，修改注册表即可。。。。。。

先导出到纯文本.csv文件，再从.csv文件导出到.mdb


Question: 大一新手求教c语言

引用 5 楼 ws_54321 的回复:我试过改float 和double,不过输入输出都用的%f。用double输100得-17.000，用float输什么都是0.000 用float和%f应该也是可以的。 如果要求输入和输出都是整数，那么3楼和4楼的方法比较好，建议楼主也试试。

引用 2 楼 brookmill 的回复:类型改了之后,scanf和printf的格式也都要改： int -- %d float -- %f double -- %lf 只上了3节课，代码写成这样真的很不错了 @brookmill 用了double 和%lf，现在成功啦！

我刚又试了下double 和%lf的方法，成功了！谢谢你啊！

使用c语言自动（隐藏）转化， celsius=5*1.0 * ((float)fahr - 32) / 9; fahr= 1.0*celsius / 5 *9 +32;

还有一个办法，不改动变量类型，但是强制他做浮点运算。 其他地方都不动，改这两处： celsius=5 * (fahr - 32.0) / 9; fahr= celsius / 5.0 *9 +32; 或者 celsius=5 * ((float)fahr - 32) / 9; fahr= (float)celsius / 5.0 *9 +32;

int celsius,fahr; 把int改成float或者double int类型是整数，整数的各种运算包括除法也都是整数，比如3/2=1