Question: 请教：这个代码的segmentation fault 在哪里？

引用 7 楼 max_min_ 的回复:  while(cnt_1 <= SIZE && fgets(names_1[cnt_1], MAX, fp1) != NULL)     {         pnames_1[cnt_1] = names_1[cnt_1];        // 这里都没有分配内存的，你定义的数组指针的，有SIZE指针而已，但是每个指针都没有分配内存              pnms_1[cnt_1] = nms_1[cnt_1];    // cnt_1的值有是是不能等于cnt_1的，但是while是可以的，所以这里也可能导致越界的危险         cnt_1++;     }     while(cnt_2 <= SIZE && fgets(names_2[cnt_2], MAX, fp2) != NULL)     {         //这里的错误和上面的类似。自己修改过来吧！每个数组指针，每个指针都分配内存过去         pnames_2[cnt_2] = names_2[cnt_2];         pnms_2[cnt_2] = nms_2[cnt_2];         cnt_2++;     }  谢谢指教。我没有分配空间，但我有让指针指向已经分配了空间的数组。如果给指针数组分配了空间，那这个数组里的指针就有了自己空间了，也就是说它们自己也成为了数组了。这样它还能影响到它所指向数组吗？

中文名字要考虑编码方式哦。

引用 5 楼 lunat 的回复:数组访问越界：  while(cnt_1 <= SIZE && fgets(names_1[cnt_1], MAX, fp1) != NULL) 改为： while(cnt_1 < SIZE && fgets(names_1[cnt_1], MAX, fp1) != NULL)   while(cnt_2 <= SIZE && fgets(names_2[cnt_2], MAX, fp2) != NULL) 改为： while(cnt_2 < SIZE && fgets(names_2[cnt_2], MAX, fp2) != NULL)   另外建议在使用指针数组之前先初始化，例如： memset(&pnames_1, 0, sizeof(pnames_1)); 谢谢！你指出的问题确实存在，但改了之后问题依旧。真是头疼了！

引用 10 楼 lunat 的回复:添加打印信息，看最后输出打印的地方在哪里，缩小问题范围，有助于分析;  for(i = 0; i < cnt_1; i++)         for(j = 0; j < cnt_2; j++)             if(strcmp(nms_1[i], nms_2[j]) == 0)             {                 fnd[i] = nms_1[i];                 cnt_fnd++;             }  这里面的fnd[i] = nms_1[i];改为： fnd[cnt_fnd] = nms_1[i]; 此是正解！谢谢！

你自己设个断点看看，这个应该会的吧？自己跟进去，单步调试。

我修正了一些错误，但主要的segmentation fault：  #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h>  #define SIZE 60 #define MAX  20  int main(void) {     char names_1[SIZE][MAX];     char names_2[SIZE][MAX];     char * pnames_1[SIZE], * pnames_2[SIZE];     char nms_1[SIZE][MAX];     char nms_2[SIZE][MAX];     char * pnms_1[SIZE], * pnms_2[SIZE];     char * fnd[SIZE];     int cnt_1 = 0, cnt_2 = 0, cnt_fnd = 0;     int i,j;     FILE *fp1, *fp2, *fp3;      if((fp1 = fopen("list1.txt", "r")) == NULL)     {         fputs("Error reading \"listing1.txt\".", stderr);         exit(1);     }     if((fp2 = fopen("list2.txt", "r")) == NULL)     {         fputs("Error reading \"listing2.txt\".", stderr);         exit(1);     }     if((fp3 = fopen("results.txt", "w")) == NULL)     {         fputs("Error writing \"results.txt\".", stderr);         exit(1);     }     while(cnt_1 <= SIZE && fgets(names_1[cnt_1], MAX, fp1) != NULL)     {         pnames_1[cnt_1] = names_1[cnt_1];         pnms_1[cnt_1] = nms_1[cnt_1];         cnt_1++;     }     while(cnt_2 <= SIZE && fgets(names_2[cnt_2], MAX, fp2) != NULL)     {         pnames_2[cnt_2] = names_2[cnt_2];         pnms_2[cnt_2] = nms_2[cnt_2];         cnt_2++;     }      for(i = 0; i < cnt_1; i++)     {         while(*(pnames_1[i]) && !isspace(*pnames_1[i]))         {             *pnms_1[i] = *pnames_1[i];             pnames_1[i]++;             pnms_1[i]++;         }         * pnms_1[i] = '\0';     }     for(i = 0; i < cnt_2; i++)     {         while(*(pnames_2[i]) && !isspace(*pnames_2[i]))         {             *pnms_2[i] = *pnames_2[i];             pnames_2[i]++;             pnms_2[i]++;         }         * pnms_2[i] = '\0';     }     for(i = 0; i < cnt_1; i++)         for(j = 0; j < cnt_2; j++)             if(strcmp(nms_1[i], nms_2[j]) == 0)             {                 fnd[i] = nms_1[i];                 cnt_fnd++;             }     if(cnt_fnd > 0)     {         for(i = 0; i < cnt_fnd; i++)         {             fputs(fnd[i], fp3);             putchar('\n');         }         fprintf(fp3, "\n%d found.", cnt_fnd);     }     else         fputs("\nNo results found.", fp3);     printf("\n%d\n", cnt_fnd);     puts("\nDone!");     fclose(fp1);     fclose(fp2);     fclose(fp3);      return 0; }

segmentation fault非法读写内存  多为  1 指针未初始化 2 数组越界 导致

出现的问题的时候没有断住吗？


Question: c语言链表中的文件问题

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试是程序员必须掌握的技能之一。

n = sizeof(*fp)错了，n不是那个文件的大小，而是FILE的大小。FILE在C里面自己有一个结构体，主要记录的是缓存区的一些信息。你要取整个文件大小的话估计要读取一遍把。不然你直接依次读取一个struct inf大小，结束判定条件是是否为空。

n=sizeof(*fp);获取到的就不是文件大小！

ftell(fp)应该可以！

n=sizeof(*fp); 应改为 n=_filelength(_fileno(fp));//仅windows下

rb是以二进制的方式读取文件。留住存放的时候是以这种形式存放的嘛？而且存储的结构体 楼主没有贴出代码，不知道是不是定长，或者结构体对齐。 如果楼主是手动写的文件，一行一条的话 那就直接以r的方式打开。 用fscanf就可以了。

"sizeof不能测fp所指向的全体的大小吗？"  sizeof(*fp)不能测fp所指向的全体的大小。sizeof(*fp)返回类型FILE的大小。  以下代码可得到fp所指向的文件的大小：    fseek(fp, 0L, SEEK_END);   n = ftell(fp);//n是文件的字节总数   fseek(fp, 0L, SEEK_SET);

文件里2进制数据是整个结构大小的若干倍数，字符数组部分比实际使用量要大，所以你会看到一些多于的东西，不过正常操作之下没影响。另外，你要重新申请空间再读入数据，文件里原有的next数据过时无效的，不可以直接引用，得用新申请的空间地址替换...

那这个问题呢： 一个文件里有n个结构体，想把这写结构体从文件中读出并打印到屏幕上，如果写成： while(fread==1) {     fread(p,sizeof(struct inf),1,fp);     p=p->next; } /*p,struct 之前均有定义*/ 所有p不是都一样的吗？ 还有还有，为什么打在屏幕上正常的东西在文件里看就是“屯屯屯”呢

换个思路，不管文件大小，也不fseek，循环检测fread的返回值不是1就停止...

不知道这样对不对  fseek(fp,0,SEEK_SET); fseek(fp,0,SEEK_END); long longBytes=ftell(fp);// longBytes就是文件的长度

那怎么测指针所指向内容所占字节数呢？

貌似sizeof（*fp），这是在计算一个指针所占的字节数，并不是等于指针所指向内容所占字节数。

真的啊！n和x一直相等，但是为什么呢？sizeof不能测fp所指向的全体的大小吗？

n=sizeof(*fp); x=sizeof(struct inf); // 确定这里循环是可以满足循环条件的么？不确定的话，在循环前打印下 n 和x的值各是多少吧 for(i=0;i<(n/x);i++) { fseek(fp,i*sizeof(struct inf),0); fread(p,sizeof(struct inf),1,fp); printf("%d号：\t姓名：%s\t电话：%s\n\n",p->num,p->name ,p->tel); }


Question: 栈从高地址到低地址分配内存

栈的生长方向，一般是由CPU确定的； 除非CPU不关心堆栈的生长方向，编译器才会自由安排。

Breakpoint 2, main () at test.s:35 35              call    _foo //调用函数foo (gdb) info reg eax            0x1      1 ecx            0x20018020       536969248 edx            0x0      0 ebx            0x22ac2c 2272300 esp            0x22abf0 0x22abf0  ebp            0x22ac08 0x22ac08 //esp < ebp， 说明是向低地址增长的 esi            0x0      0 edi            0x20039378       537105272 eip            0x40119d 0x40119d <main+21> eflags         0x246    [ PF ZF IF ] cs             0x1b     27 ss             0x23     35 ds             0x23     35 es             0x23     35 fs             0x3b     59 gs             0x0      0 (gdb) s foo () at test.s:8 8               pushl   %ebp //函数foo内部 (gdb) info reg eax            0x1      1 ecx            0x20018020       536969248 edx            0x0      0 ebx            0x22ac2c 2272300 esp            0x22abec 0x22abec  //esp 比调用函数前的值0x22abf0小了4,进一步证明栈是往低地址方向增长  ebp            0x22ac08 0x22ac08 esi            0x0      0 edi            0x20039378       537105272 eip            0x401180 0x401180 <foo> eflags         0x246    [ PF ZF IF ] cs             0x1b     27 ss             0x23     35 ds             0x23     35 es             0x23     35 fs             0x3b     59 gs             0x0      0 (gdb) n 11              movl    %esp, %ebp (gdb) info reg eax            0x1      1 ecx            0x20018020       536969248 edx            0x0      0 ebx            0x22ac2c 2272300 esp            0x22abe8 0x22abe8 //执行ebp入栈后，esp进一步减小4  ebp            0x22ac08 0x22ac08 esi            0x0      0 edi            0x20039378       537105272 eip            0x401181 0x401181 <foo+1> eflags         0x246    [ PF ZF IF ] cs             0x1b     27 ss             0x23     35 ds             0x23     35 es             0x23     35 fs             0x3b     59 gs             0x0      0 (gdb) f #0  foo () at test.s:11 11              movl    %esp, %ebp (gdb) bt #0  foo () at test.s:11 #1  0x004011a2 in main () at test.s:35 (gdb)    这个可以证明。

引用 9 楼 mujiok2003 的回复:$ cat test.c; gcc -Wall test.c -o demo; ./demo #include <stdio.h>   int main() {     void* sp = 0;     //取出当前的栈顶指针     asm("movl %%esp,%0;"         :"=r"(sp)     );     printf("sp:%p\n", sp);      asm("push $0"); //整数0入栈     //取出当前的栈顶指针     asm("movl %%esp,%0;"         :"=r"(sp)     );     printf("sp:%p\n", sp);     //出栈     asm("pop %0"        :"=r"(sp)     );     return 0; }  //sp:0x22ac10 //sp:0x22ac0c   gcc 4.7.3，上面的例子可以说明GCC的栈是往低地址方向增长。注意，这个结论不能推广到其它编译器上。 忽略

栈从高地址到低地址分配内存 是自动变量，分配内存先后得到的地址的高低问题。  如果编译器按照，自动变量的定义顺序分配自动变量内存。 那么，先定义的地址高，后定义的地址低。  如果编译器，实现的，不是这种最自然的实现的方式， 而是另有安排； 就没有办法确定自动变量定义顺序， 和自动变量的内存地址的位置的关系了。  毕竟，编译后才确定地址 而不是一边编译，一边确定地址； 所以可以任意调整，只要不影响函数运行，就是对的。

问题和实验结果不矛盾啊

如果lz的兴趣在 programming，暂时不要纠结与平台相关、实现相关的特性

与程序本身无关，与你的环境密切相关！

引用 2 楼 Benjaminzhou93 的回复:编译器相关，在vc6.0就完全是你想要的答案 测试了下，gcc把不同类型进行分区了struct < int < char 改正，gcc只把struct分为一类，int 和 char 是符合入桟顺序的另一类

引用 楼主 shihyuyao 的回复:#include <stdio.h>  struct S {     int a;     int b[20];     int c; };  int main(int argc, char *argv[]) {     struct S s, s1;     int a;     int b;      printf("%ld\n",(long int)&s);     printf("%ld\n",(long int)&s1);     printf("%ld\n",(long int)&a);     printf("%ld\n",(long int)&b);          return 0; }  140735395152864  // s 140735395152768   // s1 140735395152956  // a 140735395152952   // b   gcc4.3  为什么 s , s1 地址比 a , b 地址还低?   谢谢  没有强制规定入栈顺序啊，除非哪些处理器的调用规范强制指定了。 过分强调入栈的顺序没有意义，变量无论怎么放，只要放的地址合法，并且有显示的返回变量返回的地址（首地址）程序就能够找到它（们）

入栈顺序和函数内的变量申明顺序可能不一样， 这和编译器有一定的关系，所以不能通过一个函数内的多个变量在栈中的地址来判断栈的增长方向。 判断栈的增长方向可以使用多个函数调用，比如：A 函数调用B函数，B函数调用C函数，在A/B/C函数内部都定义一个变量（局部），然后分别打印其地址值（建议使用%p)。


Question: 急求单片机C语言编程密码锁

1、单片机这端驱动矩阵键盘和12864显示屏； 2、单片机这端驱动蜂鸣器和密码锁并检测密码锁的状态； 3、单片机把密码信息写入FLASH或者是EEPROM； 4、单片机通过串口与计算机通讯，通讯信息适当加密。  引用 楼主 u012767000 的回复:用C语言编程，矩阵键盘输入，12864显示信息。设置的密码发送到计算机存储起来，开锁是输入的密码和存储的密码进行比较正确的话开锁，错误三次，蜂鸣器报警。锁是用按键模拟的，直接接的IO口，根据高低电平的检测判断是否锁上，谢谢大家了！

先根据功能划分各个module,再细分文件和函数，搞清楚哪部分自己目前可以完成，哪部分需要学习

网上搜索下 银行的基本项目源码，参考里面的密码验证机制！ 很简单的处理方式，自己多动手写写！


Question: 新手求助

把两个if去掉就可以了，真无语，还是毕结了吧。

#include<stdio.h>  int main() {     int a,b,n,i;      scanf("%d",&i);     while(i--)     {         scanf("%d",&n);         for(a=1;a<=n;a+=2)             printf("%d ",a);//用空格分开         printf("\n");         for(b=2;b<=n;b+=2)             printf("%d ",b); //用空格分开         printf("\n");     }     return 0; }

还是不知道程序通不过的原因，唉

引用 4 楼 qqchildren 的回复:引用 3 楼 cfjtaishan 的回复:[quote=引用 2 楼 qqchildren 的回复:] [quote=引用 1 楼 cfjtaishan 的回复:] 不知道你的ACM系统是什么，有什么要求？是南阳理工学院ACM，要求不知道啊，要求应该就在题目中吧。 从网上搜到了，呵呵，不过也没看明白。程序没有多大问题，就是“硬代码”有点多。比如10000,这些建议你使用宏定义。[/quote]什么是硬代码啊？宏定义就是“#define"之类的？[/quote] 嗯，可以这么理解。

引用 3 楼 cfjtaishan 的回复:引用 2 楼 qqchildren 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 不知道你的ACM系统是什么，有什么要求？是南阳理工学院ACM，要求不知道啊，要求应该就在题目中吧。 从网上搜到了，呵呵，不过也没看明白。程序没有多大问题，就是“硬代码”有点多。比如10000,这些建议你使用宏定义。[/quote]什么是硬代码啊？宏定义就是“#define"之类的？

引用 2 楼 qqchildren 的回复:引用 1 楼 cfjtaishan 的回复:不知道你的ACM系统是什么，有什么要求？是南阳理工学院ACM，要求不知道啊，要求应该就在题目中吧。 从网上搜到了，呵呵，不过也没看明白。程序没有多大问题，就是“硬代码”有点多。比如10000,这些建议你使用宏定义。

不知道你的ACM系统是什么，有什么要求？


Question: 数据结构线性表的一个问题

求给分！加油，共勉！

