Question: 高精度加法基础

你这个是不是数位没有对齐

仅供参考：#include <stdio.h> #include <string.h> #define MAXLEN 1000 char a1[MAXLEN]; char a2[MAXLEN]; static int v1[MAXLEN]; static int v2[MAXLEN]; static int v3[MAXLEN]; int i,j,n,L,z; void main(void) {     scanf("%d",&n);     for (j=0;j<n;j++) {         scanf("%s%s",a1,a2);          L=strlen(a1);         for (i=0;i<L;i++) v1[i]=a1[L-1-i]-'0';          L=strlen(a2);         for (i=0;i<L;i++) v2[i]=a2[L-1-i]-'0';          for (i=0;i<MAXLEN;i++) v3[i]=v1[i]+v2[i];          for (i=0;i<MAXLEN;i++) {             if (v3[i]>=10) {                 v3[i+1]+=v3[i]/10;                 v3[i]=v3[i]%10;             }         }          printf("Case %d:\n", j+1);         printf("%s + %s = ", a1, a2);          z=0;         for (i=MAXLEN-1;i>=0;i--) {             if (z==0) {                 if (v3[i]!=0) {                     printf("%d",v3[i]);                     z=1;                 }             } else {                 printf("%d",v3[i]);             }         }         if (z==0) printf("0");          printf("\n");     } } //Sample Input //3 //0 0 //1 2 //112233445566778899 998877665544332211 // //Sample Output //Case 1: //0 + 0 = 0 //Case 2: //1 + 2 = 3 //Case 3: //112233445566778899 + 998877665544332211 = 1111111111111111110


Question: c程序用库在tc中找不到

楼主如果想用TC编写图形程序，可以了解一下EasyX，EasyX是Windows平台最简单的绘图函数库（名副其实），兼容BC和TC的绘图函数，在VC下用EasyX来编程跟在TC下编程绘图差不多是完全一样的。  下载一个EasyX包，里面有完整的函数手册。EasyX官网有实例。  仅供参考： 用绘图语句画机器猫（初学C语言的同学必看） http://blog.163.com/tab_98/blog/static/1192409720150316223680/

书上的题就把书扔了  老师的题就退学  30年前的技术了


Question: C语言 大神来解读这个程序

第10行到第14行完成的。 既然你只贴图，不贴代码，我也懒得打一遍你的代码了。  关键：如果c为空格，lastc也是空格，那就什么都不做了。多个空格也就没有打出来了。

单引号里本来就只能表示一个字符


Question: 能帮我看一下函数错哪里了吗，每一次都会进入add函数中的if（phear->next==0）可是第一次又改变啊

不明白你add函数里写的： if (phear->next == 0) 	{ 		phear = ptail = newnode; 		phear->next = newnode; 		getchar(); 	} 这样写根本不对。  楼上写的思路是对的，但是ptail = newnode;是没有用的，在函数内要想改变指针的指向，必须传二级指针或者一级指针的引用才行

