Question: 大神求解这些哪里错了，这是学生管理系统的部分代码，是用VisualC++6.0编写大神帮忙改一下错误不能完成编译

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

楼上真心是认真。你这问题太大。

直接复制粘贴 #include  <stdio.h>  /*标准输入/输出函数库*/ #include  <stdlib.h>  /*标准函数库*/ #include  <string.h>  /*字符串函数库*/ void  print_menu_main(); typedef struct student { 	char   name[10];          /*姓名*/ 	char   num[10];           /*学号*/ 	char   sex[10];           /*性别*/ 	int    chinese;           /*语文成绩*/ 	int    math;              /*数学成绩*/ 	int    english;           /*英语成绩*/ 	int    computer;          /*计算机成绩*/ 	struct student  *next;    /*指向下一个学生的指针*/ }stu;  stu *p, *head = NULL;  void  input_record()        /*成绩录入子函数*/ { 	while(1) 	{ 		stu *s = (stu *)malloc(sizeof(stu)); 		int  chinese,math,english,computer; 		char name[10],num[10],sex[10],i; 		system("cls");  		printf(">请输入学生信息(注最大长度为10个字符):\n"); 		printf("姓名:"); 		scanf("%s",s->name); 		printf("学号:"); 		scanf("%s",s->num); 		printf("性别:"); 		scanf("%s",s->sex); 		printf("语文:"); 		scanf("%d",&s->chinese); 		printf("数学:"); 		scanf("%d",&s->math); 		printf("英语:"); 		scanf("%d",&s->english); 		printf("计算机:"); 		scanf("%d",&s->computer); 		s->next = NULL; 		if(head == NULL) 		{ 			head = s; 			p = s; 		} 		else 		{ 			p->next = s; 		} 		printf("是否继续输入学生信息?(Y继续,N返回主菜单)"); 		char key_b_in; 		scanf("%c",&key_b_in); 		if(key_b_in == 'N') 		{ 			system("cls"); 			print_menu_main(); 			break; 		} 	}  } void  show_record()         /*成绩显示子函数*/ { 	printf("欢迎键入成绩显示功能\n"); 	stu *t = head; 	while(t) 	{ 		printf("姓名:%s,学号:%s,性别:%s,语文:%d,数学:%d,英语:%d,计算机:%d\n", t->name, t->num, t->sex, t->chinese, t->math, t->english, t->computer); 		t = t->next; 	} 	printf("是否返回主菜单?(Y返回主菜单)"); 	char key_b_in; 	scanf("%c",&key_b_in); 	if(key_b_in == 'Y') 	{ 		system("cls"); 		print_menu_main(); 	} } void  search_record()      /*成绩查询子函数*/ { 	int  key_b_in; 	printf("请问你要查询那些信息？"); 	scanf("%d",&key_b_in); 	if(key_b_in==3)  {system("cls"); print_menu_main();} } void  update_record()      /*成绩更新子函数*/ { 	int  key_b_in; 	printf("请问你要更新哪些信息呢？"); 	scanf("%d",&key_b_in); 	if(key_b_in==4)  {system("cls"); print_menu_main();} } void  delete_record()      /*成绩删除子函数*/ { 	int  key_b_in; 	printf("请问你要删除哪些信息呢？"); 	scanf("%d",&key_b_in); 	if(key_b_in==5) 	{ 		system("cls"); 		print_menu_main(); 	} } void  calculate_record()   /*成绩计算子函数*/ { 	int  key_b_in; 	printf("请问你要如何计算成绩呢？"); 	scanf("%d",&key_b_in); 	if(key_b_in==6) 	{ 		system("cls"); 		print_menu_main(); 	} } void  save_record()         /*成绩保存子函数*/ { 	int  key_b_in; 	printf("请问你要保存哪些信息呢？"); 	scanf("%d",&key_b_in); 	if(key_b_in==7) 	{ 		system("cls"); 		print_menu_main(); 	} } void  exit_system() { 	exit(0); }                             /*退出系统子函数*/ void  print_menu_main() { 	int a; 	printf("=============================================================================\n"); 	printf("|学生成绩管理系统\n"); 	printf("=============================================================================\n"); 	printf("|\n"); 	printf("| 1 输入学生信息\n"); 	printf("| 2 显示学生信息\n"); 	printf("| 3 查询学生信息\n"); 	printf("| 4 更新学生信息\n"); 	printf("| 5 删除学生信息\n"); 	printf("| 6 计算学生成绩\n"); 	printf("| 7 保存文件\n"); 	printf("| 8 退出系统\n"); 	printf("|\n"); 	printf("=============================================================================\n"); 	printf(">请选择："); 	scanf("%d",&a); 	switch(a) 	{ 	case 1:input_record();break; 	case 2:show_record();break; 	case 3:search_record();break; 	case 4:update_record();break; 	case 5:delete_record();break; 	case 6:calculate_record();break; 	case 7:save_record();break; 	case 8:exit_system();break; 	default: 		printf("输入错误，请重新输！（注意：输入有效范围1—8）\n"); 	} }	  void main() { 	print_menu_main(); }

改了，没有用呀

input_record函数里key_b_in重定义了 int  key_b_in,chinese,math,english,computer;改为int chinese,math,english,computer;


Question: c实现二分查找问题

引用 楼主 u012197585 的回复: 不是太明白您提到的写法为什么要这样写呢

scanf ("%c ") ;试试看

scanf ("%c "，&c) ;试试看

因为%c会读取掉遗留的回车符. 举个例子：比如你输入5按下回车，此时输入缓冲区是5\n scanf("%d",&num);仅仅是读取掉了5(此时输入缓冲区为\n) 等到执行到scanf("%c",&c);由于输入缓冲区不为空，所以scanf会直接读取遗留的回车符从而看起来像跳过了这句 解决方法： scanf("%c",&c);前面加一句getchar();或者fflush(stdin);都行

在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 int c; scanf("%c",&c); //时，都改为 char s[2]; int c; scanf("%1s",s); c=s[0];


Question: 声明*C某类::Getdocument();（已声明，不兼容）

加个前置声明 class CMy2015Doc; 然后在 实现文件中  #include "My2015Doc.h"

只有返回值类型不同不能构成重载

引用 1 楼 zhao4zhong1 的回复:使用强制类型转换？ 怎么强制转换呢？

使用强制类型转换？


Question: 如何编程实现客户端某程序运行的结果自动上传到服务器

命令行调用tftp？

结束前先生成，然后生成以后上传，感觉直接调你手动上传的那个函数就行了，然后再结束呗

你这个客户端都运行结束了，怎么上传啊，再写一个客户端，专门用来上传文件。


Question: opencv如何在一段视频上选取一个RotatedRect结构的感兴趣区域

仅供参考：#include <math.h> #include <string.h> #include <stdio.h> #include <windows.h> #include <gdiplus.h> #pragma comment(lib, "gdiplus.lib") using namespace Gdiplus; wchar_t formats[5][11]={     L"image/bmp",     L"image/jpeg",     L"image/gif",     L"image/tiff",     L"image/png", }; wchar_t exts[5][5]={     L".bmp",     L".jpg",     L".gif",     L".tif",     L".png", }; int GetEncoderClsid(const WCHAR* format, CLSID* pClsid) {    UINT  num = 0;          // number of image encoders    UINT  size = 0;         // size of the image encoder array in bytes    ImageCodecInfo* pImageCodecInfo = NULL;    GetImageEncodersSize(&num, &size);    if(size == 0) return -1;  // Failure    pImageCodecInfo = (ImageCodecInfo*)(malloc(size));    if(pImageCodecInfo == NULL) return -1;  // Failure    GetImageEncoders(num, size, pImageCodecInfo);    for (UINT j = 0; j < num; ++j) {       if ( wcscmp(pImageCodecInfo[j].MimeType, format) == 0 ) {          *pClsid = pImageCodecInfo[j].Clsid;          free(pImageCodecInfo);          return j;  // Success       }    }    free(pImageCodecInfo);    return -1;  // Failure } int wmain(int argc,wchar_t *argv[]) {     int r=1;     if (argc<4) {     USAGE:         wprintf(L"%s srcimg.{bmp|jpg|gif|tif|png|wmf|emf|ico}  desimg.{bmp|jpg|gif|tif|png}  angle\n",argv[0]);         return r;     }     int i;     for (i=0;i<5;i++) {         if (0==_wcsicmp(argv[1]+wcslen(argv[1])-4,exts[i])) break;     }     if (i>=5) goto USAGE;     for (i=0;i<5;i++) {         if (0==_wcsicmp(argv[2]+wcslen(argv[2])-4,exts[i])) break;     }     if (i>=5) goto USAGE;     GdiplusStartupInput gdiplusstartupinput;     ULONG_PTR gdiplustoken;     GdiplusStartup(&gdiplustoken, &gdiplusstartupinput, NULL);     {         Image img(argv[1]);         if (Ok==img.GetLastStatus()) {             UINT height = img.GetHeight();             UINT width  = img.GetWidth();             REAL angle;             if (1==swscanf_s(argv[3],L"%f",&angle)) {                 REAL size;                 size=(REAL)sqrt(1.0*width*width+1.0*height*height);                 Matrix mat;                 mat.Translate(size / -2.0f, size / -2.0f);                 mat.Rotate(-angle, MatrixOrderAppend);                 mat.Translate(size / 2.0f, size / 2.0f, MatrixOrderAppend);                 PointF pfTL((size-width)/2.0f      ,(size-height)/2.0f       );                 PointF pfTR((size-width)/2.0f+width,(size-height)/2.0f       );                 PointF pfBL((size-width)/2.0f      ,(size-height)/2.0f+height);                 PointF pfBR((size-width)/2.0f+width,(size-height)/2.0f+height);                 Graphics tgp(&img);                 Bitmap bmp((UINT)size,(UINT)size,&tgp);//Let bmp Resolution equal to img Resolution                 Graphics gp(&bmp);                 gp.SetTransform(&mat);                 gp.DrawImage(&img,pfTL);                 REAL xmin,ymin,xmax,ymax,x,y,rw,rh;                 mat.TransformPoints(&pfTL);                 xmin=xmax=pfTL.X;                 ymin=ymax=pfTL.Y;                 mat.TransformPoints(&pfTR);                 if (xmin>pfTR.X) xmin=pfTR.X;                 if (xmax<pfTR.X) xmax=pfTR.X;                 if (ymin>pfTR.Y) ymin=pfTR.Y;                 if (ymax<pfTR.Y) ymax=pfTR.Y;                 mat.TransformPoints(&pfBL);                 if (xmin>pfBL.X) xmin=pfBL.X;                 if (xmax<pfBL.X) xmax=pfBL.X;                 if (ymin>pfBL.Y) ymin=pfBL.Y;                 if (ymax<pfBL.Y) ymax=pfBL.Y;                 mat.TransformPoints(&pfBR);                 if (xmin>pfBR.X) xmin=pfBR.X;                 if (xmax<pfBR.X) xmax=pfBR.X;                 if (ymin>pfBR.Y) ymin=pfBR.Y;                 if (ymax<pfBR.Y) ymax=pfBR.Y;                 x=xmin;                 y=ymin;                 rw=xmax-x;                 rh=ymax-y;                 Bitmap* clone;                 clone = bmp.Clone(x,y,rw,rh,PixelFormat24bppRGB);//bmp.GetPixelFormat()                 CLSID encoderClsid;                 if (0<=GetEncoderClsid(formats[i],&encoderClsid)) {                     if (Ok==clone->Save(argv[2],&encoderClsid)) {                         wprintf(L"OK to %s  %s  %s  %s\n",argv[0],argv[1],argv[2],argv[3]);                         r=0;                     } else {                         wprintf(L"Error to save %s\n",argv[2]);                         r=4;                     }                 } else {                     wprintf(L"Error to GetEncoderClsid(%s,...)\n",formats[i]);                     r=3;                 }                 delete clone;             } else {                 wprintf(L"Error to get angle %s\n",argv[3]);                 r=2;             }         } else {             wprintf(L"Error to load %s\n",argv[1]);             r=5;         }     }     GdiplusShutdown(gdiplustoken);     return r; }


引用 9 楼 YsuZ30 的回复:话说什么是ac啊就是Accepted

话说什么是ac啊

引用 2 楼 sinat_34328764 的回复:楼主是故意用这么麻烦的方法做这道题么…对啊，练习指针，就是不明白怎么就不ac,(明确的结果错误)

引用 1 楼 qq423399099 的回复:p=malloc(n*sizeof(int));应该是p=(int *)malloc(n*sizeof(int));  wrong answer 不知道错在哪的话，几个办法： 1. 找个正确的程序来比对，一般能看出问题来。 2. 假设没看出来，那么自己制造一些数据进行测试，用两个程序都跑一遍，看看输出是否一致。这个做数据的话，范围得做得大一些，样本做多一些。 3. 还是没发现的话，找别人来给你看一下，去OJ相关的网上到处贴，总有热心人士会来给看看的。 (直接第三步会比较省力, 不过时间上没保证)嗯，我去改一下看看，谢谢  引用 1 楼 qq423399099 的回复:p=malloc(n*sizeof(int));应该是p=(int *)malloc(n*sizeof(int));  wrong answer 不知道错在哪的话，几个办法： 1. 找个正确的程序来比对，一般能看出问题来。 2. 假设没看出来，那么自己制造一些数据进行测试，用两个程序都跑一遍，看看输出是否一致。这个做数据的话，范围得做得大一些，样本做多一些。 3. 还是没发现的话，找别人来给你看一下，去OJ相关的网上到处贴，总有热心人士会来给看看的。 (直接第三步会比较省力, 不过时间上没保证)这样改，不就相当于新定义的内存都是int * 吗，但我要的是int啊？这样理解对吗

楼主是故意用这么麻烦的方法做这道题么…

引用 1 楼 qq423399099 的回复:p=malloc(n*sizeof(int));应该是p=(int *)malloc(n*sizeof(int));  wrong answer 不知道错在哪的话，几个办法： 1. 找个正确的程序来比对，一般能看出问题来。 2. 假设没看出来，那么自己制造一些数据进行测试，用两个程序都跑一遍，看看输出是否一致。这个做数据的话，范围得做得大一些，样本做多一些。 3. 还是没发现的话，找别人来给你看一下，去OJ相关的网上到处贴，总有热心人士会来给看看的。 (直接第三步会比较省力, 不过时间上没保证)果然，加上之后，再把  引用 1 楼 qq423399099 的回复:p=malloc(n*sizeof(int));应该是p=(int *)malloc(n*sizeof(int));  wrong answer 不知道错在哪的话，几个办法： 1. 找个正确的程序来比对，一般能看出问题来。 2. 假设没看出来，那么自己制造一些数据进行测试，用两个程序都跑一遍，看看输出是否一致。这个做数据的话，范围得做得大一些，样本做多一些。 3. 还是没发现的话，找别人来给你看一下，去OJ相关的网上到处贴，总有热心人士会来给看看的。 (直接第三步会比较省力, 不过时间上没保证)果然，加上（int*）  引用 6 楼 qq423399099 的回复:malloc返回的是void * 所以需要转换成需要的指针类型，假设你要存两个数，那么malloc(2*sizeof(int))返回的是void *类型的8个字节的内存空间的首地址 返回的是首地址啊。。。。当然用int *接收 引用 6 楼 qq423399099 的回复:malloc返回的是void * 所以需要转换成需要的指针类型，假设你要存两个数，那么malloc(2*sizeof(int))返回的是void *类型的8个字节的内存空间的首地址 返回的是首地址啊。。。。当然用int *接收嗯，明白了，多谢

