Question: 运行代码总是停止工作，求指导

引用 3 楼 cfjtaishan 的回复:建议你添加输出信息，然后根据输出信息一步一步的调试； 或者将你的demo文件（要读取的文件）发出来（不要图片形式），我帮你调试一下；已解决谢谢！

这是output里面到达特定字符串的位置，下面一行一行的数据就是要收集的

仅供参考：//NAME: essaie bla bla //DIMENSION: 8 //DATA //1  14  15 //2  11  10 //3  6   4 //4  7   13 //5  9   21 //6  19  3 //7  1   5 //8  8   8 //EOF // // 文本文件中可能还含有其他内容，但是需要用到的内容即以上  //比如data.txt: //NAME: essaie bla bla //其它内容 //DIMENSION: 8 //其它内容 //DATA //其它内容 //1  14  15 //其它内容 //2  11  10 //其它内容 //3  6   4 //其它内容 //4  7   13 //其它内容 //5  9   21 //其它内容 //6  19  3 //其它内容 //7  1   5 //其它内容 //8  8   8 //其它内容 //EOF  // 目标是要获取NAME后字串，DIMENSION后数值，以及DATA以下的数值 // 其中NAME就是随便个字句，DIMENSION是城市数量，DATA以下是城市编号，X坐标，Y坐标 // 所有的这些将赋值给一个事先定义好的结构 #include <stdio.h> #include <string.h> #define MAXCPL   80   //每行最大字符数 #define MAXCITY  100  //每组数据中DATA最多项数，DIMENSION的最大值 #define MAXNAMEL 32   //NAME最大长度 struct S {     char NAME[MAXNAMEL+1];     int  DIMENSION;     struct D {         int NO;         int X;         int Y;     } DATA[MAXCITY]; } s; FILE *f; int st,n,i; char ln[MAXCPL]; int main() {     f=fopen("data.txt","r");     if (NULL==f) {         printf("Can not open file data.txt!\n");         return 1;     }     st=0;     n=0;     while (1) {         if (NULL==fgets(ln,MAXCPL,f)) break;         if (st==0) {             if (1==sscanf(ln,"NAME: %31[^\n]",s.NAME)) st=1;         } else if (st==1) {             if (1==sscanf(ln,"DIMENSION: %d",&s.DIMENSION)) st=2;         } else if (st==2) {             if (0==strcmp(ln,"DATA\n")) st=3;         } else if (st==3) {             if (3==sscanf(ln,"%d%d%d",&s.DATA[n].NO,&s.DATA[n].X,&s.DATA[n].Y)) {                 n++;                 if (n>=MAXCITY || n>=s.DIMENSION) break;             }         }     }     fclose(f);     printf("s.NAME=[%s]\n",s.NAME);     printf("s.DIMENSION=%d\n",s.DIMENSION);     for (i=0;i<n;i++) {         printf("s.DATA[%d].NO,X,Y=%d,%d,%d\n",i,s.DATA[i].NO,s.DATA[i].X,s.DATA[i].Y);     }     return 0; } //s.NAME=[essaie bla bla] //s.DIMENSION=8 //s.DATA[0].NO,X,Y=1,14,15 //s.DATA[1].NO,X,Y=2,11,10 //s.DATA[2].NO,X,Y=3,6,4 //s.DATA[3].NO,X,Y=4,7,13 //s.DATA[4].NO,X,Y=5,9,21 //s.DATA[5].NO,X,Y=6,19,3 //s.DATA[6].NO,X,Y=7,1,5 //s.DATA[7].NO,X,Y=8,8,8


Question: 这个怎么用C编啊

int sum=0,i; for(i=0;i<100;i++) { sum+=a[i]-b[i]; }

题目错了还是就是第二个是b1-a1，这样就控制下正负号就行了

多看看书吧，基本啊

楼上少个引号

int sum=0; for(i=0;i<=99;i++) {            sum+=a[i]-b[i]   }

对应输入，然后循环相减（a[i] -= b[i] )，最后用循环把a数组的值相加就可以了。


Question: 一个关于指针和数组的问题

cfjtaishan的说法正确。但都没有说出问题关键：a是数组名，是常量，不能取地址。就像&123，是错的。常量也不接受赋值。就像不能1=2。

类型不匹配，p和a是相同类型的，一个是数组名（数组的首地址）可以看作是指针常量（不能做左值），若a是一维数组，就是一重指针常量。

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

第二种说法完全不对。第一种说法需要稍微改一下： &a为a的地址，a是一个数组，要如此做的话p需为指向数组的指针。  顺便楼上说数组就是指针的，请自行试验以下代码：  int a[42]; int **p = &a;

p是一个指针变量，应该给它赋一个地址值，一维数组名本身就是代表数组的首地址，所以p=a;    即可

数组退化后就是指针。p=&a表示p要指向a的地址，而a本来就是一个指针，所以需要一个二级指针才能指向a的地址。


Question: 内存的移位操作

建议将固定数以二进制数表示放到一个二进制数组里，然后对该这个数组进行移位，最后将数组转换成移位后的数值。

SHL		逻辑左移. 	SAL		算术左移.(=SHL) 	SHR		逻辑右移. 	SAR		算术右移.(=SHR) 	ROL		循环左移. 	ROR		循环右移. 	RCL		通过进位的循环左移. 	RCR		通过进位的循环右移. 			  以上八种移位指令,其移位次数可达255次. 			  移位一次时, 可直接用操作码. 如 SHL AX,1. 			  移位>1次时, 则由寄存器CL给出移位次数. 			  如 MOV CL,04	SHL	AX,CL


Question: C语言读入TXT文件并输入结构体中，忽略空格

#include <iostream> #include <string> #include <fstream> using namespace std;  int main(int argc, char* args[]) {     string file="123.txt";     std::fstream input(file);     if (!input.is_open())     { 	  std::cout << "Error opening file"; exit(1);     }     while (!input.eof())     { 	  char buffer[256] = { 0 }; 	  input.getline(buffer, 64); 	  std::cout << buffer << std::endl;     }      input.close();      system("pause");     return 0; }

在循环中 用fgets一行一行地读,然后用strtok分解空格得到各个字符串再放到结构体对应成员中.  我没做过,我想的.


Question: 俩字符数组名比较大小的含义

比较数组首元素的地址值，如果你需要比较ASCII，使用strcmp函数比较，或者把数组换为string类型

你用的是 char 数组，那么 s1、s2 会退化为指针，比较的结果就是恒定的，即比较其地址（指针）。 如果你用的是 string、CString 之类的，则比较运算符会被重载，这样是逐字符比较 ascii 码，同 strcmp。

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

引用 楼主 qq_38179971 的回复:#include<iostream> using namespace std; int main() { 	char s1[20],s2[20],s3[20]; 	cin>>s1>>s2; 	if(s1<s2)cout<<s1; 	else cout<<s2;  	 	return 0;   }   输入:gejianping【回车】jiang 输出:jiang  输入:ge【回车】jiang 输出:jiang   由上得出if(s1<s2)既不是比较首字母ascii码的大小也不是比较字符串的大小，那是比较什么呢？ 比较的是地址值，因为s1和s2分别表示两个数组的首地址。在内存中表示两个地址值。


Question: 坛子里的大神可以解释下原因吗？

#include<stdio.h>  int change(double x) { 	return (int)(x+0.5); }  int main() { 	double a = 26.5; 	double b = 10.0; 	printf("%lf\n", a / b); 	printf("%d\n", (int)((a / b - (int)(a / b)) * 100)); 	printf("%d\n", (int)((2.65-2 )* 100)); 	printf("%d\n",change((a / b - (int)(a / b)) * 100));	     return 0; }

浮点数转整型存在精度丢失问题，所以要么根据自己的需求自己实现一个转换函数，要么就全部用浮点数  #include<stdio.h>  int main() {     double a = 26.5;     double b = 10.0;     printf("%.30f\n",(2.65-2)*100);     return 0; }

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

很多十进制可以精确表示的小数都不能在二进制下精确表示  2.65 在内存中存储的二进制对应的十进制实际是：2.6499999999999999  转换int 是直接截断，所以结果是64  如果需要65，需要四舍五入，而不是直接转换成int


Question: 关于函数调用的问题

Lc=Lb;//加这句 MergeList_Sq(La,Lb,Lc);


Question: codeblocks mac频繁闪退

https://pan.baidu.com/s/1qYlT4Ck 如果还闪退，要么是系统有问题。


Question: 求大神帮忙

#include <stdio.h> #include <string.h>  void ps(char b[][20],int n);  int main(void) {     char p[10][20] = {         "Aafhghk", "Bbgjfjghkkh",         "Ccdfggkgdfhff", "Dfdhj",         "Egdfhd","Fsrb",         "Jdfghhk","Hfggkghhfrthfj",         "Gdfghkhfdgh","Wfdhfhjhg"     };     int i;      for(i=0;i<10;i++)         printf("%s\n", *(p+i));   /* *(p+i) is equal p[i] */     printf("\n");      ps(p, 10);     for(i=0;i<10;i++)         printf("%s\n", *(p+i));    /* *(p+i) is equal p[i] */      return 0; } void ps(char b[][20], int n) {     char s[20];     int r,i;      while(n!=0)     {         n--;         for(i=0;i<n-1;i++)         {             r = strcmp(b[i], b[i+1]);             if(r>=1)             {                 strcpy(s, b[i]);                 strcpy(b[i], b[i+1]);                 strcpy(b[i+1], s);             }         }     } }  加头文件string.h，输出时有问题，*(p+i)或者p[i]； 排序没问题

我好像头文件写错了。

单步跟踪程序运行，观察变量变化情况，分析原因


Question: 对结构体数组取地址问题

引用 7 楼 user-3 的回复:你这里只是一个结构体对象，而不是结构体  [quote=引用 6 楼 znevq 的回复:] [quote=引用 3 楼 user-3 的回复:] 你这里的arrowA只是一个结构体对象，而不是结构体数组  printf("%x\n", arrowA); 相当于只是将arrowA这个对象当十六进制整数来输出，仅取了第一个成员的成员的值  printf("%x\n", &arrowA); 则是输出这个对象的地址  老师您好，这样应该是结构体数组了吧，但结果还是一样的呀： str_A arrowA[2] = {     {&a,     &b,     &c,     &d},     {&a,     &b,     &c,     &d} }str_A;[/quote]  这不是结构体数组，只是初始结构体对象中的成员变量而已[/quote]   老师，您好，请问下面这个定义不是一个结构体数组吗？ 我一直以为是有两个相同类型的结构体成员的结构体数组啊？  str_A arrowA[2] = {      {&a,      &b,      &c,      &d},      {&a,      &b,      &c,      &d}  }

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！

str_A arrowA[2] = {      {&a,      &b,      &c,      &d},      {&a,      &b,      &c,      &d}  }   这样应该是结构体数组了吧？ 结果一样呀？

结构体变量地址和结构体地址的问题；  printf("%x\n", arrowA);输出的是结构体变量arrowA的值，不过这儿应该是指定结构体中的某个成员，结构体变量本身无法输出。  printf("%x\n", &arrowA); 输出的是全局变量arrayA的地址。

你这里只是一个结构体对象，而不是结构体  引用 6 楼 znevq 的回复:[quote=引用 3 楼 user-3 的回复:] 你这里的arrowA只是一个结构体对象，而不是结构体数组  printf("%x\n", arrowA); 相当于只是将arrowA这个对象当十六进制整数来输出，仅取了第一个成员的成员的值  printf("%x\n", &arrowA); 则是输出这个对象的地址  老师您好，这样应该是结构体数组了吧，但结果还是一样的呀： str_A arrowA[2] = {     {&a,     &b,     &c,     &d},     {&a,     &b,     &c,     &d} }str_A;[/quote]  这不是结构体数组，只是初始结构体对象中的成员变量而已

引用 3 楼 user-3 的回复:你这里的arrowA只是一个结构体对象，而不是结构体数组  printf("%x\n", arrowA); 相当于只是将arrowA这个对象当十六进制整数来输出，仅取了第一个成员的成员的值  printf("%x\n", &arrowA); 则是输出这个对象的地址  老师您好，这样应该是结构体数组了吧，但结果还是一样的呀： str_A arrowA[2] = {     {&a,     &b,     &c,     &d},     {&a,     &b,     &c,     &d} }str_A;

求大神解疑呀