单链表保持一个数据项为null的头节点,在链表头插入节点：  if (phear->next == NULL){　　//链表空     phead->next = newnode;     ptail = newnode;     newnode->next = NULL; } else { //链表非空     newnode->next = phead->next;     phead->next = newnode; }


Question: 标准中，变量声明关键字顺序！char[] a; 这样不是更明了

存在即合理。

C/C++变量类型定义语法错综复杂，有[]、*、()....  如不按标准要求的写，可能对于简单类型看似可以，但对于一些复杂的（如函数指针指向的函数又返回一个函数指针）等一些情况可能就会出现语义含糊的问题  习惯了我觉得第一种没什么不好，如果要增强可读性可以用typedef  以上个人理解

a[]这样的声明才明了吧，一看就知道是数组，而且知道是几维数组，而你所说的[]a是Java里面的声明方式。 并没有感觉[]a会符合习惯，另外，标准又不是我们制定的，讨论这个问题没什么意义。

续上 作为一个语言编译器来说，一般一个语言中的类型，最后要形成一个表，以备后用 作为c来说 我可以这么写 int a[],b; 但是如果按照你的方式 必须 int[] a; int b; 因此，int[] 和int是两个类型，所以，上边所说的类型表，至少要扩大一倍 你再想想c语言的发展，它是上世界70年代末兴起的，当时的计算机内存应该是以k计，你觉得作为c语言的作者能像现在一样挥霍内存吗？

在这个问题上C是祖先（毕竟它最老），它的的想法就是： “某个类型的变量的定义，看上去就跟该类型变量的使用，是一样一样的。” 简化版：“变量的定义方式和变量的使用方法一样”。  然后问题来了，基本上不经过训练，很多人很难理解复杂的变量定义；后续语言的发明人为了缓解这个问题，就把类型独立出来了，然后所有变量的定义方式就统一成了type var; 代表语言就是Java和Go。


Question: 请教一下大神

这是源码   #include <stdio.h> main() { int j,i,temp; int a[]={12,23,21,45,32,34,66,33,78,36};    for(i=0;i<10;i++)    {    printf("%5d",a[i]);    }    printf(" 原先数组\n");    printf("\n-------------------\n");    for(i=0;i<10;i++)    {     if (a[i]>a[i+1])    {      temp=a[i];      a[i]=a[i+1];      a[i+1]=temp;    }    for(j=0;j<10;j++)     {    printf("%5d",a[j]);    if(j==9)    printf(" 第%d次检验结束\n",i+1);     }     printf("\n-----------------\n");    }    for(i=0;i<10;i++)    {    printf("%5d",a[i]);    }    printf(" 排序后最终结果");  }

我怀疑你这能运行吗

在第一层循环内第二层循环外，再从头到尾输出一次


Question: C win32API代码编译报错  求各为师傅解决

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

检查GetDirverInfo函数： 1.如果是自己写的函数，检查拼写，大小写，参数是不是都一致（或者只写了函数声明没有实现） 2.如果是外部库里的函数，检查附加库目录和附加依赖项的配置 （工程---属性---配置属性---链接器---常规---附加库目录） （工程---属性---配置属性---链接器---输入---附加依赖项）

引用 楼主 Hy_xiaosheng 的回复:   错误	1	error LNK2019: 无法解析的外部符号 "int __cdecl GetDirverInfo(char *)" (?GetDirverInfo@@YAHPAD@Z)，该符号在函数 _main 中被引用	C:\Users\Administrator\Desktop\WindowsAPI开发详解\WindowsAPI开发详解\WindowsAPI开发详解\Start-第四章-使用FindFirstVolume系列函数遍历驱动器 获取驱动器信息.obj	WindowsAPI开发详解 错误	2	error LNK2019: 无法解析的外部符号 _WinMain@16，该符号在函数 ___tmainCRTStartup 中被引用	C:\Users\Administrator\Desktop\WindowsAPI开发详解\WindowsAPI开发详解\WindowsAPI开发详解\MSVCRTD.lib(crtexew.obj)	WindowsAPI开发详解 错误	3	error LNK1120: 2 个无法解析的外部命令	C:\Users\Administrator\Desktop\WindowsAPI开发详解\WindowsAPI开发详解\Debug\WindowsAPI开发详解.exe	1	1	WindowsAPI开发详解  把GetDirverInfo函数所在的lib得添加上

找不到对应函数的实现 要么是这个函数声明了但是没有实现 要么就是对应的lib文件没有导入到工程 要么就是调用方式两边不对应


Question: C中结构体内部的参数传递时，只有字符串传递正常，而数字无法传递，求大佬教教

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

//... scanf("%s%d%s",group[i].ContactName,&group[i].ContactNum,group[i].ContactCity); //...   但是你的ContactNum定义的是int数组，你用%d当然不能输入了。

不知道楼主从哪看出来数字无法传递。 &group[i].birthday.year=(int *)0x62d53c? 这个是存放year变量的地址


Question: 小白求教（指针）

char a[]="ABCDE";  字符串存储在内存中，末尾会自动添加一个'\0'字符，等于整数0，作为字符串的结束。（如果你自己用代码构造一个字符串，就一定要记得在末尾添加一个'\0'字符） while(*t++) 当*t=='\0'==0的时候就结束循环。


Question: 变量char (*a)[];如何赋值

引用 7 楼 GKatHere 的回复:[quote=引用 4 楼 ri_aje 的回复:] [quote=引用 3 楼 GKatHere 的回复:] [quote=引用 1 楼 jianwen0529 的回复:]   引用 2 楼 ri_aje 的回复:声明中的 [] 没啥用，直接写 const char** 就行了。 char (*a)[N];  //可以，没有常量N，死活赋不了值。 另外，char** 与char (*)[]可不一样 [/quote] char** 和 char (*a)[N] 不一样，char (*)[] 和 char (*)[N] 不一样，和 char const** 一样，别搞混了。[/quote] 有点问题：如果  char *a[]; == char** a; char (*a)[];  == char** a; char *a[] == ?? char (*a)[];  char (*b)[]; b+1; // ERROR ??    [/quote] char b=1,c=3,d=5,*a[3]={&b,&c,&d}; 	printf("%d,%d,%d",**a,*a[1],**(a+1)); 输出： 1，3，3

仅供参考：//char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf("typeid(x).name() is %s\n",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]

引用 7 楼 GKatHere 的回复:[quote=引用 4 楼 ri_aje 的回复:] [quote=引用 3 楼 GKatHere 的回复:] [quote=引用 1 楼 jianwen0529 的回复:]   引用 2 楼 ri_aje 的回复:声明中的 [] 没啥用，直接写 const char** 就行了。 char (*a)[N];  //可以，没有常量N，死活赋不了值。 另外，char** 与char (*)[]可不一样 [/quote] char** 和 char (*a)[N] 不一样，char (*)[] 和 char (*)[N] 不一样，和 char const** 一样，别搞混了。[/quote] 有点问题：如果  char *a[]; == char** a; char (*a)[];  == char** a; char *a[] == ?? char (*a)[];  char (*b)[]; b+1; // ERROR ??    [/quote] 没太看明白你的问题。 char (*) [] 是指向数组的指针，但问题是数组维度信息没有，所以只能是个指针的指针，在函数体里面用起来的时候和 char ** 没啥本质区别。

5L正解。。

int ffff(char(*a)[2]) //这样子必须指明是多少个元素的数组，表示参数是一个指向一个有两个元素的数组 {     return 1; }  void main() {     char arr[] = { 1, 2 };     ffff(&arr); }   更常见的代码是  //取得二维点的坐标值 void GetPoint(int(&p)[2]) {     p[0] = 10;     p[1] = 20; }  void main() {     int pt1[2];     int pt2[3];     GetPoint(pt1);     // 这个数组大小是3，不符合参数要求导致编译错误     // 作用是：强制使用者传递指定大小的数组     //GetPoint(pt2); }

char (*a)[100]; 	char str[100]; 	a = &str;

引用 3 楼 GKatHere 的回复:[quote=引用 1 楼 jianwen0529 的回复:]   引用 2 楼 ri_aje 的回复:声明中的 [] 没啥用，直接写 const char** 就行了。 char (*a)[N];  //可以，没有常量N，死活赋不了值。 另外，char** 与char (*)[]可不一样 [/quote] char** 和 char (*a)[N] 不一样，char (*)[] 和 char (*)[N] 不一样，和 char const** 一样，别搞混了。

引用 1 楼 jianwen0529 的回复:  引用 2 楼 ri_aje 的回复:声明中的 [] 没啥用，直接写 const char** 就行了。 char (*a)[N];  //可以，没有常量N，死活赋不了值。 另外，char** 与char (*)[]可不一样

声明中的 [] 没啥用，直接写 const char** 就行了。

引用 4 楼 ri_aje 的回复:[quote=引用 3 楼 GKatHere 的回复:] [quote=引用 1 楼 jianwen0529 的回复:]   引用 2 楼 ri_aje 的回复:声明中的 [] 没啥用，直接写 const char** 就行了。 char (*a)[N];  //可以，没有常量N，死活赋不了值。 另外，char** 与char (*)[]可不一样 [/quote] char** 和 char (*a)[N] 不一样，char (*)[] 和 char (*)[N] 不一样，和 char const** 一样，别搞混了。[/quote] 有点问题：如果  char *a[]; == char** a; char (*a)[];  == char** a; char *a[] == ?? char (*a)[];  char (*b)[]; b+1; // ERROR ??


Question: 单项链表问题

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

1.就是让current指针指向下一个结点 2.因为你把链表连起来了啊，当然可以向下打印了


Question: 蓝桥杯的一个题目

我也感觉对不上，但是这个题目的第一个测试点的输入输出就是这样，就这样搞得我完全不明白这题是干嘛的呢 或许在他的  问题描述  做文章吧  题目在这：http://lx.lanqiao.cn/problem.page?gpid=T406

贴图和文字对不上。  贴图中的样例为： 2行2列的矩阵，矩阵内容为： 1 2 3 4 输出矩阵内容 的和： 10


Question: 请教指针问题

p表示输出指针（pointer） d表示输出十进制数字（decimal）

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

指针是C里的一个精华，学好了对C编程帮助很大。你的问题楼上都回答了。 另外，我自己写了一篇博客，分析了为何指针学多了人会晕掉，欢迎阅读批评指正： http://blog.csdn.net/kelehaier/article/details/54287870

引用 1 楼 jianwen0529 的回复:%p 表示输出的是一个指定值  手误： %p 表示输出的是一个指针值

%p 表示输出的是一个指定值

p表示输出指针（pointer） d表示输出十进制数字（decimal）

％p　是输出指针的值，就是逻辑内存地址的值。

%p就专门用来输出指针的值的，显示的是十六进制的值，%d是十进制的值


Question: 关于extern的用法

这也行，求分啊

接分来了，

帮结贴

来个人把分接了。

多谢LZ。。

找到问题了，是由于有个文件没添加到组中的缘固。


Question: C语言求助！！！！！！！！

输出语句是从右边走向左边的。

关于C,C++表达式求值顺序 http://blog.csdn.net/fefe82/article/details/37833767，http://bbs.csdn.net/topics/370153775

不要在一个表达式对同一个变量多次++ 这是未定义行为。 研究这种东西并没有啥意义，除非你时间太多

这个和编译器处理函数参数的入栈顺序有关，这个例子中应该是第一个a++先入栈最后一个出栈。 有的编译器是最后一个参数先入栈。

1、不要写这种表达式  2、如果非要说就是参数是从右向左压入栈中的

因为C语言函数参数入栈顺序是从右到左的，所以计算顺序是从右到左开始计算的


Question: 请大神帮忙指点  编辑没错，运行不出来

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

1楼是把Sqstack s;改成Sqstack * s; 我这里是把Sqstack s;改成全局变量，楼主你喜欢哪个？ #include＜stdio.h＞ #include ＜malloc.h＞ #include ＜stdlib.h＞ #define STACK_SIZE 100 #define STACK_INCRE 3  typedef int ElemType; //定义栈的存储结构 struct Sqstack { 	ElemType *base; 	ElemType *top; 	int stacksize; };  struct { 	char son[20]; 	char parent[20]; 	long num; 	}related[6] = {  {"system", "mib", 1},  {"mib","", 1},  {"sysdescr", "system",1},  {"sysobjectid", "system", 2},  {"sysuptime", "system",3},  {"interface", "mib", 2}}; //初始化栈s    struct Sqstack s; void InitStack() { 	s.base=(ElemType*)malloc(STACK_SIZE*sizeof(ElemType)) ; 	if(!s.base) 	exit(1); 	s.top=s.base ; 	s.stacksize =STACK_SIZE ; 	printf("栈s已被初始化:\n"); 	} //向栈s的第i个位置压入元素e    void Push(ElemType e) { 	if(s.top-s.base==STACK_SIZE) 	{ 		  s.base=(ElemType*)realloc(s.base,(s.stacksize +STACK_INCRE)*sizeof(ElemType));    		   s.top=s.base+s.stacksize; 		      s.stacksize+=STACK_INCRE;      }     *(s.top)=e; 	s.top++;  }    		//输出栈s的栈顶元素，并赋值给变量e int Pop(ElemType &e) { 	if(s.top==s.base)    	return 0; 	--s.top; 	e=*s.top; 	return 1; }     int main() { 	int flag,j,i; 	char str[20]; 	ElemType e; 	InitStack(); 	printf("\n"); 	printf("输出查询元素："); 	gets(str); 	while (strlen(str)!=0) 	   for (i=0; i＜6; i++) 	   { 	  	if(!strcmp(str,related[i].son)) 	  	{ 	  		strcpy(str,related[i].parent);  	  		 Push(related[i].num); 	  	} 	  } 	  printf("输出栈中元素：\n"); 	  flag=Pop(e);   	while(flag!=0) 	  { 	  	printf("%d",e); 	  	flag=Pop(e); 	  	printf("\n"); 	  } }

#include<stdio.h> #include<string.h> #include <malloc.h> #include <stdlib.h>  typedef int ElemType;  #define STACK_SIZE 100 #define STACK_INCRE 3  //定义栈的存储结构 typedef struct { ElemType *base; ElemType *top; int stacksize; } Sqstack; struct {   char son[20];   char parent[20];   long num; }related[6] = {   {"system", "mib", 1},   {"mib",{0}, 1},   {"sysdescr", "system",1},   {"sysobjectid", "system", 2},   {"sysuptime", "system",3},   {"interface", "mib", 2}, };  //初始化栈s void InitStack( Sqstack *s ) {     s->base =   ( ElemType * )malloc(   STACK_SIZE * sizeof( ElemType ) ) ;     if( !s->base )     exit(1);     s->top = s->base;     s->stacksize = STACK_SIZE ;     printf( "栈s已被初始化:\n" ); }  //向栈s的第i个位置压入元素e void Push( Sqstack *s, ElemType e ) {      if( s->top - s->base == s->stacksize ){         s->base = ( ElemType * )realloc( s->base, ( s->stacksize + STACK_INCRE ) * sizeof( ElemType ) );         s->top = s->base + s->stacksize;         s->stacksize += STACK_INCRE;     }     *( s->top ) = e;     s->top++; }  //输出栈s的栈顶元素，并赋值给变量e int Pop( Sqstack *s, ElemType *e ) {     if( s->top == s->base )     return 0;     --s->top;     *e = *s->top;     return 1; }    int main( void ) {     int flag;     char str[20];     Sqstack *s;     s = ( Sqstack * )malloc( sizeof( Sqstack ) );     ElemType e;     InitStack( s );     printf( "\n" );     printf( "输入查询元素：" );     gets( str );     while( strlen( str ) != 0 )         for( int i = 0; i < 6; i++ ){             if( !strcmp( str, related[i].son ) ){                 strcpy( str, related[i].parent );                 Push( s, related[i].num );             }         }     printf( "输出栈中元素：\n" );     flag = Pop( s, &e );     while( flag != 0 ){         printf( "%d", e );         flag = Pop( s, &e );         printf( "\n" );     } } 按照你的代码改的 但输出结果不知道是不是和你的意思一样


Question: 大神有空给瞧一眼

当(low+high)之和不为2的倍数时，(low+high)/2为浮点数，因为mid为int型，所以只保留整数部分，小数部分丢弃。例如low=0；high=14；//mid=7；low=1；high=14；//mid=7。你会发现都是7。这样就无法往7以上的数组移动。

仅供参考 #include"stdio.h" main() {      int c[10]={1,2,3,4,5,6,7,8,9,10};     int high=9,low=0,mid,n;     int flag;     scanf("%d",&n);     while (n)     {  mid=(high+low)/2;     if(c[mid]==n)       {         flag=mid;        break;       }     else if(c[mid]>n)     high=mid-1;     else         low=mid+1;     }     printf("%d",flag);  }

折半查找的数应该是原先就排好顺序的

建议你去搜索下二分查找的算法和相关代码

语法，算法都有问题 还有你应该写个函数来查找返回索引，不要在main函数返回

scanf("%d,&key"); ==> scanf("%d", &key);


Question: 求大神解释下怎么用这个代码，高中自学

高中生还是把高中课程学好吧。 希望楼主不要犯类似 “早知道吃完第七个包子就饱了，我为什么还要吃前六个包子呢？！” 这种低级错误。

initgraph(&gdriver, &gmode, "C:\\tc"); 这个是TC绘图的老代码，TC是在DOS平台下。  楼主如果想用TC编写图形程序，可以了解一下EasyX，EasyX是Windows平台最简单的绘图函数库（名副其实），兼容BC和TC的绘图函数，在VC下用EasyX来编程跟在TC下编程绘图差不多是完全一样的。  下载一个EasyX包，里面有完整的函数手册。EasyX官网有实例。  仅供参考： 用绘图语句画机器猫（初学C语言的同学必看） http://blog.163.com/tab_98/blog/static/1192409720150316223680/

这是用了easyx图形库，然后画图的函数在手册里都有解释，像lineto这些看名字就明白了。

看来你这个是绘制图形的功能，大概是不能再控制台工程上使用的


Question: 精通acm规则的大神请来，一个代码自认为已经算符合题意但是就是说我答案错误，请大家一起帮忙找错

#include<stdio.h> int main() {     int n,i;     int m,j;     char c,o,p,q;     while( scanf("%d%*c",&n)!=EOF)     {         scanf("%c%c%c(%d,%d)",&c,&o,&q,&j,&m);          if((c=='a')&&(o=='d')&&(q=='d'))         {             printf("%d\n",j+m);         }          else  if((c=='m')&&(o=='u')&&(q=='l'))         {             printf("%d\n",j*m);         }          else if((c=='d')&&(o=='i')&&(q=='v'))         {             if(m==0) printf("error\n");             else if(j%m==0) printf("%d\n",j/m);             else  printf("%.2f\n",j/(float)m);         }          else if((c=='s')&&(o=='u')&&(q=='b'))         {              printf("%.d\n",j-m);         }     } } 已经改对了，不需要麻烦各位啦


Question: 求助！关于strlen获取指针变量中的个数

s++会导致字符串的首地址不断向后偏移，而你的字符串末尾‘\0’是不变的，这就导致的strlen(s)的长度不断变下，当偏移到原字符串一半长度以上时，这个for循环就结束了，也就意味着你原字符串后半部分的大写字母不会做转化。

引用 7楼我是你的主体 的回复:[quote=引用 5 楼 xiaohuh421的回复:]估计楼主是没有明白strlen是做什么用的.  strlen   按字面意思   str  就是字符串string的缩写   len就是长度length的缩写.        如它的字面意思一样, 它就是 求字符串长度的.    它是从你传的地址开始, 查找\0  也就是0作为结束,  它不会管你越不越界什么的. 反正就是从你给它的地址开始往后面找, 如果你的内存中每一个字节都不为0, 那么它就会告诉你字符串长度有几个G. 我一直以为strlen是求一个串长，仅仅想当然的求串的开始到结束，原来是从串的起始地址开始至'＼0'结束 是这样吗？[/quote]

引用 1 楼 user-7的回复:会影响的char* 字符串长度指的是当前指针位置起到\n结束符止，s++会导致指针偏移。 我以为都是从串头到串尾 蟹蟹你

引用 6 楼 自信男孩的回复: void inv (char *s) {     int i;      for (i = 0; i < strlen(s); i++) {         if (isupper(s[i]))             s[i] += 32;     } }  记着加一下isupper（）的头文件。 isupper是干嘛的 没学过。

引用 5 楼 xiaohuh421的回复:估计楼主是没有明白strlen是做什么用的.  strlen   按字面意思   str  就是字符串string的缩写   len就是长度length的缩写.        如它的字面意思一样, 它就是 求字符串长度的.    它是从你传的地址开始, 查找\0  也就是0作为结束,  它不会管你越不越界什么的. 反正就是从你给它的地址开始往后面找, 如果你的内存中每一个字节都不为0, 那么它就会告诉你字符串长度有几个G. 我一直以为strlen是求一个串长，仅仅想当然的求串的开始到结束，原来是从串的起始地址开始至'＼0'结束 是这样吗？

s++已经移动了字符串的位置，所以strlen的时候值会变化。

假如不会移动，那你又怎么能*s给某个字符赋值呢

strlen 只是计算从S指针开始到'\0'位置的字节数，你把S指针往后移那字节当然减少了，有什么问题？


Question: 求解答为啥程序会停止运行

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

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

自己动手，遇到具体问题点了再问。要让别人看到你的努力。 直接帮你做好了，说实话没有任何价值，其实是在助长你的懒惰。 你这帖子要是在stackoverflow，反对票能淹死你。

只帮你改了下面这个函数 struct address *addnew(struct address *head,char *name,char *email,char *phone) { 	struct address *p0,*p1; 	p0=(struct address *)malloc(sizeof(struct address)); 	strcpy(p0-＞name,name); 	strcpy(p0-＞email,email); 	strcpy(p0-＞phone,phone); 	p0-＞next=NULL; 	if(head==NULL) 	   head=p0; 	else 	{ 		p1=head; 		while(p1-＞next!=NULL) 		     p1=p1-＞next; 		p1-＞next=p0; 	} 	return (head); }

代码好长，好没心情去看啊！

因为你程序出问题了啊，程序不能正常运行，你单步调试下。

不要做伸手党

你至少应该描述下程序功能及运行异常 信息

因为刚刚接触c语言，所以还不会调试，，这个程序的作用就相当于是建立一个简单的通讯录系统

p1 p2可能没有初始化就使用了


Question: 链表初级

#include<stdio.h> #include<stdlib.h> struct node{     int num;     struct node *next; }; typedef struct node SNODE; SNODE* del(SNODE* head,int number) {     SNODE* p1,*p2;     if(head->next==NULL)     {         printf("\nList is NULL\n");         return(head);     }     p1=head->next;     while(number!=p1->num&&p1->next!=NULL)     {         p2=p1;         p1=p1->next;     }     if(number==p1->num)     {         if(p1==head)         head=p1->next;         else         p2->next=p1->next;         printf("delete:%d\n",number);     }     else     printf("%d not been found!\n",number);     return(head); } void print(SNODE* head) {     SNODE* p;     p=head->next;     if(p=='\0')     printf("\nLinkList is NULL\n");     else{         printf("head");         do{             printf("->%d",p->num);             p=p->next;         }while(p!=NULL);         printf("->end\n");     } } SNODE *creat() {     int data;     SNODE *h,*s,*r;     h=(SNODE*)malloc(sizeof(SNODE));     r=h;     scanf("%d",&data);     while(data!=-1)     {         s=(SNODE*)malloc(sizeof(SNODE));         s->num=data;         r->next=s;         r=s;         scanf("%d",&data);     }     r->next='\0';     return h; } int main() {     SNODE *head,*head2;     int del_num;     printf("请输入若干整型数据建立链表，以-1结束：");     head=creat();     printf("原链表内容为：\n");     print(head);     printf("\n输入要删除的数据：");     scanf("%d",&del_num);     head2=del(head,del_num);     printf("\n执行删除操作后链表内容为：\n");     print(head2);     return 0; } 这个就是我改的

引用 1 楼 qq423399099 的回复:1.printf("\nList is NULL\n");为什么一定要执行？head为空的时候才需要被执行 2. p1=head;//这个可以改成head->next吗（应该改成p1=head->next;才对，因为你的head头结点是不存储数据的（链表是带头结点的链表）） 3.//这两个head我改成head->next,  p1=head;我改成p1->head->next为什么不能删除头结点后的那个num，会错误（看不懂你描述的啥意思） 这个不是一定要执行，而是这样我就是始终无法执行了，head永远不会是空指针 3 这个 这个就执行成这样了

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

明白了，这个前面改了后面我用空指针指了

del函数里if(p1==head) head=p1->next;这句写的不对 应该是if (p1 == head->next)head->next = p1->next;  #include<stdio.h> #include<stdlib.h> struct node{ 	int num; 	struct node *next; }; typedef struct node SNODE; SNODE* del(SNODE* head, int number) { 	SNODE* p1, *p2 = NULL; 	if (head->next == NULL) 	{ 		printf("\nList is NULL\n"); 		return(head); 	} 	 p1 = head->next;  		while (number != p1->num&&p1->next != NULL) 		{ 			p2 = p1; 			p1 = p1->next; 		} 		if (number == p1->num) 		{ 			//说明删除的是第一个结点 			if (p1 == head->next) 				head->next = p1->next; 			else 				p2->next = p1->next; 			free(p1); 			printf("delete:%d\n", number); 		} 		else 			printf("%d not been found!\n", number); 		return(head); } void print(SNODE* head) { 	SNODE* p; 	p = head->next; 	if (p == '\0') 		printf("\nLinkList is NULL\n"); 	else{ 		printf("head"); 		do{ 			printf("->%d", p->num); 			p = p->next; 		} while (p != NULL); 		printf("->end\n"); 	} } SNODE *creat() { 	int data; 	SNODE *h, *s, *r; 	h = (SNODE*)malloc(sizeof(SNODE)); 	r = h; 	scanf("%d", &data); 	while (data != -1) 	{ 		s = (SNODE*)malloc(sizeof(SNODE)); 		s->num = data; 		r->next = s; 		r = s; 		scanf("%d", &data); 	} 	r->next = '\0'; 	return h; } int main() { 	SNODE *head, *head2; 	int del_num; 	printf("请输入若干整型数据建立链表，以-1结束："); 	head = creat(); 	printf("原链表内容为：\n"); 	print(head); 	printf("\n输入要删除的数据："); 	scanf("%d", &del_num); 	head2 = del(head, del_num); 	printf("\n执行删除操作后链表内容为：\n"); 	print(head2); 	return 0; }


Question: C语言文件问题

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

传递文件指针过去即可  void Write(FILE *fp) { }  又或者定义一个全局变量来保存已经打开读写开关的FILE*

以文件指针的方式传递即可，打开、关闭均放主函数中。 至于说效率问题，多次传递文件指针这个影响可以忽略不计。


Question: 遇到一个问题 想了好久也没想到思路

引用 4 楼 zhao4zhong1 的回复://把数字1到n连接起来就构成了第n个Smarandache consecutive number。Smarandache的前17个数如下： //1 //12 //123 //1234 //12345 //123456 //1234567 //12345678 //123456789 //12345678910 //1234567891011 //123456789101112 //12345678910111213 //1234567891011121314 //123456789101112131415 //12345678910111213141516 //1234567891011121314151617 //给定一个正整数n，问[1,n]之间含有多少个Smarandache consecutive number？ //输入 //多行数据组成。 //每行一个整数n，n大于1并且小于第1000个Smarandache consecutive number。 //输出 //对于每一行的数据n，输出一行，即[1,n]之间Smarandache consecutive number的个数。 // //样例输入 //1 //13 //1233 //样例输出 //1 //2 //3 #include <stdio.h> #include <string.h> char S[1000][4000]; int i,j,L,n; char ln[4000]; int main() {     for (i=0;i<1000;i++) {         L=0;         for (j=1;j<=i+1;j++) {             L+=sprintf(S[i]+L,"%d",j);         } //      printf("%4d %s\n",i+1,S[i]);     }     while (1) {         if (NULL==fgets(ln,4000,stdin)) break;         if ('\n'==ln[0]) break;         if ('\n'==ln[strlen(ln)-1]) ln[strlen(ln)-1]=0;         n=0;         for (i=999;i>=0;i--) {             if (strlen(ln)>=strlen(S[i])) {                 if (strcmp(ln,S[i])>=0) n++;                 n+=i;                 break;             }         }         printf("%d\n",n);     }     return 0; }    非常感谢！！还给我直接打出来了！ 我好好想一下  再加上百度理解  应该没问题的。

引用 2 楼 zhao4zhong1 的回复:使用char []和sprintf 不好意思哈  初学  你说的我百度了一下   但是还是没有想到怎么解决这个根本问题的核心算法   就是计算返回的数的值 可以稍微解释一下么？

使用char []和sprintf

我本来想用判断数字位数来计算的，但是想了下可行性太小了，，，需要计算的东西太多了

引用 9 楼 zhao4zhong1 的回复:[quote=引用 6 楼 NDFour 的回复:] [quote=引用 4 楼 zhao4zhong1 的回复:] //把数字1到n连接起来就构成了第n个Smarandache consecutive number。Smarandache的前17个数如下： //1 //12 //123 //1234 //12345 //123456 //1234567 //12345678 //123456789 //12345678910 //1234567891011 //123456789101112 //12345678910111213 //1234567891011121314 //123456789101112131415 //12345678910111213141516 //1234567891011121314151617 //给定一个正整数n，问[1,n]之间含有多少个Smarandache consecutive number？ //输入 //多行数据组成。 //每行一个整数n，n大于1并且小于第1000个Smarandache consecutive number。 //输出 //对于每一行的数据n，输出一行，即[1,n]之间Smarandache consecutive number的个数。 // //样例输入 //1 //13 //1233 //样例输出 //1 //2 //3 #include <stdio.h> #include <string.h> char S[1000][4000]; int i,j,L,n; char ln[4000]; int main() {     for (i=0;i<1000;i++) {         L=0;         for (j=1;j<=i+1;j++) {             L+=sprintf(S[i]+L,"%d",j);         } //      printf("%4d %s\n",i+1,S[i]);     }     while (1) {         if (NULL==fgets(ln,4000,stdin)) break;         if ('\n'==ln[0]) break;         if ('\n'==ln[strlen(ln)-1]) ln[strlen(ln)-1]=0;         n=0;         for (i=999;i>=0;i--) {             if (strlen(ln)>=strlen(S[i])) {                 if (strcmp(ln,S[i])>=0) n++;                 n+=i;                 break;             }         }         printf("%d\n",n);     }     return 0; }   不得不说， 在这里面提问 ，一段时间后，，我觉得我应该会进步飞快，，，，毕竟好多大牛回复我的我都看不懂  然后就自己去百度，，，实验，真是个好地方！！！[/quote] 你为什么不说“毕竟zhao4zhong1大牛回复我的我都看不懂”呢？[/quote]  更重要的是  我之前看过一句话：“在你觉得难得时候，其实你是在进步！“

引用 9 楼 zhao4zhong1 的回复:[quote=引用 6 楼 NDFour 的回复:] [quote=引用 4 楼 zhao4zhong1 的回复:] //把数字1到n连接起来就构成了第n个Smarandache consecutive number。Smarandache的前17个数如下： //1 //12 //123 //1234 //12345 //123456 //1234567 //12345678 //123456789 //12345678910 //1234567891011 //123456789101112 //12345678910111213 //1234567891011121314 //123456789101112131415 //12345678910111213141516 //1234567891011121314151617 //给定一个正整数n，问[1,n]之间含有多少个Smarandache consecutive number？ //输入 //多行数据组成。 //每行一个整数n，n大于1并且小于第1000个Smarandache consecutive number。 //输出 //对于每一行的数据n，输出一行，即[1,n]之间Smarandache consecutive number的个数。 // //样例输入 //1 //13 //1233 //样例输出 //1 //2 //3 #include <stdio.h> #include <string.h> char S[1000][4000]; int i,j,L,n; char ln[4000]; int main() {     for (i=0;i<1000;i++) {         L=0;         for (j=1;j<=i+1;j++) {             L+=sprintf(S[i]+L,"%d",j);         } //      printf("%4d %s\n",i+1,S[i]);     }     while (1) {         if (NULL==fgets(ln,4000,stdin)) break;         if ('\n'==ln[0]) break;         if ('\n'==ln[strlen(ln)-1]) ln[strlen(ln)-1]=0;         n=0;         for (i=999;i>=0;i--) {             if (strlen(ln)>=strlen(S[i])) {                 if (strcmp(ln,S[i])>=0) n++;                 n+=i;                 break;             }         }         printf("%d\n",n);     }     return 0; }   不得不说， 在这里面提问 ，一段时间后，，我觉得我应该会进步飞快，，，，毕竟好多大牛回复我的我都看不懂  然后就自己去百度，，，实验，真是个好地方！！！[/quote] 你为什么不说“毕竟zhao4zhong1大牛回复我的我都看不懂”呢？[/quote]  你回复的我确实有好多都看不懂，，，，但是靠着百度 还是可以慢慢理解的

引用 7 楼 yangyangsnr 的回复: #include <iostream> #include <string> using namespace std; int main() {     int n = 1;     string str;     string input;     cin>>input;     while( 1 )     {         char c[1024];         sprintf( c, "%d", n );         str += c;         if( str.size() >= input.size() ) break;         n++;     }     if( str.size() > input.size() || (str.size() == input.size() && str > input ) ) n--;     cout<<str.size()<<endl;     cout<<str<<endl;     cout<<"Total number is:"<<n<<endl;     getchar();     getchar();     return 0; }    谢谢回复   我会认真看一下的

赵老师先建表的思路挺好的，不过为啥不在建表同时把长度也算好存起来，这样拿到输入的时候就不用再循环比较字符串了啊

引用 7 楼 yangyangsnr 的回复: #include <iostream> #include <string> using namespace std; int main() {     int n = 1;     string str;     string input;     cin>>input;     while( 1 )     {         char c[1024];         sprintf( c, "%d", n );         str += c;         if( str.size() >= input.size() ) break;         n++;     }     if( str.size() > input.size() || (str.size() == input.size() && str > input ) ) n--;     cout<<str.size()<<endl;     cout<<str<<endl;     cout<<"Total number is:"<<n<<endl;     getchar();     getchar();     return 0; }   理解错了，题目说第1000位，理解成了这个数最大1000位了......

引用 6 楼 NDFour 的回复:[quote=引用 4 楼 zhao4zhong1 的回复:] //把数字1到n连接起来就构成了第n个Smarandache consecutive number。Smarandache的前17个数如下： //1 //12 //123 //1234 //12345 //123456 //1234567 //12345678 //123456789 //12345678910 //1234567891011 //123456789101112 //12345678910111213 //1234567891011121314 //123456789101112131415 //12345678910111213141516 //1234567891011121314151617 //给定一个正整数n，问[1,n]之间含有多少个Smarandache consecutive number？ //输入 //多行数据组成。 //每行一个整数n，n大于1并且小于第1000个Smarandache consecutive number。 //输出 //对于每一行的数据n，输出一行，即[1,n]之间Smarandache consecutive number的个数。 // //样例输入 //1 //13 //1233 //样例输出 //1 //2 //3 #include <stdio.h> #include <string.h> char S[1000][4000]; int i,j,L,n; char ln[4000]; int main() {     for (i=0;i<1000;i++) {         L=0;         for (j=1;j<=i+1;j++) {             L+=sprintf(S[i]+L,"%d",j);         } //      printf("%4d %s\n",i+1,S[i]);     }     while (1) {         if (NULL==fgets(ln,4000,stdin)) break;         if ('\n'==ln[0]) break;         if ('\n'==ln[strlen(ln)-1]) ln[strlen(ln)-1]=0;         n=0;         for (i=999;i>=0;i--) {             if (strlen(ln)>=strlen(S[i])) {                 if (strcmp(ln,S[i])>=0) n++;                 n+=i;                 break;             }         }         printf("%d\n",n);     }     return 0; }   不得不说， 在这里面提问 ，一段时间后，，我觉得我应该会进步飞快，，，，毕竟好多大牛回复我的我都看不懂  然后就自己去百度，，，实验，真是个好地方！！！[/quote] 你为什么不说“毕竟zhao4zhong1大牛回复我的我都看不懂”呢？

引用 7 楼 yangyangsnr 的回复: #include <iostream> #include <string> using namespace std; int main() {     int n = 1;     string str;     string input;     cin>>input;     while( 1 )     {         char c[1024];         sprintf( c, "%d", n );         str += c;         if( str.size() >= input.size() ) break;         n++;     }     if( str.size() > input.size() || (str.size() == input.size() && str > input ) ) n--;     cout<<str.size()<<endl;     cout<<str<<endl;     cout<<"Total number is:"<<n<<endl;     getchar();     getchar();     return 0; }   伙计，1024不够大嘢。

引用 4 楼 zhao4zhong1 的回复://把数字1到n连接起来就构成了第n个Smarandache consecutive number。Smarandache的前17个数如下： //1 //12 //123 //1234 //12345 //123456 //1234567 //12345678 //123456789 //12345678910 //1234567891011 //123456789101112 //12345678910111213 //1234567891011121314 //123456789101112131415 //12345678910111213141516 //1234567891011121314151617 //给定一个正整数n，问[1,n]之间含有多少个Smarandache consecutive number？ //输入 //多行数据组成。 //每行一个整数n，n大于1并且小于第1000个Smarandache consecutive number。 //输出 //对于每一行的数据n，输出一行，即[1,n]之间Smarandache consecutive number的个数。 // //样例输入 //1 //13 //1233 //样例输出 //1 //2 //3 #include <stdio.h> #include <string.h> char S[1000][4000]; int i,j,L,n; char ln[4000]; int main() {     for (i=0;i<1000;i++) {         L=0;         for (j=1;j<=i+1;j++) {             L+=sprintf(S[i]+L,"%d",j);         } //      printf("%4d %s\n",i+1,S[i]);     }     while (1) {         if (NULL==fgets(ln,4000,stdin)) break;         if ('\n'==ln[0]) break;         if ('\n'==ln[strlen(ln)-1]) ln[strlen(ln)-1]=0;         n=0;         for (i=999;i>=0;i--) {             if (strlen(ln)>=strlen(S[i])) {                 if (strcmp(ln,S[i])>=0) n++;                 n+=i;                 break;             }         }         printf("%d\n",n);     }     return 0; }   不得不说， 在这里面提问 ，一段时间后，，我觉得我应该会进步飞快，，，，毕竟好多大牛回复我的我都看不懂  然后就自己去百度，，，实验，真是个好地方！！！


Question: C语言新人，在学指针与数组这一块，某段代码一直有问题，请教！

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

太粗心了 对这种低级错误还是不注意  谢谢回复的各位！！

你的for后面多加了个;  所以for（i=0;i<number;i++）； 成一个语句 了。  流程是i=0;i++;  i=1;i++; i=2;i++;  i=3;i++;  i=4;i++ i=5; 退出循环 进入下个语句 printf("%d",i+1);   //  i=5，i+1=6

那个for后面加个；太刺眼了。

你的for循环为什么加分号呢？那就一个空的for循环了。


Question: 注册表信息修改

引用 2 楼 u013058964 的回复:有介绍如何用labview来操作注册表信息的内容吗？例如查找，替换之类！ 百度搜相关关键字。

有介绍如何用labview来操作注册表信息的内容吗？例如查找，替换之类！


Question: 数据结构适合什么时候学习？在学完c之后学怎么样？

为什么要有数据结构这个东东？ 因为要将现实世界或者抽象理论中的各种数据保存在计算机外存（光盘、硬盘、U盘……）或内存（ROM、RAM、SRAM……）里面的二进制字节数组中。 然后让CPU这个只会执行预先保存好的加减乘除移位条件转移……等机器指令的家伙按照人的意志去处理这些数据。至于具体如何处理就是所谓算法。  电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。  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);     } }