#include <stdio.h> #include <stdlib.h> #include <malloc.h> //#include <stdbool.h>  #define MAXSIZE 50 #define LIST_INIT_SIZE 10 #define LISTINCREMENT 2  typedef struct{ 	char title[MAXSIZE]; 	float rating; }ElemType; typedef struct{ 	ElemType *elem; 	int length; 	int listsize; }List;  //初始化线性表  bool InitList(List * L);  //向表中插入元素  bool ListInsert(List *, int, ElemType *);  //判断表是否为空  bool ListIsEmpty(const List * L);  //输入元素 //void input(List L); List input(List L);  int main(void) { 	List L; 	bool x; 	 	x = InitList(&L); 	if(x == true) 	{ 		printf("初始化成功！\n"); 		printf("初始化之后, L.elem = %u, L.length = %d, L.listsize = %d\n",  		L.elem, L.length, L.listsize); 	} 	else 	{ 		fprintf(stderr, "初始化失败\n"); 		exit(1); 	} 	//input(L); 	L=input(L); 	printf("L.length = %d, L.listsize = %d, L.elem = %p\n", L.length, L.listsize, L.elem); 	x = ListIsEmpty(&L); 	//之所以输出L为空，问题出在你的input()函数，你的形参是List变量而不是引用或者指针， 	//形参在input()函数中改变了但是实参却没有改变，所以还应将形参返回给实参；或者使用其他传参方式。 	if(x == true) 		puts("L为空\n"); 	else 		puts("L不为空\n");  	return 0; }  List input(List L) { 	bool x; 	for(int i = 1; i <= 3; i++) 	{ 		ElemType * e; 		e = (ElemType *)malloc(sizeof(ElemType)); 		puts("请输入电影名称："); 		gets(e->title); 		fflush(stdin); 		puts("请输入你对该电影的评分："); 		//先初始化，参见：http://bbs.csdn.net/topics/80025379 		e->rating=0; 		scanf("%f", &e->rating); 		fflush(stdin); 		x = ListInsert(&L, i, e); 		if(x == true) 			printf("插入元素成功\n"); 		else 		{ 			fprintf(stderr, "i的值错误，插入元素失败"); 			exit(1); 		} 		free(e); 	} 	return L; } bool InitList(List * L) { 	L->elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType)); 	if(L->elem == NULL) 		return false; 	else 	{ 		L->length = 0; 		//L->listsize = 0;//?size  		L->listsize = LIST_INIT_SIZE; 		return true; 	} }  bool ListInsert(List * L, int i, ElemType * e) { 	ElemType * p, * q, * newbase; 	if(i < 1 || i > L->length + 1) 		return false; 	if(L->length >= L->listsize) 	{ 		newbase = (ElemType *)realloc(L->elem, L->listsize + LISTINCREMENT * sizeof(ElemType)); 		if(newbase == NULL) 		{ 			fprintf(stderr, "表中内存已满，新内存分配失败！\n"); 			exit(1); 		} 		L->elem = newbase;//?这样做是直接将指针指向新申请的空间，原来的空间你要怎么访问？ 		L->listsize += LISTINCREMENT; 	} 	q = L->elem + i - 1; 	p = L->elem + L->length - 1; 	for(; p >= q; p--) 		*(p+1) = *p; 	*q = *e; 	L->length++; 	return true; }  bool ListIsEmpty(const List * L) { 	if(L->length == 0) 		return true; 	else 		return false; }

p = L->elem + L->length - 1;     for(; p >= q; p--)         *(p+1) = *p;     *q = *e;     L->length++;  改成:      p = L->elem + L->length - 1;     for(; p >= q; p--)         (p+1) = p;     q = e;     L->length++;

printf("初始化之后, L.elem = %u, L.length = %d, L.listsize = %d\n",         L.elem, L.length, L.listsize); 修改为: printf("初始化之后,L.length = %d, L.listsize = %d\n",          L.length, L.listsize);


Question: 关于进程问题

引用 3 楼 AnYidan 的回复:[quote=引用 2 楼 max_min_ 的回复:] 输出几种可能性是因为fork函数无法确认父子进程，到底哪个进程先执行而已！ 可能因为环境的不同，父子进程前后执行的顺序不同。 环境关乎操作系统，编译环境等条件，没有发生变化，所以结果也没有变！  ++[/quote]

引用 2 楼 max_min_ 的回复:输出几种可能性是因为fork函数无法确认父子进程，到底哪个进程先执行而已！ 可能因为环境的不同，父子进程前后执行的顺序不同。 环境关乎操作系统，编译环境等条件，没有发生变化，所以结果也没有变！  ++

应该根据的编译器的调度算法吧


Question: c语音统计execl表格中信息 求高手进来说下。

引用 4 楼 jerry_dqh 的回复:[quote=引用 楼主 ccc43542876 的回复:]   比如有这样的一个表格。我想统计某一路公交车的人流量。也就是说比如1022路公交车。我只统计上车的人次，也就是2次。怎么统计？求个思路 这种的应用不要用c,直接用excel自带的vba实现更好。当然，对你这个需求，连程序都不需要，直接用EXCEL提供的数据透视表或者数据透视图直接可以统计出来。[/quote] ++看到标题我就想说的 标题还打错了。。

引用 6 楼 jerry_dqh 的回复:[quote=引用 5 楼 ccc43542876 的回复:] [quote=引用 4 楼 jerry_dqh 的回复:] [quote=引用 楼主 ccc43542876 的回复:]   比如有这样的一个表格。我想统计某一路公交车的人流量。也就是说比如1022路公交车。我只统计上车的人次，也就是2次。怎么统计？求个思路 这种的应用不要用c,直接用excel自带的vba实现更好。当然，对你这个需求，连程序都不需要，直接用EXCEL提供的数据透视表或者数据透视图直接可以统计出来。[/quote]不知道怎么操作。哎。。c都是泪啊。。[/quote] 如果不是没有办法，肯定不能用C啊.纯属自虐啊。直接用数据透视表吧，搜索一下 excel 数据透视表，就有教程了。我做一个简单的你看下：这是原始数据，101线有上车两次  这是直接的统计结果，上面的原始数据变化，统计数据也会变化，全是excel自有功能，可以看到101有两次上车消费  [/quote]非常感谢。。确实用c写有点自虐。。我现在好不容易读出数据了。也出现乱码的情况了。不知道怎么办了都。。你这个方法我去试试

引用 楼主 ccc43542876 的回复:  比如有这样的一个表格。我想统计某一路公交车的人流量。也就是说比如1022路公交车。我只统计上车的人次，也就是2次。怎么统计？求个思路 这种的应用不要用c,直接用excel自带的vba实现更好。当然，对你这个需求，连程序都不需要，直接用EXCEL提供的数据透视表或者数据透视图直接可以统计出来。

引用 2 楼 JiMoKuangXiangQu 的回复:可参考这个链接，比较复杂： http://www.codeproject.com/search.aspx?q=c+code+read+excel&sbo=kw http://www.codeproject.com/script/Articles/ViewDownloads.aspx?aid=13852  这个是Excel格式的文档： http://www.openoffice.org/sc/excelfileformat.pdf  建议不要直接用c来操作，太复杂。可以借助成熟的模块，如com，python等之类脚本来处理比较合适。如果不是execl，如果是文本文档。每个字段之间用空格或者制表符间隔。怎么处理？

python读取很方便。先把全部数据按行读取出来，写个函数根据线路获菆数据，然后不就好处理了么。

引用 5 楼 ccc43542876 的回复:[quote=引用 4 楼 jerry_dqh 的回复:] [quote=引用 楼主 ccc43542876 的回复:]   比如有这样的一个表格。我想统计某一路公交车的人流量。也就是说比如1022路公交车。我只统计上车的人次，也就是2次。怎么统计？求个思路 这种的应用不要用c,直接用excel自带的vba实现更好。当然，对你这个需求，连程序都不需要，直接用EXCEL提供的数据透视表或者数据透视图直接可以统计出来。[/quote]不知道怎么操作。哎。。c都是泪啊。。[/quote] 如果不是没有办法，肯定不能用C啊.纯属自虐啊。直接用数据透视表吧，搜索一下 excel 数据透视表，就有教程了。我做一个简单的你看下：这是原始数据，101线有上车两次  这是直接的统计结果，上面的原始数据变化，统计数据也会变化，全是excel自有功能，可以看到101有两次上车消费

引用 4 楼 jerry_dqh 的回复:[quote=引用 楼主 ccc43542876 的回复:]   比如有这样的一个表格。我想统计某一路公交车的人流量。也就是说比如1022路公交车。我只统计上车的人次，也就是2次。怎么统计？求个思路 这种的应用不要用c,直接用excel自带的vba实现更好。当然，对你这个需求，连程序都不需要，直接用EXCEL提供的数据透视表或者数据透视图直接可以统计出来。[/quote]不知道怎么操作。哎。。c都是泪啊。。

顶一个先。。。 或者JAVA也行！


Question: 帮忙看一下。。要交作业。实在找不出了。为什么那个in函数下面执行不了

清空一下stdio流  如果是windows 下面可以在c = getchar();后面加上fflush(stdin); 如果是linux下面你可以参照  http://blog.csdn.net/csu305/article/details/3321084

#include<stdio.h> #include<stdlib.h> #define STACKSIZE 100	//初始栈的大小 #define INCREAMSIZE 10	//增加栈 #define TURE 1 #define FALSE 0  typedef struct sqstack{ 	int *top,*base; 	int stacksize; }stack;  int init_stack(stack *S){							//初始化栈 	S->base = (int *)malloc(STACKSIZE*sizeof(int)); 	if(!S->base){ 		printf("初始化失败"); 		return -1; 	} 	S->top = S->base; 	S->stacksize = STACKSIZE; 	return 0; }  int get_top(stack S){				//取栈顶元素 ，返回值 	int a; 	if(S.base == S.top){ 		printf("栈为空1"); 		return -1; 	} 	else{ 		a =*(S.top-1);	 	} 	return a; } int pop(stack *S){					//退栈 	int e; 	if(S->base == S->top){ 		printf("栈为空2"); 		return -1; 	} 	else{ 		e = *S->top--; 	} 	return e; }							 int push(stack *S,int e){				//入栈 	if(S->top - S->base == S->stacksize){ 		S->base = (int *)realloc(S->base,(INCREAMSIZE+S->stacksize)*sizeof(int)); 		S->top = S->base + INCREAMSIZE; 		S->stacksize += INCREAMSIZE; 	} 	*S->top++ = e; 	return 0; }  int precede(int op1,int op2){     //比较栈的优先级 	switch(op1){	 		case '+': 		case '-': 			switch(op2){ 				case '*': 				case '/': 				case '(': 					return '>'; 					break; 				default:return '>'; 					break; 			} 			break; 		case '*': 		case '/': 			switch(op2){ 			case '(': 				return '<'; 				break; 			default: 				return '>'; 				break; 			} 			break;  		case '(': 			switch(op2){ 			case ')': 				return '='; 				break; 			default : 				return '<'; 				break; 			} 			break; 		case ')': 			switch(op2){ 			default: 				return '>'; 				break; 			} 			break; 		case '#': 			switch(op2){ 			case '#': 				return '='; 				break; 			default: 				return '<'; 				break; 			} 			break; 			default: 				return '<'; 				break;  	} }  int in(char c){					//判断栈是不是操作符 	switch(c){ 	case '+': 	case '-': 	case '*': 	case '/': 	case '(': 	case ')': 	case '#': 		return TURE; 		break; 	default: 		return FALSE; 		break; 	} } 									 int operate(int a,int theta,int b){		//计算四则运算的值 	switch(theta){ 	case '+': 		return a+b; 		break; 	case '-': 		return a-b; 		break; 	case '*': 		return a*b; 		break; 	case '/': 		return a/b; 		break; 	} } int main(){ 	int theta,d,e,f; 	char c; 	stack OPTR,OPND; 	init_stack(&OPTR);				//初始化操作数栈和操作符栈。 	init_stack(&OPND); 	push(&OPTR,'#');		//#压入操作符栈 	c = getchar(); 	while(c !='#' || get_top(OPTR) !='#'){ 		if(in(c)){ 			push(&OPND,c); 			c = getchar(); 			printf("sdf"); 		} 		else 		switch(precede(get_top(OPTR),c)){ 			case '<': 				push(&OPTR,c); 				c=getchar(); 				break; 			case '=': 				e=pop(&OPTR); 				c = getchar(); 				break; 			case '>': 				theta = pop(&OPTR); 				d = pop(&OPND); 				f = pop(&OPND); 				push(&OPND,operate(f,theta,d)); 				break; 		}//switch  	}//while 			printf("%d",get_top(OPND)); }

在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。

请描述清楚问题


Question: Usage:%s filename是什么意思？

类似于软件使用帮助。

++  引用 1 楼 lunat 的回复:Usage:%s filename  打印一条帮助信息，告诉你这个应用程序的用法，argv[0]就是你的应用程序名称；  if(argc<2) { fprintf(stderr,"Usage:%s filename\n",argv[0]); exit(-1); }  这句话的意思是，如果没有任何命令行参数（第一个命令行参数为应用程序本身，如果制定了一个命令行参数，则argc为2），则打印一句提示信息：Usage: [你的应用程序名称] filename，即告诉你要指定一个命令行参数代表filename。

引用 1 楼 lunat 的回复:Usage:%s filename  打印一条帮助信息，告诉你这个应用程序的用法，argv[0]就是你的应用程序名称；  if(argc<2) { fprintf(stderr,"Usage:%s filename\n",argv[0]); exit(-1); }  这句话的意思是，如果没有任何命令行参数（第一个命令行参数为应用程序本身，如果制定了一个命令行参数，则argc为2），则打印一句提示信息：Usage: [你的应用程序名称] filename，即告诉你要指定一个命令行参数代表filename。  console 程序常用

原来是这个意思，谢谢大神  引用 1 楼 lunat 的回复:Usage:%s filename  打印一条帮助信息，告诉你这个应用程序的用法，argv[0]就是你的应用程序名称；  if(argc<2) { fprintf(stderr,"Usage:%s filename\n",argv[0]); exit(-1); }  这句话的意思是，如果没有任何命令行参数（第一个命令行参数为应用程序本身，如果制定了一个命令行参数，则argc为2），则打印一句提示信息：Usage: [你的应用程序名称] filename，即告诉你要指定一个命令行参数代表filename。


Question: 请教C语言实现文件的传输

网络参考下FTP文件传输啊！很多这样的例程的！

引用 2 楼 max_min_ 的回复:网络参考下FTP文件传输啊！很多这样的例程的！ 能给个链接么？

源代码可以去code project 上面去找找

引用 3 楼 mychenphotos01 的回复:[quote=引用 2 楼 max_min_ 的回复:] 网络参考下FTP文件传输啊！很多这样的例程的！ 能给个链接么？[/quote]  开源代码，google

这个最简单的就是： 服务端传文件到客户端，服务端程序读取文件中的数据依次发送到客户端，客户端程序接收到数据后写入到文件。

如果可以，请发到我的QQ邮箱，378592402@qq.com，谢谢了。


Question: 请教fgetpos函数的几个问题

引用 1 楼 bjtbjt 的回复:1 指针的指针，  代表CHAR  2 地址  fgetpos：取得当前文件的句柄函数 函数原型：int fgetpos( FILE *stream, fpos_t *pos ); 头文件：#include<stdio.h> 是否是标准函数：是 函数功能：取得当前文件的指针所指的位置，并把该指针所指的位置数存放到pos所指的对象中。pos值以内部格式存储,仅由fgetpos和fsetpos使用。其中fsetpos的功能与fgetpos相反，为了详细介绍，将在后节给与说明。 返回值：成功返回0，失败返回非0，并设置errno。 例程如下：应用fgetpos函数取得当前文件的指针所指的位置。  3  %c %s %c 你说能是多余的吗。看看函数的定义和使用方法。  第一和第二个问题，你解释了，第三个问题，回答得很白痴，类似于那些QQ群里面灌水的人常说的那种：你去看看什么什么书吧。。。故意装大师

问题1：argv[1][0]表示第一个参数的第一个字符 问题2：&pos的意思是传入pos地址，以便fgetpos(fp,&pos)可以通过地址改写pos的值 问题3："号需要转译符\，否则编译器无法正确识别  引用 楼主 zaixiankaifa 的回复:#include <stdio.h> #include <stdlib.h> char buf[132];  int main(int argc, char *argv[]) { 	FILE *fp; 	fpos_t pos; 	if(argc!=2) 	{ 		printf("usage: %s mode \n",argv[0]); 		return 1; 	} 	if(argv[1][0]!='a') 	{ 		if((fp=fopen("testfile","w+"))==NULL) 		{ 			printf("fopen failed!\n"); 			return 2; 		} 	} 	else 	{ 		if((fp=fopen("testfile","a+"))==NULL) 		{ 			printf("fopen failed!\n"); 			return 3; 		} 	} 	fputs("1234567890",fp); 	fputs("abcdefghij",fp); 	fseek(fp,0,SEEK_END); 	fgetpos(fp,&pos); 	printf("current file end position is %ld \n",pos); 	fseek(fp,30,SEEK_END); 	fgetpos(fp,&pos); 	printf("call fseek(fp,30,SEEK_END)\n"); 	printf("current file position is %ld \n",pos); 	fputs("abcdefg",fp); 	printf("write %c %s %c \n",'\"',"abcdfg",'\"'); 	fgetpos(fp,&pos); 	printf("current position of file is %ld \n",pos); 	fclose(fp); }  问题1：if(argv[1][0]!='a')这里，为什么多了一个[0]? argv[1]是参数名称，那么argv[0][1]代表什么呢？ 问题2：fgetpos(fp,&pos);pos只是fpos_t类型的变量，这里&pos取其地址是什么意思呢？ 问题3：printf("write %c %s %c \n",'\"',"abcdfg",'\"');这里的"\"","和"\"是不是多余的？  以上三个方面不是很懂，望大神指点。。。。