str_A arrowA[2] = {     {&a,     &b,     &c,     &d},     {&a,     &b,     &c,     &d}, }str_A;  也是一样的结果呀？ 这个是结构体数组了吧！？

http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

我的理解是：     printf("%x\n", arrowA); //输出arrowA的第一个元素的值     printf("%x\n", &arrowA); //输出arrowA的数组地址(第一个元素的地址)  但是不知道原因，为什么会这样？


Question: 泣血跪求！！！！#include的问题

#include<complex>  复数使用的是 C++，所以包含的头文件是没有 .h 后缀的。

忘了说了，我用的编译器是visual studio 2013

引用 1 楼 user-3 的回复:编译选项加上 -std=c99 试试  在哪儿加啊，小弟C玩的不是很6

编译选项加上 -std=c99 试试


Question: 指向字符数组的指针指针问题

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

char   Binary_Command[]="1234578963214587\0"; 字符串最后的'\0'不需要加，因为字符串结束标记是自动加的，它会占用数组的一个字节。 在Linux下不会出现这个问题。理论上输入字符串，只有遇到'\0'才会结束，否则不会自动截断字符串的。应该是其他原因；

代码全部贴出来

引用 7 楼 Janxionwang 的回复:指针定义改成这样：char *p = new char[20]();别乱改

指针定义改成这样：char *p = new char[20]();

应该不会出现你说的问题，试下输出Binary_Command的结果是什么，再看下生成的汇编代码

这个不会有问题吧，能具体讲一下你的问题吗？

我在CCS3.0和VC6.0上编写都没有问题，在CCS5.0上就出现这个问题

确实特殊并且神奇。把P初始化null一下看看。不会编译器作怪吧


Question: 没有办法了，大神们看下顺序表的问题

引用 6楼自信男孩 的回复:#include<stdio.h> #include<string.h> #include<stdlib.h> #include<malloc.h>  #define STU_NUM 100  typedef struct L l;  struct L {      int no[STU_NUM];     int b;     int c;     char name[STU_NUM][32];     int age[STU_NUM]; };  void init_info(l *p, int n) {     p->b = 0;     p->c = n; }  int insert_info(l *p, int no, char *T, int w, int j) {     int i;      if(p->c == p->b)         return -1;     if(j < 0)         j = 0;     if(j > p->b)         j = p->b;      for(i = p->b-1; i >= j; i--)     {         p->no[i+1] = p->no[i];         strcpy(p->name[i+1], p->name[i]);         p->age[i+1] = p->age[i];     }     p->no[j] = no;     strcpy(p->name[j], T);     p->age[j] = w;     p->b++;      return 0; } void show_info(l *p) {     int i;      for (i = 0; i < p->b; i++)     {         printf("学号：%d\n",p->no[i]);          printf("姓名：%s\n",p->name[i]);         printf("年龄：%d\n",p->age[i]);      }  } int search_info(l *p,int i) {     int q;     for(q=0;q<p->b;q++)         if(p->no[q] == i)             return q;     return -1; } int del_as_no(l *p, int no) {     int i, j;      for (i = 0; i < p->b; i++)         if(p->no[i] == no)             break;     if (i < p->b)     {         for (j = i; j < p->b-1; j++) {             p->no[j]=p->no[j+1];             strcpy(p->name[j], p->name[j+1]);             p->age[j] = p->age[j+1];         }         p->b--;          return i;     }     return 0; } int del_as_idx(l *p, int idx) {     int i;      if (idx < 0 || idx > p->b) {         printf("位置错误！\n");         return -1;     }     for (i = idx; i < p->b-1; i++) {         p->no[i] = p->no[i+1];         strcpy(p->name[i], p->name[i+1]);         p->age[i] = p->age[i+1];     }     p->b--;      return 0; } int main() {     l pp;     int q,t;     int item;     int A,C;      char name[32];      printf("元素地址为%p\t元素长度为%d\t元素个数为%d\n", pp.no, pp.b, pp.c);     init_info(&pp, STU_NUM);      printf("元素地址为%p\t元素长度为%d\t元素个数为%d\n", pp.no,pp.b,pp.c);     for (;;) {         printf("1、插入元素\t2、查找元素\t3、删除指定元素\t4、删除指定元素位置\t0、结束\n");          scanf("%d", &item);         if(item==1)         {             while(1)             {                 printf("请输入学号\n");                 fflush(stdin);                 scanf("%d", &A);                 if(A == 0)                     break;                 printf("请输入姓名\n");                 fflush(stdin);                 scanf("%s", name);                 if (strlen(name) <= 0)                     break;                 printf("请输入年龄\n");                 fflush(stdin);                 scanf("%d", &C);                 if(C == 0)                     break;                 printf("请输入插入位置！\n");                 fflush(stdin);                 scanf("%d", &t);                 insert_info(&pp, A, name, C, t-1);                  printf("学生信息管理系统:\n");                  show_info(&pp);               }         }         if(item == 2)         {             while(1)             {                 printf("请输入查找元素值，输入0结束查找操作！\n");                 fflush(stdin);                 scanf("%d",&q);                 if(q==0)                     break;                 t = search_info(&pp, q);                 if(t < 0)                     printf("没有找到满足条件的元素值!\n");                 else                      printf("找到满足条件的元素值，位置为%d\n",t+1);               }         }         if(item == 3)         {             while(1)             {                 printf("请输入删除元素值，输入0结束删除操作！\n");                 fflush(stdin);                 scanf("%d",&q);                 if(q==0)                     break;                 t = del_as_no(&pp, q);                 if(t<0)                     printf("没有找到符合条件的元素值！\n");                 else                 {                     printf("找到满足条件的元素值，位置为%d",t+1);                     printf("线性表为：\n");                     show_info(&pp);                 }             }         }         if(item==4)         {             while(1)             {                 printf("请输入删除元素位置，输入0结束删除操作！\n");                 fflush(stdin);                 scanf("%d",&t);                 if(t==0)                     break;                 q = del_as_idx(&pp,t);                 if (q < 0) {                     printf("没有找到符合人条件的元素值!\n");                 } else {                     printf("找到符合人条件的元素值，位置为%d",t+1);                     printf("线性表为：\n");                     show_info(&pp);                 }             }          }         if(item==0)             exit(0); }     return 0; } 函数使用f1,f2,f3...，我估计你过段时间再看这部分代码你也不知道f1,f2,f3...表示啥？ 代码写出来除了要实现对应的功能也是让别人看的，让别人去帮你看也要别人首先了解你的代码功能，但是使用这样的函数名，谁看了都费解。总之，变量名和函数名一定要做到见名知义，如果想继续编程，或走的更远建议遵循这条规则。 代码风格建议注意下，该加空格的要加空格，该回车的要回车。 name不能直接赋值，但是可以借助库函数实现，比如strcpy，strncpy等等 改了许多，暂不一一罗列了，请查看上面的代码，有问题可以继续提出来。谢谢

我擦，这么长。。

值传递   然并卵 嘿嘿

这很难么？，，

printf("元素地址为%d\t元素长度为%d\t元素个数为%d\n",pp.a,pp.b,pp.c);   这句pp没初始化就使用了

引用 1楼赵4老师 的回复:char *T定义指针取地址？

char *T


Question: 求出-10到30之内能被7或11整除，但不能同时被7或11整除的所有整数

if( ( i % 7 == 0 || i % 11 == 0 ) && ( !(  i % 7 == 0 && i % 11 == 0 ) ) )

写if((i%7==&&i%11!=0)||(i%7!=0&&i%11==0))

引用 2 楼 qq_31989333 的回复:[quote=引用 楼主 qq_38172134 的回复:] #include<stdio.h> main() { int i; for(i=-10;i<=30;i++) { if(i%7==0||i%11==0) (不知道填什么!=0) { printf("%d,",i); }  }  } -10到30之间也不存在这样的数字呀,你可以扩大一下范围,在纸上算出来这些数字,再用C语言编程算出来[/quote  ]说错了,-10到30之间存在这样的数字,但是你可以扩大范围变成-78到78.你就可以发现-77,77没有被打印出来

引用 楼主 qq_38172134 的回复:#include<stdio.h> main() { int i; for(i=-10;i<=30;i++) { if(i%7==0||i%11==0) (不知道填什么!=0) { printf("%d,",i); }  }  } -10到30之间也不存在这样的数字呀,你可以扩大一下范围,在纸上算出来这些数字,再用C语言编程算出来

if ( (i % 7 == 0 || i % 11 == 0)&&(i%77!=0 ) )  (  (能够被7整除或者能够被11整除)并且(不能同时被7和11整除)  ) 找7和11的最小公倍数也就是77


引用 8 楼 sum_TW 的回复:http://blog.csdn.net/sum_tw/article/details/68952050 参考一下  谢谢

引用 6 楼 cfjtaishan 的回复:#include<stdio.h> #include<stdlib.h> #include<string.h> #include<pthread.h> #include<unistd.h>  void *fn() {     pthread_detach(pthread_self());     return NULL; }  int main(void) {     pthread_t tid;     int i;      for (i = 0; ; i++) {         int err = pthread_create(&tid, NULL, fn, NULL);         if (err!=0) {             printf("%s\n", strerror(err));             break;         }         printf("i = %d\n", i);     }     return 0; } 你是在那个平台上运行改程序，我在Linux下运行了，没有出现错误，一直在运行（通过查看i的值）。这是一个无限创建线程，并且线程会自动释放的程序。  看来是ubuntu的问题，我换centos试了下，确实可以一直创建线程，谢谢啦，但分数怎么给你呢？

难道没人知道吗？

引用 6楼自信男孩 的回复:#include<stdio.h> #include<stdlib.h> #include<string.h> #include<pthread.h> #include<unistd.h>  void *fn() {     pthread_detach(pthread_self());     return NULL; }  int main(void) {     pthread_t tid;     int i;      for (i = 0; ; i++) {         int err = pthread_create(&tid, NULL, fn, NULL);         if (err!=0) {             printf("%s\n", strerror(err));             break;         }         printf("i = %d\n", i);     }     return 0; } 你是在那个平台上运行改程序，我在Linux下运行了，没有出现错误，一直在运行（通过查看i的值）。这是一个无限创建线程，并且线程会自动释放的程序。谢谢解答。系统是Ubuntu 16.04lts，难道是系统的问题？

引用 3楼欧阳春晖 的回复:我的理解是线程不能分离自身，要由父线程进行分离自身分离也是可以，而且在主线程中分离效果也是一样的

我的理解是线程不能分离自身，要由父线程进行分离

引用 1楼赵4老师 的回复:进程意外退出会在当前目录下产生‘core’文件或形如‘core.数字’的文件比如‘core.1234’ 使用命令 gdb 运行程序名 core或core.数字 进入gdb然后使用bt命令 可以查看进程意外退出前函数调用的堆栈，内容为从上到下列出对应从里层到外层的函数调用历史。 如果进程意外退出不产生core文件，参考“ulimit -c core文件最大块大小”命令这个试了，显示pthread create 有错，但不知道错在哪儿。


Question: 关于数组求最大最小值的问题

引用 2 楼 qq_38126053的回复:引用 1 楼 qq_36409192 的回复:你写在里面，那么你你每次的比较都是和p[0]在比较，所以根本就不是在求最值，而是在求大于第一个数的最后一个数。（注意if、for的使用都要加花括号，不加括号这个习惯是很不好的，你这个代码因为没花括号，逻辑都出问题了）哦，大概明白了，放在循环里面经过一次循环后，又把最大最小值初始化为第一个元素的值了。 其实如果只是想求一个数组的最大值和最小值的话，没必要这么麻烦，可以直接用冒泡排序，排序完了第一数就是最小值，最后一个数就是最大值(如果你没学过，可以去网上搜一下冒泡排序法)

引用 3 楼 user-2 的回复:if 后面用大括号， 否则只有一条语句属于if  #include<stdio.h> void daxiao(int *p, int g, int *da, int *xiao) {    	for (int i = 1; i < g; i++) 	{ 		int _da = p[0]; 		if (p[i]>_da) 		{ 			_da = p[i]; 			*da = _da; 		} 	} 	for (int k = 1; k < g; k++) 	{ 		int _xiao = p[0]; 		if (p[k] < _xiao) 		{ 			_xiao = p[k]; 			*xiao = _xiao; 		}  	} } int main() { 	int array[5] = { 69, 25, 6, 99, 0}; 	int a, b; 	daxiao(array, 5, &a, &b); 	printf("最大值是：%d\n", a); 	printf("最小值是：%d\n", b); 	return 0; }在这里if后面的两句不用大括号括起来运行结果都一样吧？