可以去学数据结构了。 数据结构的本质就在于：如何将现实世界中各种各样的数据放入到内存中，并且如何在内存中操作这些数据，如何评价这些存储方案和操作方法。 数据结构难学吗？是难学。 为什么难学？一开始上来就讲空间复杂度、时间复杂度，就讲抽象数据，当然难学了。

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……

首先数据结构是数据存储的方式，其次需要通过代码来展示它才能更好的理解 你只要学会一门编程语言的基础，有计算机内存的概念 就可以看数据结构了


Question: 大神来看看吧，拜谢啦

引用 1 楼 user-2的回复:意思就是用链表存储数据吧，可以自己网上找几篇讲链表的文章学习 主要是时间太急了，能帮忙改下不

百度搜相关关键字。

意思就是用链表存储数据吧，可以自己网上找几篇讲链表的文章学习


Question: 自学C的新人，请教关于gcc编译文件时遇到C11支持的问题。

引用 9 楼 ri_aje 的回复:[quote=引用 8 楼 wufhjx 的回复:] [quote=引用 7 楼 ri_aje的回复:][quote=引用 4 楼 wufhjx 的回复:] [quote=引用 1 楼 ri_aje的回复:]*_s 好像是软软的私货，gcc 估计不支持，用不带 _s 的版本吧。 书本上说不带_s的是标准函数，而这个是C11标准引入的新字符串函数。作者说这个新的函数比旧的好。上网查了好久，知道4.7后面的gcc版本都支持C11标准啊，现在我的是5.4。请问为什么还是编译不了？[/quote] 这些 safe 函数是 Annex K (optional) of ISO/IEC 9899:2011，看名字标准并没有严格要求，实现可以自决。gcc c11 的支持在这里可以查到 https://gcc.gnu.org/wiki/C11Status，里面明确说了： Bounds-checking (Annex K) [Optional]　Library issue (not implemented) ，显然没有支持呢，所以你看到链接错误。[/quote] 自决就是可以随便给这个函数起名字？不太懂。请问可以详细说一下，我应该怎么做吗？今天我换了codeblocks来运行这段代码也是不行。要崩溃了。[/quote] 自决就是就是可以自由决定是否实现这个函数，因为这个函数在标准里试定义在 annex K 里面，然后这个附录是 optional，意思就是 gcc 实不实现都行。我猜 ms 把这些推进了标准，但是遇到的阻力也不小，最后只弄了个 optional，然后非 ms 的编译器没人吊它。[/quote] 非常感谢你的回答