ls 解释了 lz 从不看语法吗？


Question: 学习数据结构的一个问题求大神

用vs编译不出来 啊

谢谢楼上，很详细

typedef int Status;  # define TRUE 1  # define FALSE 0  # define OK 1  # define ERROR 0  # define INFEASIBLE -1  # define OVERFLOW -2  # define STACK_INIT_SIZE 100  # define STACKINCREMENT 10  typedef struct   {   int *base;   int *top;   int stacksize;   }   SqStack;  /*构造一个空的堆栈*/  Status InitStack(SqStack S)   {   S.base=(int *)malloc(STACK_INIT_SIZE*sizeof(int));   if(!S.base)exit(OVERFLOW);   S.top=S.base;   S.stacksize=STACK_INIT_SIZE;   return OK;    }  /*取栈顶元素*/  Status GetTop(SqStack S,int *e)   {   if(S.top==S.base) return ERROR;   *e=*(S.top-1);   return OK;   }   /*入栈*/  Status Push(SqStack S,int e)   {   if(S.top-S.base>=S.stacksize)   {   S.base=(int *)realloc (S.base,(S.stacksize+STACKINCREMENT)*sizeof(int));   if(!S.base) exit(OVERFLOW);   S.top=S.base+S.stacksize;   S.stacksize+=STACKINCREMENT;   }   *S.top++=e;   return OK;   }  /*出栈*/  Status Pop(SqStack S,int *e)   {   if(S.top==S.base)return ERROR;   else    {   S.top--;   *e=*S.top;   return OK;   }   }   /*判断栈是否为空*/  Status StackEmpty(SqStack S)   {   if(S.top==S.base)return OK;   return ERROR;   }   /*进制转换*/   # include <stdio.h>  void main()  {   long tN;   int N,e;   char test;   SqStack S;   InitStack(S);   scanf("%ld",&tN);   if (tN<0&&tN>=-32768)    {   test='-';   N=(int)-tN;   }    else if(tN>=0&&tN<=32767)   {   test='';   N=(int)tN;   }   else {   printf("overflow\n");    exit(OVERFLOW);   }   while(N)   {   Push(S,N%8);   N=N/8;   }   printf("the number in 8-form is:\n%c",test);  while(S.top>S.base)    {   Pop(S,&e);   printf("%d",e);   }   printf("\n");   }

就是求一个数转换成2进制


Question: 求：c中strtok的使用

http://blog.csdn.net/max_min_go/article/details/9292101 参考下 strtok函数的用法！

#include <stdio.h> #include <string.h> char string[80]; char seps1[3]; char seps2[3]; char *token; char *zzstrtok (     char *string,     const char *control1,//连续出现时视为中间夹空token     const char *control2 //连续出现时视为中间无空token     ) {     unsigned char *str;     const unsigned char *ctrl1 = control1;     const unsigned char *ctrl2 = control2;     unsigned char map1[32],map2[32];     static char *nextoken;     static char flag=0;     unsigned char c;     int L;      memset(map1,0,32);     memset(map2,0,32);     do {         map1[*ctrl1 >> 3] |= (1 << (*ctrl1 & 7));     } while (*ctrl1++);     do {         map2[*ctrl2 >> 3] |= (1 << (*ctrl2 & 7));     } while (*ctrl2++);      if (string) {         if (control2[0]) {             L=strlen(string);             while (1) {                 c=string[L-1];                 if (map2[c >> 3] & (1 << (c & 7))) {                     L--;                     string[L]=0;                 } else break;             }         }         if (control1[0]) {             L=strlen(string);             c=string[L-1];             if (map1[c >> 3] & (1 << (c & 7))) {                 string[L]=control1[0];                 string[L+1]=0;             }         }         str=string;     }     else        str=nextoken;      string=str;     while (1) {         if (0==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 string++;                 str++;             } else {                 flag=1;                 str++;             }         } else if (1==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=0;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=2;                 break;             } else str++;         } else {//2==flag             if (!*str) return NULL;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=str;                 flag=0;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=str;             } else {                 string=str;                 str++;                 flag=1;             }         }     }     nextoken=str;      if (string==str) return NULL;     else             return string; } void main() {    strcpy(string,"A \tstring\t\tof ,,tokens\n\nand some  more tokens, ");    strcpy(seps1,",\n");strcpy(seps2," \t");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"1234| LIYI|China | 010 |201110260000|OK");    strcpy(seps1,"|");strcpy(seps2," ");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"1234|LIYI||010|201110260000|OK");    strcpy(seps1,"");strcpy(seps2,"|");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"1234|LIYI||010|201110260000|OK");    strcpy(seps1,"|");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"a");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"a,b");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"a,,b");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",a");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"a,");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",a,,b");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",,a,,b,,");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",,");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",,,");    strcpy(seps1,",");strcpy(seps2," ");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    } } // //[A      string          of ,,tokens // //and some  more tokens,] //Tokens: // <A>, <string>, <of>, <>, <tokens>, <>, <and>, <some>, <more>, <tokens>, <>, //[1234| LIYI|China | 010 |201110260000|OK] //Tokens: // <1234>, <LIYI>, <China>, <010>, <201110260000>, <OK>, //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234>, <LIYI>, <010>, <201110260000>, <OK>, //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234>, <LIYI>, <>, <010>, <201110260000>, <OK>, //[a] //Tokens: // <a>, //[a,b] //Tokens: // <a>, <b>, //[a,,b] //Tokens: // <a>, <>, <b>, //[,a] //Tokens: // <>, <a>, //[a,] //Tokens: // <a>, <>, //[,a,,b] //Tokens: // <>, <a>, <>, <b>, //[,,a,,b,,] //Tokens: // <>, <>, <a>, <>, <b>, <>, <>, //[,] //Tokens: // <>, <>, //[,,] //Tokens: // <>, <>, <>, //[,,,] //Tokens: // <>, <>, <>, <>,

地址嘛，格式化lx改p...

strtok的实现 可能不同编译器的强制转换不同 还是怎么得  我运行的结果是 22ff30 22ff30 22ff30      #include <stdio.h> #include <string.h>  char *my_strtok(char *src, const char *delim) { 	//char src[] = "ab:,;cd,;ef"; 	static char *savep = ""; 	char *begin, *end; 	begin = src ? src : savep; 	begin += strspn(begin, delim); 	if(*begin == '\0'){ 		savep = ""; 		return NULL; 	} 	end = begin + strcspn(begin, delim); 	if(*end != '\0'){ 		*end++ = '\0'; 	} 	savep = end; 	return begin; }  int main(void) { 	char src[] = "ab:,;cd,;ef"; 	char *token, *begin;  	for(begin = src; (token = my_strtok(begin, ",:;")); begin = NULL) 	  puts(token); 	return 0; }