Question: 求大神帮忙改良一下程序

引用 2 楼 qq_37851893 的回复:您好，谢谢您的帮助！通过您的改进确实学到了不少的东西，但是我还是想请问一下，程序中如果不输入y，输入回车直接跳的最后else后语句输出的问题可以解决吗？ 改用getchar(),scanf("%c")会忽略回车

#include <stdio.h> #include <stdlib.h> void set_color(int back, int fore) { 	char cmd[9]; 	sprintf(cmd, "color %x", back << 4 | fore); 	system(cmd); } void print_love(int back_ch, int fore_ch, int back_clr, int fore_clr) { 	set_color(back_clr, fore_clr); 	for(float y=1.5f;y>-1.5f;y-=0.1f) 	{ 		for(float x=-1.5f;x<1.5f;x+=0.05f) 		{ 			float a=x*x+y*y-1; 			putchar(a*a*a-x*x*y*y*y<=0.0f?fore_ch:back_ch); 		} 		putchar('\n'); 	} } static const int BLACK = 0; static const int BLUE = 1; static const int GREEN = 2; static const int AQUE = 3; static const int RED = 4; static const int PURPLE = 5; static const int YELLOW = 6; static const int WHITE = 7; #define L(color) ((color) | 8) #define GRAY L(BLACK) int main(void) { 	char a; 	printf("****************（y or n）\n");  	scanf("%c",&a); 	if(a=='y') print_love('*', '#', L(AQUE), PURPLE); 	else printf("********************"); 	system("pause"); }


Question: 求问下面的代码哪里错了以及怎么改？输不出来是什么原因？

楼主发现错在哪里了，谢谢楼上大神的帮助，但是比值那里还是有问题： 下面这样比较输出正确可以的                 if(strcmp(zhi, stud[i].id) == 0)                 {                     printf("%d%d%d", stud[i].score[0], stud[i].score[1], stud[i].score[2]);                 }  但这样输出又有问题了                 if(strcmp(zhi, stud[i].name) == 0) {                     printf("%s%s%s%d%d%d", stud[i].cname[0], stud[i].cname[1], stud[i].cname[2], stud[i].score[0], stud[i].score[1], stud[i].score[2]);                 }

然后楼主虽然学了c++但没有学c语言，是个学生，基础比较差，是要好好学

谢谢你说的问题，但我有尝试strcmp或strncmp这个函数，仍旧是不行，用了你的代码还是不行，同样的问题，不会报错，但无法输出值，至于你说的int用s%，我设计的是用来存课程名字符串的，所以显示用了s%，我是前面声明类型的时候写了int，这个问题现在我改了~不过还是谢谢~

这位兄台，你这个代码习惯太差了，如果你是学生的话好好学，如果你是工作了，你家老板不批你我表示很震惊

#include <stdio.h> #include <stdlib.h>  #define SIZE 10  struct   student{     char  id[20];     char  name[20];     int   cname[3];     int   score[3]; } stud[SIZE];  void input()  /* 输入学生的信息 */ {     int i;        for (i  =0; i < SIZE; i++) {          printf("第%d个学生的信息:\n",i+1);         scanf("%s%s%d%d%d%d%d%d", stud[i].id, stud[i].name,&stud[i].cname[0],&stud[i].cname[1],&stud[i].cname[2],&stud[i].score[0],&stud[i].score[1],&stud[i].score[2]);         } } void output()  /* 输出学生的信息 */ {     int i;     printf("\n");     for(i=0;i<SIZE;i++) {         printf("%s %s %d %d %d %d %d %d\n",stud[i].id,stud[i].name, stud[i].cname[0], stud[i].cname[1], stud[i].cname[2],stud[i].score[0],stud[i].score[1],stud[i].score[2]);     } } /* 成绩查询输出信息 */ void sortput() {     int z,n;	//选择项      int i;      //行      char zhi[20];      for(;n=1;) {  	    printf("Search function :\n");  	    printf("1. Search use id :\n");  	    printf("2. Search use name :\n");  	    printf("3. Search use cname :\n");         printf("4. Search all :\n");         printf("Choose :");         scanf("%d", &z);          printf("Zhi :");         scanf("%s",zhi);           printf("Search results : \n");         for(i=0;i<SIZE;i++) {//行              if(z==1)               {                 if(strcmp(zhi, stud[i].id) == 0)                 {                     printf("%d%d%d%d%d%d", stud[i].cname[0], stud[i].cname[1], stud[i].cname[2], stud[i].score[0], stud[i].score[1], stud[i].score[2]);                 }	             }             if(z==2) {                 if(strcmp(zhi, stud[i].name) == 0) {                     printf("%d%d%d%d%d%d", stud[i].cname[0], stud[i].cname[1], stud[i].cname[2], stud[i].score[0], stud[i].score[1], stud[i].score[2]);                 }           	               }             if(z==3) {                 if(atoi(zhi)== stud[i].cname[0]) {                 printf("%d", stud[i].score[0]);             } else if(atoi(zhi) == stud[i].cname[1]) {                 printf("%d", stud[i].score[1]);             } else {                 printf("%d", stud[i].score[2]);             }           }     }     if(z==4) {         output();     }	  	printf("Choose 1继续:");  	scanf("%d", &n);	     } }   int main() {	    input();    sortput(); } 问题比较多，改了改；试试这个。 问题： 1. int类型的数据不能使用%s输入，当然也不能用%s输出； 2. printf输出时，就不要加& 3. 字符串比较不能直接比较，需要借助字符库函数，比如strcmp或strncmp 4. 注意代码风格和格式


Question: 大牛快来

或者使用最新的c++11标准试试

引用 3 楼 qq_31989333 的回复:const int n = 5;加上个const 写错了#define n 3

“变量赋值”和“变量初始化”不是一回事！ “变量赋值”发生在运行期，其写法遵循赋值语法规定。 “变量初始化”发生在编译期或运行期，其写法遵循初始化列表语法规定。

老的标准，数组元素个数必须是常数表达式。 新的标准，可以是变量，但是数组不能定义时初始化。

const int n = 5;加上个const


Question: 这段代码用Dev C++为什么编译出来显示不了...？

用code：：blocks吧

可以显示啊。。我试过了，我也是devc++

用 Cygwin C++ 编译可以显示


Question: realloc引起程序触发断点，请教各位大神。

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

其他位置的越界访问，特别是越界赋值，也可能影响这儿

是否r->number的值太大了，或者根本是一个无效值，有侦测过没？

引用 7 楼 wang0635 的回复:其他位置的越界访问，特别是越界赋值，也可能影响这儿我又试了下，把realloc改成free和malloc。发现free的时候没问题，而是malloc时引发了断点。

引用 7 楼 wang0635 的回复:其他位置的越界访问，特别是越界赋值，也可能影响这儿 相关代码，结构体定义跟贴出来的一样。  void InsertRequest(int i, route *r)//将请求i中的点插入到路径r中去,并返回该请求的旅行时间; { 	request re = Request[i];//找出是哪个请求; 	int number = r->number;//确定路径中现在有多少个点; 	r->t= (task *)realloc(r->t, sizeof(task)*(number+2));//每加入一个请求会有两个点插入所以空间加2; 	r->number += 2;//点的个数+2; 	r->q += Dot[Request[i].origin].g+Dot[Request[i].end].g; 	double a;//临时变量存储各个点的到达时间; 	a = (r->t + number - 2)->D +CaTime((r->t + number - 2)->number, re.origin);//上一点到新插入请求起点的时间; 	(r->t + number - 1)->number = re.origin;//将新加入的请求插到最后; 	(r->t + number - 1)->b = Max(a, Dot[re.origin].e);//计算开始时间 	(r->t + number - 1)->D = (r->t + number - 1)->b+Dot[re.origin].d;//计算离开时间 	(r->t + number - 1)->w = Max(0, Dot[re.origin].e-a);//计算等待时间 	a = (r->t + number - 1)->D + CaTime((r->t + number - 1)->number, re.end);//上一点到新插入请求起点的时间; 	(r->t + number)->number = re.end;//记录点的编号; 	(r->t + number)->b = Max(a, Dot[re.end].e);//计算开始时间; 	(r->t + number)->D = (r->t + number)->b + Dot[re.end].d;//计算离开时间 	(r->t + number)->w = Max(0, Dot[re.end].e - a);//计算等待时间;  	a = (r->t + number)->D + CaTime((r->t + number)->number, 0);//上一点到新插入请求起点的时间; 	(r->t + number + 1)->number = 0;//最后一个点是停车场; 	(r->t + number+1)->b = a;//令回到停车场时间为a; 	(r->t + number+1)->D = a;//令回到停车场时间为a; 	(r->t + number+1)->w = 0;//等待时间必为0; 	//设置旅行时间; 	(r->t+number)->l=(r->t + number)->b - (r->t + number - 1)->D ;//该请求的记录在终点旅行时间; 	(r->t + number - 1)->l = 0;//起点的旅行时间设置为0; 	(r->t + number + 1)->l = a;//即回到停车场的时间;  } void InitSolution(solution *s) { 	int i; 	for (i = 0; i < M; i++)//对解s，初始化每条路径; 	{ 		(*s).r[i].q = 0;//载重量初始值为0; 		(s->r+i)->t = (task *)malloc(sizeof(task) * 2);//先为起点和终点的depot分配空间; 		(*s).r[i].t[0].number = 0; (*s).r[i].t[0].b = 0; (*s).r[i].t[0].w = 0; 		(*s).r[i].t[0].l = 0; (*s).r[i].t[0].D = 0;		//初始化路径;  		(*s).r[i].t[1].number = 0; (*s).r[i].t[1].b = 0; (*s).r[i].t[1].w = 0; 		(*s).r[i].t[1].l = 0; (*s).r[i].t[1].D = 0;		 		(*s).r[i].number = 2;//现在每条初始路径均只包括两个depot点 		(*s).r[i].dis = 0;//距离为0 		(*s).r[i].f = 0;//适应度为0; 		(*s).r[i].q = 0;//载重量为q; 		InitTabuList(s->r + i);//初始化禁忌表为0; 	}  	int vehicleNumber; 	attr tempAttr; 	InitAttrCount(s->attrCount);//初始化属性计数变量; 	for (i = 0; i < N; i++)//对每个请求从i=0-N-1进行分配; 	{ 		vehicleNumber=RandInt(M)-1;//返回一个1-M的值，再减一，表示车辆编号：0-M-1; 		InsertRequest(i, s->r+vehicleNumber);//将第i个请求插入到车辆编号为vehicleNumber的路径中; 		tempAttr.i = i;//请求为i 		tempAttr.k = vehicleNumber;//服务车辆为k 		AddAttr(s, tempAttr);//将属性加入到解中; 		AttrCount(s->attrCount, i, vehicleNumber);//计算pik 	} 	for (int i = 0; i < M; i++) 	{ 		(s->r+i)->f=ComputeV((s->r + i)); 		s->fit += (s->r + i)->f; 	} } void main() { 	Request = (request *)malloc(sizeof(request)*N);//共有N个请求; 	Dot = (dot *)malloc(sizeof(dot)*(2 * N + 1));//共有2N+1个点; 	ReadInfo();//读取文件信息; 	route *globalR;//存储全局最优解; 	int globalFit=10000;//存储全局最优值; 	globalR = (route *)malloc(sizeof(route)*M); 	solution *s;//初始种群s; 	s = (solution *)malloc(sizeof(solution)*POPU_SIZE); 	int i,j;//循环变量;  	for (i = 0; i < POPU_SIZE; i++) 	{ 		s[i].r = (route *)malloc(sizeof(route)*M);//每个解共有M条路径; 		s[i].fit = 0;//初始解的适应度其实可以看做为fit，因为违背时间窗约束则不可行; 		s[i].a = (attr *)malloc(sizeof(attr)*N);//属性值共有N个; 		s[i].attrCount = (int *)malloc(sizeof(int)*(N*M));//属性值共有M*N个,用来计算每个属性加入到解s的次数pik; 		s[i].attrNumber = 0;//初始化解中的属性个数; 		InitSolution(s+i);//初始化每条路径; 	}//至此每条路径初始化完成; 	for (i = 0; i < MAX_GEN; i++)//迭代次数; 	{ 		for (j = 0; j < POPU_SIZE; j++) 		{ 			NeighborSearch(s+j); 			if ((s + j)->fit < globalFit) 			{ 				RecordGlobal((s + j)->r, globalR); 			} 		} 		if (i%K == 0 && i!=0) 		{ 			IntraSearch(s+i); 		} 		 	}  	 } 只看main和InitSolution即可。