引用 8 楼 wufhjx 的回复:[quote=引用 7 楼 ri_aje的回复:][quote=引用 4 楼 wufhjx 的回复:] [quote=引用 1 楼 ri_aje的回复:]*_s 好像是软软的私货，gcc 估计不支持，用不带 _s 的版本吧。 书本上说不带_s的是标准函数，而这个是C11标准引入的新字符串函数。作者说这个新的函数比旧的好。上网查了好久，知道4.7后面的gcc版本都支持C11标准啊，现在我的是5.4。请问为什么还是编译不了？[/quote] 这些 safe 函数是 Annex K (optional) of ISO/IEC 9899:2011，看名字标准并没有严格要求，实现可以自决。gcc c11 的支持在这里可以查到 https://gcc.gnu.org/wiki/C11Status，里面明确说了： Bounds-checking (Annex K) [Optional]　Library issue (not implemented) ，显然没有支持呢，所以你看到链接错误。[/quote] 自决就是可以随便给这个函数起名字？不太懂。请问可以详细说一下，我应该怎么做吗？今天我换了codeblocks来运行这段代码也是不行。要崩溃了。[/quote] 自决就是就是可以自由决定是否实现这个函数，因为这个函数在标准里试定义在 annex K 里面，然后这个附录是 optional，意思就是 gcc 实不实现都行。我猜 ms 把这些推进了标准，但是遇到的阻力也不小，最后只弄了个 optional，然后非 ms 的编译器没人吊它。

引用 7 楼 ri_aje的回复:[quote=引用 4 楼 wufhjx 的回复:] [quote=引用 1 楼 ri_aje的回复:]*_s 好像是软软的私货，gcc 估计不支持，用不带 _s 的版本吧。 书本上说不带_s的是标准函数，而这个是C11标准引入的新字符串函数。作者说这个新的函数比旧的好。上网查了好久，知道4.7后面的gcc版本都支持C11标准啊，现在我的是5.4。请问为什么还是编译不了？[/quote] 这些 safe 函数是 Annex K (optional) of ISO/IEC 9899:2011，看名字标准并没有严格要求，实现可以自决。gcc c11 的支持在这里可以查到 https://gcc.gnu.org/wiki/C11Status，里面明确说了： Bounds-checking (Annex K) [Optional]　Library issue (not implemented) ，显然没有支持呢，所以你看到链接错误。[/quote] 自决就是可以随便给这个函数起名字？不太懂。请问可以详细说一下，我应该怎么做吗？今天我换了codeblocks来运行这段代码也是不行。要崩溃了。

引用 4 楼 wufhjx 的回复:[quote=引用 1 楼 ri_aje的回复:]*_s 好像是软软的私货，gcc 估计不支持，用不带 _s 的版本吧。 书本上说不带_s的是标准函数，而这个是C11标准引入的新字符串函数。作者说这个新的函数比旧的好。上网查了好久，知道4.7后面的gcc版本都支持C11标准啊，现在我的是5.4。请问为什么还是编译不了？[/quote] 这些 safe 函数是 Annex K (optional) of ISO/IEC 9899:2011，看名字标准并没有严格要求，实现可以自决。gcc c11 的支持在这里可以查到 https://gcc.gnu.org/wiki/C11Status，里面明确说了： Bounds-checking (Annex K) [Optional]　Library issue (not implemented) ，显然没有支持呢，所以你看到链接错误。

参考：https://gcc.gnu.org/wiki/C11Status  这个在 gcc 里貌似还没实现

*_s 好像是微软自定义的函数吧，gcc 应该不支持

引用 3 楼 小灸舞的回复:https://www.oschina.net/code/snippet_942932_23807 谢谢你的答复，我现在还看不懂这个。

引用 1 楼 ri_aje的回复:*_s 好像是软软的私货，gcc 估计不支持，用不带 _s 的版本吧。 书本上说不带_s的是标准函数，而这个是C11标准引入的新字符串函数。作者说这个新的函数比旧的好。上网查了好久，知道4.7后面的gcc版本都支持C11标准啊，现在我的是5.4。请问为什么还是编译不了？

*_s 好像是软软的私货，gcc 估计不支持，用不带 _s 的版本吧。


Question: 求在指定两个串中，在串1，不在串2的字符序列的算法

for(i = 0;i < strlen(s1); i++) { 	ind = 0; 	for(j = 0; j< streln(s2); j++) 	{ 		if(s[i] == s2[j]) 		{ 			ind = 2; 			break;	 		} 		ind = 1; 		 	} 	 	if(ind == 1) 	{ 		sprintf(buf, " %s", s1[i]); 		strcat(s3, buf); 	} 	 } s3[strlen(s3)] = '\0'; printf("s3=[%s]", s3);  注：s3中打印出的就是需要s1中存在但是在s2中不存在的字符所组成的字符串了（未经运行，仅供参考）

std::string::find

for(串1) {     for(串2)     {         if(s1[i] == s2[j])             break;     }     if(j == len2) //len2 串2的长度     {         //这个就是符合结果的字符，然后把所有这里的存储起来就是你需要的结果     } }


Question: 一个C语言的小算法题（想了好久，没搞出来。。）

引用 8 楼 cutmelon 的回复:怎么又是同一道题，还是不同的人问的 同班同学嘛。

引用 6 楼 zhao4zhong1 的回复:[quote=引用 5 楼 yangyangsnr 的回复:]  #include <iostream> #include <string> using namespace std; int main() {     int n = 1;     string str;     string input;     cin>>input;     while( 1 )     {         char c[1024];         sprintf( c, "%d", n );         str += c;         if( str.size() >= input.size() ) break;         n++;     }     if( str.size() > input.size() || (str.size() == input.size() && str > input ) ) n--;     cout<<str.size()<<endl;     cout<<str<<endl;     cout<<"Total number is:"<<n<<endl;     getchar();     getchar();     return 0; }   伙计，1024不够大嘢。[/quote] 后来发现是str += c;跟1024不够大没关系。

Talk is cheap, show me the code.

//把数字1到n连接起来就构成了第n个Smarandache consecutive number。Smarandache的前17个数如下： //1 //12 //123 //1234 //12345 //123456 //1234567 //12345678 //123456789 //12345678910 //1234567891011 //123456789101112 //12345678910111213 //1234567891011121314 //123456789101112131415 //12345678910111213141516 //1234567891011121314151617 //给定一个正整数n，问[1,n]之间含有多少个Smarandache consecutive number？ //输入 //多行数据组成。 //每行一个整数n，n大于1并且小于第1000个Smarandache consecutive number。 //输出 //对于每一行的数据n，输出一行，即[1,n]之间Smarandache consecutive number的个数。 // //样例输入 //1 //13 //1233 //样例输出 //1 //2 //3 #include <stdio.h> #include <string.h> char S[1000][4000]; int i,j,L,n; char ln[4000]; int main() {     for (i=0;i<1000;i++) {         L=0;         for (j=1;j<=i+1;j++) {             L+=sprintf(S[i]+L,"%d",j);         } //      printf("%4d %s\n",i+1,S[i]);     }     while (1) {         if (NULL==fgets(ln,4000,stdin)) break;         if ('\n'==ln[0]) break;         if ('\n'==ln[strlen(ln)-1]) ln[strlen(ln)-1]=0;         n=0;         for (i=999;i>=0;i--) {             if (strlen(ln)>=strlen(S[i])) {                 if (strcmp(ln,S[i])>=0) n++;                 n+=i;                 break;             }         }         printf("%d\n",n);     }     return 0; }

怎么又是同一道题，还是不同的人问的

char c[1024]; 这个小了，第999个数有2889位。

引用 5 楼 yangyangsnr 的回复: #include <iostream> #include <string> using namespace std; int main() {     int n = 1;     string str;     string input;     cin>>input;     while( 1 )     {         char c[1024];         sprintf( c, "%d", n );         str += c;         if( str.size() >= input.size() ) break;         n++;     }     if( str.size() > input.size() || (str.size() == input.size() && str > input ) ) n--;     cout<<str.size()<<endl;     cout<<str<<endl;     cout<<"Total number is:"<<n<<endl;     getchar();     getchar();     return 0; }   伙计，1024不够大嘢。

引用 1楼user-5 的回复:先写一个函数取得Smarandache consecutive number第n位的长度（可以建表再查） 然后对于输入src，取得它的长度m，比较它与第m位Smarandache consecutive number的大小 如果大于等于则结果为m，否则为m-1如何得到第m位的那个字符串？


Question: 链表初级

如果是初学者，不建议使用别人看不懂的或者看着别扭的语法形式去写代码。比如while (scanf("%d", &data), data != -1).写这个没错，逗号运算符嘛，以最后一个表达式作为判断true或者false，但是你考虑scanf("%d", &data)出错的情况吗？虽然一般不会出错。但是一般不出错不等于以后总不出错。 建议，按部就班，杜绝小的技巧导致大的错误。

#include<stdio.h> #include<stdlib.h>  struct node{     int num;     struct node *next; };  typedef struct node SNODE;  SNODE *creat(void) {     int ret;     SNODE *r,*h,*p;     int data;     h = (SNODE*)malloc(sizeof(SNODE));     if (!h) {         fprintf(stderr, "Malloc error!\n");         return NULL;     }     r = h;      ret = scanf("%d", &data);     while(ret > 0 && data != -1)     {         p = (SNODE*)malloc(sizeof(SNODE));         if (!p) {             fprintf(stderr, "Malloc error!\n");             return NULL;         }         p->num = data;         p->next = NULL;         r->next = p;         r = p;         ret = scanf("%d", &data);     }     p->next = NULL;      return h; } void print(SNODE *head) {     SNODE *p = NULL;     p = head->next;      if(!p)         printf("\nLinkList is NULL");     else     {         printf("\nhead");         do {             printf("->%d",p->num);             p=p->next;         }while(p != NULL);         printf("->end");     } } int main() {     SNODE *head;      head = creat();     print(head);      return 0; }  其实没有多复杂的为什么。你的语法就不应该这样，虽然编译器不给你指出错误，但是这样写就是不合法的。因为写的不对，所以结果就不能按照你想法输出。 语法上对于空指针，就是NULL，不要用'\0'，先搞明白'\0', NULL, "0", 0这些是什么，做什么用。在什么地方用什么符号，不要混哦。

p->next不赋值的话，是个垃圾值（并不是NULL，或者说'\0'） 然后就会找到垃圾值对应的地址，然后继续next 然后就会跳不出你print函数里的while循环

p是一个指针 while(scanf("%d",&data),data!=-1)  {   p=(SNODE*)malloc(sizeof(SNODE));   r->next=p;   p->num=data;   r=p;  } 看看这里面最后r = p ； 然后现在你在while之后让p = NULL； 让p的指针指向了一个未知的空间，也就让在while循环中的r = NULL；所以最后程序运行的时候，你可以看到前三个数字都已经输出，然后最后本应该结束的地方却无限的的输出一个未知的值，这是因为在print的时候无法检测到停止的地方； 也就是这里 do{    printf("->%d",p->num);    p=p->next;   }while(p!='\0');   printf("->end");


Question: 很无解的运行时间问题

我之前的项目是运用，CUDA/OpenCl/SSE ,技术的，但由于终端极限性，无法施用，     主机和终端的CPU主频比是 3.6 G/ 1.33 G, 两个平台的处理核数都是4个，按理推算， 两边的时间也就差不多10倍左右吧，怎么会相差那么多，自己写的C 代码也是要25倍差距， 是因为配置环境，或其他原因导致的？

引用 1 楼 user-3 的回复:你说的时间是walltime吧，还要看系统时间，用户时间，可以用linux time命令获取 差不多就这样

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


Question: 问一个二级指针的问题 C语言

引用 12 楼 zhao4zhong1 的回复:[quote=引用 11 楼 songjiajia 的回复:] [quote=引用 7 楼 zhao4zhong1 的回复:] A[B] *(A+B) *(B+A) B[A] //以上四行等价  "abc"[1] *("abc"+1) *(1+"abc") 1["abc"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价   谢谢 弄明白了！  再问个问题 用malloc给指针分配内存后 那内存中存放的有初始值吗 默认是0 吗？[/quote] 没有确定的初始值（是之前别的程序占用该处时遗留下来的不再使用的垃圾值） 希望为0可以memset或改用calloc  其实电脑开机后物理内存的每个字节都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。 [/quote] 恩 多谢！

引用 11 楼 songjiajia 的回复:[quote=引用 7 楼 zhao4zhong1 的回复:] A[B] *(A+B) *(B+A) B[A] //以上四行等价  "abc"[1] *("abc"+1) *(1+"abc") 1["abc"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价   谢谢 弄明白了！  再问个问题 用malloc给指针分配内存后 那内存中存放的有初始值吗 默认是0 吗？[/quote] 没有确定的初始值（是之前别的程序占用该处时遗留下来的不再使用的垃圾值） 希望为0可以memset或改用calloc  其实电脑开机后物理内存的每个字节都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。

引用 7 楼 zhao4zhong1 的回复:A[B] *(A+B) *(B+A) B[A] //以上四行等价  "abc"[1] *("abc"+1) *(1+"abc") 1["abc"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价   谢谢 弄明白了！  再问个问题 用malloc给指针分配内存后 那内存中存放的有初始值吗 默认是0 吗？

引用 4 楼 playinend 的回复:temp[ i ] 和 *( temp + i ) 一般是等同的，temp + i 是一个指针表达式 谢谢 弄明白了！  再问个问题 用malloc给指针分配内存后 那内存中存放的有初始值吗 默认是0 吗？

temp[i] 和 temp+i 是什么关系呢？ 相等

temp[i] 与 *(temp+i) 都表示第i个元素的值

看你怎么理解  temp 是char**  那么temp[i] 就是char*  temp+i 就是temp[i]  *(temp+i ) 就是temp[i]里面存的值，这个值在你的例子中，存的是一个字符串常量的地址

数组可以退化为指针的。  a[i]其实也就是*（a+i)，只是后面这个是表达式罢了。

是相等的，数组其实也能算作是指针； //假设有数组如下 int a[10]; //指针如下 int *p; //让指针指向数组 p = a;  想想看这个指针指向的是哪里？

是


Question: 函数中有scanf程序却无法输入 求解

应该没问题，VS2015 C++环境

请问这个问题解决了吗，我也遇到了