引用 7 楼 jianjiu7 的回复:[quote=引用 1 楼 qq423399099 的回复:] p=malloc(n*sizeof(int));应该是p=(int *)malloc(n*sizeof(int));  wrong answer 不知道错在哪的话，几个办法： 1. 找个正确的程序来比对，一般能看出问题来。 2. 假设没看出来，那么自己制造一些数据进行测试，用两个程序都跑一遍，看看输出是否一致。这个做数据的话，范围得做得大一些，样本做多一些。 3. 还是没发现的话，找别人来给你看一下，去OJ相关的网上到处贴，总有热心人士会来给看看的。 (直接第三步会比较省力, 不过时间上没保证)果然，加上之后，再把  引用 1 楼 qq423399099 的回复:p=malloc(n*sizeof(int));应该是p=(int *)malloc(n*sizeof(int));  wrong answer 不知道错在哪的话，几个办法： 1. 找个正确的程序来比对，一般能看出问题来。 2. 假设没看出来，那么自己制造一些数据进行测试，用两个程序都跑一遍，看看输出是否一致。这个做数据的话，范围得做得大一些，样本做多一些。 3. 还是没发现的话，找别人来给你看一下，去OJ相关的网上到处贴，总有热心人士会来给看看的。 (直接第三步会比较省力, 不过时间上没保证)果然，加上（int*）  引用 6 楼 qq423399099 的回复:malloc返回的是void * 所以需要转换成需要的指针类型，假设你要存两个数，那么malloc(2*sizeof(int))返回的是void *类型的8个字节的内存空间的首地址 返回的是首地址啊。。。。当然用int *接收 引用 6 楼 qq423399099 的回复:malloc返回的是void * 所以需要转换成需要的指针类型，假设你要存两个数，那么malloc(2*sizeof(int))返回的是void *类型的8个字节的内存空间的首地址 返回的是首地址啊。。。。当然用int *接收嗯，明白了，多谢[/quote]  引用 7 楼 jianjiu7 的回复:[quote=引用 1 楼 qq423399099 的回复:] p=malloc(n*sizeof(int));应该是p=(int *)malloc(n*sizeof(int));  wrong answer 不知道错在哪的话，几个办法： 1. 找个正确的程序来比对，一般能看出问题来。 2. 假设没看出来，那么自己制造一些数据进行测试，用两个程序都跑一遍，看看输出是否一致。这个做数据的话，范围得做得大一些，样本做多一些。 3. 还是没发现的话，找别人来给你看一下，去OJ相关的网上到处贴，总有热心人士会来给看看的。 (直接第三步会比较省力, 不过时间上没保证)果然，加上之后，再把  引用 1 楼 qq423399099 的回复:p=malloc(n*sizeof(int));应该是p=(int *)malloc(n*sizeof(int));  wrong answer 不知道错在哪的话，几个办法： 1. 找个正确的程序来比对，一般能看出问题来。 2. 假设没看出来，那么自己制造一些数据进行测试，用两个程序都跑一遍，看看输出是否一致。这个做数据的话，范围得做得大一些，样本做多一些。 3. 还是没发现的话，找别人来给你看一下，去OJ相关的网上到处贴，总有热心人士会来给看看的。 (直接第三步会比较省力, 不过时间上没保证)果然，加上（int*）  引用 6 楼 qq423399099 的回复:malloc返回的是void * 所以需要转换成需要的指针类型，假设你要存两个数，那么malloc(2*sizeof(int))返回的是void *类型的8个字节的内存空间的首地址 返回的是首地址啊。。。。当然用int *接收 引用 6 楼 qq423399099 的回复:malloc返回的是void * 所以需要转换成需要的指针类型，假设你要存两个数，那么malloc(2*sizeof(int))返回的是void *类型的8个字节的内存空间的首地址 返回的是首地址啊。。。。当然用int *接收#include<stdio.h> #include<stdlib.h>  int main(){ int i,n; float temp; float s; float *p; while(~scanf("%d",&n)) { s=0; p=(int*)malloc(n*sizeof(float)); for(i=0;i<n;i++) { scanf("%f",p+i); if(*(p+i)<*(p+i-1)) { temp=*(p+i); *(p+i)=*(p+i-1); *(p+i-1)=temp; } } for(i=n-1;i>=0;i--) { if(*(p+i)>*(p+i+1)) { temp=*(p+i); *(p+i)=*(p+i+1); *(p+i+1)=temp; } } for(i=1;i<n-1;i++) s+=*(p+i); printf("%.2f\n",s/(n-2)); } return 0; }加int* 是可以ac,但我的是float，所以我试着改成float*却错误了


Question: WIN服务会莫名消失的问题 坐等

我顶  求关注 求解答

引用 4 楼 azsx5201 的回复:是不是你的程序在重启电脑之前没有完全退出，然后重启了程序文件被损坏。  我出现过这种情况。  没有 程序文件正常 可手动正常启动

引用 2 楼 lwcvod 的回复:各种杀软，各种卫士，卸载掉，或者是添加信任  网上很多mysql服务消失的问题 都是给的解决方案 就是重新注册服务 但是我想知道为什么会消失 我想从根本上解决问题

系统没有安装杀软和其他安全软件的 软件安装路径下文件完整 服务路径正常

各种杀软，各种卫士，卸载掉，或者是添加信任


Question: 关于socket通信中memcpy()把一个数组转换成结构体的问题

引用 30 楼 xue_opnet 的回复:[quote=引用 26 楼 zhao4zhong1 的回复:] 楼主可以立即放下手头事情去街边买彩票了。 运气好到 sizeof(Gate)==strlen(Recv_Buf)+1 ！！！！！！！！！！！！！！！   Gate *clt=(Gate *)calloc(1, sizeof(Gate)); memcpy(clt,Recv_Buf,sizeof(Gate)); memmove(clt,Recv_Buf,sizeof(Gate)); 应改为 Gate *clt=(Gate *)calloc(1, sizeof(Gate)); sscanf(Recv_Buf,"%d%d%lf%lf%lf",&clt->tx_wave,&clt->gate_length,&clt->gate_length1,&clt->gate_length2,&clt->start_time); 谢谢您，五一回家没来得及及时回复您，之前我也用 sscanf(Recv_Buf,"%d%d%f%f%f",&clt->tx_wave,&clt->gate_length,&clt->gate_length1,&clt->gate_length2,&clt->start_time); 但是没有注意double类型的数据输入时不能用只能用%lf，所以每次编译到这一句程序就不执行了，现在改成%lf后结果正确了，谢谢您。[/quote]  printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。

作为一个C程序员，对  scanf,sscanf,fscanf  printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离手，曲不离口”的。

#pragma pack(push) #pragma pack(1)  // 或2，4.。。。。。。。。。。。  声明结构体 #pragma pack(pop)

引用 26 楼 zhao4zhong1 的回复:楼主可以立即放下手头事情去街边买彩票了。 运气好到 sizeof(Gate)==strlen(Recv_Buf)+1 ！！！！！！！！！！！！！！！   Gate *clt=(Gate *)calloc(1, sizeof(Gate)); memcpy(clt,Recv_Buf,sizeof(Gate)); memmove(clt,Recv_Buf,sizeof(Gate)); 应改为 Gate *clt=(Gate *)calloc(1, sizeof(Gate)); sscanf(Recv_Buf,"%d%d%lf%lf%lf",&clt->tx_wave,&clt->gate_length,&clt->gate_length1,&clt->gate_length2,&clt->start_time); 谢谢您，五一回家没来得及及时回复您，之前我也用 sscanf(Recv_Buf,"%d%d%f%f%f",&clt->tx_wave,&clt->gate_length,&clt->gate_length1,&clt->gate_length2,&clt->start_time); 但是没有注意double类型的数据输入时不能用只能用%lf，所以每次编译到这一句程序就不执行了，现在改成%lf后结果正确了，谢谢您。

引用 24 楼 li9172 的回复:recv_buf能用%s打印,  说明你收到的是字符串, 而不是int/double类型的二进制码. 内存中的二进制表示都不一样, 不能用memcpy直接拷贝到结构体中, 要从recv_buf中一项项用atoi, atof转换才行. 你的服务端那边是拿fprintf做的结构体到send_buf转换? 服务端用sprintf做的转换 sprintf(Send_Buf,"%d %d %f %f %f",info->tx_wave,info-> gate_length,info-> gate_length1,info-> gate_length2,info->start_time);

请楼主把下面这段话倒背如流，每天象祥林嫂那样多念几遍： 电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……

引用 24 楼 li9172 的回复:recv_buf能用%s打印,  说明你收到的是字符串, 而不是int/double类型的二进制码. 内存中的二进制表示都不一样, 不能用memcpy直接拷贝到结构体中, 要从recv_buf中一项项用atoi, atof转换才行. 你的服务端那边是拿fprintf做的结构体到send_buf转换? 最后一行打错了, 不是fprintf ,是sprintf

#pragma pack(1)  客户和服务端都加上这句，确定数据结构内部是紧凑的。  另外，客户机器和服务端机器的cpu大小端要一样。

收藏

引用 20 楼 zhao4zhong1 的回复:再供参考： 浮点数格式 http://bbs.csdn.net/topics/390676437 您好，用了您的代码看字节序，结果如下： 这样能说明问题吗？感觉两个int型变量分别占了两个字节，前两个double型变量占了8个字节，最后一个double变量占了9个字节，这是数组存储的时候出错了吗？

引用 20 楼 zhao4zhong1 的回复:再供参考： 浮点数格式 http://bbs.csdn.net/topics/390676437 谢谢您，我再仔细查看一下是不是字节序的问题

如果总字节数和各结构体成员相对结构体开头的字节偏移量都一致没问题的话，那只剩下字节序了。 使用下面的HexDump函数看一下是不是字节序问题： void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%08x -",i+addr);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             printf("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         printf("%s\n",binstr);     } }

电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。  不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了

引用 16 楼 zhao4zhong1 的回复:结构体字节对齐惹的祸。 参考下面：#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 // //  这是参考您的例子找出的结构体的存储位置： 可是怎么修改才会正确呢，我不明白您的意思，也不知道该怎么参考您的例子，数组中的内容就是按照int,int,double,double,double类型存储的，共32字节。结构体也是int,int,double,double,double共32字节，为什么会出错呢

引用 14 楼 zhao4zhong1 的回复:不知道有多少前人掉在TCP Socket send(人多)send(病少)send(财富) recv(人多病)recv(少财富) 陷阱里面啊！ http://bbs.csdn.net/topics/380167545 您好，我定义了一个结构体typedef struct Gate 	{ int tx_wave; 	int gate_length; 	double gate_length1; 	double gate_length2; 	double start_time; 	    }Gate; 和一个数组char Recv_Buf[1024]; 该数组里的内容为1 2 3.000000 4.000000 20.000000 用么么move或memcopy语句把数组里的数据放进结构体力 Gate *clt=(Gate *)calloc(1, sizeof(Gate)); memcpy(clt,Recv_Buf,sizeof(Gate)); memmove(clt,Recv_Buf,sizeof(Gate)); 但结果却都错的 前两个变量有值，但是不正确并且都很大，是因为什么原因呢


Question: 有一个关于C语言的小问题，感谢帮助

楼主代码贴全吧

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