char *p;; 	char s1[] = "The summer soldier, the sunshine patriot";   	p = strtok(s1, " "); 	printf(p); 	do{ 		p = strtok(NULL, ", "); //('\0', ", "); 		if (p) printf("|%s\n", p); 	}while(p);

我在32位电脑上，windows和linux上运行，都没问题，三个printf显示的都一样，是不是64位的问题？自己电脑不是64位的，没法验证。


Question: 能消除闪烁的API函数是什么

提醒：使用任何技术交替显示全屏白和全屏黑都会闪烁的。

首先你要知道闪烁是怎么产生的

你只是想消除视角上的  闪烁。

消除窗口上清除背景的闪烁没有什么函数，一般都是使用缓冲技术，即，在内存dc上做好图，然后Bitblt到目标dc

是不是太快了 就闪了 你控制下闪烁的频率试试 好使不

TC的东西吧，老古董了都。

引用 4 楼 zhao4zhong1 的回复:提醒：使用任何技术交替显示全屏白和全屏黑都会闪烁的。 ++


Question: 学习单片机C语言什么书比较好，对C有一定了解

引用 1 楼 user-8 的回复:淘宝买个板子，自己做。老板会给很多电子版的资料。  这个比较好。

51单片机应用从零开始

郭天祥的新概念51单片机c语言教程！！

引用 楼主 abc594986308 的回复:rt，求神级推荐，好书成就一生 学单片机的C，不如学那个#include<reg51.h>的东东

51单片机c语言创新教程 然后自己买个本子，倒弄到弄！

(对C有一定了解) 相关MCU 的手册

C primer plus果断此书

淘宝买个板子，自己做。老板会给很多电子版的资料。


Question: c语言链表问题求助+讨论！！

学会debug,看看为什么

http://www.cnblogs.com/Alex-bg/archive/2012/08/05/2623946.html 参考下链表的基本操作


Question: C问题

谢谢帮忙，不胜感激

int SortPrint(int val[],int valLen,int sum_number,int ch) { 	int i; 	struct record_st{ 		float fre; 		int posxy; 	}; 	struct record_st record[26]; 	//先初始化 	for(i = 0; i < valLen; i++ ) 	{ 		record[i].fre = val[i]*100/(float)sum_number; 		record[i].posxy = i; 	} 	//给record 排序 	for(i = 0; i < valLen; i++) 	{ 		for(int j = i+1;j < valLen; j++) 		{ 			if(record[i].fre > record[j].fre) 			{ 				//swap 				struct record_st tmp = record[j]; 				record[j] = record[i]; 				record[i] = tmp; 			} 		} 	} 	printf("++++++++++++++++++++\n"); 	for(i = 0; i < valLen; i++) 	{ 		int pos = record[i].posxy; 		if(val[pos] > 0)  			printf(" %c :\t%d次。\t频率：%f \n",pos + ch,val[pos],record[i].fre);	 	} 	return 0; } // SortPrint(LowerQuantity,26,len,'a'); SortPrint(CapQuantity,26,len,'A'); SortPrint(Arab,9,len,'0'); //楼主试试这个吧。 //


Question: malloc(size_t size)的物理内存分配问题

结贴。5楼的兄弟回答的最中肯 分给你。

引用 4 楼 N_sev7 的回复:[quote=引用 3 楼 u012425973 的回复:] 我就想研究操作系统底层，写了这个测试，段页式的内存管理方式，应该是会分配4k的整数倍物理空间， 您看我的那个运行结果，p1,p2,p3虚拟地址都是相差了16个字节空间，实际的结构就是4个成员指针，存储都是物理内存的地址，我是想看看malloc中的size参数影响的物理内存实际的变化。 比如说我写malloc(1000) malloc(5) 这些变化  malloc()申请分配堆内存的时候，是根据系统空闲内存空间碎片中选择一块跟你申请的内存大小差不多的内存块给你，在保护模式下你想看真的物理地址就需要 段、叶、逻辑地址、实地址之间的关系转换，所以即使逻辑地址上只相差16字节，但是实地址上相差多少就的自己算了 《个人理解，纯属虚构》[/quote]  = =！自己算一下和实际中跑一下看看能是一样的理解么。。 我接着跟再深入进去看看吧。。好多东西没学扎实，本来想偷懒问问。

引用 3 楼 u012425973 的回复:我就想研究操作系统底层，写了这个测试，段页式的内存管理方式，应该是会分配4k的整数倍物理空间， 您看我的那个运行结果，p1,p2,p3虚拟地址都是相差了16个字节空间，实际的结构就是4个成员指针，存储都是物理内存的地址，我是想看看malloc中的size参数影响的物理内存实际的变化。 比如说我写malloc(1000) malloc(5) 这些变化  malloc()申请分配堆内存的时候，是根据系统空闲内存空间碎片中选择一块跟你申请的内存大小差不多的内存块给你，在保护模式下你想看真的物理地址就需要 段、叶、逻辑地址、实地址之间的关系转换，所以即使逻辑地址上只相差16字节，但是实地址上相差多少就的自己算了 《个人理解，纯属虚构》

只能看到内存的逻辑地址，物理地址是看不到的，在应用层面也是没有意义的。  引用 楼主 u012425973 的回复: #include <stdio.h> #include <unistd.h> #include <stdlib.h>  main() { 	char *p1 = malloc(0); 	short *p2 = malloc(4); 	int *p3 = malloc(8);  	printf("p1=%p\n", p1); 	printf("++p1=%p\n", ++p1); 	printf("++p1=%p\n", ++p1); 	printf("++p1=%p\n", ++p1); 	printf("++p1=%p\n", ++p1); 	printf("++p1=%p\n", ++p1); 	printf("p2=%p\n", p2); 	printf("++p2=%p\n", ++p2); 	printf("++p2=%p\n", ++p2); 	printf("p3=%p\n", p3); 	printf("++p3=%p\n", ++p3); 	printf("++p3=%p\n", ++p3);  	printf("pid = %d\n", getpid()); 	while(1); }    下面在linux下做了测试。有一些疑问求解惑  malloc分配的指针类型影响偏移，p1，p2,p3虚拟地址因为链式存储结构4个成员的原因，所以3个首地址彼此相差了16个字节空间。就linux分配的虚拟内存来说 也看不出size的实际意义 很想知道实际映射的物理内存是什么样的？ 怎么看物理内存的具体情况呢？ 我想知道参数size的分配不同的值 做相应的操作 物理内存会有何变化？

malloc()的参数指定了在内存中划分给你多大的内存空间 不管你有没有得到，你都可以使用指针访问任意的内存位置，但如果你试图写这个位置，那么下一次你读取的时候未必就还是你写的数据，即没划分给你的内存，不保证只有你能够修改 malloc(0)在某些编译环境下会直接失败  物理内存的管理涉及操作系统底层的操作，你需要学习计算机原理等底层知识，而不是编程语言 做测试是一种很直接很不靠谱的学习方法，没有足够的理论指引你，一个现象可以让你猜出一百种奇谈怪论，更不用提“可重复性”和“语言标准”等等


Question: microsoft visual studio 2010调试

二楼不好意思，刚结帖，没看到你的回复，不好意思没给发你！

好吧，谢谢！我已经知道，感谢你的恢复！其实那个跟监视一维数组一样，数组名+“，”+长度就行

将数组变量添加到监视里面。

看不到就一个个打印吧。  引用 楼主 jianben123 的回复:亲们，microsoft visual studio 2010 怎么调试数组，其中怎样监视二维数组的值


Question: 数据结构  顺序表和链表

效率问题很复杂，你最好做下相应的测试，自己体会下。 当然还要考虑样本的情况，比如已排序的、刚好在开始位置附近找到该节点什么的。可以分为平均情况，最坏情况等等。  每种东西都有自己的特点，就比如元素数量未知的情况，链表就要优于线性表。线性表容易查找，但操作也相当不方便。链表可能会查找麻烦，但操作却方便很多。数据的样本不同，需要的操作不同，最后需要的容器也会不同，不能因为你说两者都差不多就不用另外一个吧。  比如我有N个元素，但N是多少我不知道，我难道事先分配1000000个空间？不现实吧。但我只有10个元素，而且只要简单的一些操作，可能不会有删除等操作，那我用链表不是麻烦了很多？  总之考虑如何选择一个容器、算法，要结合实际情况，样本特例等等，最后得出一个合适的结论。不会因为多数情况这个容器、算法没有优势就不去考虑，说不定你的样本几乎全是另一个容器的特例也不一定。

lz 看清楚了，对于已知下标号的插入，数组在寻找上是快，但大量的实际操作是已知元素的值，此时数组在寻找上毫无优势可言  对于不同的要求，选择不同的数据结构，没有谁一定比谁好

效率不是这么说说感觉的！ 其实写写程序才知道其中的各种条件的考虑判断！

LZ可以写个程序跑跑，然后对其profile。

可能周末了，大神们都周末娱乐区了！！！ 顺序表能根据下表直接定位到要删除的元素，然而删除后要将此元素后面的所有元素一个一个前移，这就很费时间， 然而链表虽然没有顺序表查找那么快速，但是一旦查找到，只需要将需要删除的节点free掉就OK了，只需要将此节点的next指针给其前一个节点就OK了 查找只需要比较，移动数据需要的步骤就多了 《个人理解，纯属虚构》

就这么沉了吗~~~~~

自己顶顶，，


Question: C语言手动输入字符数组 获取不正确

哦，对哦，我傻了

这个问题其实可以不用改！ 你在输入的时候直接输入25个字符就可以，不用换行输入， 它会自动输出5,5的矩阵。

引用 5 楼 AnYidan 的回复:scanf("%c", &a[i][j]); scanf(" %c", &a[i][j]);  嗯，也推荐这样改，scanf还是很强大的

#include<stdio.h> #define NUM 5 int main() {    int i,j;    char a[NUM ][NUM ];    for( i = 0; i < NUM; i++)       for( j = 0; j < NUM; j++)       {          scanf("%c", &a[i][j]);          getchar();        }  for( i = 0; i < NUM; i++)   {       for( j = 0; j < NUM; j++)            printf("%c", a[i][j]);       printf("\n");   } return 0; } 试试，吃掉了回车符

回车也是字符，所以它也会占用一个字符空间。

#include<stdio.h> #define NUM 5 int main() { 	int i,j; 	char a[NUM ][NUM ]; 	for( i = 0; i < NUM; i++) 	{ 		for( j = 0; j < NUM; j++) 		{ 			scanf("%c", &a[i][j]); 			if ( '\n' == a[i][j]) 			{ 				j--; 			} 		} 	}  	for( i = 0; i < NUM; i++) 	{ 		for( j = 0; j < NUM; j++) 			printf("%c", a[i][j]); 		printf("\n"); 	} 	//system("pause"); 	return 0; }   附上代码,考虑考虑

获取值之后，增加验证。 如果是'\n',不填值，并把j--以保证下一次循环获得的值还会赋值到这个地方

我就是不知道怎么处理这个，因为多数情况下都是因为换行符才出的问题

你忽略了换行符'\n'


Question: 早上写好的一个集合运算器，中午修改一下，就不知道怎么回事，错了，错了。

不重复集  A =1,2,5,8｝; B =2,4,6,8}; 并，交，差: Union(A,B) = {1,2,4,5,6,8} Add(A,B)   ={2,8}  Diff(A,B)  ={1,5} Diff(B,A)  ={4,6}      可重复集的一种方案：   A ={1,2,5,8｝; B ={2,4,6,8}; 并，交，差: Union(A,B) = {1,2,2,4,5,6,8,8} Add(A,B)   ={2,8} Diff(A,B)  ={1,5} Diff(B,A)  ={4,6}  集合，一般不考虑顺序； 集合排序，是为了更方便操作。

早上是好的，说明基本代码思路框架还是好的！现在乱了估计是某处一点修改导致逻辑错误了！ 可以单步调试分析下，要学会调试程序！分析代码走向

LZ程序是先排序后显示，所以显示的是排序过后的结果。如下改为先显示后排序：        printf("请输入要运算的B集合：\n");       scanf("%s",Set);       Insert(b,Set);       printf("集合B=[");       Tranver(b);       printf("]");       sort (b);       printf("请继续...\n");  对于A集合也应如此修改。

交集 两个集合都有的存入交集。  估计楼主，没有搞清楚 自己要实现可重复集，还是不重复集，如何定义并，交，差等集合运算。

集合有可重复集，和不重复集 一般的集合的实现，多半都是不重复集。  不重复集的元素顺序，一般不重要； 所以一般实现为排序集，方便处理集合的各种操作。  对于，不重复集的运算， 并集，一般就是归并两个集，并排除其中的重复元素。 差集，去掉另一个集合中有的元素，由于已经排序，实现起来也比较方便。  可重复集，需要定义何为并，何为交，才能运算。

但看程序的话没啥问题，你自己再调试看看。话说你中午改了哪里，可以说说么？  调试的话其实也不难，比如交集吧，你先输入a、b然后在进入交集函数的地方设个断点，然后看看a、b的原始状态是否是符合要求的（已排序），然后一步步单步下来就可以了，看看是不是哪里的运算顺序不符合你的想法。如果没什么错误的话，然后看看打印是否有问题。总之就是一步步单步下来的。  我粗略的看了下，没看出啥明显的错误。和3楼一样，我照你的样本输入，执行的结果是对的。你是否哪里搞错了？还是有特殊的样本？你再试试看吧。

任何修改前要做好backup 学会debug

求并集也一样简单， 将集合B作为并集基础，然后用A中的数据区跟B的数据比， 比到相等的就break， 一直到结束都没有比到相等的就直接放到最后， 循环....

LZ有些坑，跟了半天发现结果是正确的（仅限于你提供的两个输入）！！！ 在公司，上传不了东西， 其实简单的实现是 一个双重循环 用第一个集合的所有元素一个一个和第二个集合比，比到相等的就存起来，break， 继续用第二个去比....

仅供参考#include <algorithm> #include <iostream> #include <functional> #include <cstring> using namespace std; int main() {     char *Alphabet = "abcdefghijklmnopqrstuvwxyz" ;     char *Vowels   = "aeiou" ;     char *AlphaNum = "0123456789abcdef" ;     char result[45] ;     char *last ;      int lenA  = strlen(Alphabet) ;     int lenV  = strlen(Vowels  ) ;     int lenAN = strlen(AlphaNum) ;      cout << "Alphabet = " << Alphabet << endl ;     cout << "Vowels   = " << Vowels   << endl ;     cout << "AlphaNum = " << AlphaNum << endl ;      cout << "\nusing non-predicate versions" << endl ;      //non-predicate set_difference     last = set_difference(Alphabet, Alphabet+lenA,                           AlphaNum, AlphaNum+lenAN,                           result) ;     *last = 0 ;     cout << "set_difference(Alphabet, AlphaNum) =  " << result << endl ;      //non-predicate set_intersection     last = set_intersection(Alphabet, Alphabet+lenA,                             AlphaNum, AlphaNum+lenAN,                             result) ;     *last = 0 ;     cout << "set_intersection(Alphabet, AlphaNum) =  " << result << endl ;      //non-predicate set_symmetric_difference     last = set_symmetric_difference(Alphabet, Alphabet+lenA,                                     Vowels  , Vowels  +lenV,                                     result) ;     *last = 0 ;     cout << "set_symmetric_difference(Alphabet, Vowels) =  " << result << endl ;      //non-predicate set_union     last = set_union(Alphabet, Alphabet+lenA,                      AlphaNum, AlphaNum+lenAN,                      result) ;     *last = 0 ;     cout << "set_union(Alphabet, AlphaNum) =  " << result << endl ;      cout << "\nusing predicate versions" << endl ;      //predicate set_difference     last = set_difference(Alphabet, Alphabet+lenA,                           AlphaNum, AlphaNum+lenAN,                           result  , less<char>()) ;     *last = 0 ;     cout << "set_difference(Alphabet, AlphaNum) =  " << result << endl ;      //predicate set_intersection     last = set_intersection(Alphabet, Alphabet+lenA,                             AlphaNum, AlphaNum+lenAN,                             result  , less<char>()) ;     *last = 0 ;     cout << "set_intersection(Alphabet, AlphaNum) =  " << result << endl ;      //predicate set_symmetric_difference     last = set_symmetric_difference(Alphabet, Alphabet+lenA,                                     Vowels  , Vowels  +lenV,                                     result  , less<char>()) ;     *last = 0 ;     cout << "set_symmetric_difference(Alphabet, Vowels) =  " << result << endl ;      //predicate set_union     last = set_union(Alphabet, Alphabet+lenA,                      AlphaNum, AlphaNum+lenAN,                      result  , less<char>()) ;     *last = 0 ;     cout << "set_union(Alphabet, AlphaNum) =  " << result << endl ;      return 0 ; }

用户手册： 1.本程序的运行环境为DOS操作系统，执行文件为“集合运算程序.exe”. 2.进入演示程序后即显示文本方式的用户界面如图1： 3.输入“1”并且回车，则构建一个新的集合A，选择“2”，则新建一个新的集合B 4.选择“3”或者“4”并回车，则进入集合的交集或者并集运算，计算机会自动将结果输出到屏幕上。 5.按“0”并回车，则退出。   注：本程序在编写的时候出现一个小小的bug，在输入集合B的时候，立刻显示的并不是输入的集合的顺序，只经过排序算法之后的集合，如“图2”，本人输入“5476499”，它显示的是：“4456799”。这是排序算法排序过后的结果，本人在调试程序的时候一直没有debug出来，但这并不影响其运算的结果。


Question: 关于fflush（stdin）的用法有些不明白

引用 4 楼 A812185083 的回复:配图反了 fflush是用来清空缓冲区 清空之后重新换行 能说的具体点吗？不了解这是怎么运行的，缓冲区里有啥？为什么要清空？

fflush是刷新缓冲区的，因为上次的数如会将换行符滞留在设备缓冲区里，fflush是将数据都刷到内存里。

引用 4 楼 A812185083 的回复:配图反了 fflush是用来清空缓冲区 清空之后重新换行  担心输入缓存中有残留的字符

配图反了 fflush是用来清空缓冲区 清空之后重新换行

先 http://www.microsoft.com/visualstudio/chs/downloads#d-2010-express 点开Visual C++ 2010 Express下面的语言选‘简体中文’，再点立即安装  再参考C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\bsearch.c /*** *bsearch.c - do a binary search * *   Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *   defines bsearch() - do a binary search an an array * *******************************************************************************/  #include <cruntime.h> #include <stdlib.h> #include <search.h> #include <internal.h>  #if defined (_M_CEE) #define __fileDECL  __clrcall #else  /* defined (_M_CEE) */ #define __fileDECL  __cdecl #endif  /* defined (_M_CEE) */ /*** *char *bsearch() - do a binary search on an array * *Purpose: *   Does a binary search of a sorted array for a key. * *Entry: *   const char *key    - key to search for *   const char *base   - base of sorted array to search *   unsigned int num   - number of elements in array *   unsigned int width - number of bytes per element *   int (*compare)()   - pointer to function that compares two array *           elements, returning neg when #1 < #2, pos when #1 > #2, and *           0 when they are equal. Function is passed pointers to two *           array elements. * *Exit: *   if key is found: *           returns pointer to occurrence of key in array *   if key is not found: *           returns NULL * *Exceptions: *   Input parameters are validated. Refer to the validation section of the function. * *******************************************************************************/  #ifdef __USE_CONTEXT #define __COMPARE(context, p1, p2) (*compare)(context, p1, p2) #else  /* __USE_CONTEXT */ #define __COMPARE(context, p1, p2) (*compare)(p1, p2) #endif  /* __USE_CONTEXT */  #if !defined (_M_CEE) _CRTIMP #endif  /* !defined (_M_CEE) */  SECURITYSAFECRITICAL_ATTRIBUTE #ifdef __USE_CONTEXT void * __fileDECL bsearch_s (     REG4 const void *key,     const void *base,     size_t num,     size_t width,     int (__fileDECL *compare)(void *, const void *, const void *),     void *context     ) #else  /* __USE_CONTEXT */ void * __fileDECL bsearch (     REG4 const void *key,     const void *base,     size_t num,     size_t width,     int (__fileDECL *compare)(const void *, const void *)     ) #endif  /* __USE_CONTEXT */ {     REG1 char *lo = (char *)base;     REG2 char *hi = (char *)base + (num - 1) * width;     REG3 char *mid;     size_t half;     int result;      /* validation section */     _VALIDATE_RETURN(base != NULL || num == 0, EINVAL, NULL);     _VALIDATE_RETURN(width > 0, EINVAL, NULL);     _VALIDATE_RETURN(compare != NULL, EINVAL, NULL);          /*         We allow a NULL key here because it breaks some older code and because we do not dereference         this ourselves so we can't be sure that it's a problem for the comparison function         */      while (lo <= hi)     {         if ((half = num / 2) != 0)         {             mid = lo + (num & 1 ? half : (half - 1)) * width;             if (!(result = __COMPARE(context, key, mid)))                 return(mid);             else if (result < 0)             {                 hi = mid - width;                 num = num & 1 ? half : half-1;             }             else             {                 lo = mid + width;                 num = half;             }         }         else if (num)             return (__COMPARE(context, key, lo) ? NULL : lo);         else             break;     }      return NULL; }  #undef __fileDECL #undef __COMPARE

不要只看表面，去耐心理解文档

配图反了。。。我去，下面是正常的，第一张是如果去掉这句就会出现这个结果


Question: 指针

一维数组a[i]==*(a+i) 二维数组a[i][j]==*(*(a+i)+j) 记住这个公式就可以了，则 *（*a+1）==a[0][1]==2

引用 7 楼 A812185083 的回复:应该是4 首先 {1，2，3，4，5，6，7，8，9} 应该是int a[3][3] a是指针的指针，a取值指向第一个数组的首部 等于指向1 ，然后加1 就指向第一个数组的第二个数，取第二个数的值则是2 *(*(a+1)) 这个是4

引用 9 楼 maoshuoqiong 的回复:[quote=引用 8 楼 luoyz520 的回复:] *a得到数组的第一个元素1,所以*（*a+1）= *（1 + 1） = *2；获取存储在内存地址为2的值。可以试试会不会报错。。  *a是一个int*类型指针![/quote]多谢指点。*a相当于指向a[0][0]，那么*a + 1 就该是指向a[0][1],所以*(*a + 1) == 2.这样是吧？

引用 8 楼 luoyz520 的回复:*a得到数组的第一个元素1,所以*（*a+1）= *（1 + 1） = *2；获取存储在内存地址为2的值。可以试试会不会报错。。  *a是一个int*类型指针!

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

*（*a+1） 一、首先算括号内*a+1 :     这里可以将a看成是一个int**类型的指针,那么*a 就是一个int*型指针.*a+1 右移一个int位,得到指向元素2的地址。 二、*a+1是指向元素2的指针，再进行*解析，所以*(*a+1)的值应该是2  我是这么理解的，不知道对不对

多看书，逐步调试程序分析

不太会 但是应该是2 二维数组是又N个一维数组组成的

1 2 3 4 5 6 7 8 9 *（*(a + 0) + 0）= 1； *（*(a + 0) + 1）= 2； *（*(a + 0) + 2）= 3；  *（*(a + 1) + 0）= 4； *（*(a + 1) + 1）= 5； *（*(a + 1) + 2）= 6；  *（*(a + 2) + 0）= 7； *（*(a + 2) + 1）= 8； *（*(a + 2) + 2）= 9；

好好看看自己的课本！！！只能这么说


Question: unsigned int 转 16进制

教你正统的，你不用，人家跟你忽悠你倒是用上了  	char *filePath = "/data/local/tmp"; 	int l1 = strlen(filePath); 	int l = 8 + l1;  	char *buffer = (char *)malloc(sizeof(char) * l); //	memset(buffer, 0, l);多此一举  	memcpy(buffer, "SEND", 4); 	memcpy(buffer+4,l1,4); 	memcpy(buffer + 8, filePath, l1);  	for(int i=0; i<1; i++) 		printf("%02X  ", buffer[i]);

上面的代码达不到“SEND+4位长度+文件名称”的效果，应该怎么改？  红色那个怎么理解？是4位还是4字节？

char *filePath = "/data/local/tmp"; 	int l1 = strlen(filePath); 	int l = 8 + l1;  	char *buffer = (char *)malloc(sizeof(char) * l); 	memset(buffer, 0, l);  	memcpy(buffer, "SEND", 4); 	 	buffer[4] = l1 & 0xff; 	buffer[5] = (l1 >> 8) & 0xff; 	buffer[6] = (l1 >> 16) & 0xff; 	buffer[7] = (l1 >> 24) & 0xff;  	memcpy(buffer + 8, filePath, l1);  	for(int i=0; i<12; i++) 		printf("%02X  ", buffer[i]);   上面的代码达不到“SEND+4位长度+文件名称”的效果，应该怎么改？

如果文件长度是13的话，现在只是传输了  SEND0D， 后面的内容就没了，会不会是因为00后就当做字符串的结束？

引用 楼主 zzmei 的回复:int i = 13; char *c = (char *)malloc(sizeof(char) * 4);  如何把i转成16进制并存储在c里，不足4位的补上00，如果i = 13打印出来后就是 0D 00 00 00  计算机中的任何数据都以二进制的形式存储，十六进制因以与二进制转换方便，书写容易而在计算机书籍中得以大量使用

怎样构造这样的指令：       SEND+4位的文件名长度+文件名称  char *cmd = "SEND"; char *file_name = "C:/a.txt"; char *c = ..................

引用 5 楼 max_min_ 的回复:[quote=引用 4 楼 zhao4zhong1 的回复:] int i = 13; char *c; c = (char *)malloc(sizeof(char) * 4); assert(c); memcpy((void *)c,(void *)&i,4); printf("%02X %02X %02X %02X\n",  (unsigned char)c[0],  (unsigned char)c[1],  (unsigned char)c[2],  (unsigned char)c[3]); //... free(c);  大小端问题呢？[/quote] 认为跨平台的代码一定比不跨平台的代码好，就象认为双性恋一定比异性恋好一样！  ——此话非本人原创

引用 4 楼 zhao4zhong1 的回复:int i = 13; char *c; c = (char *)malloc(sizeof(char) * 4); assert(c); memcpy((void *)c,(void *)&i,4); printf("%02X %02X %02X %02X\n",  (unsigned char)c[0],  (unsigned char)c[1],  (unsigned char)c[2],  (unsigned char)c[3]); //... free(c);  大小端问题呢？

或者这样：  c[0] = i & 0xff; c[1] = (i >> 8) & 0xff; c[2] = (i >> 16) & 0xff; c[3] = (i >> 24) & 0xff;   引用 楼主 zzmei 的回复:int i = 13; char *c = (char *)malloc(sizeof(char) * 4);  如何把i转成16进制并存储在c里，不足4位的补上00，如果i = 13打印出来后就是 0D 00 00 00

或者： *(int*)c=i;

LX你这个算是什么要求啊？  memcpy(c,&i,4)即可


Question: 用C语言读取文件指定的数据，并将数据存入bin文件中

问题自己已解决！！

这不是表达式求值么？

跪求高手指点啊！

引用 2 楼 turingo 的回复:文本和文件操作用Python脚本最为合适。  [quote=引用 楼主 tanqiyingk 的回复:] 现有.inc文件A、B、C如图所示： A.inc  B_cat	 equ	0x0000 B_dog	 equ	0x0001 B_tiger	 equ	0x0002 B_sleep	 equ	0x0003 B_Bird02	 equ	0x0004  B.inc  W_train	            equ	0x0000 W_bus200            equ	0x0001 W_CAR               equ	0x0002 W_Plane3000         equ	0x0003  C.inc  M_guitar	    equ	0x0000 M_piano             equ	0x0001 M_Saxophone         equ	0x0002 M_VIOLIN            equ	0x0003  另外有TXT文件如图 equation.txt  equ_0001 = B_tiger+W_train+200+M_Saxophone+M_VIOLIN+FFH  现在要把equation.txt文件中的等式 通过inc文件里对应的内容把数据存放入一个bin文件中 其中B_ W_ M_ 要存放一个Byte表示类型。 分别用01 02 03 表示 纯数字200用04表示类型  最后的FF用一个byte存放 例如：B_tiger  B_ 表示类型 用一个byte 存为01 表示，再根据inc文件中B_tiger等于0x0002  用2两个Byte表示，存为 00 02   那么 equ_0001 = B_tiger+W_train+200+M_Saxophone+M_VIOLIN+FFH  数据存储应该为：01 00 02 02 00 00 04 00 C8 03 00 02 03 00 03 FF  注：inc文件中的内容是改变的，equation.txt文件的内容也是改变的 希望通过这个工具来得到自己想要的数据存放入BIN文件中。 希望懂的帮忙下，最好事附上源代码。谢谢！！！！[/quote]Python不了解，刚接触的C，之前用汇编

文本和文件操作用Python脚本最为合适。  引用 楼主 tanqiyingk 的回复:现有.inc文件A、B、C如图所示： A.inc  B_cat	 equ	0x0000 B_dog	 equ	0x0001 B_tiger	 equ	0x0002 B_sleep	 equ	0x0003 B_Bird02	 equ	0x0004  B.inc  W_train	            equ	0x0000 W_bus200            equ	0x0001 W_CAR               equ	0x0002 W_Plane3000         equ	0x0003  C.inc  M_guitar	    equ	0x0000 M_piano             equ	0x0001 M_Saxophone         equ	0x0002 M_VIOLIN            equ	0x0003  另外有TXT文件如图 equation.txt  equ_0001 = B_tiger+W_train+200+M_Saxophone+M_VIOLIN+FFH  现在要把equation.txt文件中的等式 通过inc文件里对应的内容把数据存放入一个bin文件中 其中B_ W_ M_ 要存放一个Byte表示类型。 分别用01 02 03 表示 纯数字200用04表示类型  最后的FF用一个byte存放 例如：B_tiger  B_ 表示类型 用一个byte 存为01 表示，再根据inc文件中B_tiger等于0x0002  用2两个Byte表示，存为 00 02   那么 equ_0001 = B_tiger+W_train+200+M_Saxophone+M_VIOLIN+FFH  数据存储应该为：01 00 02 02 00 00 04 00 C8 03 00 02 03 00 03 FF  注：inc文件中的内容是改变的，equation.txt文件的内容也是改变的 希望通过这个工具来得到自己想要的数据存放入BIN文件中。 希望懂的帮忙下，最好事附上源代码。谢谢！！！！

现在一头雾水中，不知道该怎么做好。


Question: 帮忙看下这个是什么C语法

引用 1 楼 hnwyllmm 的回复:这个是以前的C代码标准，楼主要是看很多Linux的源码，这种风格比较多惭愧，一直都没能有机会看什么源码，今天瞄了两个开源的，全是这种，吓到了。不是新的就好，

是很特殊，开眼了

这个是以前的C代码标准，楼主要是看很多Linux的源码，这种风格比较多


Question: runtime error  请各位大神帮忙

#include<stdio.h> #include<string.h> #define max 1000 int main(){      int a[max],b[max],ans[max],i,j,k,len_a,len_b;     char A[max],B[max];     while(scanf("%s %s",A,B)!=EOF) {         memset(a,0,sizeof(a));       memset(b,0,sizeof(b));         memset(ans,0,sizeof(ans));         len_a=strlen(A);        len_b=strlen(B);         for(i=0;i<len_a;i++)          if(A[i]!=0)          break;         for(j=len_a-1,k=0;j>=i;j--,k++)            a[k]=A[j]-48;        for(i=0;i<len_b;i++)            if(B[i]!=0)               break;         for(j=len_b-1,k=0;j>=i;j--,k++)            b[k]=B[j]-48;         for(i=0;i<max-1;i++)            ans[i]=a[i]+b[i];        for(i=0;i<max-1;i++)            if(ans[i]>9)         {    ans[i+1]+=ans[i]/10;                   ans[i]%=10;   }         for(i=max-1;i>0;i--)            if(ans[i]!=0)           break;         for(;i>=0;i--)            printf("%d",ans[i]);         printf("\n"); }        return 0; } 为何这个算法在oj上秒过。。。差异在哪呢？

引用 3 楼 AnYidan 的回复:最好有分析工具，先找出瓶颈 有什么样的分析工具? 分析什么的？一直都没用过哎。。

引用 2 楼 N_sev7 的回复:换成位运算来做试试 怎样就是位运算？

最好有分析工具，先找出瓶颈

换成位运算来做试试

大数运算用GMP库（http://blog.csdn.net/turingo/article/details/8249799）  引用 楼主 u010582475 的回复:这个程序 如何减短运行时间。。大数相加 相乘。 #include<stdio.h> #include<string.h> #define max 1000 int main()  { 	int result[max]; 	char ch1[max],ch2[max]; 	int i=0,tmp,len1,len2; 	memset(result,0,max); 	while(scanf("%s%s",ch1,ch2)!=EOF) 	{     len1=strlen(ch1);     len2=strlen(ch2);     int max_len=(len1>len2)?len1:len2;    	for( i=max_len-1;i>=0;i--) 	{ 	if(len1==0) 	{ 		tmp=ch2[len2-1]-'0'; 		len2--; 	} 	else if(len2==0) 	{ 		tmp=ch1[len1-1]-'0'; 		len1--; 	} 	else 	{ 	  tmp=(ch1[len1-1]-'0')+(ch2[len2-1]-'0');	 	   len1--; 	   len2--; 	}	 	   result[i]+=tmp; 	} 	result[max_len]='\0'; 	for( i=max_len-1;i>=0;i--) 	{ 		if(result[i]>9) 		{ 			tmp=result[i]; 			result[i]%=10; 			result[i-1]+=(tmp/10); 		} 	}         for(i=0;i<max_len;i++)         {           printf("%d",result[i]); 		} 		 printf("\n"); 		 	} 	    return 0; } //大数相乘 #include<stdio.h> #include<string.h> #define max 1000 int main()  { 	int result[max]; 	char ch1[max],ch2[max]; 	scanf("%s%s",ch1,ch2); 	int i=0,j=0,tmp,len1=strlen(ch1),len2=strlen(ch2); 	memset(result,0,100); 	for( i=1;i<=len1;i++) 	{ 		for( j=1;j<=len2;j++) 		{ 			tmp=(ch1[i-1]-'0')*(ch2[j-1]-'0'); 			result[i+j-1]+=tmp; 		} 	} 	result[len1+len2]='\0'; 	for( i=len1+len2-1;i>=0;i--) 	{ 		if(result[i]>9) 		{ 			tmp=result[i]; 			result[i]%=10; 			result[i-1]+=(tmp/10); 			 		} 	}         for(i=0;i<len1+len2;i++) 	     printf("%d",result[i]);              	return 0; }


Question: 菜鸟求指导 简单的C语言题目

代码是我打的！ 题目是复制的。  请不要鄙视我

你完全是复制的题目 还说简单的问题 都没有经过你大脑思考 直接复制 粘贴 复制 粘贴 推理出你这是对回答问题的人的不负责 正如别人问你如何把大象装冰箱 你什么都不知道 连最起码的打开冰箱门都没有去想 直接就对别人说 喂你知道如何把大象装冰箱吗


Question: 结构体的一些问题

为了提高总线效率 编译器会使用内存对齐

这里有内存字节对齐的！不是简单的字面的上的 参考看看 http://blog.csdn.net/hairetz/article/details/4084088

csdn 可有统计 ++， 字节对齐 的提问占有的百分比

#include <stdio.h> #define field_offset(s,f) (int)(&(((struct s *)(0))->f)) struct AD  { int a; char b[13]; double c;}; #pragma pack(push) #pragma pack(1) struct A1  { int a; char b[13]; double c;}; #pragma pack(2) struct A2  { int a; char b[13]; double c;}; #pragma pack(4) struct A4  { int a; char b[13]; double c;}; #pragma pack(8) struct A8  { int a; char b[13]; double c;}; #pragma pack(16) struct A16 { int a; char b[13]; double c;}; #pragma pack(pop) int main() {     printf("AD.a %d\n",field_offset(AD,a));     printf("AD.b %d\n",field_offset(AD,b));     printf("AD.c %d\n",field_offset(AD,c));     printf("\n");     printf("A1.a %d\n",field_offset(A1,a));     printf("A1.b %d\n",field_offset(A1,b));     printf("A1.c %d\n",field_offset(A1,c));     printf("\n");     printf("A2.a %d\n",field_offset(A2,a));     printf("A2.b %d\n",field_offset(A2,b));     printf("A2.c %d\n",field_offset(A2,c));     printf("\n");     printf("A4.a %d\n",field_offset(A4,a));     printf("A4.b %d\n",field_offset(A4,b));     printf("A4.c %d\n",field_offset(A4,c));     printf("\n");     printf("A8.a %d\n",field_offset(A8,a));     printf("A8.b %d\n",field_offset(A8,b));     printf("A8.c %d\n",field_offset(A8,c));     printf("\n");     printf("A16.a %d\n",field_offset(A16,a));     printf("A16.b %d\n",field_offset(A16,b));     printf("A16.c %d\n",field_offset(A16,c));     printf("\n");     return 0; } //AD.a 0 //AD.b 4 //AD.c 24 // //A1.a 0 //A1.b 4 //A1.c 17 // //A2.a 0 //A2.b 4 //A2.c 18 // //A4.a 0 //A4.b 4 //A4.c 20 // //A8.a 0 //A8.b 4 //A8.c 24 // //A16.a 0 //A16.b 4 //A16.c 24 // //


Question: 输入数组元素个数多于数组个数时，多出的元素去哪儿了？这个程序输入abcdef,为什么输出的是 bc啊?b前面为什么是空着的啊

getchar()应该是吸收了回车字符，如果不用getchar()吸收，为什么那么就相当于我输入了abc还有一个回车字符，这样就超出了数组数，此时a数组里放的又是些什么元素呢？麻烦大神解释一下，感激不尽！感激不尽!

试试  #include<stdio.h> int main() {int i;   char a[3] ={0},b[3] = {0};   gets(a);   getchar()   gets(b);   for(i=0;i<=2;i++)   {       printf("%c",a[i]);     printf("%c",b[i]);   }   return 0; }

谁说输出的是bc了 你眼花了吧 分明是abc啊

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

X86 堆栈是向下生长的，最后分配的在低地址，先分配的在高地址。 随着不停的压栈，地址不停地减小。

在没有对齐和乱序存储的，情况下按定义顺序存储自动变量：  函数堆栈中的数据如下： 堆栈传递的函数参数      --->  [    ] 函数返回地址现场信息    --->  [    ] 第一个自动变量          --->  [    ] 第二个自动变量          --->  [    ] 。。。。。。。。  第N个自动变量           --->  [    ]

引用 3 楼 u012495471 的回复:我想问一下，如果我输入两个字符串，输入第一个时，如果我输入的字符数超出数组个数，那么超出的字符会去哪儿？ 如果编译器是正常的，按定义顺序存储变量的话；  函数内部，第一个变量的溢出，会覆盖调用函数时， 保存的，函数返回地址和调用函数前的现场信息，  这个现场信息，具体对于X86 32Bits 就是压入堆栈的EFLAGS。 如果还在继续溢出，会覆盖函数调用时，传递的函数参数---形参--继续溢出；  会覆盖调用函数的，那个函数的，堆栈帧里的数据 ----通常是局部自动变量，或者编译器安排的临时变量。  其他函数内部变量的溢出，会覆盖按照定义的逆序，依次覆盖对应的变量直到第一个变量，然后就和第一个变量相同了。

其实电脑开机后物理内存的每个字节都是可读写的，区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。

数组b溢出时，将覆盖数组a的内容！！

如果输入的字符数+1超过数组长度，则发生溢出。超出的字符会把a数组后面的内存覆盖掉。此函数会自动添加结束符('\0')；不包含最后的换行符。  参见：gets函数说明 最新的C标准（2011）已经删除了此函数。  引用 3 楼 u012495471 的回复:我想问一下，如果我输入两个字符串，输入第一个时，如果我输入的字符数超出数组个数，那么超出的字符会去哪儿？


tiny_printf("ssdcf","result is you are SB","is",33,'i',2.3f); 常量也有类型！ C++ Floating-Point Constants Floating-point constants specify values that must have a fractional part. These values contain decimal points (.) and can contain exponents.  Syntax  floating-constant :  fractional-constant exponent-partopt floating-suffixopt digit-sequence exponent-part floating-suffixopt  fractional-constant :  digit-sequenceopt . digit-sequence digit-sequence .  exponent-part :  e signopt digit-sequence E signopt digit-sequence  sign : one of  + –  digit-sequence :  digit digit-sequence digit  floating-suffix :one of  f l F L  Floating-point constants have a “mantissa,” which specifies the value of the number, an “exponent,” which specifies the magnitude of the number, and an optional suffix that specifies the constant’s type. The mantissa is specified as a sequence of digits followed by a period, followed by an optional sequence of digits representing the fractional part of the number. For example:  18.46 38.  The exponent, if present, specifies the magnitude of the number as a power of 10, as shown in the following example:  18.46e0      // 18.46 18.46e1      // 184.6  If an exponent is present, the trailing decimal point is unnecessary in whole numbers such as 18E0.  Floating-point constants default to type double. By using the suffixes f or l (or F or L — the suffix is not case sensitive), the constant can be specified as float or long double, respectively.  Although long double and double have the same representation, they are not the same type. For example, you can have overloaded functions like  void func( double );  and   void func( long double );  C++ Integer Constants Integer constants are constant data elements that have no fractional parts or exponents. They always begin with a digit. You can specify integer constants in decimal, octal, or hexadecimal form. They can specify signed or unsigned types and long or short types.  Syntax  integer-constant :  decimal-constant integer-suffixopt octal-constant integer-suffixopt hexadecimal-constant integer-suffixopt 'c-char-sequence'  decimal-constant :  nonzero-digit decimal-constant digit  octal-constant :  0 octal-constant octal-digit  hexadecimal-constant :  0x hexadecimal-digit 0X hexadecimal-digit hexadecimal-constant hexadecimal-digit  nonzero-digit : one of  1 2 3 4 5 6 7 8 9  octal-digit : one of  0 1 2 3 4 5 6 7  hexadecimal-digit : one of  0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F  integer-suffix :  unsigned-suffix long-suffixopt long-suffix unsigned-suffixopt  unsigned-suffix : one of  u U  long-suffix : one of  l L  64-bit integer-suffix :  i64  To specify integer constants using octal or hexadecimal notation, use a prefix that denotes the base. To specify an integer constant of a given integral type, use a suffix that denotes the type.  To specify a decimal constant, begin the specification with a nonzero digit. For example:  int i = 157;   // Decimal constant int j = 0198;  // Not a decimal number; erroneous octal constant int k = 0365;  // Leading zero specifies octal constant, not decimal  To specify an octal constant, begin the specification with 0, followed by a sequence of digits in the range 0 through 7. The digits 8 and 9 are errors in specifying an octal constant. For example:  int i = 0377;   // Octal constant int j = 0397;   // Error: 9 is not an octal digit  To specify a hexadecimal constant, begin the specification with 0x or 0X (the case of the “x” does not matter), followed by a sequence of digits in the range 0 through 9 and a (or A) through f (or F). Hexadecimal digits a (or A) through f (or F) represent values in the range 10 through 15. For example:  int i = 0x3fff;   // Hexadecimal constant int j = 0X3FFF;   // Equal to i  To specify an unsigned type, use either the u or U suffix. To specify a long type, use either the l or L suffix. For example:  unsigned uVal = 328u;             // Unsigned value long lVal = 0x7FFFFFL;            // Long value specified                                    //  as hex constant unsigned long ulVal = 0776745ul;  // Unsigned long value

case 'c': 			printf("%c ",(char)va_arg(ap,int)); 			break; 		case 'f': 			printf("%f ",(float)va_arg(ap,double)); 			break;  引用 楼主 abc594986308 的回复:#include <stdio.h> #include <stdarg.h> #include <assert.h> void tiny_printf(char *format,...) { 	int i; 	va_list ap;  	va_start(ap,format); 	for(i=0;format[i]!='\0';i++) 	{ 		switch(format[i]) 		{ 		case 's':  			printf("%s ",va_arg(ap,char *)); 			break; 		case 'd': 			printf("%d ",va_arg(ap,int)); 			break; 		case 'c': 			printf("%c ",va_arg(ap,char *)); 			break; 		case 'f': 			printf("%f ",va_arg(ap,float)); 			break; 		default: 			assert(0); 		} 	} 	va_end(ap); 	putchar('\n'); }  int main(void) { 	tiny_printf("ssdcf","result is you are SB","is",33,'i',2.3); 	return 0; }


Question: 空else语句的写法哪个是对的？有什么区别

非常感谢大家

个人的习惯，表示一种逻辑框架，只是当前没有实现

推荐写法： else     NULL;

都可以。 ;表示空语句 因为{}中可以插入0~任意多条语句，空语句也算一条语句。 所以 { } // 0条语句  {     ; //1条空语句 }  {     xxxx; //随便一条语句 }  {     ;     ;     ; } 随便几条语句（包括空语句）  都是合法的。  因此，;可以有，但是是多余的。 如果没有大括号，则不能省，比如 if (...) xxx; else ; 当然，这等价 if (...) xxx;

引用 14 楼 pk297935908 的回复:方便代码的后续扩展，这种构架以防代码后续处理 如果这样，就像12楼那样比较好；  因为你的代码，不知道最后会写成啥样。 都放到大括号内，方便修改和调试。

方便代码的后续扩展，这种构架以防代码后续处理

没有区别的 分号再多都不会错

没有区别可言

if { ... } else ;

//一般习惯这样 if (...) {     //没有的话就直接写个注释在这，说不定以后可能用上 } else {     //没有的话就直接写个注释在这，说不定以后可能用上 }

都可以 但纠结这样的问题貌似没必要。。。。

写个空 else 的目的是什么呢！！！！

都不好，我的建议是，if/else要么都加大括号，要么都不加。  引用 楼主 CS_DN_Sniper 的回复: 写法1: if // 略 else {     // do nothing } 写法2： if // 略 else {     ;// do nothing }

都对

你可以上机操作下！

没有区别！效果一样的！ 都不会执行什么！

这两个有区别吗？


Question: DES加密算法 密钥位数

DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位，产生最大 64 位的分组大小


Question: 小型嵌入式系统上的字库问题

引用 9 楼 huabinsir 的回复:是这样的:  嵌入式产品上有软件，产品(包括软件)有可能卖给不同国家的客户，所以软件上的标签提示等要实现多国文字的显示. 参考7楼。

引用 1 楼 turingo 的回复:1、沿用当年DOS下著名的UCDOS字库； 2、自己写工具从Windows或者是Linux的True Type字库提取字模； 3、自己写工具从开源的True Type字库提取字模。  [quote=引用 楼主 huabinsir 的回复:] 小型嵌入式系统上的字库问题  小型嵌入式系统上经常要根据用户来换字库，请问字库是如何生成的(得到的)[/quote]

可以加一个字库芯片 ，如 gt21 系列

C源代码:12x12汉字点阵库(支持GBK)及其处理 http://download.csdn.net/detail/zhao4zhong1/2180241

1、沿用当年DOS下著名的UCDOS字库； 2、自己写工具从Windows或者是Linux的True Type字库提取字模； 3、自己写工具从开源的True Type字库提取字模。  引用 楼主 huabinsir 的回复:小型嵌入式系统上的字库问题  小型嵌入式系统上经常要根据用户来换字库，请问字库是如何生成的(得到的)

应该有商业字库

引用 5 楼 huabinsir 的回复:我不是这个意思.  小系统上要实现多国语言，这里所说的字库是指 多国语言字库. 从Windows里面抓。仅供参考： #pragma comment(lib,"gdi32") #include <windows.h> #include <stdio.h>  int main() {     const DWORD uWidth = 18 + 17 * 256, uHeight = 18 + 17 * 128;      PBITMAPINFO pbmi = (PBITMAPINFO) LocalAlloc (LPTR, sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2);     pbmi->bmiHeader.biSize = sizeof (BITMAPINFOHEADER);     pbmi->bmiHeader.biWidth = uWidth;     pbmi->bmiHeader.biHeight = uHeight;     pbmi->bmiHeader.biPlanes = 1;     pbmi->bmiHeader.biBitCount = 1;     pbmi->bmiHeader.biSizeImage = ((uWidth + 31) & ~31) / 8 * uHeight;     pbmi->bmiColors[0].rgbBlue = 0;     pbmi->bmiColors[0].rgbGreen = 0;     pbmi->bmiColors[0].rgbRed = 0;     pbmi->bmiColors[1].rgbBlue = 255;     pbmi->bmiColors[1].rgbGreen = 255;     pbmi->bmiColors[1].rgbRed = 255;      HDC hDC = CreateCompatibleDC (0);     void * pvBits;     HBITMAP hBitmap = CreateDIBSection (hDC, pbmi, 0, &pvBits, NULL, 0);     SelectObject (hDC, hBitmap);     HFONT hFont = CreateFont (16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "宋体"); //  HFONT hFont = CreateFont (16, 0, 0, 0, 0, 0, 0, 0, SHIFTJIS_CHARSET, 0, 0, 0, 0, "宋体");     SelectObject (hDC, hFont);     BitBlt (hDC, 0, 0, uWidth, uHeight, NULL, 0, 0, WHITENESS);      char c[4];     int i, j;     for (i = 128; i < 256; i++) {         sprintf (c, "%02X", i);         TextOut (hDC, 1, (i - 127) * 17 + 1, c, 2);     }     for (j = 0; j < 256; j++) {         sprintf (c, "%02X", j);         TextOut (hDC, (j + 1)* 17 + 1, 1, c, 2);     }     for (i = 128; i < 256; i++) {         for (j = 0; j < 256; j++) {             c[0] = (char) i;             c[1] = (char) j;             TextOut (hDC, (j + 1) * 17 + 1, (i - 127) * 17 + 1, c, 2);         }     }     for (i = 0; i < 130; i++) {         MoveToEx (hDC, 0, i * 17, NULL);         LineTo (hDC, uWidth, i * 17);     }     for (j = 0; j < 258; j++) {         MoveToEx (hDC, j * 17, 0, NULL);         LineTo (hDC, j * 17, uHeight);     }      BITMAPFILEHEADER bmfh;     bmfh.bfType = *(PWORD) "BM";     bmfh.bfReserved1 = 0;     bmfh.bfReserved2 = 0;     bmfh.bfOffBits = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2;     bmfh.bfSize = bmfh.bfOffBits + pbmi->bmiHeader.biSizeImage;      HANDLE hFile = CreateFile ("goal.bmp", GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);     if (hFile != INVALID_HANDLE_VALUE) {         DWORD dwWritten;         WriteFile (hFile, &bmfh, sizeof (BITMAPFILEHEADER), &dwWritten, NULL);         WriteFile (hFile, pbmi, sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2, &dwWritten, NULL);         WriteFile (hFile, pvBits, pbmi->bmiHeader.biSizeImage, &dwWritten, NULL);          CloseHandle (hFile);     }      DeleteObject (hFont);     DeleteObject (hBitmap);     DeleteDC (hDC);     LocalFree (pbmi);      return 0; }  用PhotoShop查看这个代码生成的goal.bmp 提醒：侵犯字库版权问题请自己承担。

用utf-8编码组织。  引用 5 楼 huabinsir 的回复:我不是这个意思.  小系统上要实现多国语言，这里所说的字库是指 多国语言字库.

我不是这个意思.  小系统上要实现多国语言，这里所说的字库是指 多国语言字库.


这个问题没有人知道其他的么？？？？？？？

fclose, _fcloseall Closes a stream (fclose) or closes all open streams (_fcloseall).  int fclose( FILE *stream );  int _fcloseall( void );  Function Required Header Compatibility  fclose <stdio.h> ANSI, Win 95, Win NT  _fcloseall <stdio.h> ANSI, Win 95, Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  fclose returns 0 if the stream is successfully closed. _fcloseall returns the total number of streams closed. Both functions return EOF to indicate an error.  Parameter  stream  Pointer to FILE structure  Remarks  The fclose function closes stream. _fcloseall closes all open streams except stdin, stdout, stderr (and, in MS-DOS®, _stdaux and _stdprn). It also closes and deletes any temporary files created by tmpfile. In both functions, all buffers associated with the stream are flushed prior to closing. System-allocated buffers are released when the stream is closed. Buffers assigned by the user with setbuf and setvbuf are not automatically released.  Example  /* FOPEN.C: This program opens files named "data"  * and "data2".It  uses fclose to close "data" and  * _fcloseall to close all remaining files.  */  #include <stdio.h>  FILE *stream, *stream2;  void main( void ) {    int numclosed;     /* Open for read (will fail if file "data" does not exist) */    if( (stream  = fopen( "data", "r" )) == NULL )       printf( "The file 'data' was not opened\n" );    else       printf( "The file 'data' was opened\n" );     /* Open for write */    if( (stream2 = fopen( "data2", "w+" )) == NULL )       printf( "The file 'data2' was not opened\n" );    else       printf( "The file 'data2' was opened\n" );     /* Close stream */    if( fclose( stream ) )       printf( "The file 'data' was not closed\n" );     /* All other files are closed: */    numclosed = _fcloseall( );    printf( "Number of files closed by _fcloseall: %u\n", numclosed ); }   Output  The file 'data' was opened The file 'data2' was opened Number of files closed by _fcloseall: 1     Stream I/O Routines  See Also   _close, _fdopen, fflush, fopen, freopen

FCLOSE Section: Linux Programmer's Manual (3 ) Updated: 1998-04-10  --------------------------------------------------------------------------------    NAME fcloseall - close all open streams    SYNOPSIS #define _GNU_SOURCE  #include <stdio.h>   int fcloseall(void);     DESCRIPTION The fcloseall function dissociates all open streams from its underlying file or set of functions. Any buffered output data is written first, using fflush(3). Note that the standard streams (stdin, stdout and stderr) are also closed.    RETURN VALUE This function always returns 0.    SEE ALSO close(2), fclose(3), fflush(3), fopen(3), setbuf(3)    CONFORMING TO The fcloseall function is a GNU extension.  --------------------------------------------------------------------------------


Question: 关于贝塞尔曲线的一个概念性问题

导数与二阶导数

为什么图2是错的？我的问题就是不知道如何回答 求大神点拨

求助！！！！

引用 3 楼 turingo 的回复:参考http://www.jcwcn.com/article-32008-1.html  [quote=引用 楼主 lion1899 的回复:]  期望达到的效果  错误的效果  认为正确的效果  问：图1和图3为什么正确？ 求理论支持！  本人刚涉及到贝塞尔曲线控制点算法的研究，虽然已经能算出让曲线平滑的算法，但是，不知道所谓的正确的概念。 求高手解答！拜谢！[/quote]  感谢您的回复，但是这篇帖子里没有我所需要的概念性问题。 我想问的是：          开放性的（由多条线段组成）贝塞尔曲线，当控制点满足什么样的条件时，可以认为是合理的控制点，是正确的控制点，再次感谢回复！

参考http://www.jcwcn.com/article-32008-1.html  引用 楼主 lion1899 的回复: 期望达到的效果  错误的效果  认为正确的效果  问：图1和图3为什么正确？ 求理论支持！  本人刚涉及到贝塞尔曲线控制点算法的研究，虽然已经能算出让曲线平滑的算法，但是，不知道所谓的正确的概念。 求高手解答！拜谢！

求大神点拨~~

图1为两条曲线

引用 9 楼 zhao4zhong1 的回复:[贝塞尔曲线(Bezier Curves) 2d实现] http://blog.csdn.net/pizi0475/article/details/12883403 嗯 看到了  先表示感谢！对于控制点的算法，我阅读了相关的文章，已经有了一套算法，图3就是，但是我的BOSS问了我一个问题，也是一个质疑，图2错了么？图2也对吧，怎么判定图3一定是对的呢？ 这个问题难倒我了，我的疑问主要就在这里了。 怎么才算是判定图3中的曲线是合理的唯一的一条曲线呢？

引用 7 楼 zhao4zhong1 的回复:http://blog.csdn.net/pizi0475 谢谢！！


Question: ->求讲解

引用 3 楼 max_min_ 的回复:NVIC指针的成员变量Enable[0]的值赋值为0x00040000 后面的错了吧！是不是源码阿？ 后面那个搞错了，不好意思。。。

NVIC... 这是 Arm Cortex 里面的东西 ~  GPIOB 那行比较奇怪 ~ 有贴错吗 ?

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

0x00040000 是一个值啊

NVIC->Enable[0] = 0x00040000是把NVIC结构体的Enable[0]域的赋值为0x00040000 GPIOB=GPIOB-> 0x33333333，没有这样的写法  引用 楼主 skevil 的回复:NVIC->Enable[0] = 0x00040000  是把NVIC指向0x00040000这个地址吗？   GPIOB=GPIOB-> 0x33333333;  那么这个又是什么意思呢？

GPIO?lz说的是嵌入式里面的东西哦，不太懂

第二个没看懂。。。


Question: 关于求字符串字符个数的问题

_mbslen  _mbstrlen

引用 3 楼 lidayonglove 的回复:EXEC SQL include sqlca; EXEC SQL include oraca; EXEC SQL include clsdbbuf.h; EXEC SQL include clssysvar.h; #include "clspub.h" #include "eftp_pub.h" #include "cpcb_api.h" int main(int argc,char* argv[]) {  char toString[200]; memset(toString,  0,sizeof(toString)); strcpy(toString,   argv[1]); int b,en=0,ch=0,nu=0,ot=0,sp=0; int Count=0; //en 英文字母数，ch 中文字符数，nu 数字数量，ot 其他字符数量，sp 空格数量 trim(toString); for(b=0;b<strlen(toString);++b) {   if('\0'==toString[b]) break;//判断是否结束   if(toString[b]>='a'&&toString[b]<='z'||toString[b]>='A'&&toString[b]<='Z')//判断是否是字母    ++en;   else if(toString[b]>='0'&&toString[b]<='9')//判断是否是数字    ++nu;   else if(toString[b]==' ')    ++sp;   else if(toString[b]&0x80)   {    ++b;    ++ch;   }   else    ++ot; } Count=en+nu+sp+ch+ot;   printf("英文字符共%d个\n中文字符共%d个\n数字共%d个\n空格共%d个\n其他字符共%d个",en,ch,nu,sp,ot);//打印输出结果   printf("字符总个数为[%d]",Count); return 0; }   我这个代码为什碰到空格就结束了，就不计算了 下面是执行结果 /app/clear/src/tools/charCount>charCount 李大勇123asd 1 s 英文字符共3个 中文字符共3个 数字共3个 空格共0个 其他字符共0个字符总个数为[9]我已经找到原因了，碰到空格就算是下一个参数了

引用 2 楼 turingo 的回复: int count(const char* str) { 	char* p = (char*)str; 	int c = 0;  	while(*p) 	{ 		if(*p & 0x80) 		{ 			c += 2; 			p += 2; 		} 		else 		{ 			c++; 			p++; 		} 	}  	return c; }  引用 楼主 lidayonglove 的回复:就是一个字符串，我需要统计出里面包含的字符个数，不是计算长度，也就是说一个汉字算一个、字母也算一个、数字也算一个，用什么方法你这个的确比我写的简单不少

strlen


Question: 有没关于c语言方面的书籍？

http://download.csdn.net/detail/max_min_/6333711 c和指针

是我的话， 我会先提高自己对编程的兴趣 去载个C语言经典算法100例来玩

引用 5 楼 Adol1111 的回复:《C Pirmer Plus》《c programing language》，入门绝对够了 ++ 这两本书是不错的，我比较推荐。关于读的先后顺序，我建议先看《C Prime Plus（第五版）》,看完了再看第二本吧。

《C Primer Plus 》

有很多，看你现在的水平了

引用 3 楼 neolyao 的回复:c programing language  ++

c programing language

你是要干什么用的，只是为了上课学习的，还是为了真的想学习编程？

C语言课程设计案例精编，当当网有


Question: 关于链表输出

不是这个的原因，看看错误提示，应该是 缺少了什么东西，就算把输出语句写成函数形式，也会出这个错误。 给出个具体的写法，关键是 我不知道到底是哪里错了，要是有个具体的写法就好了

不可以简单一点吗？ 写个输出struct MtdPartition的函数 在写个输出MtdWriteContext 的函数不就简单了么。

错误从 (*write).(*partition).device_index开始有的，就是说打印输出第二个结构体的时候出的错误

为什么要写成 (*write).stored  这样不是可以吗。。 write->stored

指针直接用->操作符 结构体用引用.操作符 不要乱用，不然会出错

5楼   这样 也不行 会提示  error: dereferencing pointer to incomplete type 错误


Question: const char** 转换问题

&是对于变量取地址，Str.c_str()返回的是一个值，不是一个变量。 你本来的代码是把值给了一个变量，取变量的地址。 你自己想想你现在的代码是个什么意思？

Str.c_str()本身就是一个地址值，所以不可以进行&操作。 pStr不一样，它是一个指针变量。

C++11右值引用→_→ 开玩笑的..不过你的确可以尝试下

Str.c_str()返回右值，实际上除非函数返回值是引用类型，否则函数返回的是右值类型。而取地址&需要左值

&用在变量前面是取地址，放在值前面是取啥？

Str.c_str() 返回一个地址 你可以对一个变量取址， 但是不能对一个常数取址


Question: for循环中加入scanf和printf出错，能帮忙看看不

十楼说的对，按照他说的执行成功，输出没问题！

楼主思路好不明确，仔细看看循环里的内容吧！

#include<stdio.h> #include<stdlib.h> #define N 100 #define M 10  void main() { 	int a[M][N] = {0}, b[M] = {0}, n = 0, m = 0;  	printf( "请输入存入数组的行数\n" ); 	scanf("%d",&n); 	printf( "请输入存入数组的列数\n" ); 	scanf("%d",&m); 	if( n > M || m > N ) 	{ 		return ; 	} 	 	for( int i = 0; i < n; i++ ) 	{ 		printf( "请输入a数组第%d行的系数\n", i ); 		for( int j = 0; j < m; j++ ) 		{ 			printf( "请输入a数组第%d列的系数", j ); 			scanf( "%d", &a[i][j] ); 		} 		printf( "请输入b数组第%d列的系数", i ); 		scanf( "%d", &b[i] ); 	} 	 	for( int i = 0; i < n; i++ ) 	{ 		printf( "请输入" ); 		for( int j = 0; j < m; j++ ) 		{ 			printf("%d  ", a[i][j] ); 		} 		printf( "%d\n", b[i] ); 	} 	system( "pause" ); 	return ; } 不知道这个是不是你要的

printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。  在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。

这个你的循环体有问题

// 试试这样子呢 int a[M][N],i,p,q,n,m,j,b[M];  	printf("请输入存入数组的行数："); 	scanf("%d", &n);   	printf("请输入存入数组的列数："); 	scanf("%d", &m);  	for(i=0; i<n; i++) 	{ 		printf("请输入第%d行的A系数\n", i+1); 		for(j=0; j<m; j++) 			scanf("%d", &a[i][j]); 		printf("请输入第%d行的B系数：", i+1); 		scanf("%d", &b[i]); 	}  	printf("\n\n数组列出如下：\n"); 	for(i=0; i<n; i++) 	{ 		printf("A："); 		for(j=0; j<m; j++) 			printf("%d	", a[i][j]); 		printf("	B：%d\n", b[i]); 	}

引用 5 楼 jianben123 的回复:谢谢大家的回复和帮忙，这个我是想在往两个数组中存放数据但是出现问题，谢谢你们的忙！ 一楼“使用scanf函数的时候注意I/O流中对于回车的处理，尤其在循环中”这个问题怎么避免？ 我那个按照四楼的说法改了下，但是输出是数据没放到数组中出错啦这是怎么回事  请输入存入数组的行数2 请输入存入数组的列数3 请输入第1的列系数1 22 21 请输入第1的B系数322 请输入第2的列系数1 2 2 请输入第2的B系数21 1  1  -858993460  -858993460  -858993460  -858993460  -858993460  -858993460  -8 58993460  -858993460  -858993460  0  0  0  798  438759246  6619235  6422627  668 4772  6226030  3473462  7340137  7471221  6684769  0  7274596  6881367  3407921  7798830  20  7864435  7536732  0  6881397  88  26  50  7536735  50  6357070  68 81396  50  7143535  108  0  0  7798895  0  0  0  0  0  0  0  0  请按任意键继续. . .  getchar函数调用一次，吃掉每次输入时多余的一个回车符！

for(j=0;j<m;i++) 这个for循环语句不妥，每次循环完成后j的值没有变化，所以这个循环是无限循环 后面应该是j++

不知道搂住想干所么，第2个for用j来判断，为什么用i++?? 最后一个for 也是用j作判断，为所么用i++??  以后贴程序最好说一下干什么用的，别人知道干什么，逻辑感会更好，比较容易看出问题 有行号的最好把行号也贴出来，方便回复修改哪一行

1. 插入源码 2. 指明错误

使用scanf函数的时候注意I/O流中对于回车的处理，尤其在循环中


Question: 真的郁闷了，求教linux C语言strstr函数问题

引用 8 楼 lishi_1991 的回复:我擦，看出来了，一直都是mmcblk1p* 突然变了，惯性思维害死人！多谢各位提醒啊 以为我年纪大了，眼睛不好使了呢

"mmcblk0p" 你匹配的字符串 "mmcblk1p1"你标记的字符串 不明白为什么你说打印出来了"mmcblk0p"

引用 5 楼 user-2 的回复:你的输出确实没看见 mmcblk0p 啊...画红线部分

引用 4 楼 lishi_1991 的回复:[quote=引用 2 楼 N_sev7 的回复:] 你确定有"mmcblk0p1"？？？！！！ 目测没有，打印不出来是因为返回null有啊，read_buf最后不是打印出来了mmcblockp1[/quote]      ret=strstr(read_buf,"mmcblk0p");  /////仔细检查一下你匹配的字符串

你的输出确实没看见 mmcblk0p 啊...

引用 2 楼 N_sev7 的回复:你确定有"mmcblk0p1"？？？！！！ 目测没有，打印不出来是因为返回null有啊，read_buf最后不是打印出来了mmcblockp1

再补充一下，如果一开始插了存储卡，执行结果是正常的，result = 1;但是printf("ret = %s\n",ret);还是不打印，拔下存储卡，会出现如下结果： 再插上存储卡就会出现上面执行的结果！ 各位求教，求指点迷津啊

再贴上一条比较全的执行结果  最郁闷的是为什么连printf("ret = %s\n",ret);都不打印呢


Question: printf函数

搞明白了 谢谢两位！

因为p指向一个字符串！p就标识字符串的首地址！ 加上printf函数是个格式化输出函数，%s，就是输出指针p指向的内容的！  int main() {     char *p = (char *)malloc(20);     memset(p, 0, 20); //防止出现乱码      strcpy(p,"hello");     printf("%s",p);  // p指向的存放在内存地址上的内容     printf("%p",p);  // p指向的内存地址 }

因为你输出的格式是%s 要给成*p的话 输出格式改成%c


Question: 学习C语言和高数的方法

苦命的孩子，呵呵！ 慢慢来，一切会好的！ 低调做事，抬头做人！

引用 楼主 u012435086 的回复: [size=18px] 开学两个多月了，感觉C语言和高数好难啊，有什么方法可以传授一下吗？谢谢！[/size]s  C语言，需要勤奋练习的。 我刚上大学那会儿，基本上一个 hello world 都很费解：为什么 #include <stdio.h> .... 什么 printf 。。。 当时觉得好费解，几乎连老师和同学都笑话我不是学计算机的料，呵呵  我只是好奇和求知欲：为什么计算机（软件）可以做出这个效果？计算机是个什么东西？计算机是如何执行代码指令的？记得当时我每次下课都逮着教师、教授问一些“奇葩”的问题……  给楼主鼓励一下，勤奋练习，是很重要的

引用 12 楼 zhao4zhong1 的回复:先下载Win-TC，然后参考C:\Win-TC\tcstudy.chm 那100题是不是特别重要？为什么？ 我感觉比《C primer plus》后面的题目普遍要简单些！

我也是大一，c语言就是多看书，工数把公式记熟，然后多！！做！！题！！

用c语言实现夹逼准则。 用C语言编写一元多项式求解！  。。。

引用 17 楼 u012207185 的回复:[quote=引用 12 楼 zhao4zhong1 的回复:] 先下载Win-TC，然后参考C:\Win-TC\tcstudy.chm 那100题是不是特别重要？为什么？ 我感觉比《C primer plus》后面的题目普遍要简单些！[/quote] 重要倒谈不上，先易后难练手用用。

先下载Win-TC，然后参考C:\Win-TC\tcstudy.chm

不要着急，也就一本课本，主要是花点时间，耐心，把基础概念理解了，不难的。

听我的没错，唯一的途径就是：反复练习。  高数练习：吉米多维奇习题集； C语言练习：刚入门的话，把课后习题反复做三遍即可；提升阶段可以考虑做算法题。

有些时候真的感觉是，书读百遍其义自见。我以前有的地方看不懂，然后我就把这个问题放到一边，过段时间再拿出来看一下，逐句揣摩，还不行就一直循环。当然在揣摩的过程中还应该多查阅资料，不管是网上的还是书本。然后在某个时刻，就顿悟了！

大一先玩够再说

多看看《C primer plus》把理论基础先打好

高数多做题，一般的题目都有一定的解法，熟能生巧而已。对一般的专业，高数70分和90分意义差别不大。 但C语言不同，它是以后学习所有编程语言的基础，认真看书，多多上机，最好每道题都做了，不放过任何一个细节问题，打好基础。这样以后再学C++或Java的时候，把侧重点放在面向对象上，语言细节就轻松点了。

努力学习，加大量的用心练习，自己去编写代码。

别人的学习方法不一定适合你

多跑跑机房，将书上的代码都敲一遍，将书一字一句的看完，要理解！！！多想想为什么神奇的代码能让电脑这个冷冰冰的东西按代码的制定去做一些事情，想多了就明白了     高数么，虽然我大学学的不好，但是除了一些地方特别难（现实工作中用到的可能性较小）之外，其他的都很简单，听老师讲讲，做做课后练习就可以踢球去了

其实超级简单，多敲代码就好了，不会了来这问。

高数上课时记笔记就不会分心，不管老师讲的是不是书上的题都往你本子上写，过段时间你就懂了

高数，听听老师解题思路，学习下分析题目的思维  c语言，之前没有接触过的话，一下子可能有点难，慢慢来，学习新东西就是这样的！ 多看看书，上课认真听听老师讲的理论知识！课后多敲点例程！多看书，先把理论基础学好！


Question: 求解有没有一个能返回文件长度的函数

STAT Section: Linux Programmer's Manual (2) Updated: 2004-06-23  --------------------------------------------------------------------------------    NAME stat, fstat, lstat - get file status    SYNOPSIS #include <sys/types.h>  #include <sys/stat.h>  #include <unistd.h>  int stat(const char *file_name, struct stat *buf);  int fstat(int filedes, struct stat *buf);  int lstat(const char *file_name, struct stat *buf);     DESCRIPTION These functions return information about the specified file. You do not need any access rights to the file to get this information but you need search rights to all directories named in the path leading to the file.   stat stats the file pointed to by file_name and fills in buf.   lstat is identical to stat, except in the case of a symbolic link, where the link itself is stat-ed, not the file that it refers to.   fstat is identical to stat, only the open file pointed to by filedes (as returned by open(2)) is stat-ed in place of file_name.    They all return a stat structure, which contains the following fields:    struct stat {     dev_t         st_dev;      /* device */     ino_t         st_ino;      /* inode */     mode_t        st_mode;     /* protection */     nlink_t       st_nlink;    /* number of hard links */     uid_t         st_uid;      /* user ID of owner */     gid_t         st_gid;      /* group ID of owner */     dev_t         st_rdev;     /* device type (if inode device) */     off_t         st_size;     /* total size, in bytes */     blksize_t     st_blksize;  /* blocksize for filesystem I/O */     blkcnt_t      st_blocks;   /* number of blocks allocated */     time_t        st_atime;    /* time of last access */     time_t        st_mtime;    /* time of last modification */     time_t        st_ctime;    /* time of last status change */ };  The value st_size gives the size of the file (if it is a regular file or a symlink) in bytes. The size of a symlink is the length of the pathname it contains, without trailing NUL.   The value st_blocks gives the size of the file in 512-byte blocks. (This may be smaller than st_size/512 e.g. when the file has holes.) The value st_blksize gives the "preferred" blocksize for efficient file system I/O. (Writing to a file in smaller chunks may cause an inefficient read-modify-rewrite.)   Not all of the Linux filesystems implement all of the time fields. Some file system types allow mounting in such a way that file accesses do not cause an update of the st_atime field. (See `noatime' in mount(8).)   The field st_atime is changed by file accesses, e.g. by execve(2), mknod(2), pipe(2), utime(2) and read(2) (of more than zero bytes). Other routines, like mmap(2), may or may not update st_atime.   The field st_mtime is changed by file modifications, e.g. by mknod(2), truncate(2), utime(2) and write(2) (of more than zero bytes). Moreover, st_mtime of a directory is changed by the creation or deletion of files in that directory. The st_mtime field is not changed for changes in owner, group, hard link count, or mode.   The field st_ctime is changed by writing or by setting inode information (i.e., owner, group, link count, mode, etc.).   The following POSIX macros are defined to check the file type using the st_mode field:   S_ISREG(m) is it a regular file?  S_ISDIR(m) directory?  S_ISCHR(m) character device?  S_ISBLK(m) block device?  S_ISFIFO(m) fifo?  S_ISLNK(m) symbolic link? (Not in POSIX.1-1996.)  S_ISSOCK(m) socket? (Not in POSIX.1-1996.)  The following flags are defined for the st_mode field: S_IFMT 0170000 bitmask for the file type bitfields   S_IFSOCK 0140000 socket   S_IFLNK 0120000 symbolic link   S_IFREG 0100000 regular file   S_IFBLK 0060000 block device   S_IFDIR 0040000 directory   S_IFCHR 0020000 character device   S_IFIFO 0010000 fifo   S_ISUID 0004000 set UID bit   S_ISGID 0002000 set GID bit (see below)   S_ISVTX 0001000 sticky bit (see below)   S_IRWXU 00700 mask for file owner permissions   S_IRUSR 00400 owner has read permission   S_IWUSR 00200 owner has write permission   S_IXUSR 00100 owner has execute permission   S_IRWXG 00070 mask for group permissions   S_IRGRP 00040 group has read permission   S_IWGRP 00020 group has write permission   S_IXGRP 00010 group has execute permission   S_IRWXO 00007 mask for permissions for others (not in group)   S_IROTH 00004 others have read permission   S_IWOTH 00002 others have write permisson   S_IXOTH 00001 others have execute permission   The set GID bit (S_ISGID) has several special uses: For a directory it indicates that BSD semantics is to be used for that directory: files created there inherit their group ID from the directory, not from the effective group ID of the creating process, and directories created there will also get the S_ISGID bit set. For a file that does not have the group execution bit (S_IXGRP) set, it indicates mandatory file/record locking. The `sticky' bit (S_ISVTX) on a directory means that a file in that directory can be renamed or deleted only by the owner of the file, by the owner of the directory, and by a privileged process.     RETURN VALUE On success, zero is returned. On error, -1 is returned, and errno is set appropriately.    ERRORS EACCES  Search permission is denied for one of the directories in the path prefix of file_name. (See also path_resolution(2).)  EBADF  filedes is bad.  EFAULT  Bad address.  ELOOP  Too many symbolic links encountered while traversing the path.  ENAMETOOLONG  File name too long.  ENOENT  A component of the path file_name does not exist, or the path is an empty string.  ENOMEM  Out of memory (i.e. kernel memory).  ENOTDIR  A component of the path is not a directory.     CONFORMING TO The stat and fstat calls conform to SVr4, SVID, POSIX, X/OPEN, BSD 4.3. The lstat call conforms to 4.3BSD and SVr4. SVr4 documents additional fstat error conditions EINTR, ENOLINK, and EOVERFLOW. SVr4 documents additional stat and lstat error conditions EINTR, EMULTIHOP, ENOLINK, and EOVERFLOW. Use of the st_blocks and st_blksize fields may be less portable. (They were introduced in BSD. Are not specified by POSIX. The interpretation differs between systems, and possibly on a single system when NFS mounts are involved.)  POSIX does not describe the S_IFMT, S_IFSOCK, S_IFLNK, S_IFREG, S_IFBLK, S_IFDIR, S_IFCHR, S_IFIFO, S_ISVTX bits, but instead demands the use of the macros S_ISDIR(), etc. The S_ISLNK and S_ISSOCK macros are not in POSIX.1-1996, but both will be in the next POSIX standard; the former is from SVID 4v2, the latter from SUSv2.   Unix V7 (and later systems) had S_IREAD, S_IWRITE, S_IEXEC, where POSIX prescribes the synonyms S_IRUSR, S_IWUSR, S_IXUSR.     OTHER SYSTEMS Values that have been (or are) in use on various systems: hex name ls octal description   f000 S_IFMT  170000 mask for file type   0000   000000 SCO out-of-service inode, BSD unknown type       SVID-v2 and XPG2 have both 0 and 0100000 for ordinary file   1000 S_IFIFO p| 010000 fifo (named pipe)   2000 S_IFCHR c 020000 character special (V7)   3000 S_IFMPC  030000 multiplexed character special (V7)   4000 S_IFDIR d/ 040000 directory (V7)   5000 S_IFNAM  050000 XENIX named special file       with two subtypes, distinguished by st_rdev values 1, 2:   0001 S_INSEM s 000001 XENIX semaphore subtype of IFNAM   0002 S_INSHD m 000002 XENIX shared data subtype of IFNAM   6000 S_IFBLK b 060000 block special (V7)   7000 S_IFMPB  070000 multiplexed block special (V7)   8000 S_IFREG - 100000 regular (V7)   9000 S_IFCMP  110000 VxFS compressed   9000 S_IFNWK n 110000 network special (HP-UX)   a000 S_IFLNK l@ 120000 symbolic link (BSD)   b000 S_IFSHAD  130000 Solaris shadow inode for ACL (not seen by userspace)   c000 S_IFSOCK s= 140000 socket (BSD; also "S_IFSOC" on VxFS)   d000 S_IFDOOR D> 150000 Solaris door   e000 S_IFWHT w% 160000 BSD whiteout (not used for inode)          0200 S_ISVTX  001000 `sticky bit': save swapped text even after use (V7)       reserved (SVID-v2)       On non-directories: don't cache this file (SunOS)       On directories: restricted deletion flag (SVID-v4.2)   0400 S_ISGID  002000 set group ID on execution (V7)       for directories: use BSD semantics for propagation of gid   0400 S_ENFMT  002000 SysV file locking enforcement (shared w/ S_ISGID)   0800 S_ISUID  004000 set user ID on execution (V7)   0800 S_CDF  004000 directory is a context dependent file (HP-UX)    A sticky command appeared in Version 32V AT&T UNIX.       SEE ALSO chmod(2), chown(2), readlink(2), utime(2), capabilities(7)  --------------------------------------------------------------------------------

_stat, _wstat, _stati64, _wstati64 Get status information on a file.  int _stat( const char *path, struct _stat *buffer );  __int64 _stati64( const char *path, struct _stat *buffer );  int _wstat( const wchar_t *path, struct _stat *buffer );  __int64 _wstati64( const wchar_t *path, struct _stat *buffer );  Routine Required Header Optional Headers Compatibility  _stat <sys/types.h> followed by <sys/stat.h> <errno.h> Win 95, Win NT  _wstat <sys/types.h> followed by <sys/stat.h> or <wchar.h> <errno.h> Win NT  _stati64 <sys/types.h> followed by <sys/stat.h> <errno.h> Win 95, Win NT  _wstati64 <sys/types.h> followed by <sys/stat.h> or <wchar.h> <errno.h> Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  Each of these functions returns 0 if the file-status information is obtained. A return value of –1 indicates an error, in which case errno is set to ENOENT, indicating that the filename or path could not be found.  Parameters  path  Path of existing file  buffer  Pointer to structure that stores results  Remarks  The _stat function obtains information about the file or directory specified by path and stores it in the structure pointed to by buffer. _stat automatically handles multibyte-character string arguments as appropriate, recognizing multibyte-character sequences according to the multibyte code page currently in use.   _wstat is a wide-character version of _stat; the path argument to _wstat is a wide-character string. _wstat and _stat behave identically except that _wstat does not handle multibyte-character strings.  Generic-Text Routine Mappings  TCHAR.H Routine  _UNICODE & _MBCS Not Defined _MBCS Defined _UNICODE Defined  _tstat _stat _stat _wstat  _tstati64 _stati64 _stati64 _wstati64    The _stat structure, defined in SYS\STAT.H, includes the following fields.  st_gid  Numeric identifier of group that owns file (UNIX-specific) This field will always be zero on NT systems. A redirected file is classified as an NT file.  st_atime  Time of last access of file.  st_ctime  Time of creation of file.  st_dev  Drive number of the disk containing the file (same as st_rdev).  st_ino  Number of the information node (the inode) for the file (UNIX-specific). On UNIX file systems, the inode describes the file date and time stamps, permissions, and content. When files are hard-linked to one another, they share the same inode. The inode, and therefore st_ino, has no meaning in the FAT, HPFS, or NTFS file systems.  st_mode  Bit mask for file-mode information. The _S_IFDIR bit is set if path specifies a directory; the _S_IFREG bit is set if path specifies an ordinary file or a device. User read/write bits are set according to the file’s permission mode; user execute bits are set according to the filename extension.  st_mtime  Time of last modification of file.  st_nlink  Always 1 on non-NTFS file systems.  st_rdev  Drive number of the disk containing the file (same as st_dev).  st_size  Size of the file in bytes; a 64-bit integer for _stati64 and _wstati64  st_uid  Numeric identifier of user who owns file (UNIX-specific). This field will always be zero on NT systems. A redirected file is classified as an NT file.  If path refers to a device, the size, time, _dev, and _rdev fields in the _stat structure are meaningless. Because STAT.H uses the _dev_t type that is defined in TYPES.H, you must include TYPES.H before STAT.H in your code.  Example   /* STAT.C: This program uses the _stat function to  * report information about the file named STAT.C.  */  #include <time.h> #include <sys/types.h> #include <sys/stat.h> #include <stdio.h>  void main( void ) {    struct _stat buf;    int result;    char buffer[] = "A line to output";     /* Get data associated with "stat.c": */    result = _stat( "stat.c", &buf );     /* Check if statistics are valid: */    if( result != 0 )       perror( "Problem getting information" );    else    {       /* Output some of the statistics: */       printf( "File size     : %ld\n", buf.st_size );       printf( "Drive         : %c:\n", buf.st_dev + 'A' );       printf( "Time modified : %s", ctime( &buf.st_atime ) );    } }   Output  File size     : 745 Drive         : C: Time modified : Tue May 03 00:00:00 1994   File Handling Routines  See Also   _access, _fstat, _getmbcp, _setmbcp

引用 2 楼 max_min_ 的回复:#include <stdio.h>  int main()  {    FILE *fp;    char filename[80];    long length;    printf("输入文件名:");    gets(filename);    //以二进制读文件方式打开文件    fp=fopen(filename,"rb");    if(fp==NULL)       printf("file not found!\n");    else       {         //把文件的位置指针移到文件尾           fseek(fp,OL,SEEK_END);          //获取文件长度;           length=ftell(fp);           printf("该文件的长度为%1d字节\n",length);           fclose(fp);        }  }   获取文件大小，网上很多的！ 支持版主的源码解答，比直接掉库函数要学到的东西多

Win32下，DWORD GetFileSize( HANDLE hFile, DWORD * dwHightDword );

自己封装一个吧 windows还是Linux


Question: 求教-逻辑运算

ls推荐的帖子，建议lz去看一下，关于lz的问题，lz首先要明白四点： （1）关于前缀++、--和后缀++、--的规则，lz去看一下ls两位推荐的帖子吧，肯定是好的 （2）在C/C++中，非0的整数是被认为是逻辑1的（即true）； （3）逻辑或运算||和逻辑与运算&&是有短路特性的，因为||、&&是左结合运算符，会先计算左边的值，如果左边的值可以确定这个逻辑表达式的结果的话，||、&&就不会继续在计算右边的值了，就是说，如果||左边的表达式逻辑上是1，则||不会再去管右边表达式的值，如果&&左边表达式逻辑上是0，则&&不会再去管右边表达式的值了； （4）&&和||的优先级是&&高于||的 所以：   int x,y,z;   x=y=z=6;   ++x&&++y&&++z;//第一个&&左边++x是7（逻辑1），继续计算右边的++y&&++z                 //第二个&&左边++y是7（逻辑1），继续计算++z，又是7（逻辑1）                 //所以最终逻辑表达式等效于1 && (1 && 1) = 1                 //x = y = z = 7   printf("x=%d\ty=%d\tz=%d\n",x,y,z); //========================================================= x=y=z=-8;   ++x||++y&&++z;//等效于-7(已经是逻辑1了) || anything I don't care as I'm determined to be 1                 //所以++y&&++z都没有执行，最终x = -7, y = z = -8   printf("x=%d\ty=%d\tz=%d\n",x,y,z); //========================================================= x=y=z=-3;   x++&&--y&&z--||--x;//等效于-2&&-4&&-3(已经是逻辑1了) || anything I don't care                       //所以x = -2, y = -4, z = -4   printf("x=%d\ty=%d\tz=%d\n",x,y,z);   再遇到类似的问题，lz不确定或者不懂的时候要学会设断点调试才行呢

引用 2 楼 max_min_ 的回复:http://bbs.csdn.net/topics/370153775 参考这里！就不再纠结了！ 没必要讨论在C语言里原本并无意义的问题

哎。。。


Question: 关于getchar（）出现的位置 小白求解

引用 7 楼 AnYidan 的回复:getchar()在 scanf() 后是为了取出输入缓存中的“enter" getchar()在 printf() 后是为了让console 停顿 方便观察输出 言简意赅

fread() 和 fwrite() 函数使用时注意：   The offset of a member within a structure can differ between compilers and systems, because of different alignment requirements. Indeed, some compilers have an option allowing structures to be packed tightly, to save space with a possible runtime performance penalty, or aligned accurately, to optimize runtime access of each member. This means that even on a single system, the binary layout of a structure can differ, depending on compiler options.  The binary formats used to store multibyte integers and floating-point values differ among machine architectures.

（1）printf后面写getchar()的作用 getchar()是读入输入流中的一个字符，至于lz说的printf之后的getchar()，应该是方便观察前面printf的输出吧，因为输入流中没有字符时，调用getchar()会造成等待输入，这样就可以起到system("pause")的作用了 （2）fread读入结构会有乱码 struct Data{     //... } a; 首先你要确定你的结构体是类似fwrite(&a, sizeof(Data), 1, fp)这样按字节写进去的，中间没有换行或者空格，这样才能通过fread(&a, sizeof(Data), 1, fp)还原回来

比如在main函数的末尾会加1句getchar()来表示暂停，因为VS下调试窗口会一闪而过的。也可以换成system("pause") 但是如果之前有输入的话，最好用2句getchar()前者吸收回车符，后者表示等待。 位置放哪里都可以，一般只是单纯为了吸收多余的回车符而已。

无代码无真相

在printf后面是等待输入一个字符，或者是有时候这样做可以防止程序结束！ 在scanf后面是为了吃点缓冲区里的一个回车符！  记住一点：和位置没有没关系 getchar函数只是从输入流中取走一个字符而已，没有字符就等待！

谁说一定要在printf后面 紧跟着getchar了 如果你不是读入字符 我认为没作用吧 fread乱码问题 我感觉应该与fwrite 配对使用 不要单独使用的好

getchar有一个int型的返回值.当程序调用getchar时.程序就等着用户按键.用户输入的字符被存放在键盘缓冲区中.直到用户按回车为止(回车字符也放在缓冲区中).当用户键入回车之后,getchar才开始从stdio流中每次读入一个字符.getchar函数的返回值是用户输入的第一个字符的ASCII码,如出错返回-1,且将用户输入的字符回显到屏幕.如用户在按回车之前输入了不止一个字符,其他字符会保留在键盘缓存区中,等待后续getchar调用读取.也就是说,后续的getchar调用不会等待用户按键,而直接读取缓冲区中的字符,直到缓冲区中的字符读完为后,才等待用户按键.


Question: 笔试题目，正解何在？

楼主面的是哪家公司啊？

第一题可用DFA解析字符串。

第一题可以用Shell脚本实现的不？可以就用sed,或awk或cut命令，很简单的 如果用C读入全部字符串，就以|为分割，分割字符串就行了 第二题就是封装结构体，实现结构体的相加减，也就是c＋＋里的重载，

金融衍生品  有点业务知识的话，很简单。

第一个的话，可以参考下Java的split，没什么难度，你可以看看这个 第二题应该还可以吧，第三题公式都基本告诉你了


Question: makefile加入gdb调试

把makefile中所有cc 之后都加-g 选项就可以了


Question: 哪位能讲讲这个程序

你说的这个getop()函数,不是标准库中的函数,应该是《the c programming language》这本书中的一个例子当中的函数  这个局部变量看相对谁了 相对于在主函数main中的 它是局部变量  和char s[MAXOP]的s取值是否一样？？ atof(s)  01393669  lea         eax,[s]    lea 取s的地址 汇编语言 char acm[1024] ="tmd"; char *p = acm; 01393669  lea         eax,[acm]   0139366F  mov         dword ptr [p],eax   问题2    op(p); 01393675  mov         eax,dword ptr [p]   0139367B  push        eax   0139367C  call        op (013911F4h)   01393681  add         esp,4        op(acm); 001E3675  lea         eax,[acm]   001E367B  push        eax   001E367C  call        op (01E11F4h)   001E3681  add         esp,4    这里的s代表什么意思？ s代表一个变量名称 关联着一段内存空间

char s[MAXOP];  就是这个 - -

引用 楼主 u010334406 的回复:getop和atof函数里的参数s是局部变量？和char s[MAXOP]的s取值是否一样？？这里的s代表什么意思？ 这些函数中S的意思是不是字符串的意思？


Question: 求解，一个关于c链表效率的问题

引用 6 楼 zhao4zhong1 的回复:不用if就效率高啦？我看未必。 //删除数据 int deleteData(linknode *linkhead,int pos) {     if (pos==0) return 1;     if (linkhead == null || linkhead->next == null) {         perror("链表为空\n");         return 0;     }     linknode *linklist = linkhead->next;     if (pos > 0) {         for (int count = 0;count != pos && linklist!=null; count++) linklist = linklist->next;     } else {//pos < 0         for (int count = 0;count != pos && linklist!=null; count--) linklist = linklist->prev;     } }   这种方法也不错，但是有一段重复的for代码看着略蛋疼 看来应该是最号的办法了吧

引用 4 楼 zhl11a 的回复:[quote=引用 3 楼 N_sev7 的回复:] [quote=引用 2 楼 user-3 的回复:] [quote=引用 1 楼 N_sev7 的回复:]  (pos > 0)?(linklist = linklist->next):(linklist = linklist->prev); 如果这个就不算用if-else了，那是在太简单了吧... linklist = pos > 0 ? linklist->next : linklist->prev这样应该更简洁点。 我觉得用用if-else也没影响多少效率啊[/quote] 额，是简洁了一些，但是没什么区别，所有的执行步骤还都是一样的[/quote] 这个运算符效果不是还是和if else一样的么。。 其实我的意思是先在循环外面判断，可否拿一个变量存储prev或者next，然后用那个变量决定到底是prev还是next[/quote] 开头想了想是不是可以用宏替换代码，但是后来知道宏是在运行前决定的，在if里面用不了

引用 3 楼 N_sev7 的回复:[quote=引用 2 楼 user-3 的回复:] [quote=引用 1 楼 N_sev7 的回复:]  (pos > 0)?(linklist = linklist->next):(linklist = linklist->prev); 如果这个就不算用if-else了，那是在太简单了吧... linklist = pos > 0 ? linklist->next : linklist->prev这样应该更简洁点。 我觉得用用if-else也没影响多少效率啊[/quote] 额，是简洁了一些，但是没什么区别，所有的执行步骤还都是一样的[/quote] 这个运算符效果不是还是和if else一样的么。。 其实我的意思是先在循环外面判断，可否拿一个变量存储prev或者next，然后用那个变量决定到底是prev还是next

引用 2 楼 user-3 的回复:[quote=引用 1 楼 N_sev7 的回复:]  (pos > 0)?(linklist = linklist->next):(linklist = linklist->prev); 如果这个就不算用if-else了，那是在太简单了吧... linklist = pos > 0 ? linklist->next : linklist->prev这样应该更简洁点。 我觉得用用if-else也没影响多少效率啊[/quote] 额，是简洁了一些，但是没什么区别，所有的执行步骤还都是一样的

引用 1 楼 N_sev7 的回复: (pos > 0)?(linklist = linklist->next):(linklist = linklist->prev); 如果这个就不算用if-else了，那是在太简单了吧... linklist = pos > 0 ? linklist->next : linklist->prev这样应该更简洁点。 我觉得用用if-else也没影响多少效率啊