引用 7 楼 wang0635 的回复:其他位置的越界访问，特别是越界赋值，也可能影响这儿 检查了，没有。是其他变量的越界也会影响吗？如果是t的话，这是第一次用。

引用 4 楼 wang0635 的回复:检查对 t 的使用是否曾经越界除了上面贴的赋初始值用到就再也没用到了。

引用 4 楼 wang0635 的回复:检查对 t 的使用是否曾经越界 没有这事第一次使用

检查对 t 的使用是否曾经越界

连续顶三次最多

各路大神快来，要疯了

自己顶一个吧


Question: [新人提问] VS2015 编译出错LINK

引用 2 楼 u011017860 的回复:是啊，我也不知道怎么回事。。http://blog.sina.com.cn/s/blog_13249c1060102vgap.html 看这个

估计工程类型选的不对，用了DirectX了 实际上用不着

是啊，我也不知道怎么回事。。

看lz的代码，不需要“dxerr.lib”呀


Question: 求助编译C工程(已含C源码)

突然发现，赵老师的ID是不是藏着4月1日的意思

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

C的代码能编译,通过命令行执行都行.可是这腾讯太坑爹,给的代码都无法编译


Question: 重开一帖,因为不能连续对一个人恢复三次.

引用 1 楼 user-2 的回复:可能是命令行窗口的缓冲区有限，最前面的已经被后头的覆盖了。是不是最后的内容是连续、完整的？ 是的.

使用命令重定向操作符可以使用重定向操作符将命令输入和输出数据流从默认位置重定 向到不同的位置。输入或输出数据流的位置即为句柄。  下表将列出可用的句柄。  句柄      句柄的数字代号 描述 STDIN     0              键盘输入 STDOUT    1              输出到命令提示符窗口 STDERR    2              错误输出到命令提示符窗口 UNDEFINED 3-9            这些句柄由应用程序单独定义，并且是各个工具特定的。  数字 0 到 9 代表前 10 个句柄。可以使用命令 Cmd.exe 运行程序并将该程序前 10 个 句柄中的任何一个重定向。要指定想使用的句柄，可在重定向操作符前面键入该句柄的 数字。如果未定义句柄，则默认的 < 重定向输入操作符是 0，而默认的 > 重定向输出 操作符是 1。键入 > 或 < 操作符之后，必须指定要读取或写入数据的位置。可以指定 文件名或另一个现有的句柄。  要指定重定向到现有句柄，请使用与 (&) 字符，后面接要重定向的句柄号 （例如 &句柄#）。例如，下面的命令可以将句柄 2（即 STDERR）重定向到 句柄 1（即 STDOUT）：  2>&1  下表列出了可用于将输入和输出数据流进行重定向的操作符。  重定向操作符 描述 > 将命令输出写入到文件或设备（例如打印机）中，而不是写在命令提示符窗口或句柄中。 < 从文件中而不是从键盘或句柄中读入命令输入。 >> 将命令输出添加到文件末尾而不删除文件中的信息。 >& 将一个句柄的输出写入到另一个句柄的输入中。 <& 从一个句柄读取输入并将其写入到另一个句柄输出中。 | 从一个命令中读取输出并将其写入另一个命令的输入中。也称作管道。  默认情况下，可以从键盘将命令输入（即 STDIN 句柄）发送到 Cmd.exe，然后由 Cmd.exe 将命令输出（即 STDOUT 句柄）发送到命令提示符窗口。  重定向输入 (<) 要将键盘输入重定向到文件或设备，请使用 < 操作符。例如，要从 File.txt 获取 sort 命令的输入，请键入：  sort<file.txt  File.txt 的内容将以字母顺序列表的方式显示在命令提示符窗口中。  < 操作符可以打开具有只读访问的指定文件名。所以，不能使用该操作符向文件中写入 信息。例如，如果以 <&2 启动程序，则所有试图读取句柄 0 的操作都将失败，因为句 柄 2 最初是以只写访问打开的。   注意  0 是 < 重定向输入操作符的默认句柄。 重定向输出 (>) 几乎所有的命令都将输出发送到命令提示符窗口。即使将输出发送到驱动器或打印机的 命令也会在命令提示符窗口显示消息和提示。  要将输出从命令提示符窗口重定向到文件或设备，请使用 > 操作符。可以在许多命令中 使用该操作符。例如，要将 dir 输出重定向到 Dirlist.txt，请键入：  dir>dirlist.txt  如果 Dirlist.txt 不存在，Cmd.exe 将创建该文件。如果 Dirlist.txt 存在，Cmd.exe 将使用 dir 命令的输出替换文件中的信息。  要运行 netsh routing dump 命令，然后将输出发送到 Route.cfg，请键入：  netsh routing dump>c:\route.cfg  > 操作符可以打开具有只写访问属性的指定文件。所以，不能使用该操作符读取文件。 例如，如果使用重定向 >&0 启动程序，则所有试图写入句柄 1 的操作都将失败，因为 句柄 0 最初是以只读访问打开的。   注意  1 是 > 重定向输出操作符的默认句柄。 复制句柄 重定向操作符 & 可以将输出或输入从一个指定句柄复制到另一个指定的句柄。例如， 要将 dir 输出发送到 File.txt 并将错误输出发送到 File.txt，请键入：  dir>c:\file.txt 2>&1  复制句柄时，可以复制该句柄原状态的所有特性。例如，如果一个句柄具有只写访问的 属性，则该句柄的所有副本都具有只写访问属性。不能将一个具有只读访问属性的句柄 复制到另一个具有只写访问属性的句柄。  使用 & 操作符重定向输入和副本 要将重定向输入操作符 (<) 与复制操作符 (&) 一起使用，指定的文件必须已经存在。 如果输入文件存在，Cmd.exe 将以只读方式打开该文件，然后将文件中包含的字符作为 输入发送到此命令（如同从键盘输入一样）。如果指定了句柄，Cmd.exe 将指定的句柄 复制到系统现有的句柄中。  例如，要以句柄 0 输入读取（即 STDIN）的方式打开 File.txt，请键入：  <file.txt  要打开 File.txt，并在内容排序后将输出发送到命令提示符窗口（即 STDOUT），请键入：  sort<file.txt  要查找 File.txt，然后将句柄 1（即 STDOUT）和句柄 2（即 STDERR）重定向到 Search.txt，请键入：  findfile file.txt>search.txt 2<&1  要以句柄 0 输入读取（即 STDIN）的方式复制用户定义句柄 3，请键入：  <&3  使用 & 操作符重定向输出和复制 如果将输出重定向到文件且指定了现有的文件名，Cmd.exe 将以只写方式打开文件并覆 盖该文件内容。如果指定了句柄，Cmd.exe 将文件复制到现有句柄中。  要将用户定义句柄 3 复制到句柄 1，请键入：  >&3  要将包括句柄 2（即 STDERR）的所有输出从 ipconfig 命令重定向到 句柄 1（即 STDOUT），然后将输出重定向到 Output.log，请键入：  ipconfig.exe>>output.log 2>&1  使用 >> 重定向操作符追加输出 要从命令中将输出添加到文件末尾而不丢失文件中已存在的任何信息，请使用两个连续 的大于号（即 >>）。例如，下面的命令可以将由 dir 命令生成的目录列表追加到 Dirlist.txt 文件：  dir>>dirlist.txt  要将 netstat 命令的输出追加到 Tcpinfo.txt 的末尾，请键入：  netstat>>tcpinfo.txt  使用管道操作符 (|) 管道操作符 (|) 可以提取一个命令的输出（默认情况下是 STDOUT），然后将其导入另 一个命令的输入中（默认情况下是 STDIN）。例如，下面的命令将对目录分类：  dir | sort  在本例中，将同时启动两个命令，但随后 sort 命令会暂停，直到它接收到 dir 命令 的输出为止。sort 命令使用 dir 命令的输出作为输入，然后将输出发送到 句柄 1（即 STDOUT）。  合并带重定向操作符的命令 可以通过合并带有其他命令和文件名的筛选器命令创建自定义命令。例如，可以使用以 下命令存储包含“LOG”字符串的文件名:  dir /b | find "LOG" > loglist.txt  dir 命令的输出通过 find 筛选器命令发送。包含字符串 "LOG" 的文件名作为文件名 列表（例如，NetshConfig.log、Logdat.svd 和 Mylog.bat）存储在文件 Loglist.txt 中。  要在相同命令中使用多个筛选器，请使用管道 (|) 分隔筛选器。例如，下面的命令将 搜索 C 盘上的每个目录以查找包含 "LOG" 字符串的文件名，并且在命令提示符窗口中 每次显示一屏：  dir c:\ /s /b | find "LOG" | more  利用管道 (|) 可以将 Cmd.exe 导向为通过 find 筛选器命令发送 dir 命令输出。 find 命令只选择包含字符串 "LOG" 的文件名。more 命令可以显示由 find 命令选择 的文件名（在命令提示符窗口中每次显示一屏）。有关筛选器命令的详细信息，请参阅 使用筛选器。


Question: 初次使用QT编译时总是出问题，求大神

首先正常现在可以下载的QT官网版本  都是可以直接编译的   使用的如果是QT Creator的话 更换下编译器就可以了 其他编译器需要配置 选这个QT Demo的例子都可以运行 自己写的代码也没问题

工具—选项—构建和运行—概要——不适用jom代替nmake ----奈斯

工具—选项—构建和运行—概要——不适用jom代替nmake  --------不错，可以解决问题

http://download.qt.io/archive/qt/  你试试换个版本

工具—选项—构建和运行—概要——不适用jom代替nmake


Question: 请大神帮忙解决小弟弟函数中（转义字符）遇到的问题，谢谢！

引用 6 楼 caine12345 的回复:[quote=引用 4 楼 cfjtaishan 的回复:] #include<stdio.h>  void escape(char s[],char t[]);  int main() {     char s[2000];     char t[2000];     printf("please input your character:");     fgets(t,2000,stdin);     escape(s,t);     printf("%s",s);     return 0; }  void escape(char s[],char t[]) {     int i,j;     for(i = j = 0; t[i]; i++){         switch(t[i]){             case'\n':                 s[j++] = '\\';                 s[j++] = 'n';                 break;              case'\t':                 s[j++] = '\\';                 s[j++] = 't';                 break;              default:                 s[j++] = t[i];                 break;         }     }      s[j] = '\0'; } '\t', '\n'都是一个字符，所以不能把它们看成一个字符。 但是如果输出时，你要用两个字符标识，即’\\‘, ’t', '\\', 'n' 以上是改的demo，可以试一下。  谢谢了，我还想问一下为什么我的代码在这上边都是左对齐的，你的就很规整呢？[/quote] 注意下表情符号前面的一个功能，那里面分不同的语言

引用 5 楼 cfjtaishan 的回复:注意自己的代码风格，没必要一下申请2000个字节，你平时测试能用到2000 字节吗？就是你平时测试不能一下子输入2000个字节。根据需要预估一下字节数，我估计128 字节都足够你输入的。但注意，转换后的字节数肯定比转换前的要多，所以，两个缓存不能一样大，除非他们都特别大，以至于不会越界。  谢谢！

引用 4 楼 cfjtaishan 的回复:#include<stdio.h>  void escape(char s[],char t[]);  int main() {     char s[2000];     char t[2000];     printf("please input your character:");     fgets(t,2000,stdin);     escape(s,t);     printf("%s",s);     return 0; }  void escape(char s[],char t[]) {     int i,j;     for(i = j = 0; t[i]; i++){         switch(t[i]){             case'\n':                 s[j++] = '\\';                 s[j++] = 'n';                 break;              case'\t':                 s[j++] = '\\';                 s[j++] = 't';                 break;              default:                 s[j++] = t[i];                 break;         }     }      s[j] = '\0'; } '\t', '\n'都是一个字符，所以不能把它们看成一个字符。 但是如果输出时，你要用两个字符标识，即’\\‘, ’t', '\\', 'n' 以上是改的demo，可以试一下。  谢谢了，我还想问一下为什么我的代码在这上边都是左对齐的，你的就很规整呢？

引用 2 楼 caine12345 的回复:[quote=引用 1 楼 user-2 的回复:] 输入不对，输入\n,\t就对了。  我知道，但是想问一下原因是什么呢？[/quote] 因为你程序设计读到一个斜杠，就会再读下一个字符与其配对，你输入\\n的话，\\是一组，再读就是n