#include<stdio.h> #include<stdlib.h>  #define VERTEX_MAX 26   //图的最大顶点数 #define MAXVALUE 32767 //最大值(可设为一个最大整数)  typedef struct {     int Vertex[VERTEX_MAX]; //保存顶点信息(序号或字母)     int Edges[VERTEX_MAX][VERTEX_MAX]; //保存边的权     int isTrav[VERTEX_MAX]; //遍历标志     int VertexNum; //顶点数量     int EdgeNum;//边数量     int GraphType; //图的类型(0:无向图，1:有向图) }MatrixGraph; //定义邻接矩阵图结构  void Createlin(MatrixGraph *G);//创建邻接矩阵图 void Outlin(MatrixGraph *G); //输出邻接矩阵  void Createlin(MatrixGraph *G)//创建邻接矩阵图 {     int i, j, k, weight;     int s, e;//边的起始顶点      printf("输入各顶点信息\n");     for (i = 0; i<G->VertexNum; i++) //输入顶点     {          printf("第%d个顶点:", i);         scanf("%d", &(G->Vertex[i])); //保存到各顶点数组元素中     }     printf("输入构成各边的两个顶点及权值(用逗号分隔):\n");     for (k = 0; k<G->EdgeNum; k++)  //输入边的信息     {          printf("第%d条边：", k + 1);         printf("Please input three wight separated by comma(,): ");         scanf("%d,%d,%d", &s, &e, &weight);         for (i = 0; s != G->Vertex[i]; i++); //在已有顶点中查找始点         for (j = 0; e != G->Vertex[j]; j++); //在已有顶点中查找结终点         printf("i = %d, j = %d\n", i, j);         G->Edges[i][j] = weight; //对应位置保存权值，表示有一条边         if (G->GraphType == 0)  //若是无向图             G->Edges[j][i] = weight;//在对角位置保存权值     } }  void Outlin(MatrixGraph *G)//输出邻接矩阵 {     int i, j;     for (j = 0; j<G->VertexNum; j++)         printf("\t%d", G->Vertex[j]);          //在第1行输出顶点信息     printf("\n");     for (i = 0; i < G->VertexNum; i++)     {         printf("%d", G->Vertex[i]);         for (j = 0; j < G->VertexNum; j++)         {             if (G->Edges[i][j] == MAXVALUE) //若权值为最大值                 printf("\t∞");          //输出无穷大符号             else                 printf("\t%d", G->Edges[i][j]); //输出边的权值         }         printf("\n");     } }  int main() {     MatrixGraph G; //定义保存邻接矩阵结构的图     int i, j;     printf("输入生成图的类型(0:无向图,1:有向图):");     scanf("%d", &G.GraphType); //图的种类      printf("输入图的顶点数量和边数量:(separated by comma(,): )");     scanf("%d,%d", &G.VertexNum, &G.EdgeNum); //输入图顶点数和边数      for (i = 0; i<G.VertexNum; i++)  //清空矩阵         for (j = 0; j<G.VertexNum; j++)             G.Edges[i][j] = MAXVALUE; //设置矩阵中各元素的值为最大值     Createlin(&G); //创建用邻接表保存的图     printf("邻接矩阵数据如下:\n");     Outlin(&G);     //getch();     return 0; }  需要注意两个方面：1）输入时注意需要加逗号，因为你的scanf中要求输入逗号了，类似这样输入1，2才可以； 2）看到你的程序出现段错误了。出现在 G->Edges[i][j] = weight;这行，原因是越界。有向图和无向图，我也不懂，我随便输入的，就出现了数组越界。我通过这句上面加的一句调试信息，看到i,j已经超出26了。你自己注意看一下。对于非法的输入，建议你做判断校验，另外，对i,j超出做判断，这样不会越界出现段错误。

引用 5 楼 qq423399099 的回复:你的编译器有问题吧。 我这里VS是可以正确输入的 http://blog.csdn.net/cometnet/article/details/19551125。。。。。。。。。。。。。。。。。。。。。。。。。。。。。你不说我倒没想起来 这个东西我前几周写过  运行是对的  我一般对的程序和错的程序有分类   今天第一次试是对的  然后就一直奔溃！！

引用 3 楼 qq423399099 的回复:不明白什么叫无法输入，自己检查： 1.可以查看scanf的返回值，看看成功读取了几个变量 2.scanf("%d,%d"这样的写法意味着你输入的时候必须用逗号来分隔2个数字（不能用空格） 3.可能是别的地方的错误导致了你得不到正确的结果（单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。）就是scanf本来是我要在键盘上输入值的  但是现在程序运行时根本不给我输入的机会  没办法看返回值啊

在每个最后不带\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里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。


Question: 求助，c语言程序卡死

可以了，感谢各位的帮助，忘加取地址符号了，谢谢4楼提醒

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。

换了双等号，还是不行，断点不会啊，挺急的，麻烦大神帮忙改一下，在线等

if(stu[i].mingci=1)  stu[i].score=7;  else if(stu[i].mingci=2)  stu[i].score=5;  else if(stu[i].mingci=3)  stu[i].score=3;  else if(stu[i].mingci=4)  stu[i].score=2;  else if(stu[i].mingci=5)  stu[i].score=1;  } 这一片if(=)应该是if(==)吧

加断点，进行单步调试


Question: 已知字母A的ASCII码为十进制数65，且c2为字符型，则执行语句c2＝‘A’+‘6’-‘3’后，c2中的值为

以字符格式%c输出结果为：D，以数值格式%d输出结果为：68

好的 三克油 学习了

因为在c2后面的运算里，'A'+'6'-'3'这三个用单引号括起来表示一个字符型常量，最后得到一个字符型常量，而c2又是一个char变量，所以结果保存成字符，如果说c2定义为int型，最后就会把得到的字符转换成ASCII表中对应的码值。


Question: socket FTP服务器中一用dir功能就停止工作

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 判断是否越界访问，可以在数组的最后一个元素之后对应的地址处设置数据读写断点。如果该地址对应其它变量干扰判断，可将数组多声明一个元素，并设置数据读写断点在该多出元素对应的地址上。 #include <time.h> #include <stdlib.h> #include <windows.h> int main() {     int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]      srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。     while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。         b[(a=rand()%11)]=0;         Sleep(100);         b[(a=rand()%11)]=1;         Sleep(100);         b[(a=rand()%11)]=2;         Sleep(100);         b[(a=rand()%11)]=3;         Sleep(100);         b[(a=rand()%11)]=4;         Sleep(100);     }     return 0; }

另外，由于tcp的特性，你服务器端虽然一次发一行，客户端接收到的时候可能是多行，这时也会造成szBuffer的越界

引用 4 楼 qq_35402305 的回复:[quote=引用 3 楼 cutmelon的回复:]szBuffer[ret]='\0'; 这句错了吧， szBuffer[ret]=0; 才是正道 这里应该是'\0' 空字符没错[/quote] 嗯，我不习惯这么用转义符。 不过你这里的szBuffer大小开的有问题，ret=recv(...)这里返回的是接收到的字节数，也就是说可能是80，szBuffer[80]就明显越界了，我猜你这服务器的运行路径巨深

调试下就知道哪里出错了

引用 3 楼 cutmelon的回复:szBuffer[ret]='\0'; 这句错了吧， szBuffer[ret]=0; 才是正道 这里应该是'\0' 空字符没错

先用 windows 自带的 ftp 命令测试下 ftp 的 dir 返回的数据是有一定格式的。


Question: 为啥一运行出现XX.exe已停止工作

少了个取地址符号，这种错误一般单步就能发现，出错在这一行。 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

引用 2 楼 ai977313677 的回复:你的scanf用法有问题 ,改成 scanf("*d",&n);那个星号打错了，应该是%百分号

你的scanf用法有问题 ,改成 scanf("*d",&n);

scanf("%d",&n); 还有记得return 0;


Question: 看不懂的  for循环 求解释 新手

i,j,k各不相等，但是没有j的值，if语句会出问题，建议单步调试，并且对j初始化

开始的时候j应该有赋值吧，这样没有J什么事哦

j没有值，你给j赋值后试试

i = 1      k = 1      ...      k = 4 i = 2     k = 1      ...      k = 4 ... i = 4     k = 1      ...      k = 4     这样的！还有你的j没有初始化，会有问题。以后遇到这种问题就多单步调试，看程序是怎么走的。

很明显少了个j循环  #include <stdio.h>  int main(void) { 	int i; 	int j;   //  三个 变量 分别为 I J K ; 	int k;  	printf("\n");  	for (i = 1; i < 5; i++) 	{ 		for (j = 1; j < 5; j++) 		{ 			for (k = 1; k < 5; ++k) 			{ 				if (i != k&&i != j&&j != k)// 如果 i 不等于 k 且 i不等于 j 且不等于 k;  				{ 					printf("%d %d %d\n", i, j, k);  				}  			} 		} 		  	} }


Question: 怎么使用C语言做一个射击类小游戏。

显示错误 找不到graphics头目录

用什么原件写呢

楼主的游戏做的怎么样了？  可不可以发来玩一下

srand放main函数里面调用一次

引用 6 楼 user-5的回复:[quote=引用 5 楼 qq_37167928 的回复:] [quote=引用 4 楼 user-5的回复:]随机出现用随机数啊,stdlib.h里面有srand, rand这两个函数 大神您好，其实我知道用那两个的。可是，我放进函数的时候有问题~没有理想中的效果[/quote] srand调用一次，rand调用多次，使用取模%将rand的返回调整到自己需要的范围[/quote] 这样，好的，我再试试。

引用 5 楼 qq_37167928 的回复:[quote=引用 4 楼 user-5的回复:]随机出现用随机数啊,stdlib.h里面有srand, rand这两个函数 大神您好，其实我知道用那两个的。可是，我放进函数的时候有问题~没有理想中的效果[/quote] srand调用一次，rand调用多次，使用取模%将rand的返回调整到自己需要的范围

引用 4 楼 user-5的回复:随机出现用随机数啊,stdlib.h里面有srand, rand这两个函数 大神您好，其实我知道用那两个的。可是，我放进函数的时候有问题~没有理想中的效果

随机出现用随机数啊,stdlib.h里面有srand, rand这两个函数

怎么发出来就没有换行符了

#include <stdio.h> #include <stdlib.h> #include <conio.h> #include <time.h> #include <graphics.h> typedef struct  { 	int x; 	int y; }Coord; int score = 0, life = 3;//分数和生命值。 Coord mposition, bullet, fposition;//飞机坐标，子弹坐标，敌机坐标。 void Iterface();//总界面。 void Mposition();//飞机位置。 void Bullet();//子弹位置 void Fposition();//敌机位置 void print();//打印游戏画面 void Iterface() { 	int i, j; 	char str[10]; 	initgraph(550, 660); 	HWND hwnd = GetHWnd(); 	SetWindowText(hwnd, "星际迷航                 制作:工贸梦之队"); 	Sleep(2000); 	/*settextstyle(40, 0, "隶体"); 	setcolor(RED); 	outtextxy(255, 140, "NEW"); 	settextstyle(40, 0, "楷体"); 	for (i = 0; i <= 255; i++) 	{ 		for (j = 0; j <= 255; j++) 		{ 			setcolor(RGB((i + j + 128) % 255, i, j)); 			outtextxy(205, 200, "星际迷航"); 		} 	} 	Sleep(2000); 	settextstyle(22, 0, "隶体"); 	outtextxy(310, 300, "←_←"); 	settextstyle(22, 0, "楷体"); 	outtextxy(180, 300, "容我装个B"); 	setcolor(LIGHTMAGENTA); 	Sleep(2500); 	outtextxy(175, 300, "请按任意键开始游戏!"); 	getch(); 	cleardevice();*/ 	 	settextstyle(24, 0, "楷体"); 	outtextxy(345, 40, "得分："); 	sprintf(str, "%d", score); 	outtextxy(420, 40, str); 	outtextxy(345, 65, "死亡："); 	sprintf(str, "%d", life); 	outtextxy(420, 65, str); 	settextstyle(22, 0, "楷体"); 	setcolor(LIGHTBLUE); 	outtextxy(350, 100, "操作说明:"); 	outtextxy(350, 125, "W: 射击"); 	outtextxy(350, 175, "A: 左移"); 	outtextxy(350, 200, "D: 右移"); 	outtextxy(350, 225, "空格: 暂停"); } void Mposition() {     IMAGE img1;    loadimage(&img1, "D:\\飞机.JPG");    putimage(mposition.x, mposition.y, &img1); } void print() { 	IMAGE img; 	int i,j=0; 	setcolor(BLACK); 	for (i = 0; i <= 550; i += 30) 	{ 		settextstyle(20, 30, "楷体"); 		outtextxy(i, 0, "■"); 	} 	setcolor(WHITE); 	rectangle(29, 29, 334, 633); 	rectangle(28, 28, 335, 634); 	loadimage(&img, "D:\\TT.JPG"); 	putimage(29, 29, &img); 	Mposition(); 	Bullet(); } void Bullet() { 	IMAGE img; 	loadimage(&img, "D:\\子弹.JPG"); 	putimage(bullet.x, bullet.y, &img); } void Fposition() { 	IMAGE img; 	srand(time(NULL)); 	fposition.x = rand() % 300; 	loadimage(&img, "D:\\敌机.JPG"); 	putimage(fposition.x,


边界条件 输入输出格式 ……

综合1楼2楼的改了，就可AC了。