int count = 0; 	do 	{ 		count = 0;                 count = deal();//你在deal的处理 只有对count++ 所以只要进到了条件 你这种程序必然死循环 没有退出条件  	} while (count != 0);  消环算法 自己写很容易出问题的  如果用C++ 可以用boost库

F5运行， 等死循环了. 点vs的DEBUG菜单，再点Break ALL菜单。 然后单步执行看看


Question: 向各位大神，请教log和测试的技巧，来点干活

个人瞎猜： 桌面开发调试时离不开的技术： 虚拟机（模拟不同操作系统） depends.exe（查看exe依赖的dll） 操作日志 升级日志 任务管理器（检查是否资源泄漏的办法之一： 在任务管理器 进程 查看 选择列 里面选择：内存使用、虚拟内存大小、句柄数、线程数、USER对象、GDI对象 让你的程序(进程)不退出,循环执行主流程很多遍，越多越好，比如1000000次甚至无限循环，记录以上各数值，再隔至少一小时，越长越好，比如一个月，再记录以上各数值。如果以上两组数值的差较大或随时间流逝不断增加，则铁定有对应资源的资源泄漏！ ） GDI泄露检测工具 ……

引用 8 楼 u012879787 的回复:[quote=引用 6 楼 zhao4zhong1 的回复:] 尺有所短，寸有所长。 引用 7 楼 Rewen 的回复:有很多程序打log的啊，也有很多程序不打log的。 看具体程序吧，很多365*24小时的后台程序就用log. 反之，有界面的工具多不用log，直接画面显示就可以了。   赵老师是比较推崇检测函数返回值的人， 我见过好多ui程序都不检测返回值，  似乎久而久之，导致客户端程序里没有检测返回值的习惯、和log习惯，  然后产品发不出去，  隔三差五有bug， 不是奔溃，就是这里那里有问题，  加上项目庞大，分很多个软件。  即使不是24小时要运行的，  一旦出错，你都不知道去哪个软件里找问题。   有的项目，软件就8，9个。      对于这类复杂的程序， 光部署都得学习很久， 可见其复杂性。  所谓的画图，毫无意义，根本无助于事。  [/quote]  另外也许ide的强大，导致  引用 8 楼 u012879787 的回复:[quote=引用 6 楼 zhao4zhong1 的回复:] 尺有所短，寸有所长。 引用 7 楼 Rewen 的回复:有很多程序打log的啊，也有很多程序不打log的。 看具体程序吧，很多365*24小时的后台程序就用log. 反之，有界面的工具多不用log，直接画面显示就可以了。   赵老师是比较推崇检测函数返回值的人， 我见过好多ui程序都不检测返回值，  似乎久而久之，导致客户端程序里没有检测返回值的习惯、和log习惯，  然后产品发不出去，  隔三差五有bug， 不是奔溃，就是这里那里有问题，  加上项目庞大，分很多个软件。  即使不是24小时要运行的，  一旦出错，你都不知道去哪个软件里找问题。   有的项目，软件就8，9个。      对于这类复杂的程序， 光部署都得学习很久， 可见其复杂性。  所谓的画图，毫无意义，根本无助于事。  [/quote]  引用 8 楼 u012879787 的回复:[quote=引用 6 楼 zhao4zhong1 的回复:] 尺有所短，寸有所长。 引用 7 楼 Rewen 的回复:有很多程序打log的啊，也有很多程序不打log的。 看具体程序吧，很多365*24小时的后台程序就用log. 反之，有界面的工具多不用log，直接画面显示就可以了。   赵老师是比较推崇检测函数返回值的人， 我见过好多ui程序都不检测返回值，  似乎久而久之，导致客户端程序里没有检测返回值的习惯、和log习惯，  然后产品发不出去，  隔三差五有bug， 不是奔溃，就是这里那里有问题，  加上项目庞大，分很多个软件。  即使不是24小时要运行的，  一旦出错，你都不知道去哪个软件里找问题。   有的项目，软件就8，9个。      对于这类复杂的程序， 光部署都得学习很久， 可见其复杂性。  所谓的画图，毫无意义，根本无助于事。  [/quote]  也许ide的强大导致，桌面开发人员，基本上不会又打log的习惯，甚至不知道要打log，  这种产品谁接手，谁倒霉。

引用 6 楼 zhao4zhong1 的回复:尺有所短，寸有所长。 引用 7 楼 Rewen 的回复:有很多程序打log的啊，也有很多程序不打log的。 看具体程序吧，很多365*24小时的后台程序就用log. 反之，有界面的工具多不用log，直接画面显示就可以了。   赵老师是比较推崇检测函数返回值的人， 我见过好多ui程序都不检测返回值，  似乎久而久之，导致客户端程序里没有检测返回值的习惯、和log习惯，  然后产品发不出去，  隔三差五有bug， 不是奔溃，就是这里那里有问题，  加上项目庞大，分很多个软件。  即使不是24小时要运行的，  一旦出错，你都不知道去哪个软件里找问题。   有的项目，软件就8，9个。      对于这类复杂的程序， 光部署都得学习很久， 可见其复杂性。  所谓的画图，毫无意义，根本无助于事。

引用 1 楼 qq423399099 的回复:大公司一般都有自己的日志库，相比于开源库，会在性能上进行一定优化，同时统一各个产品线的日志格式，方便日志的分析处理。  问的是： 开源软件为什么不打日志？   不是问你开源日志库，

尺有所短，寸有所长。

引用 3 楼 zhao4zhong1 的回复:1.  一般的程序不打log和开源软件不打log的区别是什么？  一般的程序比较短小且运行几次就没用了。开源软件只要不是365天x24小时/天保持运行，一般也没必要。 是因为开源作者的能力暴强，解决bug速度快，所以不打log吗？ 是因为开源作者通常都不维护365天x24小时/天保持运行的代码。   2.  我见过一个程序打log， log里居然没有行号，我不明白为什么这么打，打了有什么意义？  难道指望别人去代码里搜索字符串？ 打了行号就不用去代码里搜索字符串了？ 3.  如何做单元测试，我不需要工具名字，我举个场景，这种方式如何测试？  参考OpenCV3.1里面自带的google test？ 网络接口如何测试？ 客户端发送了数据给服务器，服务器recv后， 请问这种代码如何测试？  通过127.0.0.1？ 我看到的一些单元测试的demo，比如测试求和函数，传参数1,2进去，那么预估结果为3，  通过这种方式来判断函数的正确否，  我举的场景，如何测试 ?  参考OpenCV3.1里面自带的google test  起码搜索的更快，一眼就还知道去哪个文件，哪个函数查看，

引用 3 楼 zhao4zhong1 的回复:1.  一般的程序不打log和开源软件不打log的区别是什么？  一般的程序比较短小且运行几次就没用了。开源软件只要不是365天x24小时/天保持运行，一般也没必要。 是因为开源作者的能力暴强，解决bug速度快，所以不打log吗？ 是因为开源作者通常都不维护365天x24小时/天保持运行的代码。   2.  我见过一个程序打log， log里居然没有行号，我不明白为什么这么打，打了有什么意义？  难道指望别人去代码里搜索字符串？ 打了行号就不用去代码里搜索字符串了？ 3.  如何做单元测试，我不需要工具名字，我举个场景，这种方式如何测试？  参考OpenCV3.1里面自带的google test？ 网络接口如何测试？ 客户端发送了数据给服务器，服务器recv后， 请问这种代码如何测试？  通过127.0.0.1？ 我看到的一些单元测试的demo，比如测试求和函数，传参数1,2进去，那么预估结果为3，  通过这种方式来判断函数的正确否，  我举的场景，如何测试 ?  参考OpenCV3.1里面自带的google test  另外，一般的日志库打印出来的源文件路径貌似是相对的， 我这几天发现某个库打印出绝对路径来，  好奇怪啊。


Question: 动态数组读取数据，求大神解答

乍看起来c++的cin、cout、ifstream、ofstream、istringstream、ostringstream在输入、输出上比c的scanf、printf、fscanf、fprintf、fread、fwrite、sscanf、sprintf简单，不用格式控制符！ 但是不用格式控制符，输入输出恰好是你期望的格式的时候好说；等到输入输出不是你期望的格式的时候，你就会觉得还是用格式控制符更方便、更靠谱。 摒弃cin、cout、ifstream、ofstream、istringstream、ostringstream！ 使用scanf、printf、fscanf、fprintf、fread、fwrite、sscanf、sprintf。  对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A  电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。  不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了

最后还有个end啊，显示乱码

两个问题： 1.lithinfo *lthdemo = new lithinfo[i];这句应该放在while(!feof(fp))循环之后，不然i是0啊 2.fseek以后，指针是指向文件开头的，而开头三行的数据是要跳过的，不能直接fscanf,所以要加三行fgets  #include <iostream> #include <stdio.h> #include <fstream> #include <string.h>  using namespace std;  struct lithinfo { 	int num; 	float stdep; 	float enddep; 	char sand[256]; };  void main() { 	FILE* fp; 	char buf[1000]; 	int i=0; 	if ((fp=fopen("F:\\lith.txt","r"))==NULL) 	{ 		cout << "File open error!\n" <<endl; 		return; 	}  	char str;      // read 逗号 	char str1; 	char str2;  	  	fgets(buf,1000,fp); 	fgets(buf,1000,fp); 	fgets(buf,1000,fp);  	while(!feof(fp))    // 计算行数 	{ 		fgets(buf, 1000, fp); 		i++; 	} 	cout<<i<<endl; 	 	lithinfo *lthdemo = new lithinfo[i]; 	fseek(fp,0,SEEK_SET); // 把指针移到起始位置 	fgets(buf,1000,fp); 	fgets(buf,1000,fp); 	fgets(buf,1000,fp); 	for(int n=0;n<i - 1;n++) 	{ 		fscanf(fp,"%d %c %f %c %f %c %s",<hdemo[n].num,&str,<hdemo[n].stdep,&str1,<hdemo[n].enddep,&str2,lthdemo[n].sand); 		cout<<lthdemo[n].num <<endl; 	} 	fclose(fp); }


Question: 二进制和字符有什么关系，如何转化的

引用 10 楼 zhao4zhong1 的回复:电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。 感谢老师~~我去试一试~~~

引用 7 楼 qq423399099 的回复:这样？  #include<iostream> #include<bitset> using namespace std;  int main() {        	for(int i = 0; i <= 255; i++) 		cout << bitset<8>(i)  << endl; }   就想要这个效果的，，不过C有办法实现么。。

仅供参考：#include <stdio.h> #include <stdlib.h> #include <string.h> #include <locale.h> int main() {     int i,v;     char bs[33];     char b[33];     char hs[9];     char h[9];     char s[4];     char *e;  // 十进制整数转二进制串；     i=1024;     ltoa(i,b,2);     sprintf(bs,"%032s",b);     printf("i=%d,bs=%s\n",i,bs); // 十进制整数转十六进制串；     i=1024;     ltoa(i,h,16);     sprintf(hs,"%08s",h);     printf("i=%d,hs=%s\n",i,hs); // 十六进制字符串转成十进制数     strcpy(hs,"00000400");     sscanf(hs,"%x",&i);     printf("hs=%s,i=%d\n",hs,i); // 二进制字符串转化为十六进制字符串；     strcpy(bs,"00000000000000000000010000000000");     i=strtol(bs,&e,2);     ltoa(i,h,16);     sprintf(hs,"%08s",h);     printf("bs=%s,hs=%s\n",bs,hs); // 二进制字符串转化为十进制数；     strcpy(bs,"00000000000000000000010000000000");     i=strtol(bs,&e,2);     printf("bs=%s,i=%d\n",bs,i); // 十六进制字符串转成二进制串     strcpy(hs,"00000400");     sscanf(hs,"%x",&i);     ltoa(i,b,2);     sprintf(bs,"%032s",b);     printf("hs=%s,bs=%s\n",hs,bs); // ASC\GBK字符串转十六进制串     strcpy(s,"a汉");     i=0;     while (1) {         if (0==s[i]) break;         sprintf(hs+i*2,"%02X",(unsigned char)s[i]);         i++;     }     setlocale(LC_ALL,"chs");     printf("s=%s,hs=%s\n",s,hs); // 十六进制字符串转成汉字（GBK）及字符(ASC)     strcpy(hs,"61BABA");     i=0;     while (1) {         if (1!=sscanf(hs+i*2,"%2x",&v)) break;         s[i]=(char)v;         i++;     }     s[i]=0;     printf("hs=%s,s=%s\n",hs,s);      return 0;  } //i=1024,bs=00000000000000000000010000000000 //i=1024,hs=00000400 //hs=00000400,i=1024 //bs=00000000000000000000010000000000,hs=00000400 //bs=00000000000000000000010000000000,i=1024 //hs=00000400,bs=00000000000000000000010000000000 //s=a汉,hs=61BABA //hs=61BABA,s=a汉   再供参考：void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%08x -",i+addr);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             printf("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         printf("%s\n",binstr);     } }

这个可以有啊，C 中有个随机字符，可以考虑，用用啊，这种穷举忒好破译了，有规律。

引用 13 楼 qq423399099 的回复:不妨用itoa  #include <stdlib.h>  #include <stdio.h>  int main(void)  {  	int i; 	char str[9]; 	for(i = 0; i <= 255; i++) 	{ 		itoa(i, str, 2);  		printf("%s\n", str);  	} }  和zhao4zhong1老师给的参考很近似的~好用的！~多谢多谢~~~~

引用 4 楼 lm_whales 的回复:0~0xff 就可以了 您好~那您说的方法怎么实现呢，最好有一两行代码吧，拜托拜托啦~

引用 3 楼 github_27756899 的回复:[quote=引用 2 楼 zyx1202 的回复:] [quote=引用 1 楼 github_27756899 的回复:] #include <stdio.h>  int main(void) { 	unsigned char key[8] = {0};           //以第一个字节为例: 	while(key[0] < 255 ) 	{ 		printf("%d\n",key[0]); 		key[0]++; 	} 	printf("%d\n",key[0]); 	return 0; } 感谢这段代码。可以解释一下原理么。。。话说我的基础学得好渣。。[/quote] char 占一个字节(8位)  默认有符号 第一位是符号位  因此其范围为:(-128~127)   用unsigned 修饰将其变为无符号的 因此其范围为:(0~255) 本例中 先初始化8个unsigned char 为0     后将第一字节从0  一直加到 255 并输出. 希望我已经大概讲明.   不懂继续交流.[/quote] 已经明白啦~多谢多谢

0~0xff 就可以了

引用 2 楼 zyx1202 的回复:[quote=引用 1 楼 github_27756899 的回复:] #include <stdio.h>  int main(void) { 	unsigned char key[8] = {0};           //以第一个字节为例: 	while(key[0] < 255 ) 	{ 		printf("%d\n",key[0]); 		key[0]++; 	} 	printf("%d\n",key[0]); 	return 0; } 感谢这段代码。可以解释一下原理么。。。话说我的基础学得好渣。。[/quote] char 占一个字节(8位)  默认有符号 第一位是符号位  因此其范围为:(-128~127)   用unsigned 修饰将其变为无符号的 因此其范围为:(0~255) 本例中 先初始化8个unsigned char 为0     后将第一字节从0  一直加到 255 并输出. 希望我已经大概讲明.   不懂继续交流.

引用 1 楼 github_27756899 的回复:#include <stdio.h>  int main(void) { 	unsigned char key[8] = {0};           //以第一个字节为例: 	while(key[0] < 255 ) 	{ 		printf("%d\n",key[0]); 		key[0]++; 	} 	printf("%d\n",key[0]); 	return 0; } 感谢这段代码。可以解释一下原理么。。。话说我的基础学得好渣。。


Question: 蓝桥杯 区间k大数问题求各位解答啊。排序方面的错误，另外还有个小问题，都在注释里

引用 2 楼 lm_whales 的回复:不定长数组，看着好用，其实陷阱也不少 尽量不用为妙 不定长数组和vector都是语法糖。 语法糖越甜，编译调试查错越苦！ 把有限的生命浪费在品尝/品鉴无穷多种的语法糖中，我认为不值当。

在现实世界中，除时间和空间可能是无限的以外，其它任何事物都是有限的。

上面写错了 bool isswap = true; for(i = r -1; isswap && i >= l; --i)//冒泡排序算法  {      isswap = false;     for(j = l; j < i; ++j)      {          if(b[j]<b[j+1])         {             isswap = true;             t=b[j+1];            b[j+1]=b[j];            b[j]=t;         }     }  }

Select 可以用排序做，任何一种都可以 但是修改版 快排 是更好的选择

bool isswap = true; for(i = l; isswap && i < r-1; ++i)//冒泡排序算法  {      for(j = l; j < r - i; ++j)      {          isswap = false;         if(b[j]<b[j+1])         {             isswap = true;             t=b[j+1];            b[j+1]=b[j];            b[j]=t;         }     }  }

没人了吗

我把数组大小 改为n+1 也不行啊。不用不定长数组，宏定义一个MAX,排序那块还是有错，，，是怎么回事？

不定长数组，看着好用，其实陷阱也不少 尽量不用为妙

DEV是用的GCC做编译器，所以允许这样定义int a[n]; 楼主你的下标都是从1开始的，那就必然会造成越界，结果也就不好说了 假设你输入的n是5，你复制是从a[1]到a[5]的，越界了。。 楼主改掉以后再试试


Question: windows核心编程有些不懂

Windows驱动开发 http://www.osronline.com/  搜“毛德操”

windows技术内幕 这本书不错的。 还是要理解windows的操作和运行方式。

引用 2 楼 qq423399099 的回复:我觉得核心编程的主题思想不在编程而在核心……我身边绝大多数搞内核的基本都不是从写驱动开始，而是从windbg调试内核开始的。你不调试光想靠读书背函数名根本就没完，导出函数列表几页a4纸都写不下……而调试内核熟悉了调用关系之后也就明白了该去找什么，写驱动也就比较得心应手。技术上的话基本的算法得会一点，但是c和x86汇编必须精通（c++可以不会，因为内核里基本没有c++代码）。另外建议从内存管理模块看起（目录名mm），那块比较容易理解。书的话除了有网友提到的《Windows核心编程》外，如果真的不是闹着玩而是想学好的话建议先啃了潘爱民先生的《Windows内核原理与实现》（配合着Windows Research Kernel源码看）。 p.s. Windows内核在Windows 8和Windows 10都有较大改动，但是NT部分变动基本为零，所以你啃下来一个内核基本就通吃了。  误导人了， 先学驱动，  再结合书籍，  windbg只是一部分

边敲边学，再就是多看几遍


Question: 勇闯黄金十二宫——双鱼宫 求用c做

#include<stdio.h> int main() { 	int n,Si[40000],Fi[40000],i,j; 	while(scanf("%d",&n)!=EOF) 	{ 		int max=1; 		for(i=1;i<=n;i++) scanf("%d%d",&Si[i],&Fi[i]); 		for(i=1;i<n;i++) 		{ 			int count=1; 			for(j=i+1;j<=n;j++) 			{ 				if(Fi[j-1]>Si[j]) break; 				else {count++;if(count>max) max=count;}  			} 		} 		printf("%d\n",max); 	} 	return 0; }

//  /* Sample Input 3 0 2 0 1 1 3 Sample Output 2 */ //假设每次都是从初始时间连续进行攻击 否则需要进行排序 #include <stdio.h> #define FALSE 0 #define TRUE 1 struct attack { 	int start; 	int end; 	int time; };  int get_next_attack(struct attack att, int start , struct attack *first) { 	if (att.start == start) 	{ 		if(att.time <= first->time) 		{ 			first = &att; 		} 		return FALSE; 	}  	return TRUE;	 } int main() { 	int n; 	scanf("%d", &n); 	int i = 0; 	int start = 0; 	int attack_time = 1; 	struct attack first_att; 	for (; i < n; i++) 	{ 		struct attack att; 		scanf("%d", &att.start); 		scanf("%d", &att.end); 		att.time = att.end - att.start; 		if (i == 0) 		{ 			first_att.start = att.start; 			first_att.end = att.end; 			first_att.time = att.end - att.start; 		} 		if(TRUE == get_next_attack(att, start, &first_att)) 		{ 			start = first_att.end; 			attack_time++; 		} 	} 	printf("%d\n", attack_time); }


Question: 线性表的顺序结构

引用 6 楼 qq423399099 的回复:[quote=引用 5 楼 ri_aje 的回复:] [quote=引用 4 楼 qq423399099 的回复:] -858993460 == 0xcccccccc, debug模式下编译器对未初始化的变量赋的缺省值 说明了什么？说明你调用了InitList根本没有起到作用 楼主你调用InitList传的是一级指针，是无法改变指针的指向的 要改变指向只能传二级指针或者一级指针的引用 改为：  bool InitList(SqlList **L) { 	*L = (SqlList *)malloc(sizeof(SqlList)); 	if(L == NULL) 		return false; 	(*L)->length = 0; 	return true; }  int main(void) { 	SqlList *list; 	InitList(&list); 	printf("%p\n", &list); 	printf("***%d***\n", list->length); }  一级指针没有问题，因为楼主要修改的是对象。[/quote] 他要修改的是指针的指向，为他malloc,不是修改对象[/quote] 这就是仁者见仁的问题了，从外面的对象来看，里面的 malloc 是多余的，完全可以理解为函数是用来通过指针初始化对象的；从里面的 malloc 来看，参数应该是 *& 或 **，外面应该用指针。楼主自己不出来说清楚，谁也说不清一定是那种用法。

传一级指针的意思是： 函数中的形参的指针和main函数中的实参的指针指向了同一块内存区域 所以你想通过形参的指针改变指向的内存区域里面的内容是可以的，但你想改变main函数中的实参的指针的指向是不行的 你将malloc出来的内存地址赋值给形参的指针，只是改变了形参的指针的指向，对main函数的实参的指针是没有影响的

调试的时候发现确实是一级指针无法改变指针所以指向的，没看过二级指针，所以还是迷糊啊

引用 7 楼 ri_aje 的回复:[quote=引用 6 楼 qq423399099 的回复:] [quote=引用 5 楼 ri_aje 的回复:] [quote=引用 4 楼 qq423399099 的回复:] -858993460 == 0xcccccccc, debug模式下编译器对未初始化的变量赋的缺省值 说明了什么？说明你调用了InitList根本没有起到作用 楼主你调用InitList传的是一级指针，是无法改变指针的指向的 要改变指向只能传二级指针或者一级指针的引用 改为：  bool InitList(SqlList **L) { 	*L = (SqlList *)malloc(sizeof(SqlList)); 	if(L == NULL) 		return false; 	(*L)->length = 0; 	return true; }  int main(void) { 	SqlList *list; 	InitList(&list); 	printf("%p\n", &list); 	printf("***%d***\n", list->length); }  一级指针没有问题，因为楼主要修改的是对象。[/quote] 他要修改的是指针的指向，为他malloc,不是修改对象[/quote] 这就是仁者见仁的问题了，从外面的对象来看，里面的 malloc 是多余的，完全可以理解为函数是用来通过指针初始化对象的；从里面的 malloc 来看，参数应该是 *& 或 **，外面应该用指针。楼主自己不出来说清楚，谁也说不清一定是那种用法。[/quote]  我明白你们的意思了   malloc分配了一个新的地址而我只是改变这个新的地址里面的数据，原来地址里面的数据没有改变 但是我还是迷糊，我不是把malloc分配的地址给list吗？

引用 5 楼 ri_aje 的回复:[quote=引用 4 楼 qq423399099 的回复:] -858993460 == 0xcccccccc, debug模式下编译器对未初始化的变量赋的缺省值 说明了什么？说明你调用了InitList根本没有起到作用 楼主你调用InitList传的是一级指针，是无法改变指针的指向的 要改变指向只能传二级指针或者一级指针的引用 改为：  bool InitList(SqlList **L) { 	*L = (SqlList *)malloc(sizeof(SqlList)); 	if(L == NULL) 		return false; 	(*L)->length = 0; 	return true; }  int main(void) { 	SqlList *list; 	InitList(&list); 	printf("%p\n", &list); 	printf("***%d***\n", list->length); }  一级指针没有问题，因为楼主要修改的是对象。[/quote] 他要修改的是指针的指向，为他malloc,不是修改对象

我自己单步运行 在bool InitList(SqlList* L)里面length确实等于0 但是一离开bool InitList(SqlList* L)，length就不是0了。想不通啊，我不是传了地址进去的吗？

引用 4 楼 qq423399099 的回复:-858993460 == 0xcccccccc, debug模式下编译器对未初始化的变量赋的缺省值 说明了什么？说明你调用了InitList根本没有起到作用 楼主你调用InitList传的是一级指针，是无法改变指针的指向的 要改变指向只能传二级指针或者一级指针的引用 改为：  bool InitList(SqlList **L) { 	*L = (SqlList *)malloc(sizeof(SqlList)); 	if(L == NULL) 		return false; 	(*L)->length = 0; 	return true; }  int main(void) { 	SqlList *list; 	InitList(&list); 	printf("%p\n", &list); 	printf("***%d***\n", list->length); }  一级指针没有问题，因为楼主要修改的是对象。

我是参照李春保的数据结构一书

把那句 malloc 去掉再试一下，L 修改以后已经指向不同的对象了，后面的操作都影响不到调用端的 list 对象了。 另外，length 也拼错了，看来要么是楼主抄书钞错了，要么是书太烂了。


Question: gcc和vs编译结果不同

引用 2 楼 akirya 的回复:%4c ?这个用的不对吧 %c是读取一个字符的，写4明显不对啊。      c      Matches a sequence of characters whose length is specified by the maximum field width (default               1);  the  next  pointer  must  be a pointer to char, and there must be enough room for all the               characters (no terminating null byte is added).  The usual skip of leading white space is sup-               pressed.  To skip white space first, use an explicit space in the format.

%4c ?这个用的不对吧 %c是读取一个字符的，写4明显不对啊。

因为你用vc编译时候选择的是debug版，debug版为了便于调试等原因分配的空间是不连续的。 你可以试试用Release版。  首先你要知道你的程序 栈溢出了。栈空间的分配通常是由大到小， 所以C1地址比C2的地址大1， scanf C1的时候，C1存储的是1，之后的234就溢出了， scanf C2的时候，C2存储的是5，之后的6存储到C1中，之后的78同样溢出了。

引用 3 楼 qq423399099 的回复:楼主可以用%p打印两个字符的地址，楼主这样的用法会越界写入(也算是未定义行为) 用VS得出的结果是，两个字符地址相差12，因为是DEBUG版，所以会安插一些调试用的数据，所以相差12,（RELEASE就不是） 而在LINUX下用GCC编译得出两个字符地址相差1（而且打印的结果是1,5不是楼主的6,5） 我猜楼主的WINDOWS用GCC应该是两个字符地址相差1，而且c2分配到的地址在c1前面，所以第二次的5678 (5赋值给了c2,6覆盖到了c1) PS:这种打印结果和编译器关系很大，属于未定义行为！！！  void main() { 	char c1,c2; 	printf("%p %p\n",&c1,&c2);     scanf("%4c%4c",&c1,&c2); 	     printf("%c\n",c1);     printf("%c\n",c2); }  明白了 我的vc6.0相差为4个字节。用windows下的gcc 是相差一个字节

引用 4 楼 lgbxyz 的回复:[quote=引用 2 楼 akirya 的回复:] %4c ?这个用的不对吧 %c是读取一个字符的，写4明显不对啊。      c      Matches a sequence of characters whose length is specified by the maximum field width (default               1);  the  next  pointer  must  be a pointer to char, and there must be enough room for all the               characters (no terminating null byte is added).  The usual skip of leading white space is sup-               pressed.  To skip white space first, use an explicit space in the format. [/quote]  那lz的代码就是越界了


Question: scanf取进来总是乱码，为什么

引用 6 楼 zhao4zhong1 的回复:推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。  不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了  对电脑而言没有乱码，只有二进制字节。谢谢，理解了，

引用 1 楼 user-6 的回复:代码对file文件操作，除了数字和字符是一样的，其他一律显示为乱码。如果重新读写出来就还是你原来输入的。 乱码没有原因的吧，就像1+1为什么等于2一样。 ---新手个人见解我觉得，乱码的原因是读取时，字节数不对，又不知道哪儿不对，乱码肯定是有原因的，

引用 3 楼 qq423399099 的回复:在Debug 模式下，VC 会把未初始化的栈内存全部填成0xcc。会把未初始化的堆内存全部填成0xcd。未初始化的变量会被系统赋初值为0xCC,超过了ASCII码0-127这个范围，因此这个“字符串”被系统当成了宽字符组成的字符串，即两个字节数据组成一个字符，而0xCCCC表示的宽字符正好是乱码中的那个“烫”字。同理，0Xcdcd就是“屯”字。 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。原来这样，是因为后面的字节没有被覆盖，而只是初始化的结果，谢谢了，

如果希望写入文件的东西人可读，一般应该仅用 fprintf 。

t 方式（文本文件）打开 fread,fwrite 本来就容易出问题，应该用 fscanf,fprintf 读写 二进制应该用 b方式打开fread,fwrite读写

fwrite(pp,sizeof(struct STU),2,pfile); 是向文件中写 35个字节，结构体中的name占用的值为zhang占用了6个字节(加上'\0'占用的一个字节)，但在写的时候也是要写10个字节。后面4个字节是垃圾数据


Question: 额，现在在学数据结构，但是好像不会融会贯通

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

fromtail函数需要用while来循环读入  #include<stdio.h> #include<stdlib.h> #define ElemType int typedef struct Node {ElemType data; struct Node *next; }Node,*Linklist;   void fromtail(Linklist H) { 	int c; 	Node *p,*s; 	s=H; 	while(1) 	{ 		scanf("%d", &c); 		p=(Node *)malloc(sizeof(Node)); 		p->data = c; 		p->next = NULL; 		s->next = p; 		s = p; 		if(getchar() == '\n') 			break; 	}  }   void Get(Linklist H) { 	Node *s; 	s=H->next;  	while(s!=NULL) 	{ 		printf("%d ",s->data); 		s=s->next; 	} 	//printf("%d",s->data); 	//return s->data;   }  void main() {  	struct Node  *H; 	H=(Node *)malloc(sizeof(Node)); 	H->next=NULL; 	fromtail( H);  	Get(H);  }

下断点，调试


Question: 设计一个有 N个进程并发的进程调度程序----用c语言实现

百度上搜，应该有现成的答案。

第1个要求就很难，那么多的参数从哪儿来

引用 4 楼 u010398728 的回复:引用 3楼user-4 的回复:可以肯定这是<<操作系统>>的课程设计, 主要考察操作系统内存管理, 进程管理等方面, 祝你好运楼主你会吗 他都祝你好运了，可定是会的

引用 1楼lm_whales 的回复:好牛的要求 问题是 资源ABC的作用是什么，和指令有何关系？ 这么 样的系统，可以很简单做出来？有多少东西没考虑进去？ 时间片和 指令是什么关系？ 有额外的东西管理指令和时间片？你是这专业吗？题目完整


Question: huff_node *(int,int)' differs in levels of indirection from 'int ()'

这样就没有编译错误了，但是没有Article.txt没法继续帮楼主调试了  #define _CRT_SECURE_NO_DEPRECATE #include <stdio.h> #include <string.h> #include <stdlib.h>    //**************树的 结构***************** typedef struct { 	char letter; 	int  rate; 	int  flag; }Value;  typedef struct { 	Value weight; 	int parent; 	int *child; }huff_node;  typedef struct { 	int rate;//记录字符出现次数 主要用来判断是否第一次出现 	int pos;//记录字符在 huffmanT中的位置 }flag; //**************编码的结构**************** typedef struct { 	char ch; 	char bit[96]; }codenode;  huff_node *create_huffnode(int k,int ch);  //codenode huffman_code[n];//编码 数组 int n = 0;//huffman数组游标 flag  rate[95] = { -1 };//存储字符出现概率 char letter[95];//‘\0填充’  存储字符 huff_node * huffmanT[189];  //***1***遍历文章，计算可打印的字符的权值 void new_huffmanT(int k) { 	FILE *fp;  	int ch; 	fp = fopen("Article.txt", "rt"); 	ch = fgetc(fp); 	while (ch != EOF) 	{ 		if (rate[ch - ' '].rate == -1)//第一次出现 		{ 			huffmanT[n] = create_huffnode(k,ch); 			rate[ch - ' '].rate = 1; 			rate[ch - ' '].pos = n; 			n++; 		} 		else//出现过 		{ 			rate[ch - ' '].rate++; 			huffmanT[rate[ch - ' '].pos]->weight.rate++; 		} 		//读下一字符 		ch = fgetc(fp); 	} 	fclose(fp); }   huff_node *create_huffnode(int k,int ch) { 	huff_node *p = (huff_node *)malloc(sizeof(huff_node) + k*sizeof(int)); 	p->weight.flag = 0;//查找最小 k 个rate值时使用 	p->weight.rate = 1;//rate值 	p->weight.letter = ch ; 	p->parent = -1; 	int i; 	for (i = 0; i < k; i++) 		p->child[i] = -1; return p; }   int main() { 	int m; 	int k; 	printf("请输入huffman树的叉数"); 	scanf("%d", &k); 	new_huffmanT(k); 	getchar(); 	return 0; }   崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。


Question: 新人请教C语言问题，求解疑惑

明白了，谢谢。

应该是死循环导致的；  #include<stdio.h> #include<string.h> void main() {     char *p1,s[25]="i am",*p2,q[20]="a student.";    //s的空间应该加大一些s[64]，保证能够容纳q的数据空间     p1=s+strlen(s);     p2=q;     while(*q!='\0')    //这个地方换成p2即while (0 != *p2)     {         *p1=*p2;          p1++;          p2++;     }     *p1 = 0;     puts(s); }

你判断的是*q而++的是p2.....  #include<stdio.h> #include<string.h> void main() { 	char *p1,s[25]="i am",*p2,q[20]="a student."; 	p1=s+strlen(s); 	p2=q; 	while(*p2!='\0') 	{ 		*p1=*p2; 		p1++; 		p2++; 	} 	puts(s); }

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。


Question: 二级指针 菜鸟 求大神解惑

反正不要返回局部变量的地址..

C++ 对象有构造和析构过程 C没有  函数中中定义的局部变量 ，实际上子函数中只能传递引用，指针，或者 拷贝 通过这些方式使用  main 函数 或者任何一个函数 在调用另一个函数 返回后 继续执行 调用者（main）函数 main 并没有结束。 而被调函数的执行已经结束 函数一次结束后，这些函数使用的栈内存（函数定义的非静态变量，以及形参占用的） 会被清理回收掉，也就是内存恢复成没调用前的状态，以方便内存重新利用。 C,C++ 一个正在执行的函数，是不存在这个问题的。  函数调用，是替换跳转的解决方案 比跳转实用  函数调用，是中断当前程序执行，跳转到函数体内部执行，函数执行完毕，跳回中断处继续执行

函数返回后，除非静态变量， 函数内定义所有其它类型变量占用的空间，都会被系统收回， 否则，空间一直占用下去 很快系统就没有可用空间了   实际上，早期的编程语言，是命令式编程语言 只有跳转 没有堆栈结构  后来有了堆栈 才发展成为 过程式编程语言 函数和过程调用成为主流  有了堆栈

引用 6 楼 zhao4zhong1 的回复:其实电脑开机后物理内存的每个字节都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。很深啊 谢谢要研究下  为什么在main（）中定义的局部变量，可以在子函数中调用，没有销毁丢失那？可以用指针在其他函数中访问，而其他函数里的局部变量，在回到main函数后就被销毁那？

这种返回局部变量的地址属于未定义行为

引用 2 楼 wang0635 的回复:p所指的空间b在函数point()中相当于是自动变量，函数返回后其位置已经释放，后面的printf()函数调用时，一般会再次使用那些位置，当然原来的东西就被冲掉了。可以这样  static int     b[6] = { ... };只 有在调用一次printf()函数后才会冲掉吗？我单步看到没有调用printf（）前还在栈中，难道不是退出调用函数后立刻销毁吗？谢谢你，加static 变为静态变量后一直存在，没什么问题啦，只是对二级指针不太懂，在实验一些自己的想法，更了解指针。

怎么还有人返回局部变量的地址，编译器还是太好心了。


Question: 数据结构迷宫

S->top为 0xCCCCCCCC是因为指针没有初始化 VC的DEBUG版会把未初始化的指针自动初始化为0xCCCCCCCC  崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

仅供参考：/**  * @Title  老鼠走迷宫的拓展探究  * @Author 孙琨  * @Date   2013-11-16  * @At     XUST  * @All Copyright by 孙琨  *  */  #include <iostream> using namespace std;  int maze[9][9] = { // 初始化迷宫，英文maze为“迷宫”     {2,2,2,2,2,2,2,2,2},     {2,0,0,0,0,0,0,0,2},     {2,0,2,2,0,2,2,0,2},     {2,0,2,0,0,2,0,0,2},     {2,0,2,0,2,0,2,0,2},     {2,0,0,0,0,0,2,0,2},     {2,2,0,2,2,0,2,2,2},     {2,0,0,0,0,0,0,0,2},     {2,2,2,2,2,2,2,2,2} };  int startI = 1,startJ = 1; // 入口行列坐标 int endI = 7,endJ = 7;     // 出口行列坐标  void visit(int i,int j)  // 自动搜寻路径 {     int m,n;      maze[i][j] = 1;      if((i == endI) && (j == endJ))     {         cout << endl << "显示路径:" << endl;         for(m=0; m<9; m++)         {             for(n=0; n<9; n++)             {                 if(maze[m][n] == 2)                     cout << "■";                 else if(maze[m][n] == 1)                     cout << "♀";                 else                     cout << "  ";             }             cout << endl;         }     }      if(maze[i][j+1] == 0)         visit(i,j+1);     if(maze[i+1][j] == 0)         visit(i+1,j);     if(maze[i][j-1] == 0)         visit(i,j-1);     if(maze[i-1][j] == 0)         visit(i-1,j);      maze[i][j] = 0;  }  int main(void) {     int i,j;      cout << "显示迷宫: " << endl;     for(i=0; i<9; i++)     {         for(j=0; j<9; j++)         {             if(maze[i][j] == 2)                 cout << "■" ;             else                 cout << "  " ;         }         cout << endl;     }      visit(startI,startJ);      return 0; }

这是还没有写完的


Question: 求大神帮我解一道题，是在是搞不会。

感谢。。。。。。。。。。

#include<stdio.h> #include<math.h>  int main(){      double eps, cur_num, last_num = 1.0; 	scanf("%lf", &eps); 	int i = 0; 	double S = 1.0; 	while(++i) 	{ 		cur_num = ((i % 2) * -2 + 1) / double(i * 3 + 1); 		S += cur_num; 		 		if(abs(last_num) - abs(cur_num) < eps) 			break; 		last_num = cur_num; 	} 	printf("%.4lf\n", S); }


Question: 求助：CXX0017:ERROR:symbol "" not found

引用 8 楼 lm_whales 的回复:传递引用的版本，代码比传递指针的干净多了 而且也符合我们的思维逻辑  传递指针，要额外迁就指针的写法， 过多关注与实现逻辑， 而不是问题逻辑。  直接把 算法伪代码，改成程序，就是二叉树的插入，创建和遍历了  遍历不需要指针的指针，也不需要传递引用， 因为我们只是使用节点的数据，并不打算改变节点的值。   typedef int keytype; typedef struct BinTree{     keytype key;     struct BinTree *lchild,*rchild; } *BSTree,BSTNod ;  void InsertBST(BSTree &bst,int key) { BSTNod *s; if ( bst == NULL)/*递归结束条件*/ { s = (BSTree)malloc(sizeof(BSTNod)) ;//申请新的节点s s->key = key; s->lchild =NULL; s->rchild =NULL; bst = s ;  } else if (key <  bst->key ) { InsertBST(bst->lchild,key);/*将s插入左子树*/  } else if (key > bst->key) { InsertBST(bst->rchild,key);/*将s插入右子树*/ }  }  void CreateBST(BSTree& bst) { int key; bst = NULL; scanf("%d",&key); while (key != 0)        /*输入0结束*/ { InsertBST(bst,key); scanf("%d",&key); } }  void InOrder(BSTree bst) { if (bst != NULL) { InOrder(bst->lchild); printf("%d ",bst->key); InOrder(bst->rchild); } } //添加一个释放所有节点的代码 void Release(BSTree & root){      if(root){           Release (root->lchild);           Release (root->rchild);           free(root);        } }  int main() { BSTree root = NULL; ///直接定义为节点（指针）类型即可 CreateBST(root); InOrder(root); Release(root) return 0; }  谢谢谢谢！

#include<stdio.h> #include<stdlib.h>  typedef struct node { int key; struct node *lchild,*rchild; }BSTNod,*BSTree;  void InsertBST(BSTree *bst,int key) { 	BSTNod *s; 	if ( *bst == NULL)/*递归结束条件*/ 	{ 		s = (BSTree)malloc(sizeof(BSTNod)) ;//申请新的节点s 		s->key = key; 		s->lchild =NULL; 		s->rchild =NULL; 		*bst = s ; //这地方修改一下，不应该给 bst 赋 地址值                                //1)局部变量地址不能储存，                                //2）bst 是节点（指针）的地址，我们要改变的是节点（指针）的值 	} 	else if (key < ( (*bst)->key) ) 	{ 		InsertBST(&((*bst)->lchild),key);/*将s插入左子树*/ 	} 	else if (key > ((*bst)->key)) 	{ 		InsertBST(&((*bst)->rchild),key);/*将s插入右子树*/ 	}  }  void CreateBST(BSTree *bst) { 	int key;         ///bst = NULL; ///不可给节点（指针）的地址赋值 	*bst = NULL; /// 应该给节点（指针）赋值, 	scanf("%d",&key); 	while (key != 0)        /*输入0结束*/ 	{ 		InsertBST(bst,key); 		scanf("%d",&key); 	} }  void InOrder(BSTree bst) ///遍历不修改节点本身，直接传递跟指针就可以了。 { 	if (bst != NULL) 	{ 		InOrder(bst->lchild);  //直接传递指针 		printf("%d ",bst->key); //直接指向 		InOrder(bst->rchild); //直接传递指针 	} }   int main() { 	BSTree root = NULL; 	CreateBST(&root); 	InOrder(root); 	return 0; } 如此修改一下，就好了 其实如果是C++可以传递引用 这样就不必传递节点的指针了

引用 5 楼 qq423399099 的回复:可以编译啊。。楼主是不是把最后的][/code]没有删掉 楼主复制粘贴过去试试，有问题再发上来  #include<stdio.h> #include<stdlib.h>  typedef struct node { int key; struct node *lchild,*rchild; }BSTNod,*BSTree;  void InsertBST(BSTree *bst,int key) { 	BSTNod *s; 	if ( bst == NULL)/*递归结束条件*/ 	{ 		s = (BSTree)malloc(sizeof(BSTNod)) ;//申请新的节点s 		s->key = key; 		s->lchild =NULL; 		s->rchild =NULL; 		bst = &s ; 	} 	else if (key < ( (*bst)->key) ) 	{ 		InsertBST(&((*bst)->lchild),key);/*将s插入左子树*/ 	} 	else if (key > ((*bst)->key)) 	{ 		InsertBST(&((*bst)->rchild),key);/*将s插入右子树*/ 	}  }  void CreateBST(BSTree *bst) { 	int key; 	bst = NULL; 	scanf("%d",&key); 	while (key != 0)        /*输入0结束*/ 	{ 		InsertBST(bst,key); 		scanf("%d",&key); 	} }  void InOrder(BSTree *bst) { 	if (bst != NULL) 	{ 		InOrder(&(*bst)->lchild); 		printf("%d ",(*bst)->key); 		InOrder(&(*bst)->rchild); 	} }   int main() { 	BSTree *root = NULL; 	CreateBST(root); 	InOrder(root); 	return 0; }  是可以编译，但执行有问题。root指针那一块设置断点的话，就会显示XX0017:ERROR:symbol "" not found

引用 2 楼 lm_whales 的回复:没问题啊？你的类型定义呢？ 哦哦，这里。 typedef struct node { 	int key; 	struct node *lchild,*rchild; }BSTNod,*BSTree;

引用 1 楼 qq423399099 的回复:楼主代码贴全，别说你已经贴全了噢 sorry. typedef struct node { 	int key; 	struct node *lchild,*rchild; }BSTNod,*BSTree;

没问题啊？你的类型定义呢？

楼主代码贴全，别说你已经贴全了噢


Question: char*s  和 char s[]的问题

to只有7个字节的空间，你硬要往里塞9个字节。

越界操作，你可以通过sizeof看一下b的空间（会算上'\0')，然后strlen()看一下a的长度（不算'\0'）；拷贝到的目的空间要足够大；

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

学习了，感谢讲解

判断是否越界访问，可以在数组的最后一个元素之后对应的地址处设置数据读写断点。如果该地址对应其它变量干扰判断，可将数组多声明一个元素，并设置数据读写断点在该多出元素对应的地址上。 #include <time.h> #include <stdlib.h> #include <windows.h> int main() {     int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]      srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。     while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。         b[(a=rand()%11)]=0;         Sleep(100);         b[(a=rand()%11)]=1;         Sleep(100);         b[(a=rand()%11)]=2;         Sleep(100);         b[(a=rand()%11)]=3;         Sleep(100);         b[(a=rand()%11)]=4;         Sleep(100);     }     return 0; }

数组b下标越界#include<stdio.h> char *copy(char *,char *); int main() { char *a = "123456789"; char b[10] = "abcdefg"; printf("%s\n%s\n", a, b); char *p = b;  copy(a, p);  printf("%s\n%s\n", a,p);  return 0; }  char *copy(char *from, char *to) { char *p=to; while (*from) 	{*to++ = *from++; 	} *to = '\0'; return p; }

copy函数里to越界写入了 照理a指针的值应该是不会有影响的，因为a指向的是常量区的字符串 这是我VS调试的结果：

感觉是whlie循环出错，条件*from不满足进不了循环

因为越界写，a被覆盖了 printf("a = %p\n",a); 看看，指针 a的值 是否有变化

gcc下没什么问题，我也没看出来有什么问题

你的while循环的条件根本不成立，所以一调用你自己写的copy函数直接把a[0]赋值为结束符”/0“

引用 6 楼 fornetuse123 的回复:[quote=引用 5 楼 fornetuse123 的回复:] *to++ = *from++;           \\你的想法：b数组的各个元素被改写为f；实际上：b数组的第一个元素被改写为f后，执行下面语句  *to = '\0';                             \\这里错了，应该是最后一个*（to+1）指向了一个野指针，所以报错 *（to+1）位于栈中b变量的高地址处已经是别的数据了，比如可能是EBP或者返回地址了，这个位置有可能也是栈保护随机数的位置，所以报告说b变量崩溃了

*to++ = *from++;           \\你的想法：b数组的各个元素被改写为f；实际上：b数组的第一个元素被改写为f后，执行下面语句  *to = '\0';                             \\b数组的第一个元素被改写为终止符；随后的各个元素也都是终止符  这样你打印a、b将只显示a，而b是一个都是终止符元素的数组，所以什么都不显示

gcc和vc2012编译通过，没问题


Question: 0xC0000005: 写入位置 0x0000000C 时发生访问冲突

没有对申请内存空间就往里写数据肯定出错了！

没有分配内存就写入数据了

调试一下就行了，这些还要靠自己。

0x0000000C很接近0x00000000位置。这个错误肯定是对某个NULL指针进行了写入操作 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

它前面一行 s = top = base; 这不把s的值又变成NULL了吗


Question: C语言怎么调用Active X 对象？？

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

作为com对象来调用，有很多接口的。


Question: 字符串和字符串函数

建议把char c；换成int c;用m也是建议:int *m;此时m为野指针哦，用之前献给其分配空间，因为野指针其只想的地址可能是不可写的；所以用之前先给其分配一个可读可写的内存区域，使用malloc吧

c是char类型变量，可以存储一个char数据 m是char*类型变量，可以存储一个指针数据，*m就是这个指针表示地址的单元。m值是多少？那个单元在什么地方？不知道。就往里面存东西，当然要出问题了

刚刚用这个软件不咋太会调试，见笑了，嗯记住你的话了

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。


Question: 一直循环输出地址一样的数据,找不到哪里错了,着急啊啊,在线等大神快来拯救我...

感谢您的建议,长远来看肯定受用不少 不过这是今晚十二点前要交的项目的一部分,您介意帮忙看看吗?


Question: 编写一个程序，输入N个用户的姓名和电话号码，按照用户姓名的词典顺序排列输出用户的姓名和电话号码。

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

在设立断点之后要printf里面的东西添加监视为0

改了scanf在后边加了一个getchar吞掉回车 但是还是不明白

你的scanf("%s %d\n",&info[i].name,&info[i].phone); scanf里面不要加\n 写入字符串不用加&,你的phone为什么要一个200大小的数组？感觉一个int就行了 楼主可以单步观察一下每部的变量的值以及结果 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）

1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34 #include<stdio.h> #include<string.h> struct Person{ 	char name[50]; 	int phone[200]; }tmp,array[100]; void byname(struct Person array[],int n) { 	int i,j; 	struct Person tmp; 	for(i=0;i<n;i++){ 		for(j=i;j<n;j++) 		{ 			if(strcmp(array[i].name,array[j].name)>0) 			{ 				tmp=array[i]; 				array[i]=array[j]; 				array[j]=tmp;			 			} 		} 	} } int main() { 	struct Person info[100]; 	int i,n; 	scanf("%d",&n); 	for(i=0;i<n;i++) 		scanf("%s %d\n",&info[i].name,&info[i].phone); 	byname(info,n); 	for(i=0;i<n;i++) 		printf("%12s %12d\n",array[i].name,&array[i].phone);	 	return 0; } 又写了一个还是不行


Question: 一个C语言问题  有一点点没明白 指向结构体数组的引用

楼主先入为主了，觉得第一个stu_p[0][i]对应第一个%d,第二个stu_p[0][i]对应第二个%d是这样想的么？ 其实下面那样就行了，后面的参数都是没用的，楼主是不是明白了什么呢  for (i = 0; i < 3; ++i)    printf("%d,%d,%d,%c\n", stu_p[0][i]);

第三条printf不明白 for (i = 0; i < 3; ++i) printf("%d,%d,%d,%c\n", stu_p[0][i], stu_p[0][i], stu_p[0][i], stu_p[0][i]);


Question: linux 按退格键显示^H问题

使用NCURSES库 ？


Question: 关于数组清零后再输出的问题

引用 16 楼 zhao4zhong1 的回复:我的意思是你要小心结构体字节对齐问题。 我在网上找了很多程序，好像大家都没有涉及结构体字节对齐问题。直接用memcpy（）把一个数组拷贝到一个结构体中的，但是我这么做发现拷贝到结构体中的数据是错的，现在在研究结构体字节的对齐方式

“多一少一”问题占程序员常犯错误的10%以上！ 避免“多一少一”问题的方法之一是将比如<10甚至<5的数代入程序片断，搬手指头心算验证一下程序到底应该写为 x、x-1、x+1中的哪个？ <、<=、==、>、>=中的哪个？

引用 7 楼 xue_opnet 的回复:[quote=引用 4 楼 cyfcsd 的回复:] 程序片段看不懂啊，你能不能把整个程序发出来啊  程序涉及的太多，贴的程序越多。越乱。 贴出来的程序的功能就是socket通信，客户端发一个数组给服务端，服务端收到数组后打印出数组中的内容，接着再把数组转换成结构体，再打印出结构体中的内容。[/quote] 那问题是出在哪儿了啊，看不懂啊，你要自己学会调试，关键弄明白数据是怎么传的，然后找个地方打断点看看是不是正确的，要是不行就直接输出，这样逐步确定出错地方 比如说发送消息之前看看传进去的实参，进入函数后看看传进来的形参，转换之后看看转换之后的结果，返回前看看返回的参数，返回后看看返回的结果。。。 再厉害的大神也是这么调试的，那些一眼就看出错误的人都是以前犯过同样的错误！

我的意思是你要小心结构体字节对齐问题。

6楼的回答。。。。 sizeof的是数组名，又不是指针名，怎么会是4呢

引用 4 楼 cyfcsd 的回复:程序片段看不懂啊，你能不能把整个程序发出来啊  程序涉及的太多，贴的程序越多。越乱。 贴出来的程序的功能就是socket通信，客户端发一个数组给服务端，服务端收到数组后打印出数组中的内容，接着再把数组转换成结构体，再打印出结构体中的内容。

memset(Send_Buf,0,sizeof(Send_Buf)+1);  你这个memset是有问题的，应该是memset(Send_Buf,0,20*sizeof(char));  ，你的那个Send_buf只是数组的首地址的指针而已，顶多开辟4个字节的空间， 再加1也就5个字节。

清空了就是什么都没有了呗

程序片段看不懂啊，你能不能把整个程序发出来啊

引用 14 楼 zhao4zhong1 的回复:玄  参考下面：#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 // //  没有看出来哪里是数组中的数据转换到结构体中。 #define field_offset(s,f) (int)(&(((struct s *)(0))->f))这条语句是定义了一个结构体中数据的位置 #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;}; 这是定义了几个结构体 组函数用来把结构体中的内容输出，在哪里给结构体赋值的呢？

引用 9 楼 cyfcsd 的回复:[quote=引用 7 楼 xue_opnet 的回复:] [quote=引用 4 楼 cyfcsd 的回复:] 程序片段看不懂啊，你能不能把整个程序发出来啊  程序涉及的太多，贴的程序越多。越乱。 贴出来的程序的功能就是socket通信，客户端发一个数组给服务端，服务端收到数组后打印出数组中的内容，接着再把数组转换成结构体，再打印出结构体中的内容。[/quote] 那问题是出在哪儿了啊，看不懂啊，你要自己学会调试，关键弄明白数据是怎么传的，然后找个地方打断点看看是不是正确的，要是不行就直接输出，这样逐步确定出错地方 比如说发送消息之前看看传进去的实参，进入函数后看看传进来的形参，转换之后看看转换之后的结果，返回前看看返回的参数，返回后看看返回的结果。。。 再厉害的大神也是这么调试的，那些一眼就看出错误的人都是以前犯过同样的错误！[/quote] 嗯嗯，谢谢指导

引用 11 楼 zhao4zhong1 的回复:参考printf的源代码C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\output.c 请问，如果把一个数组里的内容转换到结构体中，用下面的语句实现，正确吗？                struct Gate clt;  		memset(Recv_Buf,0,sizeof(Recv_Buf)); 		ret=recv(sClinetSock,Recv_Buf,sizeof(Recv_Buf),0); 		printf("Recv_Buf Mesg:%s\n",Recv_Buf); 		memset(&clt,0,sizeof(info)); 		memcpy(&clt,Recv_Buf,sizeof(clt));

引用 1 楼 cyfcsd 的回复:那个memset里面不用+1吧，就是20个字节清0啊，没有21个字节  你用%s的格式输出，默认是遇到‘\0’就停止的，而‘\0’对应的ASCII码就是0，所以一遇到Send_Buf[0]就停止了，因为这里面放的就是0  谢谢，这个问题解决了，但是我遇到了下面的问题。socket通信。客户端发送语句为： send(sClntSock,Send_Buf,sizeof(Send_Buf),0); 发送的消息为：  服务端程序功能是接收到数组后再转换为结构体，程序为：                int ret;                info = (Gate *)calloc(1, sizeof(Gate));                memset(Recv_Buf,0,sizeof(Recv_Buf)+1); 		ret=recv(sClinetSock,Recv_Buf,sizeof(Recv_Buf),0); 		printf("Recv_Buf Mesg:%s",Recv_Buf); 		struct Gate Gate; 		memset(info,0,sizeof(Gate)); 		memcpy(info,Recv_Buf,sizeof(Gate));                 printf("Packet Report: \nOPNET Time = %f\ntx_wave = %d\n gate_length = %d\n gate_length1 = %f\ngate_length2 = %f\n", info->start_time,info->tx_wave,info-> gate_length,info-> gate_length1,info-> gate_length2); 结构体内容为： typedef struct Gate 	{ int tx_wave; 	int gate_length; 	int gate_length1; 	int gate_length2; 	double start_time; 	    }Gate; 结果输出的内容为：  请问这又是为什么呢?

memset(Send_Buf,0,sizeof(Send_Buf));不用加1的 memset是按字节赋值，Send_Buf[0]被赋值成了0000 0000，Send_Buf[1]被赋值成了0000 0000........... 0000 0000即ASCII码为0，即'\0' 如楼上所说用%s的格式输出，默认是遇到‘\0’就停止的


Question: uva1589 测试过很多数据没问题 但就是wa

wrong answer 不知道错在哪的话，几个办法： 1. 找个正确的程序来比对，一般能看出问题来。 2. 假设没看出来，那么自己制造一些数据进行测试，用两个程序都跑一遍，看看输出是否一致。这个做数据的话，范围得做得大一些，样本做多一些。 3. 还是没发现的话，找别人来给你看一下，去OJ相关的网上到处贴，总有热心人士会来给看看的。 (直接第三步会比较省力, 不过时间上没保证)

能不能帮我看下 数据测试过很多了 也去udebug上提交过


Question: 请教一个简单问题，关于vs2010中自定义函数。

类型定义， 常量定义 外部变量定义 函数声明 inline 函数 模板函数和模板类 等等 这些东西，对C,C++来说，属于接口性质的东西 可以放在头文件里  函数定义， 类静态变量定义 以及一些文件自己使用的 接口性质的代码，放在实现文件.c,.cpp 中

引用 6 楼 qq423399099 的回复:Myh.cpp第一行写#include"Myh.h" 同时你的.h以及.cpp文件也要包含需要的另外的头文件  感谢~明白了 嘿嘿

引用 3 楼 lm_whales 的回复:其实如果不是临时起意，可以先规划好 .cpp，.h 的名字 直接在 .cpp 写程序 外部接口，写在.h 内部接口，实现 写在.cpp  谢谢热心回复，但是我不太理解，能不能通俗点，我觉得自定义函数越来越多的时候，每次创建新自定义函数都要下拉很久很麻烦，所以想把自定义函数放进一个.cpp，但是一引用，就无法打开包括文件。

引用 1 楼 qq423399099 的回复:源文件上右键，添加--新建项 取名为Myh.cpp 第一行写上#include"Myh.h" 然后将main函数里的自定义函数直接ctrl+x,ctrl+v过去 完成！！  谢谢回复  另外我想知道新建Myh.cpp之后，第一行写#include"Myh.cpp"对吧，但是我试了下发现不行啊。 我把自定义函数放进myh.cpp，在里面会有很多未定义标识符。

剪切，复制，整理。 就这么简单


Question: c语言 1+1*2+1*2*3+......

循环内还要再嵌套一层循环求1*2*3*... 外层循环是把每个加起来

多用用for , 理解理解. 参考代码如下:  #include<stdio.h>  int main()  {       int i,n,m=1,s=0;  //修改      printf("Please input the number:\n");      scanf("%d",&n);      printf("n=%d\n",n);      for(i=1;i<=n;i++)     //修改      {        m=m*i;   //修改       s=s+m;  //修改      }      printf("s=%d\n",s);      return 0; }

#include<stdio.h>  int main()  {       int i,n,m=1;  //修改      printf("Please input the number:\n");      scanf("%d",&n);      printf("n=%d\n",n);      for(i=1;i<=n;i++)     //修改      {        int s=0;    //修改       m=m*i;   //修改       s=s+m;  //修改      }      printf("s=%d\n",s);      return 0; }

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


Question: C socket , 救急！！！

引用 1 楼 CharlesSimonyi 的回复:66行：printf("Connected in!"); exit(0); 退出程序，后面的         if((pid = fork()) == 0) {             char cnt[] = "HTTP/1.1 403 Forbidden\r\nServer:Cary\r\nContent-Type:text/html\r\nContent-Length: 25727\r\nConnection:close\r\n\r\n";             write(client_sock, cnt, strlen(cnt));             close(client_sock);  永远不会执行 谢谢版主 , 问题已解决 , centos7 firewalld 没关 , 我一直以为是 firewall , 少了个 d  , 所以只关了 iptables , firewalld 没关 , 于是外面无法访问 , nc 也无法穿透 ...

引用 1 楼 CharlesSimonyi 的回复:66行：printf("Connected in!"); exit(0); 退出程序，后面的         if((pid = fork()) == 0) {             char cnt[] = "HTTP/1.1 403 Forbidden\r\nServer:Cary\r\nContent-Type:text/html\r\nContent-Length: 25727\r\nConnection:close\r\n\r\n";             write(client_sock, cnt, strlen(cnt));             close(client_sock);  永远不会执行 在 if((pid=fork())==0)  现在代码被我改成 if(pid < 0) {             perror("Error in fork!");         } else if(pid ==0) {             char cnt[] = "HTTP/1.1 403 Forbidden\r\nServer:Cary\r\nContent-Type:text/html\r\nContent-Length: 3\r\nConnection:close\r\n\r\nHi!";             write(client_sock, cnt, strlen(cnt));             printf("Has sent!\r\n");             close(client_sock);             exit(1);         } 这样了 , 在本机使用 curl 127.0.0.1:99 一点问题都没有 , 其它机器则不行 , 防火墙是关闭状态的

引用 1 楼 CharlesSimonyi 的回复:66行：printf("Connected in!"); exit(0); 退出程序，后面的         if((pid = fork()) == 0) {             char cnt[] = "HTTP/1.1 403 Forbidden\r\nServer:Cary\r\nContent-Type:text/html\r\nContent-Length: 25727\r\nConnection:close\r\n\r\n";             write(client_sock, cnt, strlen(cnt));             close(client_sock);  永远不会执行 谢谢，忘记说了，那句是为了调试的，那一句就永远不会执行了


Question: 求助，结构体引用变量初始化问题

为什么VS编译后显示拒绝访问，其他软件可以

shuru函数里XiShuJuZhen&t;改为XiShuJuZhen t;

关闭UAC和杀毒软件。 以管理员身份运行 以XP兼容模式运行 重新build-重建工程-重装vs-重装系统


Question: 用c调用linux指令

就算你要分析结果，也可以凑合用 system("指令 <in.txt >out.txt");//然后读out.txt的内容

如果你要分析执行结果, 用popen; 如果不要, 为什么不用system呢?

int create_procress(const char *path,const char *name,const char *arg) {     pid_t pid;      pid=fork();     if(pid == 0)     {         if(execl(path,name,arg,NULL) == -1)         {             perror(path);             _exit(-1);         }     }     else if(pid == -1)         return -1;      return 0; } 参数path为执行外部程序的路径 name为运行程序的名称（argv[0]） arg为命令行参数（从argv[1]开始）

给一个不用system的理由

引用 4 楼 user-8 的回复:[quote=引用 1 楼 qq423399099 的回复:] 方法1：popen()会调用fork()产生子进程，然后从子进程中调用/bin/sh -c来执行参数command的指令。 方法2：使用vfork()新建子进程，然后调用exec函数族 参考：http://blog.sina.com.cn/s/blog_8043547601013rxf.html  int execl(const char *path, const char *arg, ...);  int execlp(const char *file,  const char *arg, ...);   int execle(const char *path, const char *arg,  ..., char * const envp[]);  int execv(const char *path,  char *const argv[]); int execvp(const char *file,  char *const argv[]);  int execve(const char *file,char *const argv[], char *const envp[]);[/quote] +++ 这些也可以完成system的功能； system还是比较简单的；

推荐popen()，还可以获取执行后返回的输出内容并进行分析和处理

进程还不会，先留着，过两天再回来看

引用 1 楼 qq423399099 的回复:方法1：popen()会调用fork()产生子进程，然后从子进程中调用/bin/sh -c来执行参数command的指令。 方法2：使用vfork()新建子进程，然后调用exec函数族 参考：http://blog.sina.com.cn/s/blog_8043547601013rxf.html  int execl(const char *path, const char *arg, ...);  int execlp(const char *file,  const char *arg, ...);   int execle(const char *path, const char *arg,  ..., char * const envp[]);  int execv(const char *path,  char *const argv[]); int execvp(const char *file,  char *const argv[]);  int execve(const char *file,char *const argv[], char *const envp[]);

用system("make")不会死人的。


Question: 求大神帮我改下错误初学驱动..

Windows驱动开发 http://www.osronline.com/

吃屎 我是圣道


Question: 数组在栈中存储问题

引用 6 楼 qq423399099 的回复:整个数组。。。连续的一片内存 可以打印地址来验证。。。  int arr[10]; printf("%p %p %p\n", &arr[0], &arr[1], &arr[2]);

数组在栈里面是怎样存储的，是单个元素存储还是直接存整个数组

楼主是想问分配以后的存储情况呢还是正在分配时候的存储情况

还是没有说明原因，而且全局变量是在静态区的，不是在堆里面

看你数组类型定义呀  栈中存储整个数组，每个数组元素又是根据你定义的类型决定的。


Question: C语言多次调用DLL接口后申请不到函数句柄问题

要看DLL的接口是怎么export出来的，或者是调用方式是什么。

无代码铁定无法分析，有代码，也需要有心人来分析。

检查是否资源泄漏的办法之一： 在任务管理器 进程 查看 选择列 里面选择：内存使用、虚拟内存大小、句柄数、线程数、USER对象、GDI对象 让你的程序(进程)不退出,循环执行主流程很多遍，越多越好，比如1000000次甚至无限循环，记录以上各数值，再隔至少一小时，越长越好，比如一个月，再记录以上各数值。如果以上两组数值的差较大或随时间流逝不断增加，则铁定有对应资源的资源泄漏！


Question: 字符串指针

嗯，对着呢

char alter_ar(char *ar) {  int i; char tmp[100] = {0}; int a = strlen(ar);  	char *p = ar+a-1; printf("now p is %p",p); for(i = 0;i<a;i++,p--) {  tmp[i]=*p; printf("now p is %p\n",p); } //ar[i]='\0'; p = tmp; return p; }

明白了明白了谢了

引用 5 楼 lck898989 的回复:谢谢耐心的回复！还是不太明白，为啥会覆盖呢， 楼主你想想，第一次进for循环，此时i是0，而p指着最后一个字符（即'a'）,然后你进行ar[i]=*p;的操作 也就是说原来的"hellosda"被你改成了"aellosda" 第二次循环后"aellosda"变成了"adllosda" ..... 等到p移动到了前半段字符串以后，此时原来前半段的字符串"hell"早就被之前的四次循环而修改成了"adso"了

谢谢耐心的回复！还是不太明白，为啥会覆盖呢，

你char *alter_ar(char *ar)函数的实参是char so[SIZE]数组的指针  所以你ar[i]=*p;实际上是对原数组char so[SIZE]="hellosda";进行前后置换，有没有临时存储区，所以前3个都被后3个覆盖掉了

楼主不能直接这样覆盖掉ar[i]=*p; 这样的话，原来的前半段的字符都被后面的字符给覆盖了  #include<stdio.h> #include<string.h> #define SIZE 60 char *alter_ar(char *ar);  int main(void) { 	char so[SIZE]="hellosda"; 	printf("the location of so is %p\n",so); 	puts(so); 	//alter_ar(so); 	puts(alter_ar(so)); 	return 0; } char *alter_ar(char *ar) { 	int i; 	int a = strlen(ar); 	char *p = ar+a-1; 	char arr[32] = {0}; 	printf("now p is %p",p); 	for(i = 0;i<a;i++,p--) 	{  		arr[i]=*p; 		printf("now p is %p\n",p); 	} 	arr[i]='\0'; 	strcpy(ar, arr); 	 	return p+1; }

谢谢！地址是连着的啊，但是输出的结果好像有点问题

哪里不完整了 打印出的地址不是连着的么


Question: DEVC运行一个程序会死机

引用 4 楼 qq423399099 的回复:我上面贴代码了啊。。。 你少了一句s=h; 要删除第一个元素，必须有这句，因为删除第一个元素他不会进入while循环，s也就不会被赋值到，是个野指针由衷感谢，谢谢你。

引用 1 楼 qq423399099 的回复:崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。我刚才改了下，正确了可是不能删除第一个位置的数 void shanchu(struct node *h,int y)  {  	 	struct node *p,*s; 		p=h->next ; 		while(p->data !=y&&p!=NULL) 		{ 			s=p; 			p=p->next ; 		} 		s->next=p->next; 		free(p);  } 应该怎么修改，麻烦你了

insert和shanchu函数都有问题  #include<stdlib.h> #include<stdio.h> struct node { 	int data; 	struct node *next; } ; struct node *create()	//用头插法创建一个链表 { 	int x; 	struct node *head,*p; 	head=(struct node*)malloc(sizeof(struct node));	//建立头节点  	head->next =NULL; 	scanf("%d",&x); 	while(x!=-999) 	{ 		p=(struct node*)malloc(sizeof(struct node)); 		p->data=x; 		p->next=head->next;	//将p放在头节点之后 		head->next=p; 		scanf("%d",&x);  	} 	return(head); }  void outline(struct node *h)	//输出一个链表 { 	struct node *p; 	p=h->next; 	printf("\n"); 	while(p!=NULL) 	{ 		printf("%5d",p->data ); 		p=p->next; 	} }  void insert(struct node *h,int x,int y)	//将y插到x后面 { 	struct node *p,*s; 	p=h->next; 	while(p->data!=x&&p!=NULL) 	{ 		p=p->next ;  	} 	s=(struct node*)malloc(sizeof(struct node)); 	s->data =y; 	s->next =p->next ; 	p->next =s; }  void shanchu(struct node *h,int x)	//删除链表中数据为x的节点 { 	struct node *p,*s; 	s=h; 	p=h->next ; 	while(p->data!=x&&p!=NULL) 	{ 		s=p;//s指向前一个节点 		p=p->next ; 	} 	s->next=p->next ; 	free(p); }  int main() { 	int a,b; 	struct node *h; 	h=create(); 	outline(h);  	printf("\ninput a,b:"); 	scanf("%d%d",&a,&b);  	insert(h,a,b); 	outline(h); 	shanchu(h,a); 	outline(h); }


Question: 关于存储含空格的字符串

楼主是没有把ii的值重新置为0吧

在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 int c; scanf("%c",&c); //时，都改为 char s[2]; int c; scanf("%1s",s); c=s[0];


Question: 帮忙看个问题Cpp2.obj : error LNK2001: unresolved external symbol "int __cdecl max(int,

代码没问题的，我这里可以编译运行 楼主是不是创建工程有问题？ 要创建控制台程序才行

max_test.cpp #include<stdio.h> #include "max.h" int main() {     int x=2,y=5;     int s;     s=mymax(2,5);     printf("%d  ",s);     return 0; } max_fa.cpp #include"max.h"   int mymax(int x,int y) {     if(x>y) return x;     else return y; } max.h #ifndef MAX_H #define MAX_H   int mymax(int x,int y); #endif

引用 6 楼 zhao4zhong1 的回复://max_test.cpp #include<stdio.h> #include "max.h" int main() {     int x=2,y=5;     int s;     s=mymax(2,5);     printf("%d  ",s);     return 0; }   //max.h: #ifndef MAX_H #define MAX_H  int mymax(int x,int y); #endif  //max_fa.cpp: #include"max.h"  int mymax(int x,int y) {     if(x>y) return x;     else return y; }   Compiling... Skipping... (no relevant changes detected) max_fa.cpp Linking... LIBCD.lib(wincrt0.obj) : error LNK2001: unresolved external symbol _WinMain@16 Debug/wj.exe : fatal error LNK1120: 1 unresolved externals 执行 link.exe 时出错.  wj.exe - 1 error(s), 0 warning(s) 完全复制代码后重新建立又出现了这个问题

//Cpp2.cpp #include<stdio.h> #include "max.h" int main() {     int x=2,y=5;     int s;     s=mymax(2,5);     printf("%d  ",s);     return 0; }   //max.h: #ifndef MAX_H #define MAX_H  int mymax(int x,int y); #endif  //max_fa.cpp: #include"max.h"  int mymax(int x,int y) {     if(x>y) return x;     else return y; }   将max_fa.cpp添加到项目源代码中？

是哪个max换成mymax？

引用 2 楼 zhao4zhong1 的回复:请将max替换为mymax 是哪个max替换成mymax？

请将max替换为mymax

楼主是自己编译链接的吗，建议贴一下指令


没把相关cpp放在同一个项目中。 笔误写错了，函数原型和函数实现不一致。 ……

引用 3 楼 zhao4zhong1 的回复:项目、属性、链接器、常规、附加库目录：填写附加依赖库所在目录 分号间隔多项 项目、属性、链接器、输入、附加依赖项：填写附加依赖库的名字.lib 空格或分号间隔多项 不行 作业交cpp给老师 把自己电脑环境设置了没用啊 应该不是这个的问题吧  老师给的代码

引用 1 楼 qq423399099 的回复:LNK2019一般是链接问题，只有声明而找不到实现 建议楼主贴一下几个文件开头的几句include 同时是用的是IDE还是自己手动编译链接的 能不能求个联系方式 project太长了 我贴不上去


Question: 那位大神可以解读一下UNIX环境高级编程第三版第四章22节的那个递归读目录的程序啊

第一遍看都费劲，这个别人帮不了你，还得看

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

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


Question: C语言编程求组

#define LENGTH 10 #define NUM 10 struct avaiable{     char name[LENGTH];     int encrypted; };   struct current{     int mode;     char name[LENGTH];     char name1[LENGTH];     char pass[LENGTH]; };   struct setting{     struct avaiable avaiable_w[NUM];     struct current current_w; };   struct setting *info_st;   int main() {     char name1[10]={"dasd"};    //以下两句也是可以的，只是这个是在栈上（也可以直接使用alloca)，如果使用malloc是在堆上申请；     struct setting info_val;     info_st = &info_val;     info_st->current_w.mode = 22;     printf("%d\n",info_st->current_w.mode);       memcpy(info_st->avaiable_w[0].name,name1,sizeof(name1));     info_st->avaiable_w[0].encrypted=1;       printf("%s\n",info_st->avaiable_w[0].name);     printf("%d\n",info_st->avaiable_w[0].encrypted);     return 0; }  出现端错误的原因是因为info_st是指向NULL，即不可读不可写的区域，那么你对其赋值是对其进行写操作，所以会出现内存访问出错，所以就会出现端错误；

#define LENGTH 10 #define NUM 10 struct avaiable{     char name[LENGTH];     int encrypted; };   struct current{     int mode;     char name[LENGTH];     char name1[LENGTH];     char pass[LENGTH]; };   struct setting{     struct avaiable avaiable_w[NUM];     struct current current_w; };   struct setting info_st;   int main() {     char name1[10]={"dasd"};     info_st.current_w.mode = 22;     printf("%d\n",info_st.current_w.mode);       memcpy(&info_st.avaiable_w[0].name,name1,sizeof(name1));     info_st.avaiable_w[0].encrypted=1;       printf("%s\n",info_st.avaiable_w[0].name);     printf("%d\n",info_st.avaiable_w[0].encrypted);      return 0; }

刚试了这样也行的，呵呵，

学习中，楼上回复太好了，感觉要用它，info_st->avaiable_w[0].name，要给其开辟空间的，因为其定义是指针的，不像struct setting  info_st[100],之类的吧，呵呵，也在学习之中，望指点

要为指针先malloc一个空间才行  #define LENGTH 10 #define NUM 10 struct avaiable{     char name[LENGTH];     int encrypted; };   struct current{     int mode;     char name[LENGTH];     char name1[LENGTH];     char pass[LENGTH]; };   struct setting{     struct avaiable avaiable_w[NUM];     struct current current_w; };   struct setting *info_st;   int main() {     char name1[10]={"dasd"}; 	info_st = (struct setting *)malloc(sizeof(struct setting));     info_st->current_w.mode = 22;     printf("%d\n",info_st->current_w.mode);       memcpy(info_st->avaiable_w[0].name,name1,sizeof(name1));     info_st->avaiable_w[0].encrypted=1;       printf("%s\n",info_st->avaiable_w[0].name);     printf("%d\n",info_st->avaiable_w[0].encrypted);     return 0; }

Linux： 进程意外退出会在当前目录下产生‘core’文件或形如‘core.数字’的文件比如‘core.1234’ 使用命令 gdb 运行程序名 core或core.数字 进入gdb然后使用bt命令 可以查看进程意外退出前函数调用的堆栈，内容为从上到下列出对应从里层到外层的函数调用历史。 如果进程意外退出不产生core文件，参考“ulimit -c core文件最大块大小”命令  Windows： 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。

给自己顶一下


Question: 【求助】怎么实现线性表（顺序表）的排序（C语言）

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

仅供参考：//不带表头结点的单向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> #include <locale.h> struct NODE {     int          data;     struct NODE *next; } *head,*p,*q,*s,*p1,*p2,*q1,**ta; int i,k,n,t,m,v,N=10; int main() {     setlocale(LC_ALL,"chs");     srand(time(NULL));      head=NULL;      printf("创建%d个节点的单链表:",N);//创建N个节点的单链表     p=head;     for (i=0;i<N;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) exit(1);         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         if (NULL==p) {             head=q;             p=head;         } else {             p->next=q;             p=q;         }     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      k=3;     v=5;     printf("将值为%d的结点插入到单链表的第%d个结点前:",v,k);//将值为v的结点插入到单链表的第k个结点前     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) exit(1);             q->data=5;             q->next=head;             head=q;             break;         } else {             if (k-1==n) {                 q=(struct NODE *)malloc(sizeof(struct NODE));                 if (NULL==q) exit(1);                 q->data=5;                 q->next=p->next;                 p->next=q;                 break;             }         }         p=p->next;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      k=5;     printf("删除第%d个节点:",k);//删除第k个节点     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=head;             head=head->next;             free(q);             break;         } else {             if (k-1==n) {                 q=p->next;                 if (q) {                     p->next=q->next;                     free(q);                 }                 break;             }         }         p=p->next;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      printf("从小到大排序:");//从小到大排序     for (p=head,p1=NULL;p!=NULL;p1=p,p=p->next) {         for (q=p->next,q1=p;q!=NULL;q1=q,q=q->next) {             if (p->data > q->data) {                  //交换data //              printf("swap %02d %02d\n",p->data,q->data); //              t=p->data;p->data=q->data;q->data=t;                  //或者                  //交换next //              printf("swap %02d %02d\n",p->data,q->data);                 if (p==head) {//p是头                     if (p->next==q) {//pq挨着                         head=q;                         p->next=q->next;                         q->next=p;                         q=p;                         p=head;                     } else {//pq不挨着                         head=q;                         p2=p->next;                         p->next=q->next;                         q->next=p2;                         q1->next=p;                         q=p;                         p=head;                     }                 } else {//p不是头                     if (p->next==q) {//pq挨着                         p1->next=q;                         p->next=q->next;                         q->next=p;                         q=p;                         p=p1->next;                     } else {//pq不挨着                         p1->next=q;                         p2=p->next;                         p->next=q->next;                         q->next=p2;                         q1->next=p;                         q=p;                         p=p1->next;                     }                 }                  //输出整个单链表 //              s=head; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d->",s->data); //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个单链表并计算链表长度n     n=0;     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         n++;         s=s->next;     }      printf("将整个链表逆序:");//将整个链表逆序     if (n>=2) {         p=head;         q=p->next;         p->next=NULL;         while (1) {             q1=q->next;             q->next=p;             p=q;             q=q1;             if (NULL==q) break;         }         head=p;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      m=4;     n=6;     printf("将单链表中前%d个结点和后%d个结点进行互换:",m,n);//将单链表中前m个结点和后n个结点进行互换,m+n为链表总长     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m==k) {             q=p;         }         s=p;         p=p->next;     }     q1=head;     head=q->next;     s->next=q1;     q->next=NULL;      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //释放所有节点     p=head;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //创建10个节点的单链表:08->74->07->23->03->99->31->56->88->16-> //将值为5的结点插入到单链表的第3个结点前:08->74->05->07->23->03->99->31->56->88->16-> //删除第5个节点:08->74->05->07->03->99->31->56->88->16-> //从小到大排序:03->05->07->08->16->31->56->74->88->99-> //将整个链表逆序:99->88->74->56->31->16->08->07->05->03-> //将单链表中前4个结点和后6个结点进行互换:31->16->08->07->05->03->99->88->74->56-> //


Question: 为什么我的嵌入式SQL读不到double类型的数据

不知道你的嵌入式SQL有没有CAST或CONVERT函数。

引用 4 楼 litch008 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] 如果有，可以select CAST(SCALE AS char(20)),…… 您真的是太厉害了，按您说的这样一改果真查出正确的数据来了，谢谢您[/quote]

引用 3 楼 zhao4zhong1 的回复:如果有，可以select CAST(SCALE AS char(20)),…… 您真的是太厉害了，按您说的这样一改果真查出正确的数据来了，谢谢您

如果有，可以select CAST(SCALE AS char(20)),……

引用 1 楼 zhao4zhong1 的回复:不知道你的嵌入式SQL有没有CAST或CONVERT函数。没看见有，是跟数据的转换有关吗？


Question: 新手小白学C该用什么IDE

notepad, cmd 免下载，免安装

cygwin,gcc

Dev C++异常适合初学者

推荐使用编辑器，C语言没必要用IDE  推荐VIM 。  我个人使用Emacs写代码，超好用， 写文档可以用Emacs的org-mode，太强大了。

Visual C++ 2010 Express简体中文版http://pan.baidu.com/s/1bnwRVLt 这个比官网上的小。

Visual C++ 2015 Community

WIN下试试code block :http://www.codeblocks.org/downloads Visual C++ 2010 Express简体中文版http://pan.baidu.com/s/1bnwRVLt LINUX下试试clang PS：都可以去官网下的

用VS，2010版本比较适合初学者吧 http://blog.csdn.net/cometnet/article/details/19551125

引用 5 楼 sinservice 的回复:Emacs 可见   Emacs中文网 http://emacser.com/  其实，我还是推荐在GNU/Linux上使用Emacs，用linux做你的工作/开发/娱乐环境。  也能玩windows大型3D游戏（占硬盘10G以上的，吃显卡性能的）。  推荐 Ubuntu 14.04 Desktop 操作系统。  下载Emacs：     sudo apt-get install emacs24  或者从“Ubuntu软件中心”安装。  老机器吧？  现在的计算机，买的时候，大多是正版windows， 你只装linux，不浪费windows授权了吗？    再说了， 对一些开源项目，基本上是没有工程文件，  用ide,如何导入文件夹？   ide大多是居于工程文件的，当然也有基于文件夹的，如source insigh


Question: 关于scanf函数输入的问题

你用了while循环，每次都只是一个int被负值，并不是楼主理解的那样。 第二个问题应该是编译器设置的问题。

电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。

1.scanf的返回值是接收到的变量值的个数，第一次输入28，读到了c变量里（成功读入），所以返回1，判断while(1==1)为真， 然后继续进入while循环，scanf继续等待输入........... 2.int型是2/4个字节???是什么

因为while==1总是为真，相当于这是一个无限循环， 他就不断读入intc

while 一个蹲坑，为什么一天可以去4个人上厕所？


Question: 一个问题，什么鬼？

第三行应该是main不是menu吧？ 同时STARS加上双引号，printf后面加40是干嘛？  #define STARS "************" printf("%s%s\n", STARS , STARS );


Question: 链表合并函数有点不明白，新手求助！

如果不通过返回值从而修改headc的指向，那么必须传入二级指针或者一级指针的引用 这里以二级指针为例：  #include<stdio.h> #include<stdlib.h> #define ERROR 0; #define OK 1; typedef struct Lnode{ 	int data; 	struct Lnode *next; }Lnode; Lnode *initial(void); //Lnode *merge(Lnode *heada,Lnode *headb); void merge(Lnode *heada,Lnode *headb,Lnode **headc); int getelem(Lnode *L_first ,int loca,int *elem_need);   int main() { 	int elem1,elem2,elem3; 	Lnode *heada,*headb,*headc; 	heada = initial(); 	headb = initial(); 	getelem(heada,4,&elem1); 	getelem(headb,4,&elem2); 	printf("elem1= %d,elem2 = %d\n",elem1,elem2); 	//headc = merge(heada,headb); 	merge(heada,headb,&headc); 	printf("???\n"); 	getelem(headc,5,&elem3); 	printf("???\n"); 	printf("headc5 = %d\n",elem3); 	return 0; }  void merge(Lnode *heada,Lnode *headb,Lnode **headc) {     Lnode *ptra;     Lnode *ptrb;     Lnode *ptrc;     ptra = heada->next;     ptrb = headb->next;     *headc = ptrc = heada;     while(ptra && ptrb){         if(ptra->data<ptrb->data){                 printf("????\n");             ptrc->next = ptra;             ptrc = ptra;             ptra = ptra->next;         }         else{             ptrc->next = ptrb;             ptrc = ptrb;             ptrb = ptrb->next;         }     }     ptrc->next=ptra?ptra:ptrb;     free(ptrb); 	//*headc=ptrc; }  /* Lnode *merge(Lnode *heada,Lnode *headb) { 	Lnode *ptra,*ptrb,*ptrc; 	Lnode *headc; 	ptra = heada->next; 	ptrb = headb->next; 	headc = ptrc = heada; 	while(ptra && ptrb){ 		if(ptra->data<ptrb->data){ 			ptrc->next = ptra; 			ptrc = ptra; 			ptra = ptra->next; 		} 		else{ 			ptrc->next = ptrb; 			ptrc = ptrb; 			ptrb = ptrb->next; 		} 	} 	ptrc->next=ptra?ptra:ptrb; 	free(ptrb); 	return headc; } */ int getelem(Lnode *L_first ,int loca,int *elem_need) { 	//L为指向struct Lnode的指针。 	//寻在第loca个元素，将其值赋值给elem_need指向的值返回ok否则ERROR. 	int cnt=1; 	Lnode *Pointer; 	Pointer = L_first->next; 	while(Pointer && cnt<loca){ 		cnt++; 		Pointer = Pointer -> next; 	} 	if(!Pointer || cnt>loca){ 		return ERROR; 	} 	*elem_need = Pointer->data; 	return OK; } Lnode *initial(void) { 	Lnode *head; 	Lnode *ptr1,*ptr2; 	int judge=0; 	head = (Lnode *)malloc(sizeof(Lnode)); 	ptr1=ptr2=(Lnode *)malloc(sizeof(Lnode)); 	printf("enter the data:\n"); 	scanf("%d",&ptr1->data); 	while(ptr1->data>0){ 		judge += 1; 		if(judge==1){ 			head->next = ptr1; 			ptr2 = ptr1; 		} 		else{ 			ptr2->next = ptr1; 			ptr2 = ptr1; 		} 		ptr1 = (Lnode *)malloc(sizeof(Lnode)); 		printf("enter the data:\n"); 		scanf("%d",&ptr1->data); 	} 	ptr2->next = NULL; 	free(ptr1); 	ptr1 = NULL; 	return head; }

在主函数用getelem获取结点数值的时候 无法获得合并链表后的值 但是在函数merge中调用就可以。

把函数merge改为这样的形式 不用return   void merge(Lnode *heada,Lnode *headb,Lnode *headc) {     Lnode *ptra;     Lnode *ptrb;     Lnode *ptrc;     ptra = heada->next;     ptrb = headb->next;     headc = ptrc = heada;     while(ptra && ptrb){         if(ptra->data<ptrb->data){                 printf("????\n");             ptrc->next = ptra;             ptrc = ptra;             ptra = ptra->next;         }         else{             ptrc->next = ptrb;             ptrc = ptrb;             ptrb = ptrb->next;         }     }     ptrc->next=ptra?ptra:ptrb;     free(ptrb); } 然后调试的时候就有问题？？？为什么呢   求助大神帮助


Question: 【数据结构】OJ平台的输出超限

边界条件 字斟句酌

引用 1 楼 ihewro 的回复:改了好久还是不行，我又换了一种写法，还是不行。。。。。。。。 求大神！！！ #include <stdio.h> //预定义常量和类型  #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -1  #define SElemType int #define Status int  #define MAXSIZE 1001//顺序线性表的初始容量 //#define LISTINCREMENT 10  /*【1】定义顺序栈的结构类型*/ typedef struct  { 	 int data[MAXSIZE]; 	 int top; }SqStack;   /*【2】初始化顺序栈，即头指针值赋为 -1 */ Status InitStack(SqStack *l) { 	l->top = -1; 	return OK; }  /*【3】出栈*/ Status PopStack(SqStack *l) { 	int e; 	if(l->top == -1) 	{ 		printf("ERROR"); 		return ERROR; 	} 	e = l->data[l->top]; 	printf("%d ",e); 	l->top --; 	return OK; }  /*【4】进栈*/ Status PushStack(SqStack *l,int n) { 	if(l->top == MAXSIZE - 1) 	{ //		printf("错误！"); 		return ERROR; 	} 	l->top++; 	l->data[l->top] = n;  	return OK; }  void main () { 	char ch;; 	SqStack la; 	InitStack(&la); 	int i; 	i = 1; 	while (scanf("%c",&ch)!=EOF) 	{ 		while(ch!='\n') 		{ 			if(ch =='\n') 				break; 			if(ch == 'P') 			{ 				PushStack(&la,i); 				i = i+1; 			} 			if(ch == 'Q') 			{ 				PopStack(&la); 			} 			scanf("%c",&ch); 		} 		i = 1; 		InitStack(&la); 		printf("\n"); 	}  }  是这个，贴错了 #include <stdio.h> #include <string.h> //预定义常量和类型  #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -1  #define SElemType int #define Status int  #define MAXSIZE 1001//顺序线性表的初始容量 //#define LISTINCREMENT 10  /*【1】定义顺序栈的结构类型*/ typedef struct  { 	 int data[MAXSIZE]; 	 int top; }SqStack;   /*【2】初始化顺序栈，即头指针值赋为 -1 */ Status InitStack(SqStack *l) { 	l->top = -1; 	return OK; }  /*【3】出栈*/ Status PopStack(SqStack *l) { 	int e; 	if(l->top == -1) 	{ 		printf("ERROR"); 		return ERROR; 	} 	e = l->data[l->top]; 	printf("%d ",e); 	l->top --; 	return OK; } /*【4】进栈*/ Status PushStack(SqStack *l,int n) { 	if(l->top == MAXSIZE - 1) 	{ //		printf("错误！"); 		return ERROR; 	} 	l->top++; 	l->data[l->top] = n; 	return OK; }  void main () { 	SqStack la; 	InitStack(&la); 	char c[1000]; 	while(scanf("%s",c)!=EOF) 	{ 		int i; 		int n = 1; 		for(i = 0;i < strlen(c);i++) 		{ 			 			if(c[i] == 'P') 			{ 				PushStack(&la,n); 				n = n+1; 			} 			if(c[i] == 'Q') 			{ 				PopStack(&la); 			} 		} 		printf("\n");  		i = 1; 		InitStack(&la);  	} }


Question: c语言问题

我这里的sum是对的，不知道楼主是用什么数据测出来不对的？ gt70值是0是因为*count++;用法不对，++的优先级比*要高，由于是后++ 所以可以看成先执行*再执行++（但是++针对的是count指针，即指针向后移了一位，不是针对*count的++） 改成(*count)++就行了  #include <stdio.h>  /* userCode(<80字符): 自定义函数之原型声明 */ void scanfArr(float a[],int n,float *sum,int *count);  int main(void) { 	float arr1[6], arr2[8], arr3[12], sumA, sumB, sumC; 	int gt70A, gt70B, gt70C;  	scanfArr(arr1,6,&sumA,>70A);  /* userCode(<80字符): 调用函数读 6个数到arr1中，并计算和及>70的个数 */ 	scanfArr(arr2,8,&sumB,>70B);  /* userCode(<80字符): 调用函数读 8个数到arr2中，并计算和及>70的个数 */ 	scanfArr(arr3,12,&sumC,>70C);  /* userCode(<80字符): 调用函数读12个数到arr3中，并计算和及>70的个数 */  	printf("\narr1[ 5]=%4.1f, sum(arr1)=%5.1f, cnt(arr1)=%d",   arr1[5],  sumA, gt70A); 	printf("\narr2[ 7]=%4.1f, sum(arr2)=%5.1f, cnt(arr2)=%d",   arr2[7],  sumB, gt70B); 	printf("\narr3[11]=%4.1f, sum(arr3)=%5.1f, cnt(arr3)=%d\n", arr3[11], sumC, gt70C);  	return 0; }  /* User Code Begin：考生在此后完成自定义函数的设计，行数不限 */ void scanfArr(float a[],int n,float *sum,int *count) { 	int i; 	float *p; 	p=a; 	*sum=0; 	*count=0; 	printf("请输入%2d个数: ",n); 	for(i=0;i<n;i++) 	{ 		scanf("%f",p+i); 		*sum=*sum+*(p+i); 		if(*(p+i)>70) 		{ 			(*count)++; 		} 	} 	return; }


Question: 大家帮我看下这样理解有啥问题？

像printf("%2s","goto");这样的打印着实没搞过，几乎都直接printf("%s","goto");了，学习了

1.%5.3s"表示最少输出5位，最多输出3位,如果字符串长度小于3那么，这个3相当于没有作用，不够5位，则在左侧用空格补充 2.%2s表示最少输出2位长度的字符串，不够在字符串左侧用空格补充 3."%2.3s"表示最少输出2位，最多输出3位,所以输出了got

请通读MSDN中的“Format Specification Fields: printf and wprintf Functions”。


Question: 读可执行文件二进制问题

你在上面不是用fgets的方式计算文件大小吗，那是不对的  fp = fopen("1.exe", "rb"); fseek(fp, 0, SEEK_END); //fp指针移动的文件尾 size = ftell(fp); //计算文件大小 fseek(fp, 0, SEEK_SET);//fp指针移动的文件头 while (!feof(fp)) {//开始读取文件     fread(buf, 1, n, fp); }

我没有fgets,我用的就是dread

推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。  不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了

二进制不能用fgets读取，fgets是读一行的。  fp = fopen('1.exe", "rb"); while (!feof(fp)) {     fread(buf, 1, n, fp); }


Question: 有谁有现成的c语言解释器吗

flex＋bison 参考Tiny C Compiler源代码

词法分析器可以参考flex


Question: 如何用c或c++在unicode的txt文件中添加内容？

3楼lgbxyz的方法很好，昨晚试了一下就解决问题。 本想也花时间尝试一下1楼的方法，但是实施细节不清楚，因此向他提问，但是等不到回答。 既然问题已解决，就不想在这问题上花太多时间纠缠了。1楼对此问题提供了线索，开拓了我的眼界，因此也给点分。 由于我英文太差，所以二楼的就不给分了。

是不是要写成“FILE* out_file = fopen("test.txt", "w+,ccs=Unicode");”？ 有这样的教材吗？什么书名？有连接吗？  引用 1 楼 user-3 的回复:fopen函数可以指定编码格式呀  	wchar_t* data = L"测试"; 	FILE* out_file = fopen("test.txt", "w+,ccs=UTF-8"); 	fwrite(data, wcslen(data) * sizeof(wchar_t), 1, out_file); 	fclose(out_file);  写入和读取的编码格式一致，就没有问题 是不是要写成“FILE* out_file = fopen("test.txt", "w+,ccs=Unicode");”？ 有这样的教材吗？什么书名？有连接吗？

引用 1 楼 user-3 的回复:fopen函数可以指定编码格式呀  	wchar_t* data = L"测试"; 	FILE* out_file = fopen("test.txt", "w+,ccs=UTF-8"); 	fwrite(data, wcslen(data) * sizeof(wchar_t), 1, out_file); 	fclose(out_file);  写入和读取的编码格式一致，就没有问题 是不是要写成“FILE* out_file = fopen("test.txt", "w+,ccs=UTF-8");”？ 有这样的教材吗？什么书名？有连接吗？

你新写的文件应该用wb模式打开，而不应该是“w”模式。

fopen supports Unicode file streams. A flag specifying the desired encoding may be passed to fopen when opening a new file or overwriting an existing file, like this:  fopen("newfile.txt", "rw, ccs=<encoding>");  Allowed values of the encoding include UNICODE, UTF-8, and UTF16-LE. If the file is already in existence and is opened for reading or appending, the Byte Order Mark (BOM) is used to determine the correct encoding. It is not necessary to specify the encoding with a flag. In fact, the flag will be ignored if it conflicts with the type of the file as indicated by the BOM. The flag is only used when no BOM is present or if the file is a new file. The following table summarizes the modes used in for various flags given to fopen and Byte Order Marks used in the file.  Encodings Used Based on Flag and BOM Flag  No BOM (or new file)  BOM: UTF-8  BOM: UTF-16   UNICODE  ANSI  UTF-8  UTF-16LE   UTF-8  UTF-8  UTF-8  UTF-16LE   UTF-16LE  UTF-16LE  UTF-8  UTF-16LE


Question: 求C/c++如何编写读取txt文件中数组的程序编写

乍看起来c++的cin、cout、ifstream、ofstream、istringstream、ostringstream在输入、输出上比c的scanf、printf、fscanf、fprintf、fread、fwrite、sscanf、sprintf简单，不用格式控制符！ 但是不用格式控制符，输入输出恰好是你期望的格式的时候好说；等到输入输出不是你期望的格式的时候，你就会觉得还是用格式控制符更方便、更靠谱。 摒弃cin、cout、ifstream、ofstream、istringstream、ostringstream！ 使用scanf、printf、fscanf、fprintf、fread、fwrite、sscanf、sprintf。  仅供参考：//NAME: essaie bla bla //DIMENSION: 8 //DATA //1  14  15 //2  11  10 //3  6   4 //4  7   13 //5  9   21 //6  19  3 //7  1   5 //8  8   8 //EOF // // 文本文件中可能还含有其他内容，但是需要用到的内容即以上  //比如data.txt: //NAME: essaie bla bla //其它内容 //DIMENSION: 8 //其它内容 //DATA //其它内容 //1  14  15 //其它内容 //2  11  10 //其它内容 //3  6   4 //其它内容 //4  7   13 //其它内容 //5  9   21 //其它内容 //6  19  3 //其它内容 //7  1   5 //其它内容 //8  8   8 //其它内容 //EOF  // 目标是要获取NAME后字串，DIMENSION后数值，以及DATA以下的数值 // 其中NAME就是随便个字句，DIMENSION是城市数量，DATA以下是城市编号，X坐标，Y坐标 // 所有的这些将赋值给一个事先定义好的结构 #include <stdio.h> #include <string.h> #define MAXCPL   80   //每行最大字符数 #define MAXCITY  100  //每组数据中DATA最多项数，DIMENSION的最大值 #define MAXNAMEL 32   //NAME最大长度 struct S {     char NAME[MAXNAMEL+1];     int  DIMENSION;     struct D {         int NO;         int X;         int Y;     } DATA[MAXCITY]; } s; FILE *f; int st,n,i; char ln[MAXCPL]; int main() {     f=fopen("data.txt","r");     if (NULL==f) {         printf("Can not open file data.txt!\n");         return 1;     }     st=0;     n=0;     while (1) {         if (NULL==fgets(ln,MAXCPL,f)) break;         if (st==0) {             if (1==sscanf(ln,"NAME: %32[^\n]",s.NAME)) st=1;         } else if (st==1) {             if (1==sscanf(ln,"DIMENSION: %d",&s.DIMENSION)) st=2;         } else if (st==2) {             if (0==strcmp(ln,"DATA\n")) st=3;         } else if (st==3) {             if (3==sscanf(ln,"%d%d%d",&s.DATA[n].NO,&s.DATA[n].X,&s.DATA[n].Y)) {                 n++;                 if (n>=MAXCITY || n>=s.DIMENSION) break;             }         }     }     fclose(f);     printf("s.NAME=[%s]\n",s.NAME);     printf("s.DIMENSION=%d\n",s.DIMENSION);     for (i=0;i<n;i++) {         printf("s.DATA[%d].NO,X,Y=%d,%d,%d\n",i,s.DATA[i].NO,s.DATA[i].X,s.DATA[i].Y);     }     return 0; } //s.NAME=[essaie bla bla] //s.DIMENSION=8 //s.DATA[0].NO,X,Y=1,14,15 //s.DATA[1].NO,X,Y=2,11,10 //s.DATA[2].NO,X,Y=3,6,4 //s.DATA[3].NO,X,Y=4,7,13 //s.DATA[4].NO,X,Y=5,9,21 //s.DATA[5].NO,X,Y=6,19,3 //s.DATA[6].NO,X,Y=7,1,5 //s.DATA[7].NO,X,Y=8,8,8    再供参考：#include <stdio.h> char s[]="123 ab 4"; char *p; int v,n,k; void main() {     p=s;     while (1) {         k=sscanf(p,"%d%n",&v,&n);         printf("k,v,n=%d,%d,%d\n",k,v,n);         if (1==k) {             p+=n;         } else if (0==k) {             printf("skip char[%c]\n",p[0]);             p++;         } else {//EOF==k             break;         }     }     printf("End.\n"); } //k,v,n=1,123,3 //k,v,n=0,123,3 //skip char[ ] //k,v,n=0,123,3 //skip char[a] //k,v,n=0,123,3 //skip char[b] //k,v,n=1,4,2 //k,v,n=-1,4,2 //End.

试了下楼主的代码发现第一行的数据是能读进来的啊 感觉楼主你这样n<point-1的话，如果文件里面最后没有空行的话，会少读一行

我写的这个程序为啥写到另一个txt里面的时候不是从第一个开始写的，第一个数跑哪去了#include <stdio.h> #include <stdlib.h> #include <iostream> #include <fstream> #include <math.h>  using namespace std;  void main() { 	FILE *fp;  	char buf[1024]; 	int i=0;				// 首先计算数据有多少行 	if((fp=fopen("1004.txt","r"))==NULL) 	{ //打开txt文件 		perror("File open error!\n"); 		return; 	}  	while(!feof(fp)) 	{ 		fgets(buf, 1000, fp); 		i++; 	}  	cout << i-1 << endl;  	int point = i; 	float *value = new float[i]; //如何 定义动态数组 	float *depth = new float[i]; 	fseek(fp,0,SEEK_SET); // 把指针移到起始位置  //	float stdep;  //	fscanf(fp,"%f",&stdep); //	cout << stdep <<endl;  	for (int k=0; k<point-1; k++) 	{ 	fscanf(fp,"%f %f",&depth[k],&value[k]); 	cout << value[k]<<' '<<depth[k] <<endl; 	}  	fclose(fp);  //关闭指针  	  	const char * pFileName="1005.txt";/*定义想输出的文件名*/ 	FILE * pFile;/*定义文件指针*/ 	pFile=fopen(pFileName,"wt"); /*以文本方式打开文件用于输出*/ 	if ( NULL == pFile ) 	{ 		perror("打开文件失败"); 		return; 	} 	for (int n=0; n<point-1; n++) 	{ 	fprintf(pFile,"%f %f\n",value[n],depth[n]); 	} 	if ( ferror(pFile) ) 	{ 		perror("写文件失败"); 		/*关闭文件后返回*/ 		fclose(pFile); 		return; 	}  	printf("文本文件成功写入\n"); 	/*不要忘记关闭文件*/ 	fclose(pFile); 	return; }

我是想要能读取数据，还有使用动态数组

不就是拷贝个文件嘛  #include <stdio.h> int main() {     int ch;      freopen("1.txt", "r", stdin);     freopen("2.txt", "w", stdout);     while (EOF != (ch = getchar()))         putchar(ch);     return 0; }

ifstream读，ofstream写

怎么把txt中的数读到另一个txt里面啊？？？？

是的。我写了一个能读出来的程序，但是还没写出来怎么把txt中的数读到另一个txt里面 #include <stdio.h> #include <stdlib.h> #include <iostream> #include <math.h> #include <fstream>  using namespace std;  void main() { 	FILE *fp;  	//float data[6000][2]={0};   // 必须用动态数组定义 	char buf[1024]; 	int i=0;				// 首先计算数据有多少行 	if((fp=fopen("1004.txt","r"))==NULL) 	{ //打开txt文件 		perror("File open error!\n"); 		return; 	}  	while(!feof(fp)) 	{ 		fgets(buf, 1000, fp); 		i++; 	}  	cout << i-1 << endl;  	int point = i; 	float *value = new float[i]; //如何 定义动态数组 	float *depth = new float[i]; 	fseek(fp,0,SEEK_SET); // 把指针移到起始位置  	float stdep;  	fscanf(fp,"%f",&stdep); 	cout << stdep <<endl;  	for (int k=0; k<point-1; k++) 	{ 	fscanf(fp,"%f %f",&depth[k],&value[k]); 	cout << value[k]<<' '<<depth[k] <<endl; 	}  	fclose(fp);  //关闭指针  }

一个两列不知道多少行的数组读出来，然后要怎么写入另一个文件呢？一样写成两列N行？

是要读取txt文件中的n列2行的数组，写到另外的一个txt文件中

#include <fstream> #include <iterator> #include <string> #include <algorithm>  using namespace std;  int main() { 	ifstream fin("1.dat"); 	ofstream fout("2.dat"); 	ostream_iterator<string> out(fout, "\n"); 	string str; 	 	while (getline(fin, str)) 	{ 		*out = str; 	} 	fin.close(); 	fout.close(); 	 	return 0; }