引用 1 楼 user-2 的回复:输入不对，输入\n,\t就对了。  我知道，但是想问一下原因是什么呢？

输入不对，输入\n,\t就对了。


Question: 为什么一直wrong anwser 求助

int main() { int n,i,a[110]={0},min1=100; while(scanf("%d",&n)!=EOF) {     min1初值是100，万一输入的那些数都比100大呢？岂不是到最后找的的最小数只能是100了？跟谁交换？

试了一下，没错误啊。

请您整理好逻辑后重新编写代码，说不定会有意外的惊喜


Question: [新人求助]  文本太长 使用fgets(),fputs()不能完整地将文本内容打印出来.只打印了一部分.

我贴的这段代码有处理超长行的逻辑。   cmd窗口显示不下太多内容请参考下面： 使用命令重定向操作符可以使用重定向操作符将命令输入和输出数据流从默认位置重定 向到不同的位置。输入或输出数据流的位置即为句柄。  下表将列出可用的句柄。  句柄      句柄的数字代号 描述 STDIN     0              键盘输入 STDOUT    1              输出到命令提示符窗口 STDERR    2              错误输出到命令提示符窗口 UNDEFINED 3-9            这些句柄由应用程序单独定义，并且是各个工具特定的。  数字 0 到 9 代表前 10 个句柄。可以使用命令 Cmd.exe 运行程序并将该程序前 10 个 句柄中的任何一个重定向。要指定想使用的句柄，可在重定向操作符前面键入该句柄的 数字。如果未定义句柄，则默认的 < 重定向输入操作符是 0，而默认的 > 重定向输出 操作符是 1。键入 > 或 < 操作符之后，必须指定要读取或写入数据的位置。可以指定 文件名或另一个现有的句柄。  要指定重定向到现有句柄，请使用与 (&) 字符，后面接要重定向的句柄号 （例如 &句柄#）。例如，下面的命令可以将句柄 2（即 STDERR）重定向到 句柄 1（即 STDOUT）：  2>&1  下表列出了可用于将输入和输出数据流进行重定向的操作符。  重定向操作符 描述 > 将命令输出写入到文件或设备（例如打印机）中，而不是写在命令提示符窗口或句柄中。 < 从文件中而不是从键盘或句柄中读入命令输入。 >> 将命令输出添加到文件末尾而不删除文件中的信息。 >& 将一个句柄的输出写入到另一个句柄的输入中。 <& 从一个句柄读取输入并将其写入到另一个句柄输出中。 | 从一个命令中读取输出并将其写入另一个命令的输入中。也称作管道。  默认情况下，可以从键盘将命令输入（即 STDIN 句柄）发送到 Cmd.exe，然后由 Cmd.exe 将命令输出（即 STDOUT 句柄）发送到命令提示符窗口。  重定向输入 (<) 要将键盘输入重定向到文件或设备，请使用 < 操作符。例如，要从 File.txt 获取 sort 命令的输入，请键入：  sort<file.txt  File.txt 的内容将以字母顺序列表的方式显示在命令提示符窗口中。  < 操作符可以打开具有只读访问的指定文件名。所以，不能使用该操作符向文件中写入 信息。例如，如果以 <&2 启动程序，则所有试图读取句柄 0 的操作都将失败，因为句 柄 2 最初是以只写访问打开的。   注意  0 是 < 重定向输入操作符的默认句柄。 重定向输出 (>) 几乎所有的命令都将输出发送到命令提示符窗口。即使将输出发送到驱动器或打印机的 命令也会在命令提示符窗口显示消息和提示。  要将输出从命令提示符窗口重定向到文件或设备，请使用 > 操作符。可以在许多命令中 使用该操作符。例如，要将 dir 输出重定向到 Dirlist.txt，请键入：  dir>dirlist.txt  如果 Dirlist.txt 不存在，Cmd.exe 将创建该文件。如果 Dirlist.txt 存在，Cmd.exe 将使用 dir 命令的输出替换文件中的信息。  要运行 netsh routing dump 命令，然后将输出发送到 Route.cfg，请键入：  netsh routing dump>c:\route.cfg  > 操作符可以打开具有只写访问属性的指定文件。所以，不能使用该操作符读取文件。 例如，如果使用重定向 >&0 启动程序，则所有试图写入句柄 1 的操作都将失败，因为 句柄 0 最初是以只读访问打开的。   注意  1 是 > 重定向输出操作符的默认句柄。 复制句柄 重定向操作符 & 可以将输出或输入从一个指定句柄复制到另一个指定的句柄。例如， 要将 dir 输出发送到 File.txt 并将错误输出发送到 File.txt，请键入：  dir>c:\file.txt 2>&1  复制句柄时，可以复制该句柄原状态的所有特性。例如，如果一个句柄具有只写访问的 属性，则该句柄的所有副本都具有只写访问属性。不能将一个具有只读访问属性的句柄 复制到另一个具有只写访问属性的句柄。  使用 & 操作符重定向输入和副本 要将重定向输入操作符 (<) 与复制操作符 (&) 一起使用，指定的文件必须已经存在。 如果输入文件存在，Cmd.exe 将以只读方式打开该文件，然后将文件中包含的字符作为 输入发送到此命令（如同从键盘输入一样）。如果指定了句柄，Cmd.exe 将指定的句柄 复制到系统现有的句柄中。  例如，要以句柄 0 输入读取（即 STDIN）的方式打开 File.txt，请键入：  <file.txt  要打开 File.txt，并在内容排序后将输出发送到命令提示符窗口（即 STDOUT），请键入：  sort<file.txt  要查找 File.txt，然后将句柄 1（即 STDOUT）和句柄 2（即 STDERR）重定向到 Search.txt，请键入：  findfile file.txt>search.txt 2<&1  要以句柄 0 输入读取（即 STDIN）的方式复制用户定义句柄 3，请键入：  <&3  使用 & 操作符重定向输出和复制 如果将输出重定向到文件且指定了现有的文件名，Cmd.exe 将以只写方式打开文件并覆 盖该文件内容。如果指定了句柄，Cmd.exe 将文件复制到现有句柄中。  要将用户定义句柄 3 复制到句柄 1，请键入：  >&3  要将包括句柄 2（即 STDERR）的所有输出从 ipconfig 命令重定向到 句柄 1（即 STDOUT），然后将输出重定向到 Output.log，请键入：  ipconfig.exe>>output.log 2>&1  使用 >> 重定向操作符追加输出 要从命令中将输出添加到文件末尾而不丢失文件中已存在的任何信息，请使用两个连续 的大于号（即 >>）。例如，下面的命令可以将由 dir 命令生成的目录列表追加到 Dirlist.txt 文件：  dir>>dirlist.txt  要将 netstat 命令的输出追加到 Tcpinfo.txt 的末尾，请键入：  netstat>>tcpinfo.txt  使用管道操作符 (|) 管道操作符 (|) 可以提取一个命令的输出（默认情况下是 STDOUT），然后将其导入另 一个命令的输入中（默认情况下是 STDIN）。例如，下面的命令将对目录分类：  dir | sort  在本例中，将同时启动两个命令，但随后 sort 命令会暂停，直到它接收到 dir 命令 的输出为止。sort 命令使用 dir 命令的输出作为输入，然后将输出发送到 句柄 1（即 STDOUT）。  合并带重定向操作符的命令 可以通过合并带有其他命令和文件名的筛选器命令创建自定义命令。例如，可以使用以 下命令存储包含“LOG”字符串的文件名:  dir /b | find "LOG" > loglist.txt  dir 命令的输出通过 find 筛选器命令发送。包含字符串 "LOG" 的文件名作为文件名 列表（例如，NetshConfig.log、Logdat.svd 和 Mylog.bat）存储在文件 Loglist.txt 中。  要在相同命令中使用多个筛选器，请使用管道 (|) 分隔筛选器。例如，下面的命令将 搜索 C 盘上的每个目录以查找包含 "LOG" 字符串的文件名，并且在命令提示符窗口中 每次显示一屏：  dir c:\ /s /b | find "LOG" | more  利用管道 (|) 可以将 Cmd.exe 导向为通过 find 筛选器命令发送 dir 命令输出。 find 命令只选择包含字符串 "LOG" 的文件名。more 命令可以显示由 find 命令选择 的文件名（在命令提示符窗口中每次显示一屏）。有关筛选器命令的详细信息，请参阅 使用筛选器。

引用 3 楼 qq_31989333 的回复:不知道哪位朋友可以实际的试验一下我的代码呢. test.txt文件里面复制这个链接里面(全部复制)http://www.yjbys.com/gongwuyuan/show-532844.html  复制这个链接里面的  政府工作报告(全部复制) 粘贴到test.txt

引用 1 楼 zhao4zhong1 的回复:仅供参考：#include <stdio.h> #include <string.h> #define MAXLEN 1000 char ln[MAXLEN]; FILE *f; int i,z; int b,n,L; int main(int argc,char **argv) {     if (argc<2) {         printf("Usage:%s fullpathfilename.ext\nget total blank/non-blank/total linenumbers.\n",argv[0]);         return 1;     }     f=fopen(argv[1],"r");     if (NULL==f) {         printf("Can not open file [%s]!\n",argv[1]);         return 2;     }     z=0;     b=0;     n=0;     L=0;     while (1) {         if (NULL==fgets(ln,MAXLEN,f)) break;         L=strlen(ln);         if ('\n'==ln[L-1]) {             if (0==z) {                 for (i=0;i<L-1;i++) {                     if (!(' '==ln[i] || '\t'==ln[i])) break;                 }                 if (i<L-1) z=1;//当前行不是空行             }             if (0==z) b++; else n++;             z=0;         } else {             if (0==z) {                 for (i=0;i<L;i++) {                     if (!(' '==ln[i] || '\t'==ln[i])) break;                 }                 if (i<L) z=1;//当前行不是空行             }         }     }     fclose(f);     if (L>0 && '\n'!=ln[L-1]) {         if (0==z) b++; else n++;//最后一行末尾无'\n'也计算     }     printf("File:[%s] total blank/non-blank/total linenumbers is %d/%d/%d\n",argv[1],b,n,b+n);     return 0; }   菜鸟真心看不懂啊.太复杂了. 还是感谢赵老师.


Question: 字符串的截取

已经解决了， 伪代码如下，感谢各位大神。  还有赵大神提供的方法看的晕，太复杂了 	char *input_tmp = buffer; 				char *token;  				while((token = strsep(&input_tmp, "\n")) != NULL){  					//printf("input = %s\n", input_tmp); 					if(input_tmp == NULL) 						break;  					char *p = strtok(token, ",");   					rowid = atoi(p);  					p = strtok(NULL, ","); 					id = atoi(p);  					p = strtok(NULL, ","); 					 					if(strcmp(p, "name") == NULL) 						continue; 					else 						strcpy(name, p);  					p = strtok(NULL, ","); 					strcpy(grouid, p);  					p = strtok(NULL, ","); 					strcpy(ip, p);  					p = strtok(NULL, ","); 					state = atoi(p);  					//printf("%d@%d@%s@%s@%s@%d\n", rowid, id, name ,grouid, ip, state)

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

仅供参考：//NAME: essaie bla bla //DIMENSION: 8 //DATA //1  14  15 //2  11  10 //3  6   4 //4  7   13 //5  9   21 //6  19  3 //7  1   5 //8  8   8 //EOF // // 文本文件中可能还含有其他内容，但是需要用到的内容即以上  //比如data.txt: //NAME: essaie bla bla //其它内容 //DIMENSION: 8 //其它内容 //DATA //其它内容 //1  14  15 //其它内容 //2  11  10 //其它内容 //3  6   4 //其它内容 //4  7   13 //其它内容 //5  9   21 //其它内容 //6  19  3 //其它内容 //7  1   5 //其它内容 //8  8   8 //其它内容 //EOF  // 目标是要获取NAME后字串，DIMENSION后数值，以及DATA以下的数值 // 其中NAME就是随便个字句，DIMENSION是城市数量，DATA以下是城市编号，X坐标，Y坐标 // 所有的这些将赋值给一个事先定义好的结构 #include <stdio.h> #include <string.h> #define MAXCPL   80   //每行最大字符数 #define MAXCITY  100  //每组数据中DATA最多项数，DIMENSION的最大值 #define MAXNAMEL 32   //NAME最大长度 struct S {     char NAME[MAXNAMEL+1];     int  DIMENSION;     struct D {         int NO;         int X;         int Y;     } DATA[MAXCITY]; } s; FILE *f; int st,n,i; char ln[MAXCPL]; int main() {     f=fopen("data.txt","r");     if (NULL==f) {         printf("Can not open file data.txt!\n");         return 1;     }     st=0;     n=0;     while (1) {         if (NULL==fgets(ln,MAXCPL,f)) break;         if (st==0) {             if (1==sscanf(ln,"NAME: %31[^\n]",s.NAME)) st=1;         } else if (st==1) {             if (1==sscanf(ln,"DIMENSION: %d",&s.DIMENSION)) st=2;         } else if (st==2) {             if (0==strcmp(ln,"DATA\n")) st=3;         } else if (st==3) {             if (3==sscanf(ln,"%d%d%d",&s.DATA[n].NO,&s.DATA[n].X,&s.DATA[n].Y)) {                 n++;                 if (n>=MAXCITY || n>=s.DIMENSION) break;             }         }     }     fclose(f);     printf("s.NAME=[%s]\n",s.NAME);     printf("s.DIMENSION=%d\n",s.DIMENSION);     for (i=0;i<n;i++) {         printf("s.DATA[%d].NO,X,Y=%d,%d,%d\n",i,s.DATA[i].NO,s.DATA[i].X,s.DATA[i].Y);     }     return 0; } //s.NAME=[essaie bla bla] //s.DIMENSION=8 //s.DATA[0].NO,X,Y=1,14,15 //s.DATA[1].NO,X,Y=2,11,10 //s.DATA[2].NO,X,Y=3,6,4 //s.DATA[3].NO,X,Y=4,7,13 //s.DATA[4].NO,X,Y=5,9,21 //s.DATA[5].NO,X,Y=6,19,3 //s.DATA[6].NO,X,Y=7,1,5 //s.DATA[7].NO,X,Y=8,8,8

用strstr

是的 ，  这个buffer里也带有\n换行符。

使用strtok按逗号分割字符串  用法及例子参看：http://en.cppreference.com/w/c/string/byte/strtok


Question: 请教C语言 堆栈释放崩溃 问题

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

引用 3 楼 Westlake96 的回复:[quote=引用 1 楼 user-2 的回复:] 对于第一个：  scanf("%d", &(st + i)->age); %d对应的应该是int，%c对应的是char，你的age要用%c  同理scanf("%d", &(st + i)->sex);这句  非常感谢 问题终于找到了 但是又出现了一个新的问题   #include <stdio.h> #include <stdlib.h> #include <string.h> #pragma warning(disable:4996)   typedef struct {     char name[16];     unsigned char age;     unsigned char sex; } Student;   int main(void) {     Student *st = (Student *)malloc(sizeof(Student) * 2);     memset(st, 0, sizeof(Student) * 2);     for (int i = 0; i < 2; i++)     {         printf("pls input name:");         scanf("%s", (st + i)->name);         printf("pls input age:");         scanf("%c", &(st + i)->age);         printf("pls input sex(0/1):");         scanf("%c", &(st + i)->sex);         printf("\n");     }     free(st);     return 0; }  以上代码 在输入数据的时候 每次输入完成name后 就直接输入sex了 跳过了age的输入 请问应该如何解决呢？[/quote]  scanf 后面加个getchar(); 把缓冲区中的换行符接收了  否则会直接被下一个 scanf("%c", ...) 接收

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

引用 1 楼 user-2 的回复:对于第一个：  scanf("%d", &(st + i)->age); %d对应的应该是int，%c对应的是char，你的age要用%c  同理scanf("%d", &(st + i)->sex);这句  非常感谢 问题终于找到了 但是又出现了一个新的问题   #include <stdio.h> #include <stdlib.h> #include <string.h> #pragma warning(disable:4996)   typedef struct {     char name[16];     unsigned char age;     unsigned char sex; } Student;   int main(void) {     Student *st = (Student *)malloc(sizeof(Student) * 2);     memset(st, 0, sizeof(Student) * 2);     for (int i = 0; i < 2; i++)     {         printf("pls input name:");         scanf("%s", (st + i)->name);         printf("pls input age:");         scanf("%c", &(st + i)->age);         printf("pls input sex(0/1):");         scanf("%c", &(st + i)->sex);         printf("\n");     }     free(st);     return 0; }  以上代码 在输入数据的时候 每次输入完成name后 就直接输入sex了 跳过了age的输入 请问应该如何解决呢？

对于第二个：  错误原因同第一个


Question: 算法提高 盾神与积木游戏 ,自己编的提交上去后只对了两个，但是感觉没有错误，求大神指导

可是我没有用动态规划啊

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


Question: 【C语言】请问我的这个嵌套switch函数里最后的括号怎么结不了尾？

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

就是最后反大括号打出来不对齐 下一个函数也一直有问题


Question: 使用fgets()遇到的一个问题

引用 1 楼 user-1 的回复:line 是一个字符串buff。假如上一次读取到的行是 tttttttttttttttttttttttttttttttttttttttttttt。下一次读取的行是abc，那么此时line 的内容是abcttttttttttttttttttttttttttttttttttttttttttttttttttt。这就会造成错误的判断。 所以，在fgets之间，要使用memset对line清空。  谢谢！解决了我的问题 ：）


Question: 为什么这段while循环执行第二次的时候没有让我进行键盘录入就直接跳过了？？？

第二次匹配的是'\n'回车符

引用 7 楼 HJMing123 的回复:[quote=引用 6 楼 qq_31989333 的回复:] 修改成这样的 #include<stdio.h> int main ( ) { 	char ch1; 	while ( true ) 	{  		ch1=getchar ( ); 		if ( ch1 == '@' )    //输入以@结束 		{ 			break; 		} 		else 		{ 			puts ( "ok" ); 		} 		while ( getchar ( ) != '\n' ); 	} 	return 0; }   C Primer Plus中有很多关于这个问题的例子.  你也可以搜索while(getchar( )!='\n)     continue; 不是很熟悉C语言，特别是一些细节上的问题，能再问一下这个问题吗？  while(isEmpty_Seq(S2)==-1)         {              Pop_Seq(S2,ch2);       //出栈             Push_Seq(S3,ch2);     //入栈         }  int isEmpty_Seq(SeqStack &S) {     if(S.top==-1)     {         printf("栈空");         return 1;     }     else         return -1;  } 我如果执行下面这个语句，代码就会一直循环执行isEmpty函数，请问这是为什么呢？[/quote] 我还是个菜鸟,上学期学的数据结构都忘光了.现在正在重新学习. 你还是问其他人吧. 你可以在CSDN博客里面搜索一些人写的有关栈的代码.有很多  我上个学期也写了数据结构有关栈 的代码,如果你要的话,发私信给我.

引用 4 楼 u010165006 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] 在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 char c; scanf("%c",&c); //时，都改为 char s[2]; char c; scanf("%1s",s); c=s[0];  scanf("%1s",s); c=s[0]; 和 scanf("%c",&c); 的区别是什么？[/quote] 前者会自动跳过空格或Tab或Enter

引用 6 楼 qq_31989333 的回复:修改成这样的 #include<stdio.h> int main ( ) { 	char ch1; 	while ( true ) 	{  		ch1=getchar ( ); 		if ( ch1 == '@' )    //输入以@结束 		{ 			break; 		} 		else 		{ 			puts ( "ok" ); 		} 		while ( getchar ( ) != '\n' ); 	} 	return 0; }   C Primer Plus中有很多关于这个问题的例子.  你也可以搜索while(getchar( )!='\n)     continue; 不是很熟悉C语言，特别是一些细节上的问题，能再问一下这个问题吗？  while(isEmpty_Seq(S2)==-1)         {              Pop_Seq(S2,ch2);       //出栈             Push_Seq(S3,ch2);     //入栈         }  int isEmpty_Seq(SeqStack &S) {     if(S.top==-1)     {         printf("栈空");         return 1;     }     else         return -1;  } 我如果执行下面这个语句，代码就会一直循环执行isEmpty函数，请问这是为什么呢？

scanf从输入缓冲区中提取字符，如果输入缓冲区为空，则等待键盘输入。 第一次scanf的时候，键盘输入以后输入缓冲区中还有一个回车符，第二次scanf的时候直接从缓冲区中提取回车符。

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

因为最后的回车换行符\n也会留在缓冲区，下一次接收到\n  scanf("%c",&ch1);后面加上一句getchar();接收\n


Question: 关于快速排序的非递归算法的时间复杂度和空间复杂度

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

引用 2 楼 zhao4zhong1 的回复:各种排序算法动画演示http://www.webhek.com/misc/comparison-sort/ 老师你可能会错我的意思了 我是想问 ①为什么快速排序的非递归算法会比递归算法还慢 ②快速排序的平均空间复杂度O(nlog2 n)是指栈的空间还是栈的空间加上其他的空间？

3000个数据会慢到9秒那已经看上去像平方复杂度了。估计哪里写扯了。 复杂度是指最坏复杂度。你一个特定的数据能做到更优并不奇怪。


Question: 关于limit头文件相关问题。

引用 2 楼 z245821190 的回复:那你能说说什么时候才用limits头文件里的值吗 使用grep（linux）或findstr（windows）命令搜索crt\src\目录下的所有文件，看哪些包含字符串"limits.h"

那你能说说什么时候才用limits头文件里的值吗

#include <stdio.h> #include <limits.h>  #define min(x,y) ((x)<(y)?(x):(y))  int mindistance(int a[], int b[],int m,int n) {     int minimum = INT_MAX;     int x = 0, y = 0;     while (x < m && y < n) {         if (a[x] >= b[y]) {             minimum=min(minimum, a[x]-b[y]);             y++;         } else {             minimum=min(minimum,b[y]-a[x]);             x++;         }     }     return minimum; } int main() {     int a[6] = {8,18,28,38,48,49};     int b[6] = {7,15,16,17,18,56};     int m, n;      m = n =6;     printf("%d\n", mindistance(a, b, m, n));     return 0; } 头文件名写错了，include应该是limits.h； int m = n =6; 这样定义，n是未定义的，改一下；如上的代码，注意下代码风格～

引用 3 楼 zhao4zhong1 的回复:[quote=引用 2 楼 z245821190 的回复:] 那你能说说什么时候才用limits头文件里的值吗 使用grep（linux）或findstr（windows）命令搜索crt\src\目录下的所有文件，看哪些包含字符串"limits.h"[/quote] C:\Program Files\Microsoft Visual Studio 8\VC\crt\src>grep -0is limits.h *.c *.cpp File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\assert.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\dbgheap.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\dbghook.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\dospawn.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\fread.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\gets.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\initctyp.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\initmon.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\lcnvinit.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\lconv.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\localtim.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\loctim64.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\makepath.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\mbrtowc.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\mbsnbcol.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\mbsncoll.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\mbsnicol.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\mlock.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\output.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\putch.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\putwch.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\rotl.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\rotr.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\sbheap.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\setenv.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\setvbuf.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\sprintf.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\stdargv.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\strlwr.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\strncoll.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\strnicol.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\strtol.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\strtoq.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\strupr.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\strxfrm.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\swprintf.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\vsprintf.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\vswprint.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\wcrtomb.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\wcsncoll.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\wcsnicol.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\wcstol.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\wcstombs.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\wcstoq.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\wcsxfrm.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\wctomb.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\wild.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\wperror.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\xmbtowc.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\xstol.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\xstoll.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\xstoul.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\xstoull.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\xstrxfrm.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\xtoa.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\xwcsxfrm.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\xwctomb.c File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\swprintn.cpp File: C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\vswprinn.cpp

[quote=引用 1 楼 cfjtaishan 的回复:] [我把头文件改了，不报错，但是输出结果也不对呀~结果应该是1，现在是0，还有哪里有问题吗？

引用 2 楼 z245821190 的回复:那你能说说什么时候才用limits头文件里的值吗 这个问题问的很没意义，当然是你需要用的时候用啊 http://www.yiibai.com/c_standard_library/limits_h.html

引用 2 楼 z245821190 的回复:那你能说说什么时候才用limits头文件里的值吗 一般是用到某个类型的最大值或者最小值时会用到吧，尤其是在嵌入式平台，由于其会设计不同的硬件平台，不同的编译器会对不同类型的数据大小做一些限制； 建议看一下limits.h里的内容，根据内容来区分在什么场合下使用。


Question: 关于C语言函数传参和函数调用的问题

引用 6 楼 sxh2016 的回复:[quote=引用 4 楼 xian_wwq 的回复:] [quote=引用 3 楼 sxh2016 的回复:] 那函数的输出型参数和输入型参数又是什么意思呢？  可以简单理解为数据流向， 输入型是由使用者提供，完成函数执行； 输出型参数是函数执行完后，还会给使用者返回数据；[/quote] 返回的是函数加工过的数据嘛？返回的数据放到了哪里呢？[/quote]  是的，返回的是处理过的数据，数据存在函数调用者传入的对象中 要返回数据传入的只可能是指针类型，值类型是没有办法返回数据的

引用 3 楼 sxh2016 的回复:那函数的输出型参数和输入型参数又是什么意思呢？  可以简单理解为数据流向， 输入型是由使用者提供，完成函数执行； 输出型参数是函数执行完后，还会给使用者返回数据；

那函数的输出型参数和输入型参数又是什么意思呢？

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

调用约定 https://msdn.microsoft.com/zh-cn/magazine/9b372w95.aspx

引用 4 楼 xian_wwq 的回复:[quote=引用 3 楼 sxh2016 的回复:] 那函数的输出型参数和输入型参数又是什么意思呢？  可以简单理解为数据流向， 输入型是由使用者提供，完成函数执行； 输出型参数是函数执行完后，还会给使用者返回数据；[/quote] 返回的是函数加工过的数据嘛？返回的数据放到了哪里呢？

一般都是传值，指针类型也是传值，只是传的是指针值，只有引用类型的实际是传地址

调用时传入的是实参，定义和声明时是形参； 形参和实参在不同的函数栈，是相互独立的。

--------- rc = gslX680_ts_init(client, ts);括号里的是传入的值？ 函数调用都是传值，地址(指针)也是一个值，主要是看这个值的类型，从函数声明来看client和ts都是一个指向结构体的指针  --------- static int gslX680_ts_init(struct i2c_client *client, struct gsl_ts *ts)括号里是输入的值？ 括号里是这个函数的形式参数，换句话说：括号里的是描述当调用gslX680_ts_init时，需要传递的参数的顺序，参数的类型。


Question: 在linux上通过txt文件修改linux 的Ip

grep、sed、awk提取IP ifconfig修改IP crontab间隔一定时间执行

主要是运用到文件打开，文件读写，字符串匹配，以及数值和字符串的转换等等； 建议楼主先自己写写，具体遇到问题再让大家帮你解决。

可以详细点吗，这命令只是查信息的

pwd，sed，ifconfig，crontab，……


Question: 一个关于xcode的问题

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

第二个没有\n，回车符。 在windows下或者标准的C程序编译器，或者在Linux下运行，最后一行都会运行的。因为程序结束，系统会清理该程序在内存里空间，包括将在内存里的数据刷到终端或者文件。


Question: c语言关于FLOAT输出问题

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

引用 楼主 MYsce 的回复:#include<stdio.h> int main(void) {	float ftemp; 	printf("请输入:"); 	scanf("%f",&ftemp); 	printf("f = %f  e = %E\n",ftemp,ftemp); 	return 0;  }  怎么我输出会21.290001呢，我想输出是21.290000我想输出21.290000怎么会这样 我用的是win10 vs2010  浮点型的精度问题


Question: 求助大神啊！！本人新手

不错不错，有设计感

不要把方法设为静态的，这种方法

就是当点击这张图里的返回，返回到这张图而这里面的数据不会被重新实例化

不懂，能不能描述清楚点；贴代码

求各位大神！！


Question: 求助 C语言realloc和free触发断点的问题

引用 1 楼 user-5 的回复:估计使用堆内存越界导致堆破坏  一般在释放或重新分配时会导致崩溃  所以检查你代码有没越界等 如果是这样，楼主可以从网上下载完全也堆工具进行检测。 以下是参考资料和下载链接： 堆调试工具——pageheap的使用和原理分析 pageheap下载1 pageheap下载2 如有安全软件拦截，可放行。

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

myRealloc(&buf, bufSize, bufSize);  myRealloc函数中后面的两个实参是一样的，大小一样，就没有old或者new，这样会导致myRealloc中的buf越界。  #include <stdio.h> #include <stdlib.h> #include <string.h>  #pragma warning(disable:4996)  void myRealloc(int **buf, int oldsize, int newsize) {     int *tmp = (int *)calloc(sizeof(int), newsize);     for (int i = 0; i < oldsize; i++)     {         *(tmp + i) = *(*buf + i);     }     free(*buf);     *buf = tmp; }  int main(void) {     FILE *fr = fopen("d:\\test.txt", "rb");     int bufSize = 10;     int bufIndex = 0;     int *buf = (int *)calloc(sizeof(int), bufSize);     int *count = (int *)calloc(sizeof(int), bufSize);      while (!feof(fr))     {         int tmp = 0;         fscanf(fr, "%d", &tmp);         int index = getBufIndex(buf, bufSize, tmp);         if (index == -1)         {             *(buf + bufIndex) = tmp;             *(count + bufIndex) += 1;             bufIndex++;             if (bufIndex == bufSize)             {                 //bufSize *= 1.5;   /*del */                 myRealloc(&buf, bufSize, bufSize * 1.5);    /*old and new*/                 printf("%d\n", bufSize);             }         }         else         {             *(buf + index) = tmp;             *(count + index) += 1;         }     }      free(buf);     free(count);     puts("over");     return 0; }

#include <stdio.h> #include <stdlib.h> #include <string.h>   #pragma warning(disable:4996)   int main(void) {     int bufLen = 10;     int *nums = calloc(sizeof(int), bufLen);     for (int i = 0; i < 10000; i++)     {         *(nums + i) = i;         if (i == bufLen - 1)         {             realloc(nums, bufLen * 1.5);             bufLen *= 1.5;             printf("%d\n", bufLen);         }     }     puts("--over--");     return 0; } 该程序已经越界，注意，第一次realloc是将nums的空间缩小了，原来是10 × 4 = 40, 现在的长度是10 × 1.5 = 15； 但是realloc申请的新空间没有给nums，所以nums的有效空间还是40（10个int），即使这样，还是越界，因为i的值在增加； 如果你的想法是递增的增加内存，详见下面的demo: #include <stdio.h> #include <stdlib.h> #include <string.h>  #pragma warning(disable:4996)  int main(void) {     int i;     int bufLen = 10;     //int *nums = calloc(sizeof(int), bufLen);     int *nums = (int *)calloc(bufLen , sizeof(int));      for (i = 0; i < 10000; i++) {         *(nums + i) = i;         printf("i = %d\n", i);         if (i == bufLen - 1) {             nums = (int *) realloc(nums, bufLen * sizeof(int) * 1.5);             if (!nums) {                 fprintf(stdout, "realloc error!\n");                 exit(-1);             }             bufLen *= 1.5;             printf("bufLen = %d\n", bufLen);         }     }     puts("--over--");     return 0; }

引用 2 楼 ptrunner 的回复:bufLen*1.5只分配了15Byte，而For循环中为10000，内存越界导致的。 buf是有变化的哦  buf  *= 1.5 想的是每次分配空间不够用了 就分配一个比现在空间大1.5倍的空间存放数据


Question: 神奇的六位数

引用 2 楼 qq_36409192 的回复:最直接，最暴力的方法，从100000向999999进行搜索，满足条件的输出。  这个暴力法就太慢了

最暴力的方法，从100000向166666进发，爆炸了计算

1/7 呗 。。。

最直接，最暴力的方法，从100000向999999进行搜索，满足条件的输出。

六位数最高位只能是1，因为它乘以6还是一个六位数，即乘以6后不能有进位。同时次高位不能大于等于7，因为次高位是7或更大，乘以6后会有进位，即使在最高为为1时。 可以继续根据其他的方法将可能的六位数缩小范围


Question: 数据存储和打印

找到一个资料，可能对你有用http://blog.csdn.net/libing403?viewmode=contents

电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

主要是输出时，格式不一样，格式表示的数据的范围不一样；所以，内存里的数据是一样的，输出格式不一样，同一个数据输出的值可能不一样。


Question: 函数的调用问题，求大神救急，在线等！

引用 5 楼 caine12345 的回复:[quote=引用 4 楼 cfjtaishan 的回复:] #include<stdio.h>  void escape(char s[],char t[]);  int main() {     int c;     char s[32];     char t[32];      printf("plese input you arr:");     fgets(t, 32, stdin);     //scanf("%s", t);     puts(t);     escape(s, t);          printf("%s", s);         /*     while ((c = getchar()) != EOF) {         printf("%s",s);     }     */      return 0; }   void escape(char s[],char t[]) {     int i, j;      for(i = j = 0; t[i] != '\0'; i++){         switch (t[i]){             case '\n':                 s[j++] = '\\';                 s[j++] = 'n';                 break;              case '\t':                 s[j++] = '\\';                 s[j++] = 't';                 break;              default:                 s[j++] = t[i];                 break;         }     }     s[j] = '\0'; }  escape函数没有问题，不过scanf不能输入\t和\n到缓存里。建议使用fgets函数。另外， 之所以会出现多次输出，是因为while循环导致的。  谢谢！不过为什么scanf不能输入\t 、\n到缓存里呢？[/quote] scanf若同时输入多个变量时，是以空格（也可以多个空格）做了间隔区分的，所以\t是多个空格，也就是不能输入的； 另外，标准输入是行缓冲，输入\n标志输入结束；

你把函数的参数改成引用形。

引用 4 楼 cfjtaishan 的回复:#include<stdio.h>  void escape(char s[],char t[]);  int main() {     int c;     char s[32];     char t[32];      printf("plese input you arr:");     fgets(t, 32, stdin);     //scanf("%s", t);     puts(t);     escape(s, t);          printf("%s", s);         /*     while ((c = getchar()) != EOF) {         printf("%s",s);     }     */      return 0; }   void escape(char s[],char t[]) {     int i, j;      for(i = j = 0; t[i] != '\0'; i++){         switch (t[i]){             case '\n':                 s[j++] = '\\';                 s[j++] = 'n';                 break;              case '\t':                 s[j++] = '\\';                 s[j++] = 't';                 break;              default:                 s[j++] = t[i];                 break;         }     }     s[j] = '\0'; }  escape函数没有问题，不过scanf不能输入\t和\n到缓存里。建议使用fgets函数。另外， 之所以会出现多次输出，是因为while循环导致的。  谢谢！不过为什么scanf不能输入\t 、\n到缓存里呢？

引用 1 楼 hdt 的回复:你这个程序有问题，比如原字符串abc\ncde; 按照你的程序将变为abc\nde 其次 \\ 变为 \ n=》n 因此你的程序里面\ n 是两个字符 而\n是一个字符 那请问该怎么解决呢？我需要修改哪部分代码？


Question: 学习方向的问题  谢谢你了

有时去执行一个错误的决定总比优柔寡断或者没有决定要好得多。

有帮助，just do it

引用 4 楼 bravery36的回复:当然有帮助，但是你要有自己的目标。你的目的是求职还是学习？求职的话还是可以更有针对性一点。 好  谢谢你了 我现在大一   主要还是学习吧

引用 5 楼 ck2333的回复:在掌握一两门基础变成语言后，建议去学一下数据结构与算法分析。 好  谢谢你了  我现在就真正学

引用 3 楼 自信男孩的回复:嗯，如果是通过自己的编译运行，调试的，对自己的编程能力还是有很大帮助的；建议在原来的基础上在进行优化，比如不完善的功能，效率不高的地方，性能不好的地方或者可以添加一些新的功能；这样对自己的编程能力有一个升华。 嗯  好  谢谢  我会努力的

在掌握一两门基础变成语言后，建议去学一下数据结构与算法分析。

引用 1 楼 user-6的回复:当然有了，有些东西光看懂了没用，在实践中才会发现其实没懂 谢谢你了  我学C语言的时候一直喜欢编写一些小游戏  然后害怕这些东西不但浪费时间还对我的编程能力没有用

当然有了，有些东西光看懂了没用，在实践中才会发现其实没懂

《Visual C++ 游戏开发经典案例详解》

引用 13 楼 赵4老师的回复:[quote=引用 11 楼 qq_36686996 的回复:] [quote=引用 10 楼 赵4老师的回复:]有时去执行一个错误的决定总比优柔寡断或者没有决定要好得多。 嗯   对的  但是  我已经做好了贪吃蛇和飞机大战还有俄罗斯方块了  现在准备在做推箱子  但是我不知道是否应该再花这个时间了  所以咨询一下各位大佬的[/quote] 推箱子游戏VC6源代码 http://download.csdn.net/detail/zhao4zhong1/3230945[/quote] 谢谢你了  我会好好看的  感谢感谢

引用 11 楼 qq_36686996 的回复:[quote=引用 10 楼 赵4老师的回复:]有时去执行一个错误的决定总比优柔寡断或者没有决定要好得多。 嗯   对的  但是  我已经做好了贪吃蛇和飞机大战还有俄罗斯方块了  现在准备在做推箱子  但是我不知道是否应该再花这个时间了  所以咨询一下各位大佬的[/quote] 推箱子游戏VC6源代码 http://download.csdn.net/detail/zhao4zhong1/3230945

犹豫继续呆在屋里还是出门，先稍微到门外走几步，然后再决定。

引用 10 楼 赵4老师的回复:有时去执行一个错误的决定总比优柔寡断或者没有决定要好得多。 嗯   对的  但是  我已经做好了贪吃蛇和飞机大战还有俄罗斯方块了  现在准备在做推箱子  但是我不知道是否应该再花这个时间了  所以咨询一下各位大佬的


Question: 蓝桥杯模拟赛的填空题


Question: 结构体数组的初始化

C语言中数组定义 和初始化都会讲到这些内容的。

用大括号这种语法只能在初始化时，而不能在之后的赋值时使用

引用 3 楼 sinat_35134692 的回复:[quote=引用 2 楼 wang0635 的回复:] 这是赋值，不允许的。 初始化可以用初始值列表。真想这样写，可以强制转换，如     head[0] = (headtype){ "abcde", 0 };     head[1] = (headtype){ "cdefg", 3 }; 多谢解答，想问下为什么加了一个强制类型转换就可以了？可以简要分析下么，谢谢[/quote]告诉编译器它是结构体而不是数组

。楼上都是对的。。。。。。。。

“变量赋值”和“变量初始化”不是一回事！ “变量赋值”发生在运行期，其写法遵循赋值语法规定。 “变量初始化”发生在编译期或运行期，其写法遵循初始化列表语法规定。

引用 2 楼 wang0635 的回复:这是赋值，不允许的。 初始化可以用初始值列表。真想这样写，可以强制转换，如     head[0] = (headtype){ "abcde", 0 };     head[1] = (headtype){ "cdefg", 3 }; 多谢解答，想问下为什么加了一个强制类型转换就可以了？可以简要分析下么，谢谢

在定义时可以这样初始化，但是单独操作不这样赋值了。   strncpy(head[0].str, "abcde", 10); head[0].len = 0; strncpy(head[1].str, "cdefg", 10); head[1].len = 3; 只能这样赋值了。


Question: C 语言，用SDK API 链接数据库，怎么链接？

犯了个低价错误 因为C FREE 导入ODBC32的时候，是包含路径的的。记得把路径删除掉。 来个人顶贴吧，我散60分

SQL Server自带的命令行工具比如bcp就是用C/C++写的。

自己来顶贴 各位大神们，别给我 一个链接，或者MSDN 让我自己去看。 我看过了，没成功，所以才来找高人的。 谢谢


Question: c语言指针问题

从前面可以看出，你的头指针没问题，且你传入的参数node没有判空或者node本身就是野指针，亦或者node->next就是野指针。你可以去看一看的参数node.

注意一下你传进来的参数node是否为野指针，或者NULL

node万一是NULL呢？


Question: B_PTR( var )  ( (byte *) (void *) &(var) )的疑问

引用 4 楼 zuixin369 的回复:[quote=引用 2 楼 zhao4zhong1 的回复:] //C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+   我没有看懂，这些与我的问题有什么关联，能否说明白一些。[/quote] //| (type)           | Type cast (conversion)                  | Right to left |

引用 3 楼 zuixin369 的回复:[quote=引用 1 楼 user-2 的回复:] 转换一次就够了 你的方法有问题。指针和unsigned int类型未必有相同的位数，考虑到可移植性，还是指针稳妥  转换一次你的意思是下面的形式？ #define  B_PTR( var )  ( (byte *) &(var) )  指针和unsigned int类型未必有相同的位数，考虑到可移植性，还是指针稳妥。这句话怎么理解，能够举个例子说明一下[/quote] 如keil c中的int是16位的，通用指针是24位的

引用 2 楼 zhao4zhong1 的回复://C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+   我没有看懂，这些与我的问题有什么关联，能否说明白一些。

引用 1 楼 user-2 的回复:转换一次就够了 你的方法有问题。指针和unsigned int类型未必有相同的位数，考虑到可移植性，还是指针稳妥  转换一次你的意思是下面的形式？ #define  B_PTR( var )  ( (byte *) &(var) )  指针和unsigned int类型未必有相同的位数，考虑到可移植性，还是指针稳妥。这句话怎么理解，能够举个例子说明一下

引用 11 楼 zuixin369 的回复:[quote=引用 9 楼 user-2 的回复:] [quote=引用 7 楼 zuixin369 的回复:] [quote=引用 5 楼 user-2 的回复:] [quote=引用 3 楼 zuixin369 的回复:] [quote=引用 1 楼 user-2 的回复:] 转换一次就够了 你的方法有问题。指针和unsigned int类型未必有相同的位数，考虑到可移植性，还是指针稳妥  转换一次你的意思是下面的形式？ #define  B_PTR( var )  ( (byte *) &(var) )  指针和unsigned int类型未必有相同的位数，考虑到可移植性，还是指针稳妥。这句话怎么理解，能够举个例子说明一下[/quote] 如keil c中的int是16位的，通用指针是24位的[/quote]  即使没有相同的位数，24位的通用指针经强制转换16位的int，还会出错吗？ 另，你说的经过一次转换后就行了， #define  B_PTR( var )  ( (byte *) &(var) ) #define  B_PTR( var )  (  (void *) &(var) ) 你的意思定义成上述两种形式都是OK？[/quote] 应该用第一种形式 第二种形式是转换成void型指针了，赋值给其他变量没问题，而间接求值时还要转换 24位的通用指针经强制转换16位的int，有风险的，不能保证不出问题[/quote]  #define  B_PTR( var )  ( (byte *) &(var) ) 我认可这样的写法，但是该宏定义中间还转换为void* ，这样做的目的是什么，看见网上好多这样的写法[/quote] 很多的东西，实际上是同一个，转来转去的，到哪儿去找第一个真正这样写的人呢？只有他知道

引用 10 楼 zhao4zhong1 的回复://| (type)           | Type cast (conversion)                  | Right to left | (type)操作符是按从右到左优先级结合的。 意思就是说比如： (type1)(type2)a的类型是type1 (type2)(type1)a的类型是type2  那为什么中间要用void*，这样的目的是什么，不可能没有目的吧

引用 9 楼 user-2 的回复:[quote=引用 7 楼 zuixin369 的回复:] [quote=引用 5 楼 user-2 的回复:] [quote=引用 3 楼 zuixin369 的回复:] [quote=引用 1 楼 user-2 的回复:] 转换一次就够了 你的方法有问题。指针和unsigned int类型未必有相同的位数，考虑到可移植性，还是指针稳妥  转换一次你的意思是下面的形式？ #define  B_PTR( var )  ( (byte *) &(var) )  指针和unsigned int类型未必有相同的位数，考虑到可移植性，还是指针稳妥。这句话怎么理解，能够举个例子说明一下[/quote] 如keil c中的int是16位的，通用指针是24位的[/quote]  即使没有相同的位数，24位的通用指针经强制转换16位的int，还会出错吗？ 另，你说的经过一次转换后就行了， #define  B_PTR( var )  ( (byte *) &(var) ) #define  B_PTR( var )  (  (void *) &(var) ) 你的意思定义成上述两种形式都是OK？[/quote] 应该用第一种形式 第二种形式是转换成void型指针了，赋值给其他变量没问题，而间接求值时还要转换 24位的通用指针经强制转换16位的int，有风险的，不能保证不出问题[/quote]  #define  B_PTR( var )  ( (byte *) &(var) ) 我认可这样的写法，但是该宏定义中间还转换为void* ，这样做的目的是什么，看见网上好多这样的写法

引用 7 楼 zuixin369 的回复:[quote=引用 5 楼 user-2 的回复:] [quote=引用 3 楼 zuixin369 的回复:] [quote=引用 1 楼 user-2 的回复:] 转换一次就够了 你的方法有问题。指针和unsigned int类型未必有相同的位数，考虑到可移植性，还是指针稳妥  转换一次你的意思是下面的形式？ #define  B_PTR( var )  ( (byte *) &(var) )  指针和unsigned int类型未必有相同的位数，考虑到可移植性，还是指针稳妥。这句话怎么理解，能够举个例子说明一下[/quote] 如keil c中的int是16位的，通用指针是24位的[/quote]  即使没有相同的位数，24位的通用指针经强制转换16位的int，还会出错吗？ 另，你说的经过一次转换后就行了， #define  B_PTR( var )  ( (byte *) &(var) ) #define  B_PTR( var )  (  (void *) &(var) ) 你的意思定义成上述两种形式都是OK？[/quote] 应该用第一种形式 第二种形式是转换成void型指针了，赋值给其他变量没问题，而间接求值时还要转换 24位的通用指针经强制转换16位的int，有风险的，不能保证不出问题

引用 6 楼 zhao4zhong1 的回复:[quote=引用 4 楼 zuixin369 的回复:] [quote=引用 2 楼 zhao4zhong1 的回复:] //C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+   我没有看懂，这些与我的问题有什么关联，能否说明白一些。[/quote] //| (type)           | Type cast (conversion)                  | Right to left | [/quote]  大侠，我始终没有明白，你说的这些与我问的有什么关联，求指教

引用 5 楼 user-2 的回复:[quote=引用 3 楼 zuixin369 的回复:] [quote=引用 1 楼 user-2 的回复:] 转换一次就够了 你的方法有问题。指针和unsigned int类型未必有相同的位数，考虑到可移植性，还是指针稳妥  转换一次你的意思是下面的形式？ #define  B_PTR( var )  ( (byte *) &(var) )  指针和unsigned int类型未必有相同的位数，考虑到可移植性，还是指针稳妥。这句话怎么理解，能够举个例子说明一下[/quote] 如keil c中的int是16位的，通用指针是24位的[/quote]  即使没有相同的位数，24位的通用指针经强制转换16位的int，还会出错吗？ 另，你说的经过一次转换后就行了， #define  B_PTR( var )  ( (byte *) &(var) ) #define  B_PTR( var )  (  (void *) &(var) ) 你的意思定义成上述两种形式都是OK？


Question: c语言简单问题求解

引用 4 楼 tiandragon00 的回复:时间复杂度是N 不是N的平方 嗯？你确定我的算法的时间复杂度是N的平方？ 我想我们先搞清楚时间复杂度是如何计算的~

仅供参考：#include <stdio.h> #include <string.h> char s1[]="delete"; char s2[]="select"; unsigned char n[256]={0}; char r[257]; int i,L,o=0; void main() {     L=strlen(s1); for (i=0;i<L;i++) if (!n[(unsigned int)s1[i]]) n[(unsigned int)s1[i]]=++o;     L=strlen(s2); for (i=0;i<L;i++) if (!n[(unsigned int)s2[i]]) n[(unsigned int)s2[i]]=++o;     L=0; 	for	(o=1;o<=256;o++) { 		for	(i=0;i<256;i++)	{ 			if (o==n[i]) { 				r[L++]=i; 				break; 			} 		} 		if (i>=256)	break; 	}     r[L]=0;     printf("[%s]\n",r); } //[deltsc]

时间复杂度是N 不是N的平方

大牛，能具体点吗？

顺序异或~~

引用 3 楼 cfjtaishan 的回复:定义一个一维数组，长度是26（26个字母）；通过遍历字符串然后统计字符的个数；最后遍历该一维数组，输出个数为1的 部分代码： 	int  stat[26]; 	memset(stat, 0, 26*sizeof(int)); 	char t; 	cin >> t; 	while (t >= 'a' && t <='z') 	{ 		stat[t - 'a']++; 		cin >> t; 	} 	for (int i = 0; i < 26; i++) 	{ 		if (stat[i] == 1) 			cout << " " << (char)(i + 'a'); 	}

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

能否解释一下