while(scanf("%d%d%d",&year,&month,&day)!=EOF){  这行错误了，应该改成下面的  while(scanf("%d%d%d",&year,&month,&day)==3){   你的代码在linux里面Ctrl+D根本结束不了。你可以看看scanf返回值的意思。

“输入数据有多组，每组占一行，数据格式为YYYY/MM/DD组成”  scanf("%d%d%d",&year,&month,&day)  应该为  scanf("%d/%d/%d",&year,&month,&day)  （%d之间有 ‘/ ’ ）


Question: 如有大神帮我解决难题 定感激不尽

提醒：再牛×的老师也无法代替学生自己领悟和上厕所！

自己的作业通常还不至于难道请大神帮忙。请百度这个小神就行。

void stuid_find() {//学号查找 利用strcmp()函数       int i,flag=0,k;       char wqs[MIN_C];       k=1;       system("cls");       puts("***************>>>>>>当前模式以学号查询信息状态<<<<<<*************");       while(k) {           printf("请键入学生学号： ");           scanf("%s",wqs);           for(i=0; i<i_entry; i++)               if(strcmp(DATA[i].stuid,wqs)==0) {                   printf("%-18s",&DATA[i].stuid);                   printf("%-16s",DATA[i].name);                   printf("%-4s",&DATA[i].age);                   printf("%-6s",DATA[i].gender);                   printf("%-12s",&DATA[i].birth);                   printf("%-16s",DATA[i].add);                   printf("%-16s",DATA[i].tle);                   printf("%-15s\n",DATA[i].email);                   flag=1;               }           if(flag==0)               puts("未查找到该同学信息，如需录入信息请重新键入命令.");           LIGHT();           puts("请按照文字提示键入命令：");           printf("\t\t1.继续查询\n\t\t0.退出查询\n请键入命令:");           GREEN();           scanf("%d",&k);       }   }      void name_find() {//姓名查找 利用函数strcmp()==0 的特性       int i,flag=0,k;       char wqs[MIN_C];       k=1;       system("cls");       puts("***************>>>>>>当前模式以姓名查询信息状态<<<<<<*************");       while(k) {           printf("请键入学生姓名： ");           scanf("%s",wqs);           for(i=0; i<i_entry; i++)               if(strcmp(DATA[i].name,wqs)==0) {                   printf("%-18s",&DATA[i].stuid);                   printf("%-16s",DATA[i].name);                   printf("%-4s",&DATA[i].age);                   printf("%-6s",DATA[i].gender);                   printf("%-12s",&DATA[i].birth);                   printf("%-16s",DATA[i].add);                   printf("%-16s",DATA[i].tle);                   printf("%-15s\n",DATA[i].email);                   flag=1;               }           if(flag==0)               puts("未查找到该同学信息，如需录入信息请重新键入命令.");           LIGHT();           puts("请按照文字提示键入命令：");           printf("\t\t1.继续查询\n\t\t0.退出查询\n请键入命令:");           GREEN();           scanf("%d",&k);       }   }      void case4() {       int v;       LIGHT();       printf("提示：1,按照学号查询；2,按照姓名查询.请键入：");       GREEN();       scanf("%d",&v);       if(v==1) {           stuid_find();       }       if(v==2) {           name_find();       }   }      void deal() {//主要处理函数       int k,flag,p;       p=1;       notice();       flag=1;       while(flag) {           if(p>1)               notice();           scanf("%d",&k);           system("cls");           switch(k) {               case 0: {                   puts("温馨提醒：");                   puts("\t    ^…………^……^^谢谢您的支持,欢迎再次使用!^^……^…………^ ");                   puts("\t*******学生基本信息已保存在当前目录文件 student_data.txt 下********");                   flag=0;                   LIGHT();                   break;               }               case 1: {                   case1();                   break;               }               case 2: {                   case2();                   break;               }               case 3: {                   case3();                   break;               }               case 4: {                   case4();                   break;               }               case 5: {                   case5();                   break;               }               default: {                   RED();                   printf("请正确键入命令前数字！\n");                   GREEN();                   break;               }           }           p=1103;           puts("\n");       }   }      int main() {       if ((fp = fopen("student_data.txt", "r+")) == NULL) {           fp = fopen("student_data.txt", "w+");       }       init();//文件的初始化读入       GREEN();//控制台颜色为绿色       printf(" >************欢 迎 您 使 用 学 生 信 息 管 理 系 统(正式版1.0.1)************<\n");       printf(">*************     请键入以下命令行所对应的数字进行操作：     *************<\n");       printf(">*************   请确定正确退出程序,否则文件将不被正常保存.     *************<\n");       deal();//处理数据       fclose(fp);//文件正常关闭       return 0;   }

#include <stdio.h>   #include <string.h>   #include <stdlib.h>   #include <math.h>   #include <windows.h>   #define MIN_C 100//每个数据对应字符串类型占据的大小   #define MAX_G 1000//学生信息量大小      int i_entry;//学生的人数统计   FILE *fp;//文件指针      struct student {       char stuid[MIN_C];//学生学号       char name[MIN_C];//学生姓名       char age[3];//学生年龄       char gender[MIN_C];//学生性别       char birth[MIN_C];//学生出生日期       char add[MIN_C];//学生地址       char tle[MIN_C];//学生电话       char email[MIN_C];//学生邮箱   } DATA[MAX_G];      struct student temp;//用于排序的中间变量      void init() {//文件的初始化读取       while (!feof(fp)) {           fscanf(fp, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", DATA[i_entry].stuid, DATA[i_entry].name, DATA[i_entry].age,                  DATA[i_entry].gender, DATA[i_entry].birth, DATA[i_entry].add, DATA[i_entry].tle, DATA[i_entry].email);           i_entry++;       }   }      void file_save() {//信息以文件格式录入函数       fprintf(fp, "%s\t\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", DATA[i_entry].stuid, DATA[i_entry].name,DATA[i_entry].age,               DATA[i_entry].gender, DATA[i_entry].birth, DATA[i_entry].add, DATA[i_entry].tle, DATA[i_entry].email);   }      void RED() {//控制台调整前景色为红色       HANDLE kai_1 = GetStdHandle(STD_OUTPUT_HANDLE);       SetConsoleTextAttribute(kai_1, FOREGROUND_INTENSITY | FOREGROUND_RED); // 为红色   }      void GREEN() {//控制台调整前景色为绿色       HANDLE kai_2 = GetStdHandle(STD_OUTPUT_HANDLE);       SetConsoleTextAttribute(kai_2, FOREGROUND_INTENSITY | FOREGROUND_GREEN);// 为绿色   }      void LIGHT() {//控制台调整前景色为强光       HANDLE kai_2 = GetStdHandle(STD_OUTPUT_HANDLE);       SetConsoleTextAttribute(kai_2, FOREGROUND_INTENSITY | FOREGROUND_INTENSITY);// 为强光   }       void notice() {//提示信息       RED();       puts("\t\t\t1.学生综合信息录入");       puts("\t\t\t2.学生综合信息浏览");       puts("\t\t\t3.综合信息排序浏览");       puts("\t\t\t4.学生个人信息查询");       puts("\t\t\t5.学生综合信息修改");       printf("\t\t\t0. 退  出  系  统\n");       GREEN();       printf("请键入：");   }      void entry() {//学生信息的录入       int flag,i;       system("cls");       init();       flag=1;       puts("***************>>>>>>当前模式为学生信息录入状态<<<<<<*************");       printf("请输入学生学号：");       flag=1;//标识变量，用以判断该信息是否已存在       scanf("%s",&DATA[i_entry].stuid);       for(i=0; i<i_entry; i++) //判断输入数据的正误，即文件中是否已存在该信息           if(strcmp(DATA[i].stuid,DATA[i_entry].stuid)==0) {               flag=0;               break;           }       if(flag==1) {           printf("请输入学生姓名：");           scanf("%s",DATA[i_entry].name);           printf("请输入学生年龄：");           scanf("%s",DATA[i_entry].age);           printf("请输入学生性别：");           scanf("%s",DATA[i_entry].gender);           printf("请输入学生出生年月日(以/隔开)：");           scanf("%s",DATA[i_entry].birth);           printf("请输入学生联系地址：");           scanf("%s",DATA[i_entry].add);           printf("请输入学生联系电话：");           scanf("%s",DATA[i_entry].tle);           printf("请输入学生联系邮箱：");           scanf("%s",DATA[i_entry].email);           file_save();       }       if(flag==0)           puts("该学号已经存在，如需修改请转到修改命令！");   }      void Change(int x) {//学生信息的更改提示内容       printf("请输入修改后的学生学号：");       scanf("%s",DATA[x].stuid);       printf("请输入修改后的学生姓名：");       scanf("%s",DATA[x].name);       printf("请输入修改后的学生年龄：");       scanf("%s",DATA[x].age);       printf("请输入修改后的学生性别：");       scanf("%s",DATA[x].gender);       printf("请输入修改后的学生出生年月日(以/隔开)：");       scanf("%s",DATA[x].birth);       printf("请输入修改后的学生联系地址：");       scanf("%s",DATA[x].add);       printf("请输入修改后的学生联系电话：");       scanf("%s",DATA[x].tle);       printf("请输入修改后的学生联系邮箱：");       scanf("%s",DATA[x].email);       puts("数据修改完成！");       file_save();   }      void case5() {//信息更改       int flag,i,t;       system("cls");       puts("***************>>>>>>当前模式为学生信息修改状态<<<<<<*************");       LIGHT();       printf("选定检索方式：1.学号检索\t2.姓名检索.   请键入：");       GREEN();       flag=0;       scanf("%d",&t);       if(t==2) {           init();           LIGHT();           printf("请输入需要修改的学生姓名：");           scanf("%s",&DATA[i_entry].name);           GREEN();           for(i=0; i<i_entry; i++) //判断输入数据的正误               if(strcmp(DATA[i].name,DATA[i_entry].name)==0) {                   flag=1;                   break;               }           if(flag==1) {               Change(i);           }           if(flag==0)               puts("该姓名不存在，请检查输入是否有误！");       }       if(t==1) {           LIGHT();           init();           printf("请输入需要修改的学生学号：");           scanf("%s",&DATA[i_entry].stuid);           GREEN();           for(i=0; i<i_entry; i++) //判断输入数据的正误               if(strcmp(DATA[i].stuid,DATA[i_entry].stuid)==0) {                   flag=1;                   break;               }           if(flag==1) {               Change(i);           }           if(flag==0)               puts("该学号不存在，请检查输入是否有误！");       }   }      void i_printf() {//学生信息的输出       int i;       printf("学号\t姓名\t年龄\t性别\t出生年/月/日\t联系地址\t联系电话\t联系邮箱");       printf("\n");       for(i=0; i<i_entry; i++) {           printf("%-18s",&DATA[i].stuid);           printf("%-16s",DATA[i].name);           printf("%-4s",&DATA[i].age);           printf("%-6s",DATA[i].gender);           printf("%-12s",&DATA[i].birth);           printf("%-16s",DATA[i].add);           printf("%-16s",DATA[i].tle);           printf("%-15s\n",DATA[i].email);       }   }      void case1() {//当键入数字 1 之后的执行情况       int flag;       flag=1;       while(flag) {           entry();           LIGHT();           printf("提示：1,继续录入；0,录入完成.是否继续录入：");           GREEN();           scanf("%d",&flag);           i_entry++;       }   }      void case2() {       puts("***************>>>>>>当前模式为学生信息浏览状态<<<<<<*************");       i_printf();   }      void stuid_sort() {//学号排序 冒泡排序算法       int r,t;       system("cls");       puts("***************>>>>>>当前模式以学号排序后浏览状态<<<<<<*************");       //struct student temp;       for(r=1; r<i_entry; r++) {           for(t=0; t<i_entry-r; t++) {               if(strcmp(DATA[t+1].stuid, DATA[t].stuid)<0) {//学号由低到高                   temp=DATA[t+1];                   DATA[t+1]=DATA[t];                   DATA[t]=temp;               }           }       }   }      void name_sort() {//姓名排序 冒泡排序算法       int j,k;       system("cls");       puts("***************>>>>>>当前模式以姓名排序后浏览状态<<<<<<*************");       //struct student temp;       for(j=1; j<i_entry; j++) {           for(k=0; k<i_entry-j; k++) {               if(strcmp(DATA[k+1].name,DATA[k].name)<0) {                   temp=DATA[k+1];                   DATA[k+1]=DATA[k];                   DATA[k]=temp;               }           }       }   }      void case3() {       int v;       LIGHT();       printf("提示：1,按照学号排序；2,按照姓名排序.请键入：");       GREEN();       scanf("%d",&v);       if(v==1) {           stuid_sort();           i_printf();       }       if(v==2) {           name_sort();           i_printf();       }   }

主要的几个考点： 1.文件的读取与存储问题 2.结构体的应用 3.函数的定义 4.排序 自己尝试着去写一下。

#include <stdio.h> #include <stdlib.h> #define SIZE 20 /* run this program using the console pauser or add your own getch, system("pause") or input loop */   	struct student 	{char name[20]; 	int no; 	int score[3]; 	}stud[SIZE]; 	int main() 	{void find(int p);  	 void sort(void);  	int i,j,x; 	FILE *fp; 	fp=fopen("121.txt","rb"); 	if((fp=fopen("121.txt","rb"))==NULL) 	{printf("The file can't open'"); 	exit(0); 	} 	printf("sorted student's scores list as follow\n'"); 	printf("--------------------------------------\n"); 	printf("NAME      NO.   YINGYU TINENG ZHIAN\n"); 	printf("--------------------------------------\n"); 	for(i=0;i<SIZE;i++) 	{	fscanf(fp,"%s %d %d %d %d",stud[i].name,&stud[i].no,&stud[i].score[0],&stud[i].score[1],&stud[i].score[2]); 	printf("%s       %d       %d      %d     %d\n",stud[i].name,stud[i].no,stud[i].score[0],stud[i].score[1],stud[i].score[2]); 	} 	find(x); 	sort(); 	fclose(fp); 	return 0; } void find(int p)   {int i,x;   printf("请输入学生学号：");    scanf("%d",&x);    if(x<1||x>20)    printf("你输入的数据错误\n");     for(i=1;i<=20;i++)      if(x==i)        printf("该学生的英语、体能、治安分数分别是：%d %d %d\n",stud[i-1].score[0],stud[i-1].score[1],stud[i-1].score[2]);   }   void sort(void)   {struct student temp[20];   int a,b;   int sum[20];   for(a=0;a<20;a++)   sum[a]=stud[a].score[0]+stud[a].score[1]+stud[a].score[2];   for(b=0;b<20;b++)   {for(a=0;a<20;a++)     if(sum[a]<sum[a+1])    {temp[a]=stud[a];    stud[a]=stud[a+1];    stud[a+1]=temp[a];    }    for(b=0;b<20;b++)    printf("%s       %d       %d      %d     %d   %d\n",stud[b].name,stud[b].no,stud[b].score[0],stud[b].score[1],stud[b].score[2],sum[b]); 	}    } 赵老师 最后一个函数为什么不能实现用总分排序？？

我可以帮你把最后那项完成  难点：不知道怎么做 解决办法：上csdn发帖 编程小结或体会：还是得靠自己

1，文件读写 2，排序算法、插入算法 3，数据基本类型操作 都是基础问题，这里没人会给你写出来的，自己好好学一下就差不多能写出来了

引用 2 楼 qq_37242769 的回复:百度没用了 赵老师 救我 我现在救你实际上是害你。

百度没用了 赵老师 救我


Question: 【小白求助】把字符串写入文件出现乱码！！再次读取文件好像出现了错误

windows里常见的内存填充数据含义  * 0xABABABAB : Used by Microsoft's HeapAlloc() to mark "no man's land" guard bytes after allocated heap memory 漱 * 0xABADCAFE : A startup to this value to initialize all free memory to catch errant pointers 涵? * 0xBAADF00D : Used by Microsoft's LocalAlloc(LMEM_FIXED) to mark uninitialised allocated heap memory 很? * 0xBADCAB1E : Error Code returned to the Microsoft eVC debugger when connection is severed to the debugger 撅饰 * 0xBEEFCACE : Used by Microsoft .NET as a magic number in resource files 烫烫 * 0xCCCCCCCC : Used by Microsoft's C++ debugging runtime library to mark uninitialised stack memory 屯屯 * 0xCDCDCDCD : Used by Microsoft's C++ debugging runtime library to mark uninitialised heap memory 葺葺 * 0xDDDDDDDD : Used by Microsoft's free() or delete to mark freed heap memory 蕲蕲 * 0xDEADDEAD : A Microsoft Windows STOP Error code used when the user manually initiates the crash  * 0xFDFDFDFD : Used by Microsoft's C++ debugging heap to mark "no man's land" guard bytes before and after allocated heap memory  * 0xFEEEFEEE : Used by Microsoft's HeapFree() to mark freed heap memory

1、释放内存造成的 2、读写的方式也会有影响

windows里常见的内存填充数据含义 * 0xABABABAB : Used by Microsoft's HeapAlloc() to mark "no man's land" guard bytes after allocated heap memory * 0xABADCAFE : A startup to this value to initialize all free memory to catch errant pointers * 0xBAADF00D : Used by Microsoft's LocalAlloc(LMEM_FIXED) to mark uninitialised allocated heap memory * 0xBADCAB1E : Error Code returned to the Microsoft eVC debugger when connection is severed to the debugger * 0xBEEFCACE : Used by Microsoft .NET as a magic number in resource files * 0xCCCCCCCC : Used by Microsoft's C++ debugging runtime library to mark uninitialised stack memory * 0xCDCDCDCD : Used by Microsoft's C++ debugging runtime library to mark uninitialised heap memory * 0xDDDDDDDD : Used by Microsoft's free() or delete to mark freed heap memory * 0xDEADDEAD : A Microsoft Windows STOP Error code used when the user manually initiates the crash * 0xFDFDFDFD : Used by Microsoft's C++ debugging heap to mark "no man's land" guard bytes before and after allocated heap memory * 0xFEEEFEEE : Used by Microsoft's HeapFree() to mark freed heap memory

“葺”的GB码是0xdddd, 在这里查到0xdddd的解释 Microsoft Visual C++ compiled code with memory leak detection turned on. Usually, DEBUG_NEW was defined. Memory with this tag signifies memory that has been freed (by free() or delete) by the application. It is how you can detect writing to memory that has already been freed. For example, if you look at an allocated memory structure (or C++ class) and most of the members contain this tag value, you are probably writing to a structure that has been freed.   也就是向已经free的堆内存写导致的

二进制形式写文件，如果你打开有可能会出现乱码；如果想用写可读的文本形式，建议不要使用二进制形式写。

你在strcpy(inf.NUMBER,p);之前就已经free(p)，不出乱码才有鬼了


Question: 求帮我这个菜鸟看看哪里错了，到输入第二个学生信息就挂了。

改变指针指向的内存空间的内容，用一级指针就行了。 要改变指针的指向才需要用二级指针。 改成下面这样就行了：  #include <stdio.h> #include <malloc.h> struct student { 	int age; 	char name[40]; 	float score; };  void intput(struct student *st, int len); void output(struct student *st, int len);  int main(void) { 	int len; 	printf("请输入学生人数："); 	scanf("%d", &len); 	struct student * st = (struct student*)malloc(sizeof(struct student) * len); 	intput(st, len); 	output(st, len);  	return 0; }  void intput(struct student *st, int len) { 	int i; 	for (i = 0; i<len; ++i) 	{ 		printf("请输入第%d个人的姓名：", i + 1); 		scanf("%s", &st[i].name); 		printf("请输入第%d个人的年龄：", i + 1); 		scanf("%d", &st[i].age); 		printf("请输入第%d个人的分数：", i + 1); 		scanf("%f", &st[i].score); 	} }  void output(struct student *st, int len) { 	int i; 	for (i = 0; i<len; ++i) 	{ 		printf("第%d个人的信息:\n", i + 1); 		printf("姓名：%s\n", st[i].name); 		printf("年龄：%d\n", st[i].age); 		printf("分数：%f\n", st[i].score); 	} }

给指针数组分配内存时要循环一个一个分配的

#include ＜stdio.h＞ #include ＜malloc.h＞ struct student { 	int age; 	char name[40]; 	float score; }; 	void intput(struct student **st, int len); 	void output(struct student **st, int len); int main (void) { 	int k; 	const int len=3; 	struct student *st[len];     for (k=0;k＜len;k++)     {     st[k]= (struct student * )malloc(sizeof (struct student) );     } 	intput(st, len); 	output(st, len); 	return 0; } void intput(struct student **st, int len) { 	int i; 	for (i=0; i＜len; ++i) 	{ 		printf("请输入第%d个人的姓名：", i+1); 		scanf("%s", &st[i]-＞name); 		printf("请输入第%d个人的年龄：", i+1); 		scanf("%d", &st[i]-＞age); 		printf("请输入第%d个人的分数：", i+1); 		scanf("%f", &st[i]-＞score); 		} } 		void output(struct student **st, int len) { 	int i; 	for (i=0; i＜len; ++i) 	{ 		printf("第%d个人的信息:\n", i+1); 		printf("姓名：%s\n", st[i]-＞name); 		printf("年龄：%d\n", st[i]-＞age); 		printf("分数：%f\n", st[i]-＞score); 	 } }

st是指向动态分配的内存空间的指针，然后在函数里改变指针指向的内存空间的内容，所以定义了形参是**类型。这个想法没问题吧？

是想把st定义成存储student指针的数组吗，在main中初始化st的时候要有两个*，然后传到函数中的时候不需要取地址符。 struct student **st = (struct student **)malloc(sizeof(struct student *) * len); st是一个一维数组，数组元素是student类型的指针。


Question: linux下的动态库为什么不需要lib文件

没有, 凑字, 凑字...    这也没啥用啊...

引用 3 楼 mLee79 的回复:ELF 本来就有加载视图和链接视图.   PE实际上也有的,  WIN 下 mingw32/gcc,  cygwin/gcc 都不用 .lib 就可以链接 dll,  即使你用 M$VC, 一个 dll你没lib的话, 你也可以从 dll 生成导入库 .lib 没有问题的, 我一般都用  mingw32 为开源库生成 dll,  手工生成 lib 在 M$VC 里用,  感觉就是 M$ 的人写 linker 的时候偷懒罢了...  windows下的#pragma可以写在文件内，不在链接时指定，linux有没有这种方式啊

引用 1 楼 zjq9931 的回复:有的，编译的时候不用def文件就可以不生成lib文件。 只要头文件就可以。  当然加载的时候要用显式加载。 不能用隐式加载了。  这是两个概念，和链接完全没关系，不知道windows平台的gcc支不支持这种


Question: 关键路径

代码发上来。。。。。。。。。。。。


Question: 如何用C语言创建Access数据库（mdb文件）

C不能调用ODBC吗？ ODBC不是C写的吗？

引用 1 楼 zhao4zhong1 的回复:调用ODBC ？    ODBC驱动管理器中， 可以选择 ACCESS odbc驱动，创建 空数据库， 想知道 C语言能实现access数据库创建吗？

调用ODBC ？


Question: 怎么实现把图的多条关键路径输出到显示页面上？在线等，，，，急急急

页面？参考HTML5！

用不同的存储方式会输出不同的拓扑序列，比如用栈和用队列的结果就不一样，可以理解成一个追求深度，一个追求广度……


Question: 电脑如何控制手机并收到手机上的声音

引用 1楼user-1 的回复:远程桌面类似的软件通常是需要流媒体的参与： 1. 手机端采集桌面进行视频编码,采集音频进行编码,根据通信协议所能承载的Container类型进行Mux，最后通过网络传出。 举个例子，抓取手机桌面，使用H.264格式编码；抓取音频信息，使用AAC编码；Mux为flv格式，通过rtmp协议传出 2. 电脑端则需要对应的接收通信协议传输过来的内容，Demux flv文件，解码音视频信息，最后播放呈现  为什么要压缩，因为原始数据很大，要去冗余。 为什么会卡顿，要么是传输码率大于带宽，来不及传输；要么是电脑解码慢；不过通常是前者可能性较大，降低分辨率，降低帧率等等即可如果采用vnc传输 怎样解决卡顿画面卡顿问题 声音不需要了 只需要解决画面卡顿 减少帧数吗


Question: 关于C Primer Plus一处疑问

引用 4 楼 zhu339111520 的回复:不这么写怎么显出与众不同呢，不这么写怎么来彰显自己的牛逼气息呢  牛逼不用显

引用 3 楼 gblhack 的回复:[quote=引用 1 楼 ipqtjmqj 的回复:] 上一行，printf里面 引用 2 楼 paschen 的回复:printf 里让number = i  确实是这样，作者为什么这样写呢，很容易让人忽略啊，我觉得这不是好习惯吧。[/quote]  那就建议分成两条语句写，毕竟代码是写给人看的

引用 3 楼 gblhack 的回复:[quote=引用 1 楼 ipqtjmqj 的回复:] 上一行，printf里面 引用 2 楼 paschen 的回复:printf 里让number = i  确实是这样，作者为什么这样写呢，很容易让人忽略啊，我觉得这不是好习惯吧。[/quote] number可以小于等于max, scanf("%lf", &ptd[i])不返回1时，循环就结束了

不这么写怎么显出与众不同呢，不这么写怎么来彰显自己的牛逼气息呢

引用 1 楼 ipqtjmqj 的回复:上一行，printf里面 引用 2 楼 paschen 的回复:printf 里让number = i  确实是这样，作者为什么这样写呢，很容易让人忽略啊，我觉得这不是好习惯吧。

printf 里让number = i

上一行，printf里面


Question: C语言求帮助，程序写完了，但这个报告怎么做？？？求帮助

你不是有 ①②③④。。。。 描述下功能就好了

做了什么不重要；重要的是如何包装成做了什么。

最多只能做到  // 程序入口点 void main()  卒于2017年1月3日，享年XX岁。


Question: C语言 如何解读下面程序 18行的bool有什么作用

就是记录当前输入 num 不是质数啊，注释里不是写了吗。


Question: 大神看过来！编写找出100以内的素数程序时，运行结果47后面为什么多出了换行

谢谢，我明白了

#include<stdio.h> #include<math.h> void main()  { int a[100]; int i,j=0,k; double b; printf("100以内的素数有：\n"); for(i=0;i<99;i++) { a[i]=i+2; b=sqrt(a[i]); for(k=2;k<=b;k++) 	if(a[i]%k==0)break; 		if(k>b) 		{ 			printf("%5d",a[i]); 			j=j+1; 		 		if(j%5==0) 			printf("\n"); 		}  } printf("\n");  }


Question: 字符简单问题

其实电脑开机后物理内存的每个字节都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。

我的头都转的脖子疼了。终于看明白题目了。 原因是越界了，建议使用strncpy strncpy(s1, s2, strlen(s1));有多少空间就能装多少字符，多了装不了溢出了。溢出没关系，不要溢到只读区域，不然就会出现段错误。所以，小心一些，strncpy比strcpy安全一些了。 不是所有情况都会出现段错误，但是溢出是必定的，你把这两个变量定义成全局的或者在栈上申请空间试试。有可能会拷贝成功。但是不建议这样做，只是作为一个尝试。

引用 楼主 w_linux 的回复:为什么77题答案是有可能导致数据错误，而不是B选项这个答案  用隐式长度定义数组，则必须给数组赋初始值，这样编译器会根据实际后面数值长度来给数组定长。 char s1[] = "That girl"; // 加上\0共10字节 char s2[] = "is beatiful";  // 加上\0共12字节 把s2的内容复制到s1中，导致数组越界，出现不可预测的问题。

字符数组越界是未定义行为

因为后者长度大于前者，后者复制到前者会跃出边界 可能导致程序崩溃，也可能导致不仅仅是s1中的数据被篡改  这个行为涉及到修改了别的内存

s1的长度未知，所以会导致数据错误。


Question: c语言数据的读取

引用 4 楼 qq_37235706 的回复:①	从文件中读入20位学生英语、体能、治安学三门课的成绩（每名学生成绩信息均包括姓名，学号，分数）。  ②编写查询函数，实现输入学生学号，输出该学生三门课的成绩的功能。 ③编写排序函数，采用冒泡法，将学生总成绩成绩按照从高到低进行排序，排序由排序函数实现，在主函数中调用实现排序，并在主函数中输出排序后的成绩单（要求用指针实现参数传递）。 ④编写插入函数，实现再输入一个学生三门课的成绩，将此学生总成绩按照排序规律插入原学生成绩数组。 ⑤将排好序的成绩单进行反序存放，即原来是总成绩从高到低，现在改为从低到高排列。      ⑥将以上程序结果打印输出，验证程序是否正确实现题目要求。 ⑦在项目报告中画出程序流程图，说明程序设计的算法，附主要程序段。 ⑧在项目报告中说明程序设计过程中的难点、解决办法及编程小结或体会。 大神我必定以高分相赠。急切谢谢 c++操作excel不是很灵活，可以改成读取csv文件， 另附一个大一时候得一个类似的作业， 可以参考，but，代码很烂，毕竟大一。。。

好像改了之后还是错误的

我这个题目就是在excel中旅读取20个学生成绩的题目，这该怎么写呢

是不是编译不过啊，你这一句 if((fg=fopen("学生成绩信息表.xls","r+"))==NULL ) 中的变量打错了，把fg改成fp


Question: c语言的字符串问题

恩，谢谢啦~

a[10] 只能赋值一个字符，况且你还越界了

引用 11 楼 qq_36380978 的回复:[quote=引用 10 楼 paschen 的回复:] [quote=引用 9 楼 qq_36380978的回复:][quote=引用 8 楼 paschen 的回复:] [quote=引用 7 楼 qq_36380978 的回复:] 那a=“abc”为什么也不可以呢？  a不是指针，是数组，数组不允许这样赋值，指针就可以  数组要用strcpy[/quote]  可a不是地址么？我的理解是将字符串的第一个字符的地址付给a。。。为什么这样就不对呢？[/quote] a是数组，不是指针，数组名可以退化为指针，但数组不是指针[/quote]，糊涂了，，，，，[/quote]  你要指针写成char* a;  总之记住，数组不是指针  数组没有 a= "123" 这种赋值方法

引用 10 楼 paschen 的回复:[quote=引用 9 楼 qq_36380978的回复:][quote=引用 8 楼 paschen 的回复:] [quote=引用 7 楼 qq_36380978 的回复:] 那a=“abc”为什么也不可以呢？  a不是指针，是数组，数组不允许这样赋值，指针就可以  数组要用strcpy[/quote]  可a不是地址么？我的理解是将字符串的第一个字符的地址付给a。。。为什么这样就不对呢？[/quote] a是数组，不是指针，数组名可以退化为指针，但数组不是指针[/quote]，糊涂了，，，，，

引用 9 楼 qq_36380978的回复:[quote=引用 8 楼 paschen 的回复:] [quote=引用 7 楼 qq_36380978 的回复:] 那a=“abc”为什么也不可以呢？  a不是指针，是数组，数组不允许这样赋值，指针就可以  数组要用strcpy[/quote]  可a不是地址么？我的理解是将字符串的第一个字符的地址付给a。。。为什么这样就不对呢？[/quote] a是数组，不是指针，数组名可以退化为指针，但数组不是指针

引用 8 楼 paschen 的回复:[quote=引用 7 楼 qq_36380978 的回复:] 那a=“abc”为什么也不可以呢？  a不是指针，是数组，数组不允许这样赋值，指针就可以  数组要用strcpy[/quote]  可a不是地址么？我的理解是将字符串的第一个字符的地址付给a。。。为什么这样就不对呢？

引用 7 楼 qq_36380978 的回复:那a=“abc”为什么也不可以呢？  a不是指针，是数组，数组不允许这样赋值，指针就可以  数组要用strcpy

那a=“abc”为什么也不可以呢？

数组名是数组的首地址，是一个常量，可以给该地址的内存单元（数组第一个元素）赋值，不能改变该常量，常量没有内存空间存你要赋的值。  和指针的区别：指针本身也是一个变量，在内存中有自己的空间，来存放所指向内容的地址。所以指针可以为左值，数组名不可以

a[10] 表示的是字符串中的第11个字符  你只能在声明时这样用

语法规则而已 见其他楼！！

char a[10]="abc"是字符数组初始化同时赋值abc缺省了7个字符，char a[10];    //定义字符数组，a[10]=“abc”是给数组第10个元素赋值，数组下标最大是9，溢出了。

这样不合法呀

这是规定，字符串的初始化和平常一样，但是赋值需要调用strcpy函数


Question: 求助

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

fscanf是读文本，fread是读二进制，这两个一般不会混用在同一个文件里吧，除非你的文件就是第一个元素是文本，后面的都是二进制那么存的

如果你代码没问题，那就是在fscanf和fread之间fclose再fopen一下（这样才能把缓存中的数据真正写入到文件中）

引用 1 楼 user-4 的回复: struct student     {     char name[20];     int no;     int score[3];     int yingyu;     int tineng;     int zhian; } stud[SIZE];   文件的格式和读取格式要匹配。


Question: 无法调用自己写的函数用的vs2008

将所有源文件的扩展名由.c改为.cpp再试试。

还是不行啊。

//不需要这些 //#ifdef  __cplusplus //extern "C" { //#endif     //创建并返回一个空线性表     extern SeqList* Seqlist_Creat(int capacity);     //销毁一个线性表     extern void SeqList_Destroy(SeqList *list);     //将一个线性表list中所有元素清空，线性表回到创建时初始状态     extern void SeqList_Clear(SeqList *list);       extern int SeqList_Length(SeqList* List);       extern int SeqList_Capacity(SeqList* List);       extern int SeqList_Insert(SeqList* List, SeqListNode* node, int pos);       extern SeqListNode* SeqList_Get(SeqList* list, int pos);       extern SeqListNode* SeqList_Delete(SeqList* list, int pos);           //#ifdef  __cplusplus //} //#endif

工程中添加已有文件试试


Question: 在C语言中如何用全零表示零

浮点数格式 http://bbs.csdn.net/topics/390676437

用浮点数表示，尾数用补码表示（0.00000000）阶码用移码表示（0 00000在补码中1.00000表示负一，在用移码表示，加上2^n为0.00000）


Question: 关于全局变量！！！

楼主看下，在另一个函数使用len的值之前，是否已经调用了给len赋值的函数。  如果没有在使用之前调用赋值的函数，那么值是不会改变的。  #include <stdio.h>  int len = 0;  void setLen() { 	len = 100; }  void useLen() { 	len += 20; }  void main() { 	setLen(); 	useLen(); 	printf("%d\n",len); }


Question: 怎么得出Arduino IMU的三个数据，我弄了很久都没搞出来

VS IDE中，在不明白的符号上点鼠标右键，选转到定义或查找所有引用。


Question: 一个转义的问题

提醒：sscanf是开源的。 参考：C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\input.c

引用 7 楼 neunap 的回复:引用 楼主 kinolukaslana 的回复:源代码：  #include<stdio.h> int main() { 	char a[10] = { "\0" }; 	sscanf("qweiorewq","%*[^e]%[^w]",a); 	printf("%s", a); 	return 0; } 问题来了： 如果在转义哪里第一个[]里改成q或者w，就没有任何显示，求解？！  先说明一下，捕获的前提是每一项都需要匹配成功，才能够正常继续下一项匹配，如果匹配不成功，后续的匹配不会继续进行 比如，int a; char b[100];你需要捕获scanf("%d%s"， &a, b);但是实际输入的字符串是123 456（空白符在匹配%d时会忽略掉，这样会正常捕获123和"abc"，但是如果你输入的是h123 456，这样第一项就没有匹配成功，是不会再向后匹配的，这只能说明你要求的输入格式和实际输入格式不匹配。   sscanf("qweiorewq","%*[^e]%[^w]",a); %*[^e]：捕获到"qw"，因为带'*'，所以捕获之后舍弃 %[^w]：捕获到"eiore"，正常输出   sscanf("qweiorewq","%*[^q]%[^w]",a); %*[^q]：捕获不到数据，输入格式不匹配，直接退出 %[^w]：不进行捕获   sscanf("qweiorewq","%*[^w]%[^w]",a); %*[^w]：捕获不到数据，输入格式不匹配，直接退出 %[^w]：不进行捕获  引用 5 楼 kinolukaslana 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] An asterisk (*) following the percent sign suppresses assignment of the next input field, which is interpreted as a field of the specified type. The field is scanned but not stored.但是老师，这个*不储存输入缓冲区的输入我理解，但是为什么我吧后面^也就是相反储存的不为^后面的字符，加上前面的*就是读取但是不储存，但是问题在于我把^后面的字符改成string的前两个就会整个string都不读取，意思就是后面的那个%就没有任何作用了，为什么会这样？   先说明一下，捕获的前提是每一项都需要匹配成功，才能够正常继续下一项匹配，如果匹配不成功，后续的匹配不会继续进行 比如，int a; char b[100];你需要捕获scanf("%d%s"， &a, b);但是实际输入的字符串是123 456（空白符在匹配%d时会忽略掉，这样会正常捕获123和"abc"，但是如果你输入的是h123 456，这样第一项就没有匹配成功，是不会再向后匹配的，这只能说明你要求的输入格式和实际输入格式不匹配。   sscanf("qweiorewq","%*[^e]%[^w]",a); %*[^e]：捕获到"qw"，因为带'*'，所以捕获之后舍弃 %[^w]：捕获到"eiore"，正常输出   sscanf("qweiorewq","%*[^q]%[^w]",a); %*[^q]：捕获不到数据，输入格式不匹配，直接退出 %[^w]：不进行捕获   sscanf("qweiorewq","%*[^w]%[^w]",a); %*[^w]：捕获到"q"，因为带'*'，所以捕获之后舍弃 %[^w]：捕获不到数据，输入格式不匹配，直接退出[/quote] 谢谢！昨天晚上我自己突然想通了，解释很详细！

引用 楼主 kinolukaslana 的回复:源代码：  #include<stdio.h> int main() { 	char a[10] = { "\0" }; 	sscanf("qweiorewq","%*[^e]%[^w]",a); 	printf("%s", a); 	return 0; } 问题来了： 如果在转义哪里第一个[]里改成q或者w，就没有任何显示，求解？！  先说明一下，捕获的前提是每一项都需要匹配成功，才能够正常继续下一项匹配，如果匹配不成功，后续的匹配不会继续进行 比如，int a; char b[100];你需要捕获scanf("%d%s"， &a, b);但是实际输入的字符串是123 456（空白符在匹配%d时会忽略掉，这样会正常捕获123和"abc"，但是如果你输入的是h123 456，这样第一项就没有匹配成功，是不会再向后匹配的，这只能说明你要求的输入格式和实际输入格式不匹配。   sscanf("qweiorewq","%*[^e]%[^w]",a); %*[^e]：捕获到"qw"，因为带'*'，所以捕获之后舍弃 %[^w]：捕获到"eiore"，正常输出   sscanf("qweiorewq","%*[^q]%[^w]",a); %*[^q]：捕获不到数据，输入格式不匹配，直接退出 %[^w]：不进行捕获   sscanf("qweiorewq","%*[^w]%[^w]",a); %*[^w]：捕获不到数据，输入格式不匹配，直接退出 %[^w]：不进行捕获  引用 5 楼 kinolukaslana 的回复:引用 3 楼 zhao4zhong1 的回复:An asterisk (*) following the percent sign suppresses assignment of the next input field, which is interpreted as a field of the specified type. The field is scanned but not stored.但是老师，这个*不储存输入缓冲区的输入我理解，但是为什么我吧后面^也就是相反储存的不为^后面的字符，加上前面的*就是读取但是不储存，但是问题在于我把^后面的字符改成string的前两个就会整个string都不读取，意思就是后面的那个%就没有任何作用了，为什么会这样？   先说明一下，捕获的前提是每一项都需要匹配成功，才能够正常继续下一项匹配，如果匹配不成功，后续的匹配不会继续进行 比如，int a; char b[100];你需要捕获scanf("%d%s"， &a, b);但是实际输入的字符串是123 456（空白符在匹配%d时会忽略掉，这样会正常捕获123和"abc"，但是如果你输入的是h123 456，这样第一项就没有匹配成功，是不会再向后匹配的，这只能说明你要求的输入格式和实际输入格式不匹配。   sscanf("qweiorewq","%*[^e]%[^w]",a); %*[^e]：捕获到"qw"，因为带'*'，所以捕获之后舍弃 %[^w]：捕获到"eiore"，正常输出   sscanf("qweiorewq","%*[^q]%[^w]",a); %*[^q]：捕获不到数据，输入格式不匹配，直接退出 %[^w]：不进行捕获   sscanf("qweiorewq","%*[^w]%[^w]",a); %*[^w]：捕获到"q"，因为带'*'，所以捕获之后舍弃 %[^w]：捕获不到数据，输入格式不匹配，直接退出

引用 1 楼 adusuccessfully 的回复:请教下楼主，scanf那句怎么理解呢？？赵老师回答的很准确

谢谢楼上赵老师！

To read strings not delimited by space characters, a set of characters in brackets ([ ]) can be substituted for the s (string) type character. The corresponding input field is read up to the first character that does not appear in the bracketed character set. If the first character in the set is a caret (^), the effect is reversed: The input field is read up to the first character that does appear in the rest of the character set.  Note that %[a-z] and %[z-a] are interpreted as equivalent to %[abcde...z]. This is a common scanf function extension, but note that the ANSI standard does not require it.

请教下楼主，scanf那句怎么理解呢？？


Question: 有关二叉树的先序创建如何停止的问题

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

仅供参考：#include <iostream> #include <stack> #include <queue> #include <locale.h> using namespace std; typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int CreateBiTree(BiTree &T) {//按先序序列创建二叉树     char data;     scanf("%c",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         T = NULL;     } else {         T = (BiTree)malloc(sizeof(BiTNode));         T->data = data;         //生成根结点         CreateBiTree(T->lchild);//构造左子树         CreateBiTree(T->rchild);//构造右子树     }     return 0; } void Visit(BiTree T) {//输出     if (T->data != '#') {         printf("%c ",T->data);     } } void PreOrder(BiTree T) {//先序遍历     if (T != NULL) {         Visit(T);               //访问根节点         PreOrder(T->lchild);    //访问左子结点         PreOrder(T->rchild);    //访问右子结点     } } void InOrder(BiTree T) {//中序遍历     if (T != NULL) {         InOrder(T->lchild);     //访问左子结点         Visit(T);               //访问根节点         InOrder(T->rchild);     //访问右子结点     } } void PostOrder(BiTree T) {//后序遍历     if (T != NULL) {         PostOrder(T->lchild);   //访问左子结点         PostOrder(T->rchild);   //访问右子结点         Visit(T);               //访问根节点     } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。     stack<BiTree> stack;     BiTree p = T;//p是遍历指针     while (p || !stack.empty()) {   //栈不空或者p不空时循环         if (p != NULL) {             stack.push(p);          //存入栈中             printf("%c ",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             p = stack.top();        //退栈             stack.pop();             p = p->rchild;          //访问右子树         }     } } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     stack<BiTree> stack;     BiTree p = T;//p是遍历指针     while (p || !stack.empty()) {   //栈不空或者p不空时循环         if (p != NULL) {             stack.push(p);          //存入栈中             p = p->lchild;          //遍历左子树         } else {             p = stack.top();        //退栈，访问根节点             printf("%c ",p->data);             stack.pop();             p = p->rchild;          //访问右子树         }     } }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     stack<BiTreePost> stack;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || !stack.empty()) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack.push(BT);             p = p->lchild;         }         while (!stack.empty() && (stack.top())->tag == 'R') {//左右子树访问完毕访问根节点             BT = stack.top();             stack.pop();//退栈             printf("%c ",BT->biTree->data);         }         if (!stack.empty()) {//遍历右子树             BT = stack.top();             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     } }  void LevelOrder(BiTree T) {//层次遍历     if (T == NULL) return;     BiTree p = T;     queue<BiTree> queue;//队列     queue.push(p);//根节点入队     while (!queue.empty()) {    //队列不空循环         p = queue.front();      //对头元素出队         printf("%c ",p->data);  //访问p指向的结点         queue.pop();            //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue.push(p->lchild);         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue.push(p->rchild);         }     } } int main() {     BiTree T;      setlocale(LC_ALL,"chs");     CreateBiTree(T);      printf("先序遍历        ：");PreOrder  (T);printf("\n");     printf("先序遍历(非递归)：");PreOrder2 (T);printf("\n");                                                printf("\n");     printf("中序遍历        ：");InOrder   (T);printf("\n");     printf("中序遍历(非递归)：");InOrder2  (T);printf("\n");                                                printf("\n");     printf("后序遍历        ：");PostOrder (T);printf("\n");     printf("后序遍历(非递归)：");PostOrder2(T);printf("\n");                                                printf("\n");     printf("层次遍历        ：");LevelOrder(T);printf("\n");      return 0; } //ABC##DE#G##F### //先序遍历        ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历        ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历        ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历        ：A B C D E F G //  ///       A ///      / ///     B ///    / \ ///   C   D ///      / \ ///     E   F ///      \ ///       G

引用 2 楼 qq_36409192 的回复:严格上来讲，这样创建二叉树是不对的。正如你所说，如果我需要二叉树的值为#，这个时候这样创建二叉树就不行了，但是，这种递归建立二叉树其实就只是想告诉你，在最后的叶子结点，我需要一个出口而已，并不一定是要用#符号的，楼主没必要纠结这里，弄懂了就可以。  那怎么样才能设置一个不与任何符号重合的出口呢？ 比如说Elemtpye是int的话，一般都是用-1或0什么的作为停止标志，可是如果这时候要输入的范围是整数范围，也就是0和-1都可以当做值，这样的话该怎么建树？ 万分感谢！

引用 1 楼 jianwen0529 的回复:#既然能作为值，那你就不应该换一个字符作为终止符号吗  呃，可是有的时候不知道什么符号就会用上啊。假如Elemtype是int的话，而将要输入的值的范围是全体整数，这个时候怎么设置终止符号？

引用 4 楼 talentxt 的回复:[quote=引用 2 楼 qq_36409192 的回复:] 严格上来讲，这样创建二叉树是不对的。正如你所说，如果我需要二叉树的值为#，这个时候这样创建二叉树就不行了，但是，这种递归建立二叉树其实就只是想告诉你，在最后的叶子结点，我需要一个出口而已，并不一定是要用#符号的，楼主没必要纠结这里，弄懂了就可以。  那怎么样才能设置一个不与任何符号重合的出口呢？ 比如说Elemtpye是int的话，一般都是用-1或0什么的作为停止标志，可是如果这时候要输入的范围是整数范围，也就是0和-1都可以当做值，这样的话该怎么建树？ 万分感谢！[/quote] 如果你输入的是int型的数，那么你在定义ch的时候，你定义成char型，然后(*T)->data = ch-‘0’;就可以了，结束的标志为任意一个不是数字符的符号就可以了，比如#。

#既然能作为值，那你就不应该换一个字符作为终止符号吗