Question: PAT甲级题库1001. A+B Format 某个测试点出错

希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

a , b = input().split(' ') s = int(a) + int(b) if s < 0:     s1=str(-s)     print('-',end='') else:     s1=str(s) for i in range(1,len(s1) + 1):     print(s1[i-1] ,',' if i%3==len(s1)%3 and i!=len(s1) else '', sep='', end='')   #9行搞定

#include <iostream> #include <cstdio> #include <cstdlib>   using namespace std;  int main() {     int a, b, sum, c;     sum = 0;      scanf("%d %d", &a,&b);     sum = a + b;      if(sum < 1000 && sum > -1000)         printf("%d\n",sum);     else if(sum < 1000000 && sum > -1000000)         printf("%d,%03d\n", sum/1000, abs(sum % 1000));     else {         c = sum % 1000000;         printf("%d,%03d,%03d\n", sum / 1000000, abs(c/1000), abs(c%1000));     }      return 0; } 20分代码

第十六行  printf("%d,%03d,%03d",sum/1000000,abs(c/1000000),abs(c%1000));可能有点问题     999999+9999999=1，999，998

同楼主，我是第十个测试点一直错

#include <stdio.h> #include <stdlib.h>  int main() {     int a, b, sum, c;     sum = 0;      scanf("%d %d", &a,&b);     sum = a + b;      if(sum < 1000 && sum > -1000)         printf("%d\n",sum);     else if(sum < 1000000 && sum > -1000000)         printf("%d, %03d\n", sum/1000, abs(sum % 1000));     else {         c = sum % 1000000;         printf("%d, %03d, %03d\n", sum / 1000000, abs(c/1000000), abs(c%1000));     }      return 0; } abs头文件是stdlib.h，不是math.h吧 我是在Linux下测试的


Question: C语言函数参数问题

引用是足，画蛇添足的足。个人意见。

学严蔚敏落下的毛病

C语言下没有引用，C++才有，所以要地址传递，可以用指针

#include<iostream.h> void Exchg3(int &x, int &y) {    int tmp = x;    x = y;    y = tmp;    cout<<"x = "<<x<<",y = "<<y<<endl; } main() {    int a = 4;    int b = 6;    Exchg3(a, b);    cout<<"a = "<<a<<",b = "<<b<<endl;    return(0); }

C语言没有引用，关于C语言的知识，可以参考一下这个http://blog.csdn.net/libing403?viewmode=contents

C里面没有引用的

里面有关于c语言的资料，对你可能有用 http://blog.csdn.net/libing403?viewmode=contents

C语言没有引用，C++才有  C语言需要按指针传递来达到类似引用的效果

c要改参数值，只能用指针，传实参地址进去了

引用是C++的特殊使用，C语言不支持。建议使用指针。 #include <stdio.h>  void Exchg3(int *x, int *y) {    int tmp = *x;    *x = *y;    *y = tmp;    printf("x = %d,y = %d\n", *x, *y); } int main() {    int a = 4;    int b = 6;     Exchg3(&a, &b);    printf("a = %d, b = %d\n", a, b);     return 0; }

楼主说对了，c里面不能用引用

C语言里没有引用，只有指针，只能用int *p，或者如果不需要改变实参可以传值

引用 1 楼 user-12的回复:C++才有引用，C只有指针 那在C里面，定义函数参数时，上面两种都不可以吗，只能int*p？

明白了，感激各位大神

C++才有引用，C只有指针


Question: malloc怎么申请一个动态的空间

m没有初始化    malloc   申请空间时是要必须知道要申请的空间的大小(要申请空间的字节数)

你的m没有值，编译器不知道要申请的空间大小 int m = 3;

引用 6 楼 zhao4zhong1 的回复:int m=0; int *p; sum(a,&m);  //m需要在sum求出来 if (m>0) {  p=(int*)malloc(m*sizeof(int));  if (p==NULL) {   printf("Can not malloc %d bytes to p!",m*sizeof(int));   exit(1);  }  ...  free(p); } 谢谢！您的意思我懂了，先调用sum求出m,再malloc,再调用sum输出p，非常感谢！确实是我设计上的问题

引用 4 楼 doubyZZ 的回复:[quote=引用 1 楼 starytx 的回复:] 你的m没有值，编译器不知道要申请的空间大小 int m = 3;因为申请的时候，空间大小我不知道，要在后面的函数中求出来。[/quote]那你这个就是死循环了，设计上有问题，m还没有求出来，却要在sum中对p进行输出。

引用 1 楼 starytx 的回复:你的m没有值，编译器不知道要申请的空间大小 int m = 3;因为申请的时候，空间大小我不知道，要在后面的函数中求出来。

m未初始化，编译器给它的是一个随机值（这个随机值可能比较大），那么申请到的空间大小是不确定的（随机的）；


Question: deb包转rpm包

不会的，alien就是那么几个参数

参数不对？ http://www.linuxidc.com/Linux/2015-09/122573.htm


Question: 一个关于宏展开的问题。

引用 1 楼 zhao4zhong1 的回复:#与##在宏定义中的--宏展开 #include <stdio.h> #define f(a,b) a##b #define g(a)   #a #define h(a) g(a) int main() {         printf("%s\n", h(f(1,2)));   // 12         printf("%s\n", g(f(1,2))); // f(1,2)         return 0; } 宏展开时： 如果宏定义以#开头，不展开参数，直接替换。 故g(f(1,2))--->#f(1,2)--->"f(1,2)"； 如果宏定义不以#开头，展开参数，直接替换，由外层向里层，如果碰到的是#开头的宏，不继续往里层展开，往外层展开。 由外层向里层，如果碰到的是以非#开头的宏，继续往里层走，直至最里层，开始一层层往外层展开。 故h(f(1,2))--->h(12)--->g(12)---->#12----->"12"。 PS： ##在宏中定义，是字符连接符 如a##b##c 等同于 "abc" #在宏开头出现，是表示宏展开的方式不同 #a 等同于"a" #abc 等同于 "abc" 复杂的: #include <stdio.h> #define f(a,b) a##b #define g(a)   #a #define h(a) g(a) int main() {         char a = 'a';         cout<<g(a)<<endl; // a         cout<<g(g(a))<<endl; // a         printf("%s\n", h(f(1,2)));   // 12         printf("%s\n", g(f(1,2))); // f(1,2)         printf("%s\n", g(h(f(1,2)))); // h(f(1,2))         printf("%s\n", h(g(f(1,2)))); // "f(1,2)"         printf("%s\n", h(h(f(1,2)))); // "12"         system("pause");         return 0; } 预处理后的：（在编译选项中添加/EP /P后编译生成的.i文件。gcc加-E） int main() {         char a = 'a';         cout<<"a"<<endl;         cout<<"g(a)"<<endl;         printf("%s\n", "12");         printf("%s\n", "f(1,2)");         printf("%s\n", "h(f(1,2))");         printf("%s\n", "\"f(1,2)\"");         printf("%s\n", "\"12\"");         system("pause");         return 0; } --------------------------------------------------- 宏解析 1.       ##操作符 ##操作符它的作用是在替代表中将其前后的参数连接成为一个预处理符号，它不能出现于宏替代表的开端和末尾。 例： #define concat(s,t) s##t #define AAA ABC concat(A, AA) 将被替换成 ABC 2.       重新扫描和替换 在替换列表中的所有参数替换过之后，预处理器将对结果token序列重新扫描以便对其中的宏再次替换。 当正在替换的宏在其替换列表中发现自身时，就不再对其进行替换。在任何正在嵌套替换的宏的替换过程中遇到正被替换的宏就对其不再进行替换（防止递归）。 例： #define ROOT AAA CCC #define AAA ROOT ROOT 将被替换成 ROOT CCC 看了好几遍，终于明白了，受益匪浅！谢谢！

宏定义即等价替换 https://wenku.baidu.com/view/b615bd64be1e650e52ea9939.html

##是直接连接两个参数  # 把参数变成一个字符串  http://www.cnblogs.com/hnrainll/archive/2012/08/15/2640558.html

按顺序展开！


Question: 建立一个链表，每个结点包括学生的学号，姓名和学生的平均成绩；输入一个学生的名字，如果链表中有该学生，则删除该结点

p不为空就删除

4. 还有字符串比较，要用字符串函数。

#include<stdio.h> #include<stdlib.h> #include<string.h>  typedef struct student {      char num[20];     char name[20];     int aver;     struct student *next; }STU;      STU *creat();     STU *del(STU *head,char name[20]);     void display(STU *);  int main() {     STU *head, *s;     char name[20];      head = creat();     printf("输入个数：");      display(head);     printf("要删除的名字：");     fgets(name, 20, stdin);     name[strlen(name) - 1] = 0;     head = del(head, name);//     display(head);      return 0; }  STU *creat() {     STU *head,*p,*s;     int key = 1, n;     char k[3],aver[3];      head = (STU *)malloc(sizeof(STU));     p = head;     while(key)     {         printf("输入：");         gets(k);         n=atoi(k);         if(n!=0)         {             s=(STU *)malloc(sizeof(STU));             printf("输入名字：");             gets(s->name);             printf("输入学号：");             gets(s->num);             printf("输入成绩：");             gets(aver);             s->aver=atoi(aver);             p->next = s;             p = s;         }         else             key=0;     }     p->next = NULL;     s = head;     head = head->next;     free(s);    /* need to free */     return(head); }   STU *del(STU *head,char name[20]) {     STU *p,*q;     if(head == NULL)         printf("error \n");      if(strcmp(head->name,name) == 0) {         p = head;         head = head->next;         free(p);     } else {         q = head;         p = head->next;         while (p) {             if (strncmp(p->name, name, 20) == 0) {                 q->next = p->next;                 free(p);                 break;             }             p = p->next;             q = q->next;         }         if (!p)             printf("Not found!\n"); /*         while(p && p->name != name)             if((p->name)!=name)             {                 q=p;                 p=p->next;                 printf("ok\n");             }         if(p!=NULL)         {             q->next=p->next;             free(p);             printf("ok\n");         }         else             printf("not found\n");             */     }     return head; }  void display(STU *head) {     STU *p;     p = head;       printf("chain is : \n");     while (p) {         printf("%s %s %d \n", p->name, p->num, p->aver);         p = p->next;     }     /*        printf("chain is : \n");        if(head!=NULL) {        do {        printf("%s %s %d \n", p->name, p->num, p->aver);        p=p->next;        } while(p!=NULL);        }        */ } 参考一下这个代码吧； 问题：1. fgets比gets安全，建议使用fgets，但是注意fgets可能将\n输入到缓存里，注意去掉； 2. 创建链表时，若想去掉岗哨节点，记着free掉其空间； 3. del删除一个节点时，注意要返回新的头节点，因为删除的有可能就是头节点。不论是通过返回值返回还是传入传出参数返回。

while(p!=NULL && (p->name)!=name)             if((p->name)!=name)  这里的比较用strcmp进行字符串的比较

你具体的错是指哪里错或者怎么错，说清楚一点，要不然找错误得仔仔细细分析一遍你的代码。


Question: 分组密码之LED算法

百度搜相关关键字。


Question: c语言中如何在不影响程序运行的情况下实现背景音乐循环

MCI ？

开线程或者进程；多线程或者多进程都可以实现并发

不影响运行，貌似就是开个线程，在里边循环播放了

看你是用什么方式播放背景音的， 有些播放函数直接支持循环播放的

加开一个线程去执行音乐播放


Question: 小白求助，关于双散列的问题，求大神解答，谢谢！

此题目是在数据结构与算法分析--c语言实现中看到的， 求解答，谢谢


Question: 指针变量访问数组总是出现数组第一个元素！求大佬解惑！

不用element这个变量，在输出时直接将element换成*（addr+i）

就像上面各位说的，你的element的值一直都没有变，一直都是数组的第一个元素的值，应该把指针朝后移动一位才可以

element是一个int对象，值是不会变的，所以一直是第一个元素，换成addr++就可以了 printf("a[%d]=%d\n",i,addr++);

指针偏移取值

数组名是整个数组的的起始地址，也同时是数组第一个元素的地址。

#include<stdio.h>     int main() { 	int a[5] = { 1, 2, 3, 4, 5, }; 	int *addr; 	int i; 	  	addr = a; 	int *element = addr;  	for (i = 0; i<5; i++) 	{ 		printf("a[%d]=%d\n", i, *element++); 	} 	system("pause"); 	return 0; }

引用 3 楼 岛是海的一块疤的回复:element   代表了数组首元素的地址， 你可以 在输出的时候 对  element++  然后就可以了 看错了，  变量 element是  数组首元素的值  你可以输出的时候把element   换为  * (add++)

数组名是数组第一个元素的地址

#include <stdio.h>   int main() {     int a[5] = {1, 2, 3, 4, 5,};     int *addr;     int i;     int element;      addr = a;     element = *addr;      for(i=0;i<5;i++)         printf("a[%d]=%d\n", i, addr[i]);       return 0; } element是数组a的第一个元素的值，所以只输出第一个元素的值。 改成这样就可以了。 printf("a[%d]=%d\n", i, addr[i]);


Question: 数组太大时生成失败

引用 2 楼 doubyZZ 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 建议在堆上申请大缓存。使用malloc, realloc, calloc 栈的空间是有限的，函数栈的空间更是有限的。 堆上的空间相对栈而言，是比较可观的。用完，记着手动释放。 malloc申请成功后，数组怎么存进去呢？ 例如: int *p; p=(int*)malloc(633*475*sizeof(int)); （然后我是不是还是要定义一个数组） int a[633][475]={.................}; p=a[0]; 不知道是不是我想法有问题，望指出，谢谢！[/quote]  直接使用malloc申请得到的空间（你上面代码中的p）代替数组  后面直接使用p，不需要再int a[633][475]

引用 7 楼 qq_36409192 的回复:[quote=引用 2 楼 doubyZZ 的回复:] [quote=引用 1 楼 cfjtaishan 的回复:] 建议在堆上申请大缓存。使用malloc, realloc, calloc 栈的空间是有限的，函数栈的空间更是有限的。 堆上的空间相对栈而言，是比较可观的。用完，记着手动释放。 malloc申请成功后，数组怎么存进去呢？ 例如: int *p; p=(int*)malloc(633*475*sizeof(int)); （然后我是不是还是要定义一个数组） int a[633][475]={.................}; p=a[0]; 不知道是不是我想法有问题，望指出，谢谢！[/quote]   引用 2 楼 doubyZZ 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 建议在堆上申请大缓存。使用malloc, realloc, calloc 栈的空间是有限的，函数栈的空间更是有限的。 堆上的空间相对栈而言，是比较可观的。用完，记着手动释放。 malloc申请成功后，数组怎么存进去呢？ 例如: int *p; p=(int*)malloc(633*475*sizeof(int)); （然后我是不是还是要定义一个数组） int a[633][475]={.................}; p=a[0]; 不知道是不是我想法有问题，望指出，谢谢！[/quote] 楼主想说的是不是malloc一个二维数组？ 	int **p; 	p=(int **)malloc(633 * sizeof (int *)); 	for(int i = 0; i < 633; i++) 	{ 		p[i]=(int *)malloc(475 * sizeof(int)); 	}[/quote]解了我一个大惑，谢谢啊

引用 11 楼 zhao4zhong1 的回复:仅供参考：#include <stdio.h> #include <stdlib.h> #include <malloc.h> int **newarr2d(int rows,int cols) {     int **p,i;      p=(int **)malloc(rows*sizeof(int *));     if (NULL==p) exit(1);     for (i=0;i<rows;i++) {         p[i]=(int *)malloc(cols*sizeof(int));         if (NULL==p[i]) exit(1);     }     return p; } void deletearr2d(int **p,int rows) {     int i;      for (i=0;i<rows;i++) {         free(p[i]);     }     free(p); } int main() {     int **arr2d,i,j,r,c;      r=4;     c=5;     //在堆中开辟一个4×5的二维int数组     arr2d=newarr2d(r,c);     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             arr2d[i][j]=i*c+j;         }     }     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             printf(" %2d",arr2d[i][j]);         }         printf("\n");     }     deletearr2d(arr2d,r);      r=6;     c=3;     //在堆中开辟一个6×3的二维int数组     arr2d=newarr2d(r,c);     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             arr2d[i][j]=i*c+j;         }     }     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             printf(" %2d",arr2d[i][j]);         }         printf("\n");     }     deletearr2d(arr2d,r);      return 0; } //  0  1  2  3  4 //  5  6  7  8  9 // 10 11 12 13 14 // 15 16 17 18 19 //  0  1  2 //  3  4  5 //  6  7  8 //  9 10 11 // 12 13 14 // 15 16 17 // 非常感谢 ！

引用 9 楼 cfjtaishan 的回复:[quote=引用 6 楼 doubyZZ 的回复:] [quote=引用 4 楼 cfjtaishan 的回复:] [quote=引用 2 楼 doubyZZ 的回复:] [quote=引用 1 楼 cfjtaishan 的回复:] 建议在堆上申请大缓存。使用malloc, realloc, calloc 栈的空间是有限的，函数栈的空间更是有限的。 堆上的空间相对栈而言，是比较可观的。用完，记着手动释放。 malloc申请成功后，数组怎么存进去呢？ 例如: int *p; p=(int*)malloc(633*475*sizeof(int)); （然后我是不是还是要定义一个数组） int a[633][475]={.................}; p=a[0]; 不知道是不是我想法有问题，望指出，谢谢！[/quote] malloc之后，你把p当成数组使用就可以了。[/quote]请问是直接p[633][475]={..........};这样赋值吗？[/quote] 申请了633 × 475个sizeof(int)的长度，这是一个一维数组，不要当成二维数组。[/quote]明白了，谢谢！果然还是对指针似懂非懂

引用 6 楼 doubyZZ 的回复:[quote=引用 4 楼 cfjtaishan 的回复:] [quote=引用 2 楼 doubyZZ 的回复:] [quote=引用 1 楼 cfjtaishan 的回复:] 建议在堆上申请大缓存。使用malloc, realloc, calloc 栈的空间是有限的，函数栈的空间更是有限的。 堆上的空间相对栈而言，是比较可观的。用完，记着手动释放。 malloc申请成功后，数组怎么存进去呢？ 例如: int *p; p=(int*)malloc(633*475*sizeof(int)); （然后我是不是还是要定义一个数组） int a[633][475]={.................}; p=a[0]; 不知道是不是我想法有问题，望指出，谢谢！[/quote] malloc之后，你把p当成数组使用就可以了。[/quote]请问是直接p[633][475]={..........};这样赋值吗？[/quote] 申请了633 × 475个sizeof(int)的长度，这是一个一维数组，不要当成二维数组。

引用 6 楼 doubyZZ 的回复:[quote=引用 4 楼 cfjtaishan 的回复:] [quote=引用 2 楼 doubyZZ 的回复:] [quote=引用 1 楼 cfjtaishan 的回复:] 建议在堆上申请大缓存。使用malloc, realloc, calloc 栈的空间是有限的，函数栈的空间更是有限的。 堆上的空间相对栈而言，是比较可观的。用完，记着手动释放。 malloc申请成功后，数组怎么存进去呢？ 例如: int *p; p=(int*)malloc(633*475*sizeof(int)); （然后我是不是还是要定义一个数组） int a[633][475]={.................}; p=a[0]; 不知道是不是我想法有问题，望指出，谢谢！[/quote] malloc之后，你把p当成数组使用就可以了。[/quote]请问是直接p[633][475]={..........};这样赋值吗？[/quote] 可以，注意不要越界。

引用 2 楼 doubyZZ 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 建议在堆上申请大缓存。使用malloc, realloc, calloc 栈的空间是有限的，函数栈的空间更是有限的。 堆上的空间相对栈而言，是比较可观的。用完，记着手动释放。 malloc申请成功后，数组怎么存进去呢？ 例如: int *p; p=(int*)malloc(633*475*sizeof(int)); （然后我是不是还是要定义一个数组） int a[633][475]={.................}; p=a[0]; 不知道是不是我想法有问题，望指出，谢谢！[/quote]   引用 2 楼 doubyZZ 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 建议在堆上申请大缓存。使用malloc, realloc, calloc 栈的空间是有限的，函数栈的空间更是有限的。 堆上的空间相对栈而言，是比较可观的。用完，记着手动释放。 malloc申请成功后，数组怎么存进去呢？ 例如: int *p; p=(int*)malloc(633*475*sizeof(int)); （然后我是不是还是要定义一个数组） int a[633][475]={.................}; p=a[0]; 不知道是不是我想法有问题，望指出，谢谢！[/quote] 楼主想说的是不是malloc一个二维数组？ 	int **p; 	p=(int **)malloc(633 * sizeof (int *)); 	for(int i = 0; i < 633; i++) 	{ 		p[i]=(int *)malloc(475 * sizeof(int)); 	}

引用 4 楼 cfjtaishan 的回复:[quote=引用 2 楼 doubyZZ 的回复:] [quote=引用 1 楼 cfjtaishan 的回复:] 建议在堆上申请大缓存。使用malloc, realloc, calloc 栈的空间是有限的，函数栈的空间更是有限的。 堆上的空间相对栈而言，是比较可观的。用完，记着手动释放。 malloc申请成功后，数组怎么存进去呢？ 例如: int *p; p=(int*)malloc(633*475*sizeof(int)); （然后我是不是还是要定义一个数组） int a[633][475]={.................}; p=a[0]; 不知道是不是我想法有问题，望指出，谢谢！[/quote] malloc之后，你把p当成数组使用就可以了。[/quote]请问是直接p[633][475]={..........};这样赋值吗？

引用 3 楼 zhao4zhong1 的回复:在占用内存空间较大的局部数组声明的前面加static将其从堆栈数据段挪到全局数据段即可避开因局部数组大小超过默认堆栈大小1MB造成程序不能正常运行的问题。 容量大小从小到大：栈≤全局数据≤堆≤文件≤硬盘≤磁盘阵列≤云存储 当程序需要使用比如2GB～1TB左右的存储时，最简单的办法恐怕得是用文件读写模拟内存读写了吧。windows参考_fseeki64函数，linux参考fseeko64函数。 FILE *fA;fA=fopen("A","rb+");_fseeki64(fA,10000000000i64*sizeof(int),SEEK_SET);fputc(fA,0);//int A[10000000000]; int B; _fseeki64(fA,9999999999i64*sizeof(int),SEEK_SET);fread(&B,1,sizeof(int),fA);//B=A[9999999999]; _fseeki64(fA,9999999999i64*sizeof(int),SEEK_SET);fwrite(&B,1,sizeof(int),fA);//A[9999999999]=B; fclose(fA);存到全局数据段就成功了，非常感谢！！！！！

引用 2 楼 doubyZZ 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 建议在堆上申请大缓存。使用malloc, realloc, calloc 栈的空间是有限的，函数栈的空间更是有限的。 堆上的空间相对栈而言，是比较可观的。用完，记着手动释放。 malloc申请成功后，数组怎么存进去呢？ 例如: int *p; p=(int*)malloc(633*475*sizeof(int)); （然后我是不是还是要定义一个数组） int a[633][475]={.................}; p=a[0]; 不知道是不是我想法有问题，望指出，谢谢！[/quote] malloc之后，你把p当成数组使用就可以了。

引用 1 楼 cfjtaishan 的回复:建议在堆上申请大缓存。使用malloc, realloc, calloc 栈的空间是有限的，函数栈的空间更是有限的。 堆上的空间相对栈而言，是比较可观的。用完，记着手动释放。 malloc申请成功后，数组怎么存进去呢？ 例如: int *p; p=(int*)malloc(633*475*sizeof(int)); （然后我是不是还是要定义一个数组） int a[633][475]={.................}; p=a[0]; 不知道是不是我想法有问题，望指出，谢谢！


Question: 求大神帮忙！练习程序出错了，但看不懂，求大神帮忙解释下

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

#include <stdio.h>  int main(void) {      int c, ni, nw, nc, inword = 1;     inword = 0;     ni = nw = nc=0;      while((c = getchar()) != EOF)     {         nc++;         if(c =='\n')             ni++;         if(c == ' ' || c == '\t' || c == '\n')             inword = 0;         else if(inword == 0) {             inword = 1;             nw++;         }     }     printf("line=%d word=%d character=%d\n", ni, nw, nc);      return 0; } 除了nl未定义，改成ni之外。 判断条件里c == ' '，应是空格。inword应该初始化。

你定义了ni，却使用nl E:\C++\练习\main.c|12|error: 'nl' undeclared (first use in this function)|

在main()前面加一个int，还有ni和nl好像搞混了，还有第二个if后面是c==' '（空格，不是空的）


Question: 霍夫曼编码

引用 1 楼 zhao4zhong1 的回复:百度搜相关关键字。  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！ 别乱复制了，我连代码都没贴啊，代码不能一直靠自己一个人写吧，站在别人肩膀上快点， 我就只是想知道怎么算的，给我一个算式就行了，不是算法


Question: 关于变量自增自减的输出问题

1、参数是从右向左压入栈中  2、后置++实现的时刻是未定义的，涉及到顺序点，可能是在整个语句执行之后才自加  3、关于C,C++表达式求值顺序  http://bbs.csdn.net/topics/370153775  4、return加表达式 返回的是表达式的运算结果

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

不要研究这个了，只要知道 ++i返回自增后的结果，i++返回后自增就行了

return的返回值是数值还是字符串，跟函数的定义的返回值类型有关。

从右想向，这是参数入参的顺序，即函数参数的压栈顺序是从右向左压栈，所以先计算printf最右边的表达式的值，将值压入栈。(这是你的编译器决定的压栈顺序） 但是自增和自减使用时有副作用，所以不建议这样传递函数参数。建议先计算再传参。 对于类似的的问题,建议减少或者不用（同一个变量的多个参数的）自增或自减作为函参。

这个跟编译器的实现有关系，没必要太较真了，编译器的行为就是你看到的这样，记住就可以了 return加表达式就是返回表达式的值，它必须是一个数或者一个字符，其实字符也是一个数

实质上可将++分情况扩展如下 i++ {     int temp = i;     i += 1;     return temp; }  ++i {     i += 1;     return i; }   回到你的问题： 1. 自右向左， ++i, i++ =>  4, 2 要特别说明的是，不同编译器，产生结果可能不同。为了避免依赖编译器产生结果，最好将可能发生歧义的地方分两行计算。 2. 返回字符、数值跟返回类型有关，如函数原型中返回类型为指针，则也可返回指针


Question: C语言枚举的一点疑问

++  引用 1 楼 cfjtaishan 的回复:#include <stdio.h> #include <stdlib.h>  typedef struct NODE{     struct NODE *Prev;     struct NODE *Next;     char *value;     int type; }*Node;  int main(int argc, char const *argv[]) {     struct NODE L = { NULL, NULL, "l", 1};     printf("l1 success \n");     struct NODE L2 = {&L, NULL, "l2", 2};     L.Next = &L2;     printf("l2 success \n");      Node L3 = (Node) malloc(sizeof(struct NODE));     L2.Next = L3;     L3->value = "l3";     L3->type = 3;     L3->Prev = &L2;     printf("l3 success \n");      Node L4 = (Node) malloc(sizeof(struct NODE));     L3->Next = L4;     L4->value = "l4";     L4->type = 4;     L4->Prev = L3;     L4->Next = NULL;     printf("l4 success \n");     return 0; } 注意Node是指针，sizeof(Node)的长度是4（32位系统），不是sizeof(struct NODE)的长度。 代码请参考上面的。


Question: 点的用法

//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 | //+------------------+-----------------------------------------+---------------+

点表示结构体的域，你是在学STM32编程吧，结构体如下：           typedef struct         {                 uint32_t GPIO_Pin;                             GPIOMode_TypeDef GPIO_Mode;                    GPIOSpeed_TypeDef GPIO_Speed;                  GPIOOType_TypeDef GPIO_OType;                  GPIOPuPd_TypeDef GPIO_PuPd;             }GPIO_InitTypeDef;          GPIO_InitTypeDef  GPIO_InitStructure;  引用 楼主 qq_38617915 的回复:GPIO_InitStructure  .   GPIO_Speed 在这个里面的   .  （点）表示什么意思？

如： struct TEST { string s_Name; int        i_Age; string  s_sex; }； TEST.s_Name="hello world!";

点操作符，既是成员访问符

这个应该是结构体变量使用结构体成员的符号吧，你可以确认一下GPIO_InitStructure变量是不是结构体类型，并且GPIO_Speed是不是这个结构体里的一个成员


Question: 《C Primre Plus》看完了，下面该看什么书？

这么早就开始学了

推荐《C和指针》、《C专家编程》

在不影响学习的基础上，要多实践敲代码，算法是灵魂

还是自己尝试写点代码，然后可以上c语言三剑客了

引用 5 楼 zhao4zhong1 的回复:高中生还是上好高中课程吧。 希望楼主不要犯类似 “早知道吃完第七个包子就饱了，我为什么还要吃前六个包子呢？！” 这种低级错误。 顶一个。

现在的高中生好牛啊！！ 不过还是建议先学好高中课本，进一所好大学，这样眼界比较开阔     然后，你会发现还是干别的比当码农好…………

《深度探索C++对象模型》

可以看《C和指针》，专门用来学习指针的，对将来理解JAVA中的引用打下一个良好的基础

楼主多长时间把primer plus看完了啊

引用 5 楼 zhao4zhong1 的回复:高中生还是上好高中课程吧。 希望楼主不要犯类似 “早知道吃完第七个包子就饱了，我为什么还要吃前六个包子呢？！” 这种低级错误。  +1

引用 5 楼 zhao4zhong1 的回复:高中生还是上好高中课程吧。 希望楼主不要犯类似 “早知道吃完第七个包子就饱了，我为什么还要吃前六个包子呢？！” 这种低级错误。 有道理～什么时间做什么事情还是比较好的。除非你比别人学的快，学得透彻。 就像建高楼一样，地基需要打好了才行呢

做到基本都理解，还不能算是看完这本书。有没有把书上的小程序都敲进电脑测测？有没有改改这些程序。还有这本书后面的练习题有没有都做了。理解伦理知识还是不够的，主要的是要提高实践能力。

《代码大全》，《代码大全》，《代码大全》

想进一步夯实理论就《C++编程思想》； 想结合平台就《Windows核心技术》、《UNIX编程艺术》 想做GUI就看看Qt 等等。。。


Question: 代码出错问题： error C129: missing ';' before 'T0RH'

typedef byte uint8

uint8 不是C C++内置数据类型，需要包含的头文件或者用户代码中有定义  类似如下： typedef unsigned short uint8;

typedef unsigned char uint8;


Question: 求大神请教这是怎么回事！！

#include<stdio.h> int main(void) {     int lxjcj;     int i = 1;     int leiXin;      for (i = 1; i <= 1;)     {         scanf("%d", &leiXin);         switch (leiXin)         {             case 1:                 lxjcj = 1000;                 i = 2;                 printf("%d", lxjcj);    /*去掉&*/                 break;             default:                 i = 1;                 printf("输入有误，请重新");                 break;         }     } } printf若输出某个变量的值，不需要加&


Question: 为什么我照教材上打还会出错勒（明明一模一样的啊）

两个问题： 1. max函数未定义； 2. max的声明建议不要放在main函数体内，建议放在函数之外；不论函数还是变量都要遵循先声明后使用的原则；

int main() {     int max(int x,int y); //只是声明     int a,b,c;     scanf("%d,%d",&a,&b);     c=max(a,b);     printf("max=%d\n",c);     return 0; }  int max(int x,int y) //函数的定义 {     return x > y ? x : y; }PS：函数声明请不要放在函数里面，这是很老式的风格和习惯，现如今会感觉很丑陋！


Question: 求助：C语言给结构体赋值的时候发生了莫名其妙的事情

结构体初始化，建议一个一个的赋值，这样做可能较为繁琐，但是不会出现大的问题；即使有问题也好定位。

微软的 C 编译器我就不吐槽了，也不知道哪年才开始支持这种指定成员初始化。 反正别家编译器好几年前都支持了，现在他才支持起来，居然还是个残废。

VS2013 Win7下没问题 可能跟编译器版本有关，或者抽风

首先 你没有 .d 啊      union{         int a;         int b;         int c;         int d;     }; 是一个共用体类型 你没有定义共同体变量

C99的新特性，就不要在VS上试了 GCC表示毫无压力

#include<stdio.h> #include<stdlib.h> #include<string.h>  typedef struct _test { 	int id; 	char name[30]; 	int level; 	int stock; 	double price; 	char name2[39]; 	union{ 		int a; 		int b; 		int c; 		int d; 	};   }Test;    int main(void) {  	Test test = {  		.id=1 ,"abc",.level=  1,.stock=5,.d=10  		   	}; 	  	system("pause"); 	return 0; }    抱歉第一次登论坛，不懂规矩，这是我第一张图的代码，里面的char name2[39]只要一换位置就会出现我说的问题

请贴代码，没代码谁知道你说什么


Question: 求帮忙看看程序哪出错了，迷宫求得的路径是错的

建议你在必要位置设置断点，然后单步跟踪程序运行，看每一步变量变化情况是否与你期望的一致，很容易找到原因，别人不知你程序表示的意思，所以不好帮你找

int Initstack(stack *s) {     s->base = (selemtype *)malloc(STACK_INITSIZE * sizeof(selemtype));     if (!s->base)         exit(-1);     s->top = s->base;     s->stacksize = STACK_INITSIZE * sizeof(selemtype);      return 0; }  int push(stack *s, selemtype e) {     if ((s->top) - (s->base) > s->stacksize) {         s->base = (selemtype *)realloc(s->base, (STACK_INITSIZE + INCREMENT) * sizeof(selemtype));         if (!s->base)             exit(-1);         s->stacksize += INCREMENT * sizeof(selemtype);         //s->top = s->base + s->stacksize;     }     *s->top++ = e;      return 0; } 注意这两个地方也是有问题的。注意栈的长度

int pass(position p){ 	if (maze[p.x][p.y] == 0) 		return 1; 	return 0; } 写代码要稍微小心点，你这x，y大小一致所以没有引发奔溃，如果x>y。。。 给个建议，多断点调试下


Question: 堆排序写的是对的，为什么排序不正确，到底哪里错呢

12行 a[i]=a[childmax]; -> a[p]=a[childmax];

还没学到数据结构呢    你可以把数组改小一些  例如   int a[7] = {1,3,5,4,0,6,7};然后自己逐步调试一下，调出监视窗口验证一下


Question: 为什么我的哈夫曼的编码是这样的？

楼上说的都很重要，但是这个程序问题并不处在返回值上，没有前缀的程序，有些编译器会默认为void，而这个程序子函数都没用到返回值，所以影响不大。我稍微看了下，暂且发现了你的输出code数组是字符型数组，用的却是%d，其他建树这方面我没太看，应该问题不大。引用引用一楼回答 1、在VS2010上调试，这三个函数都需要加void，声明该函数是没有返回值的，否则编译不过。 creat_huff(struct node Htree[]) code_huff(struct node Htree[]) main() 2、调试结果不符合预期，需要自己单步调试。单步跟总能跟到出问题点。

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

引用 1 楼 adusuccessfully 的回复:1、在VS2010上调试，这三个函数都需要加void，声明该函数是没有返回值的，否则编译不过。 creat_huff(struct node Htree[]) code_huff(struct node Htree[]) main() 2、调试结果不符合预期，需要自己单步调试。单步跟总能跟到出问题点。


Question: 不带头结点单链表

void destroy(node *head) {     clear(&head); }  void clear(node **head) {     node *pcur = *head, *q;      while (pcur) {         q = pcur->link;         free(pcur);         pcur = q;     }     *head = NULL; } 改一下clear函数，需要将最新的header返回，所以使用二重指针可以实现。  node* find_by_index(node *head, int i) {     node* curr = head;     int j;      for (j = 0; j < i && curr; curr = curr->link, j++)         ;     return curr; } 注意该函数还有隐藏bug，上面是改过之后的。需要判断curr是否为NULL。 void remove_by_value(node *head, int value) {     node* curr = NULL;     if (head->value == value) {         curr = head;         node* next = curr->link;         free(curr);         curr = next;         head = curr;    /* store header */     }     else         curr = head;     while (curr != NULL) {         if (curr->value == value) {             node* next = curr->link;             node* prev = head;             while (prev->link != curr)                 prev = prev->link;             prev->link = next;             free(curr);             curr = next;         }         else             curr = curr->link;     } } 同理这个也是有潜在的bug.

遇到问题可以打断点单步调试

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

暂时先不管代码可读性，您只用看clear函数看出了什么问题，其他的函数在main中没有调用，不用看

2、代码的易读性不强。运行程序在需要输入时没有任何提示具体要输入什么信息，自己可能清楚当前该输入什么东西。但让读代码和想调试代码的人就得单步调试，很费时间。

1、node* new = malloc(sizeof(node)); 这个命名不合适，new在C++是一个关键字，我在VS2010中把楼主的代码粘贴调试会编译不过。

这个问题是：清空有问题，但不知道问题出在哪了？


Question: 请问怎么使光标向右移动一格？

Linux下参考CURSES库。

仅供参考：#include <windows.h> #include <stdio.h>  void ConPrint(char *CharBuffer, int len); void ConPrintAt(int x, int y, char *CharBuffer, int len); void gotoXY(int x, int y); void ClearConsole(void); void ClearConsoleToColors(int ForgC, int BackC); void SetColorAndBackground(int ForgC, int BackC); void SetColor(int ForgC); void HideTheCursor(void); void ShowTheCursor(void);  int main(int argc, char* argv[]) {    HideTheCursor();    ClearConsoleToColors(15, 1);    ClearConsole();    gotoXY(1, 1);    SetColor(14);    printf("This is a test...\n");    Sleep(5000);    ShowTheCursor();    SetColorAndBackground(15, 12);    ConPrint("This is also a test...\n", 23);    SetColorAndBackground(1, 7);    ConPrintAt(22, 15, "This is also a test...\n", 23);    gotoXY(0, 24);    SetColorAndBackground(7, 1);    return 0; }  //This will clear the console while setting the forground and //background colors. void ClearConsoleToColors(int ForgC, int BackC) {    WORD wColor = ((BackC & 0x0F) << 4) + (ForgC & 0x0F);    //Get the handle to the current output buffer...    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    //This is used to reset the carat/cursor to the top left.    COORD coord = {0, 0};    //A return value... indicating how many chars were written    //not used but we need to capture this since it will be    //written anyway (passing NULL causes an access violation).    DWORD count;     //This is a structure containing all of the console info    // it is used here to find the size of the console.    CONSOLE_SCREEN_BUFFER_INFO csbi;    //Here we will set the current color    SetConsoleTextAttribute(hStdOut, wColor);    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //This fills the buffer with a given character (in this case 32=space).       FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);        FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       //This will set our cursor position for the next print statement.       SetConsoleCursorPosition(hStdOut, coord);    } }  //This will clear the console. void ClearConsole() {    //Get the handle to the current output buffer...    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    //This is used to reset the carat/cursor to the top left.    COORD coord = {0, 0};    //A return value... indicating how many chars were written    //   not used but we need to capture this since it will be    //   written anyway (passing NULL causes an access violation).    DWORD count;    //This is a structure containing all of the console info    // it is used here to find the size of the console.    CONSOLE_SCREEN_BUFFER_INFO csbi;    //Here we will set the current color    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //This fills the buffer with a given character (in this case 32=space).       FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       //This will set our cursor position for the next print statement.       SetConsoleCursorPosition(hStdOut, coord);    } }  //This will set the position of the cursor void gotoXY(int x, int y) {    //Initialize the coordinates    COORD coord = {x, y};    //Set the position    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord); }  //This will set the forground color for printing in a console window. void SetColor(int ForgC) {    WORD wColor;    //We will need this handle to get the current background attribute    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    CONSOLE_SCREEN_BUFFER_INFO csbi;     //We use csbi for the wAttributes word.    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //Mask out all but the background attribute, and add in the forgournd color       wColor = (csbi.wAttributes & 0xF0) + (ForgC & 0x0F);       SetConsoleTextAttribute(hStdOut, wColor);    } }  //This will set the forground and background color for printing in a console window. void SetColorAndBackground(int ForgC, int BackC) {    WORD wColor = ((BackC & 0x0F) << 4) + (ForgC & 0x0F);;    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), wColor); }  //Direct console output void ConPrint(char *CharBuffer, int len) {    DWORD count;    WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), CharBuffer, len, &count, NULL); }  //Direct Console output at a particular coordinate. void ConPrintAt(int x, int y, char *CharBuffer, int len) {    DWORD count;    COORD coord = {x, y};    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    SetConsoleCursorPosition(hStdOut, coord);    WriteConsole(hStdOut, CharBuffer, len, &count, NULL); }  //Hides the console cursor void HideTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = FALSE; 	  SetConsoleCursorInfo(hStdOut, &cciCursor);    } }  //Shows the console cursor void ShowTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = TRUE; 	  SetConsoleCursorInfo(hStdOut, &cciCursor);    } }

引用 3 楼 amocken 的回复:[quote=引用 1 楼 wang0635的回复:]printf(" "); 这样输出空格不会把原来显示的覆盖掉吗？[/quote]可以在程序中记住这一行输出的内容，到下一个字符后再后退，如     printf("abcde123");     printf("\b\b\b1"); 光标就跑到1后面了

引用 4 楼 paschen的回复:输出一个空格：printf(" ");   如果要移动光标到指定坐标位置，windows下可以用SetConsoleCursorPosition函数 这样输出空格不会把原来显示的覆盖掉吗？

引用 1 楼 wang0635的回复:printf(" "); 这样输出空格不会把原来显示的覆盖掉吗？

空格 字数字数字数字

printf(" ");


Question: 泊松分酒

百度搜相关关键字。

而且，为什么3009这个既符合三等分，也符合四等分，往后再走一步就行  你把输入的顺序修改一下看可以吗

4等分的时候 你这个3009是正确结果啊，但是为什么出来的全是3009

3009是什么意思？

第二个图的程序是怎么实现的啊？

怎么做到的呀?


Question: 求问c语言字符串问题

空串的标识法不是这样的。“”这样才是表示空串；为什么要赋值"()"，还要看这个程序的功能是做什么的，跟括号是不是有关系

首先它不是空字符串 其次它表示的就是 （） 这个字符串（里面包含一对括号）


Question: 找图的问题

参考开源http://www.autohotkey.com源代码中ImageSearch功能。

附上源码地址 http://www.vcchar.com/thread-1965-1-1.html

/**获得屏幕图片的相关信息**/ void GetScreenData(int dx,int dy) {  	HBITMAP   hBitmap,hOld;         //图片句柄 	HDC   hDC,hcDC;                 //设备DC 	BITMAPINFO   b;                 //图片数据信息 	HANDLE   hp;                    //句柄  	dwX=GetSystemMetrics(SM_CXSCREEN);          //屏幕的宽度 	dwY=GetSystemMetrics(SM_CYSCREEN);          //屏幕的高度  	dwX=min(dwX,(unsigned)dx);      //取给定宽度与获得宽度的最小那个 	dwY=min(dwY,(unsigned)dy);      //取给定高度与获得高度的最小那个 	hDC=::GetWindowDC(NULL);        //获得一个设备DC 	hcDC=CreateCompatibleDC(hDC); 	hBitmap=CreateCompatibleBitmap(hDC,dwX,dwY);   //在DC中创建一个兼容DC图片缓冲区 	hOld=(HBITMAP)SelectObject(hcDC,hBitmap);      //将hcDc选择到设备中去 	BitBlt(hcDC,0,0,dwX,dwY,hDC,0,0,SRCCOPY);       //将hDc中的像素直接复制到hcDc中 	/*设置屏幕图片的信息*/ 	bb.bmWidth=dwX;       //宽度 	bb.bmHeight=dwY;      //高度 	bb.bmPlanes=1;         //绘图面板数，一般为1 	bb.bmWidthBytes=bb.bmWidth*3;   //宽度的字节数，一行占多少个字节 	bb.bmBitsPixel=3;              //像素位数 	bb.bmType=0;                   //图片类型  	/*设置图片信息*/ 	b.bmiHeader.biSize   =   sizeof(BITMAPINFOHEADER);       //图片头大小 	b.bmiHeader.biWidth=dwX;                                 //图片宽度 	b.bmiHeader.biHeight=dwY;                                //图片长度 	b.bmiHeader.biPlanes   =   1;                            //绘图面板数 	b.bmiHeader.biBitCount   =24;                            //图像的位数，24真彩色 	b.bmiHeader.biCompression   =   BI_RGB;                  //指定的压缩算法(格式)，BI_RGB不压缩 	b.bmiHeader.biSizeImage   =   0;                        //图片实际大小，宽*高*byte，指定了BI_RGB就为0  	b.bmiHeader.biXPelsPerMeter   =   0;                    //每米包含的像素数 	b.bmiHeader.biYPelsPerMeter   =   0;  	b.bmiHeader.biClrUsed   =   0;                         //使用的颜色数，0表示使用全部颜色 	b.bmiHeader.biClrImportant   =   0;                    //重要的颜色数,0表示全部重要  	/*颜色表**/ 	b.bmiColors[0].rgbBlue=8;                               //蓝色值 	b.bmiColors[0].rgbGreen=8;                              //绿色值 	b.bmiColors[0].rgbRed=8;                                //红色值 	b.bmiColors[0].rgbReserved=0;                           //保留 	//在堆上分配空间 	hp=GetProcessHeap(); 	lpBufscr=(char *)HeapAlloc(hp,HEAP_ZERO_MEMORY,bb.bmHeight*bb.bmWidth*4);  	GetDIBits(hcDC,hBitmap,0,dwY,lpBufscr,&b,DIB_RGB_COLORS);                    //获取指定兼容位图的位,在hcDc上  	//释放申请的DC 	ReleaseDC(NULL,hDC); 	DeleteDC(hcDC); 	DeleteObject(hBitmap); 	DeleteObject(hOld); 	//	HeapFree(hp,0,lpBufscr);  }

引用 楼主 suifengjz 的回复:关于找图的相关问题，图片下面有个窗口的时候找不到图，但是右边的那个图后面什么都没有的可以找到，请问这是什么原因呢，该怎么解决呢/**获得图片信息**/ void GetBmpData(LPCTSTR lpszName) { 	HANDLE hp; 	HDC hdc,hdcmem; 	HBITMAP hBm;  	BITMAPINFO   b; 	//加载图片 	hBm=(HBITMAP)LoadImage(GetModuleHandle(0),/*"c:\\1.bmp"*/lpszName,IMAGE_BITMAP,0,0,LR_CREATEDIBSECTION|LR_LOADFROMFILE); 	if(hBm==NULL) 		{ 			 			MessageBox(NULL, L"LoadImage Errorm,未加载图片，坐标可能不正确 !", TEXT("Error"), MB_OK); 				// return FALSE; 		}  	GetObject(hBm,sizeof(BITMAP),(LPVOID)&bm); //获得句柄 	hdc=::GetWindowDC(NULL); 	hdcmem=CreateCompatibleDC(hdc); 	SelectObject(hdcmem,hBm); 	BitBlt(hdcmem,0,0,bm.bmWidth,bm.bmHeight,hdcmem,0,0,SRCCOPY); 	b.bmiHeader.biSize   =   sizeof(BITMAPINFOHEADER); 	b.bmiHeader.biWidth=bm.bmWidth; 	b.bmiHeader.biHeight=bm.bmHeight; 	b.bmiHeader.biPlanes   =   1; 	b.bmiHeader.biBitCount   =24; 	b.bmiHeader.biCompression   =   BI_RGB; 	b.bmiHeader.biSizeImage   =   0; 	b.bmiHeader.biXPelsPerMeter   =   0; 	b.bmiHeader.biYPelsPerMeter   =   0; 	b.bmiHeader.biClrUsed   =0; 	b.bmiHeader.biClrImportant   =   0; 	b.bmiColors[0].rgbBlue=8; 	b.bmiColors[0].rgbGreen=8; 	b.bmiColors[0].rgbRed=8; 	b.bmiColors[0].rgbReserved=0;  	hp=GetProcessHeap(); 	lpBufbmp=(char *)HeapAlloc(hp,HEAP_ZERO_MEMORY,bm.bmHeight*bm.bmWidth*4); 	GetDIBits(hdc,hBm,0,bm.bmHeight,lpBufbmp,&b,DIB_RGB_COLORS);  	DeleteObject(&hBm); 	DeleteDC(hdc); 	DeleteDC(hdcmem); }


Question: c语言

各种排序算法动画演示http://www.webhek.com/misc/comparison-sort/  ＜1000个元素，冒泡排序 ＜100000个元素，qsort函数 ＜10000000个元素，放数据库中，建索引，（B+树排序） ≥10000000个元素，没用到过。

第二个 用冒泡法就可以实现数组里面的排序问题了  你可以先存到数组里面再排序  发给你一个代码 你看看就知道冒泡怎么使用了 #include<stdio.h> #include<stdlib.h> void BubbleSort(int a[],int n) {  int i,j,power;  for(i=n-1;i>0;i--)  {   for(j=0;j<i;j++)   { 	if(a[j]>a[j+1]) 	{ 		power=a[j]; 		a[j]=a[j+1]; 		a[j+1]=power; 	}   }  } } int main(void) { 	int a[]={8,3,6,1,68,12}; 	int n=6; 	int i; 	for(i=0;i<n;i++) 	BubbleSort(a,n); 	printf("排序后:"); 	for(i=0;i<n;i++) 	printf("%d\t",a[i]); 	printf("\r\n"); 	system("PAUSE"); 	return 0; }

第2个时快速排序法 第3个是递归实现。

http://blog.csdn.net/morewindows/article/details/6684558 可以参考一下


Question: 数据挖掘算法  急求 ！！

建议楼主移驾其他讨论区


Question: dhcp 启动不了

把你的dhcp服务器的配置文件的地址段设置成跟正在使用的网卡地址段在一个网段内就通了，启动服务，立即生效，

百度搜用半角双引号括住的对应错误信息。

没有人帮帮忙么..........真不知道啊我


Question: typeof

typeof没见过，typedef倒是见过，就是起别名  相当于给node*类型起个名叫  ptrtonode(翻译成中文指向node的指针)  然后又给指向node的指针起了俩名字  list， position  为啥要起别名，是因为想增加代码可读性，虽然他们类型是一样的，但是可以起个别名写代码的时候好理解

typeof是什么？ typedef倒是有的。其实就是其别名，即struct node *别名分别是ptrtonode， list, position;  用list或ptrtonode或position定义变量时，和struct node *定义的变量类型都是一样的。


Question: 数据结构的堆栈，和内存空间的堆栈有什么区别和关系吗？？

引用 1 楼 jianwen0529 的回复:数据结构分堆结构，栈结构。 内存区也分堆内存，栈内存。  它们除了名字一样没有什么必然的联系。就跟苹果一样，一个是水果一个是品牌。 前者是组织数据的一种手段（或者叫工具），后者只是指明数据存储在哪种内存区之上。 1 楼回答的那么形象，该结帖了。

百度搜相关关键字。

数据结构也有堆，和内存堆没啥关系。两个栈都是先进后出。 堆栈就是栈，不是堆和栈的合称。

数据结构的堆栈是指两种不同的处理方式，内存的堆栈是不同的存储区域，这两者没有直接关系

数据结构的堆栈，一般是一个意思即栈，遵循先进后出。 内存中的堆区和栈区，主要是针对不同的变量，函数的存放区域。比如堆上空间，是动态申请和动态释放的，需要开发者自己手动申请，并且手动释放，对于堆上的空间申请和释放有专门的函数比如malloc，free等。 对于栈上的空间，主要是存放函数，局部变量等等，但是这个栈内存也是遵循先进后出的使用原则。 所以，数据结构的堆栈和内存的堆栈（内存还分只读数据段，代码段，数据段等等）是不同的概念，对于栈都是遵循先进后出的原则。详细的概念说明，建议去网上搜一下


Question: 求帮忙看看我的代码，哪里出问题了。计算组合数

#include <stdio.h> #include <stdlib.h>  long jc(int x);  int main() {     int a,b,c,m,n;     long s;      printf("input m,n=");     scanf("%d,%d", &m, &n);     for(a = 1;a <= m; a++)         for(b = 1; b <= n; b++)             for(c = 1; c <= (m-n); c++)             {                 s = jc(a)/jc(b)/jc(c);                 printf("%ld\n",s);             }     //system("pause");     return 0; } long jc(int x) {     int i;     long p=1;     for(i = 1; i <= x; i++)         p = p*i;     return (p); } 问题： 1. 函数不能嵌套； 2. m !=0 n != 0是判断语句； 3. scanf需要加&

仅供参考：  #include <stdio.h>  long jc(int x) {     if (x <= 1) return x;     return x * jc(x - 1); }  int main() {     int m = 0, n = 0;     long s;     printf("input m,n=");     scanf("%d,%d", &m, &n);     if (m <= 0 || n <= 0 || m < n)     {         printf("Input error.");         return 0;     }     s = jc(m) / jc(n) / jc(m - n);     printf("C（m,n）= %ld", s);     return 0; }

#include <stdio.h> #include <stdlib.h>  // 这不是求阶乘吧？ long jc(int x) {     int i; long p = 1;     for (i = 1; i <= x; i++) p = p*i;     return(p); }  int main() {     int a, b, c, m, n;     long s;     //m != 0; n != 0; //这是什么？     printf("input m,n=");     //scanf("%d,%d", m, n);     scanf("%d,%d", &m, &n);     //这么多循环？     for (a = 1; a <= m; a++)         for (b = 1; b <= n; b++)             for (c = 1; c <= (m - n); c++)             {                 s = jc(a) / jc(b) / jc(c);                 printf("%ld", s);             }     system("pause");     return 0; }


Question: C语言中利用0地址求结构体中的字段的偏移量时涉及的问题

struct xing *p = 0; 等同于 struct xing *p = NULL; size_t offset = (size_t) (&p->age); 这句是得到age的地址值，并没有读取或写p->age的值。

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

int main() {     // 字段地址就是单纯的 对象首地址 + 偏移字节，当对象首地址为0时，得出的等同于偏移地址     struct xing *p = (xing*)1000;      size_t offset = (size_t)(&p->age);     printf("age的偏移量为：%d\n", offset);     return 0; }

是不能访问那里的数据，这里使用 & 来取结构体某成员的地址（0时得出的刚好是偏移地址）是可以的，因为这不涉及到读写操作。

这里没有访问地址里的内容，只是用地址来计算位置


Question: 结构体中同一成员变量两种定义的用法

引用 2 楼 jianwen0529 的回复: void op(struct funarg_s *fa) { #ifdef _XX_YY_     long   lrtn;     //... #else     char lrtn;     //... #endif // _XX_YY_      fa->rtn = lrtn;                                             //有时会返回异常     //memcpy(&fa->rtn, &lrtn, sizeof(fa->rtn)); } 错了，char那里应该是个数组  void op(struct funarg_s *fa) { #ifdef _XX_YY_     long   lrtn;     //...     fa->rtn = lrtn;                                             //有时会返回异常  #else     char crtn[4];     //...     memcpy(&fa->rtn, &crtn, sizeof(char)*4); #endif // _XX_YY_ }

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


Question: vs中的c程序该语句    typedef short bool; 报错，怎么破？bool必须换名字吗？

#ifndef __cplusplus typedef unsigned char bool; #endif

你建立的是cpp当然用的是c++运行库

既然是c程序,把源文件后缀改成.c就行了

引用 7 楼 jianwen0529 的回复:[quote=引用 5 楼 peterlee1983 的回复:] [quote=引用 2 楼 jianwen0529 的回复:] 你建立的是cpp当然用的是c++运行库 拜托，咱建立的就是.c[/quote]  纯粹C是没有任何问题的，估计是其他原因。 你可以参考3楼 也可以直接使用C99直接导入stdbool.h，这里有定义bool类型，你这句别名就不再需要。  // VS2013 // main.c  #include <stdio.h>  typedef short bool; #define false 0; #define true  1;  int main() {     bool b = true;     printf("%d\n", b);     if (b)     {         printf("The bool value is true\n");     }     return 0; }[/quote] 代码有点小问题，#define 后面不应该有；分号

引用 5 楼 peterlee1983 的回复:[quote=引用 2 楼 jianwen0529 的回复:] 你建立的是cpp当然用的是c++运行库 拜托，咱建立的就是.c[/quote]  纯粹C是没有任何问题的，估计是其他原因。 你可以参考3楼 也可以直接使用C99直接导入stdbool.h，这里有定义bool类型，你这句别名就不再需要。  // VS2013 // main.c  #include <stdio.h>  typedef short bool; #define false 0; #define true  1;  int main() {     bool b = true;     printf("%d\n", b);     if (b)     {         printf("The bool value is true\n");     }     return 0; }

C++里有bool关键字  从语义上讲也不建议把short用bool代替

引用 2 楼 jianwen0529 的回复:你建立的是cpp当然用的是c++运行库 拜托，咱建立的就是.c

建议不要将short的别名为bool，因为bool本身就是类型（C99），建议将short定义成其他名字，比如s16等等


Question: 菜鸟求教编译链接问题

没用过这个编译工具，不懂。 楼主为啥要使用这个编译工具？？？

你的代码分布在3个c程序里，编译的时候只编译一个.c，这样是不行的，需要把所有的.c编译成.obj或者是.o，然后链接到一起才可以。 没用过这个ide，应该是在类似工程的地方设置吧


Question: C求教,脑筋急转弯？

/* 假设有5台设备，其中1台(编号X)控制另外4台(编号为A,B,C,D)。 程序开始时发送指令{1,1,1,1}控制对应的4台设备进行初始化，设备正常运转则返回{1,1,1,1}。 然后开始运行程序，若C设备故障，则返回{1,1,0,1}     继续对剩余的三台ABD循环测试发送{1,1,0,1}. 若B故障，则发送{1,0,0,1} ------ 哪路故障放弃哪路   */  #include <stdio.h>  typedef struct device { 	int device[4]; 	int status[4]; }DEVICE;  DEVICE device_test;  void device_init(int id) { 	int status=0; 	//这里填充发送1指令之类的设备初始化函数，成功status=1，否则status=0 	if(status) 		device_test.status[id]=1; 	else 		device_test.status[id]=0; 		 }  void re_init() { 	int count; 	while(1) 	{ 		for(count=0;count<4;count++) 		{ 			if(device_test.status[count]) 					;//正常设备忽略 			else				 				device_init(count);//不正常的再次初始化 		} 		//当设备初始化全部失败退出 		//if(全失败) 		//break；		 	} }  int main(void) { 	int count;	 	//赋值设备ID，第一次初始化，得到返回状态 	for(count=0;count<4;count++) 	{ 		device_test.device[count]=count; 		device_init(device_test.device[count]); 	} 	//重新初始化 	re_init();  	return 0;  } 不知道是不是类似这个的，细节自己补充吧。


Question: 请教大神 现在学习Windows驱动开发 看什么书入门好?

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

Windows驱动开发技术详解

引用 6 楼 qq_18599547 的回复:[quote=引用 2 楼 zhao4zhong1 的回复:] Windows驱动开发 http://www.osronline.com/ 赵老师   那个网站 课程收费的  3000+美刀 我是穷B - - [/quote] 这个网站里面除了收费课程以外就没有其它免费可获得的有用信息了？

引用 2 楼 zhao4zhong1 的回复:Windows驱动开发 http://www.osronline.com/ 赵老师   那个网站 课程收费的  3000+美刀 我是穷B - -

引用 3 楼 cfjtaishan 的回复:学习C语言，除了学习基本的C库函数使用，主要的还有系统开发。建议可以了解和熟悉一下系统函数。驱动学习还是要求有一定的C语言功底的  开发系统,这个还不行- -  系统函数 常用的基本都了解.

引用 1 楼 user-3 的回复:Windows驱动开发技术详解 这本书是不是有点老了啊 - -


Question: LoadImage返回值为零，求助

https://msdn.microsoft.com/en-us/library/windows/desktop/ms648045(v=vs.85).aspx  If the function succeeds, the return value is the handle of the newly loaded image.  If the function fails, the return value is NULL. To get extended error information, call GetLastError.  调用GetLastError判断失败原因

引用 2 楼 cfjtaishan 的回复:查看一下是否是路径问题，建议将错误号对应的错误信息打印出来 怎么打印错误信息，新手表示不懂

查看一下是否是路径问题，建议将错误号对应的错误信息打印出来

引用 楼主 suifengjz 的回复:同一个dll，静态调试的时候可以找到图片句柄 lhBm=(HBITMAP)LoadImage(NULL,/*"c:\\1.bmp"*/lpszName,IMAGE_BITMAP,0,0,LR_CREATEDIBSECTION|LR_LOADFROMFILE); 动态调试的时候，同样的代码却找不到图片句柄，不知道该怎么修改#include <direct.h> #include <tchar.h> #include <stdio.h> #include <windows.h> #include "atlstr.h" typedef int(*lpFindBmpFun)(int, int,int,int,LPCTSTR,int&,int&); //宏定义函数指针类型 typedef int(*lpFindBmpFunok)(int, int,int,int,LPCTSTR,int,int,int,int&,int&); //宏定义函数指针类型 extern "C" __declspec(dllimport)int FindBmp(int x1,int y1,int x2,int y2, LPCTSTR lpszName,int &fx,int &fy);  extern "C" __declspec(dllimport) int FindBmpEx(int x1,int y1,int x2,int y2,LPCTSTR lpszName,int backcolor,int errorcolor,int errorcount,int &fx,int &fy); int main(int argc, char *argv[]) { 	HINSTANCE hDll; //DLL句柄  	lpFindBmpFun FindBmpFun; //函数指针 	lpFindBmpFunok FindBmpExFun; //函数指针 	hDll = LoadLibrary(L"..\\Debug\\FindProc.dll"); 	if (hDll != NULL) 	{ 		FindBmpFun = (lpFindBmpFun)GetProcAddress(hDll, "FindBmp"); 		FindBmpExFun = (lpFindBmpFunok)GetProcAddress(hDll, "FindBmpEx"); 		if (FindBmpFun != NULL||FindBmpExFun != NULL) 		{ 			TCHAR buffer[MAX_PATH] = {0}; 			_tgetcwd(buffer, MAX_PATH); 			TCHAR s[20]=_T("\\PIC \\1.bmp"); 			_tcscat_s(buffer,s); 			//  LPCTSTR lpszName =(const TCHAR*) (buffer); 			LPCTSTR lpszName =LPCTSTR (&buffer[0]) ;//用这句不行hBm会为0， 			//LPCTSTR lpszName =L"d:\\1.bmp";//直接用这句时就可以，求解决方法 			int fx,fy; 			int result =FindBmpFun(0,0,1920,1080,  lpszName ,  fx, fy);  			BITMAP bm;   //自定义图片  			HDC hdc,hdcmem; 			HBITMAP hBm; 			BITMAPINFO   b; 			//加载图片 			hBm=(HBITMAP)LoadImage(NULL,/*"c:\\1.bmp"*/lpszName,IMAGE_BITMAP,0,0,LR_CREATEDIBSECTION|LR_LOADFROMFILE); 			if(hBm==NULL) 			{ 				// MessageBox("LoadImage Error !"); 				MessageBox(NULL, L"LoadImage Error !", TEXT("Error"), MB_OK); 				// return FALSE; 			}  			printf("%d""\n", result); 			printf("X的坐标是：%d\n", fx); 			printf("Y的坐标是：%d\n",fy);  			system("pause");  		} 		FreeLibrary(hDll); 	} 	return 0; }


Question: 输入56，怎么转换成0x56

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

int decNum = 56; int hexNum = (decNum/10)*16+(decNum%10);

#include <stdio.h> #include <stdlib.h> int main(void) { 	int n = 0; 	scanf("%x", &n); 	printf("n = 0x%X\n", n); 	 	const char *str = "56"; 	long m = strtol(str, NULL, 16); 	printf("m = 0x%X\n", m); 	 	return 0; }


Question: 帮帮忙，求各位路过的大神帮忙检查一下，给点意见

#include<stdio.h>  void print_rank(int score);  int main(void) {     int score;    //case 1:     while (1) {         printf("Please input a student's score: ");         scanf("%d", &score);         if (score < 0 || score > 100)             break;         print_rank(score);     }     //case 2:     int i;     for (i = 0; ;i++) {         printf("Please input a student's score: ");         scanf("%d", &score);         if (score < 0 || score > 100)             break;         print_rank(score);     }      //case 3:     do {         printf("Please input a student's score: ");         scanf("%d", &score);         print_rank(score);     } while (score >= 0 && score <= 100);      return 0; }   void print_rank(int score) {     int rank = score / 10;      switch(rank) {         case 10:         case 9:             printf("A+\n");             break;          case 8:             printf("B+\n");             break;          case 7:             printf("C+\n");             break;          case 6:             printf("D+\n");             break;          case 5:         case 4:         case 3:         case 2:         case 1:         case 0:             printf("E\n");             break;          default:             printf("Not support!\n");             break;     } }

你试一下这个  #include<stdio.h> int main() {     int s,y;     printf("Input Score:");     scanf("%d",&s);     do     {         if(s>=0&&s<=100)         {              y=s/10;             switch(y)             {                 case 9:case 10:printf("%d的等级为a\n",s);break;                 case 8:printf("%d的等级为b\n",s);break;                 case 7:printf("%d的等级为c\n",s);break;                 case 6:printf("%d的等级为d\n",s);break;                 default:printf("%d的等级为e,不及格\n",s);break;             }         }         else         {             break;         }     }while(scanf("%d",&s)); }


Question: C语言指针问题

*q=A[i]; 改成 q=&A[i];

#include <stdio.h> #include <stdlib.h>  int main() {     int A[10];     int *q = NULL;     int i;     for(i = 0; i < 10; i++)         A[i]=i;     q = (int *)malloc(sizeof(int));     for(i = 0; i < 10; i++){         *q = A[i];         printf("%d\n",*q);     }     return 0; }

#include <stdio.h>  int main() { 	int a[10];  	int *q ; 	int i; 	q  = &a[0]; 	 	for(i =0;i < 10; i++) 	{ 		a[i]=i; 	}  	for(i=0;i < 10;i++) 	{ 		 		*q = a[i]; 		printf("%d\n",*(q+i)); 	} }

指针：保存一个对象的地址值 对指针使用 * ，表示解引用操作，也就是获得指针指向的地址的对象 你的指针指向NULL，你给空地址上的位置赋值，所以报错

给指针赋的是地址，不是值，而且在使用指针的时候一定要给指针分配空间。（1楼2楼都对）                而且你的输出也有问题， for(i = 0;1<10;1++) {      printf("%d ",*(q+i)); } 其实数组也相当于指针 *(q+i)  == q[i]       a[i] == *(a + i) 你直接输出*q只会得到首地址的值即q[0]也就是a[0]的值

*q=A[i]; 改成 q=&A[i];

我就想问问到底谁说对了？

int *q=NULL;你这是个空指针，怎么能解引用 *p？ 你要指向一个地方啊，比如用malloc分配一个空间 int *q = malloc(sizeof(int));

问题在没有对q赋一个合法的地址，就使用*q=A[i];这是q指向何处？ 正确的做法 q=a; for(i=0;i<10;i++){ printf("%d\n",*q++); }

感谢大神们的解读，小白知道问题了


Question: 结构体二维数组如何写文件和读文件

用容器Qtl

C语言该如何写？

引用 3 楼 adeng1919 的回复:当然不是，你好好看看  QFile file("./table1");      bool ret = file.open(QIODevice::ReadWrite|QIODevice::Truncate);     QDataStream out(&file);     if (!ret)     {         qDebug() << "open table1 failed";     }     for (int i = 0; i < rows; i++)     {         for (int j = 0; j < columns; j++)         {             out << p1_list[i][j].flag << p1_list[i][j].punched;         }     }     file.flush();     for (int i = 0; i < rows; i++)     {         for (int j = 0; j < columns; j++)         {             out >> p_list[i][j].flag >> p_list[i][j].punched;         }     }      file.close();  这么写岂不是很麻烦么？

当然不是，你好好看看

引用 1 楼 adeng1919 的回复:都用Qt了，直接用QDataStream来读写二进制数据不是更简单，不用操心内存管理 我用的结构体，QDataStream只能写Qt指定的类型格式啊


Question: fstream  的getline 会在读取后在buf的尾部加一个字符串结尾终结符‘0’吗？

std::istream::getline  istream& getline (char* s, streamsize n ); istream& getline (char* s, streamsize n, char delim );  参数就是char *,所以会加,(所以还要求指定最大长度) 改用std::getline(tmp, cfgFile);

水→谁

引用 3 楼 SXJIAKE 的回复:[quote=引用 2 楼 zhao4zhong1 的回复:] 不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！老师不就是你吗，回帖不就是你这段文字吗。[/quote] 我不入地狱，水入地狱？

引用 2 楼 zhao4zhong1 的回复:不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！老师不就是你吗，回帖不就是你这段文字吗。


Question: 将一个数组中的值按照逆序重新存放

《关于利用scanf()函数做为do-while循环条件的分析》 https://blog.csdn.net/eudemon_cn/article/details/6583620

是不是scanf()不能做关系符的左半边，记得c=getchar()可以，因为是c，而scanf()感觉既不是变量又不是常量。

Linux：Ctrl+D Windows：Enter、Ctrl+Z、Enter

#include<stdio.h>  int main() {     int a[100];     int m;     int i = 0, n = 0, temp;     while(scanf("%d",&m) != EOF && n < 100){         a[i++] = m;         n++;     }         i=0;     while(i < n/2){         temp = a[n-1-i];         a[n-1-i]=a[i];         a[i] = temp;         i++;     }     for(i=0;i<n;i++)         printf("%d ", a[i]);     putchar(10);     return 0; } Linux下输入EOF的快捷键是：ctrl+d,windows下是Ctrl+z 注意加上n < 100

windows中的EOF是这样输入的： 回车 ctrl+Z 回车


Question: 下面这个程序的结果是什么？

未定义行为  关于C,C++表达式求值顺序  http://bbs.csdn.net/topics/370153775

这个题没意义。因为  answer = Func() - Func() * Func();  中，哪一个函数调用先执行？ 这就是C语言标准中说的“未定义行为”， 即使是同一种编译器，不同的版本，结果都可能不一样。 典型的谭氏风格题目。


Question: 找不到错误了！！！愚昧一下午

单从CheakCapacity看不出什么问题，建议将相关的代码也贴出来，比如数据结构定义等等

error C2143: 语法错误 : 缺少“;”(在“类型”的前面) 原因与解决方案： 纯c要求局部变量定义必须在函数或局部空间的开头，然后才能有其他语句。  纯c确实对变量声明的位置有要求，c++却可以随用随定义的。 说明vs是严格执行了纯C的标准。  变量任意定义是c99的标准。

tmp = (DataType*)realloc (Seq->p, (Seq->_capacity+ADD_SIZE)*sizeof(DataType));  >main.c  1>c:\users\han\documents\visual studio 2008\projects\动态顺序表的实现（c语言版）\动态顺序表的实现（c语言版）\main.c(18) : error C2143: 语法错误 : 缺少“)”(在“;”的前面)  1>c:\users\han\documents\visual studio 2008\projects\动态顺序表的实现（c语言版）\动态顺序表的实现（c语言版）\main.c(18) : error C2059: 语法错误 : “)”

双击错误提示，定位到出错的语句，自己找找看！  还有更为详细的信息提示，这里看不出什么问题


Question: 创建一个顺序表存放在一个数组中

如果是.c文件，变量必须在作用域的开始定义

#include<stdio.h> #include <stdlib.h>  #define MAXSIZE 100  typedef int elemtype;  typedef struct {     elemtype data[MAXSIZE];     int last; }seqlist;  seqlist *init() {     seqlist *L;     L = (seqlist *)malloc(sizeof(seqlist));     if (!L) {         fprintf(stderr, "malloc error!\n");         exit(-1);     }     L->last = -1;      return L; } int insert(seqlist *L,elemtype x,int i) {     int j;     for(j = L->last; j >= i-1; j--)         L->data[j+1] = L->data[j];     L->data[i-1] = x;     L->last = L->last+1;      return 1; } void show(seqlist *L) {     int i;      for(i = 0; i < 10; i++)         printf("%d ", L->data[i]);     putchar(10); }  int main() {     int a[10]={0,-1,-2,1,2,3,7,-3,0,10};     int i;     seqlist *L;      L = init();     for(i=0;i<10;i++)         insert(L,a[i],i+1);     show(L);     return 0; }  show函数直接定义成void类型，不需要返回值就不用定义成有返回值的。 程序没问题，估计是跟编译器有关，旧的编译器对变量的声明和定义要求是声明都要放在前面，新的要求就相对宽些，可以什么时候使用，什么时候定义。

编译器太老了，换新一点的。 或者，把 main 中的 int a[10]={0,-1,-2,1,2,3,7,-3,0,10}; int i; 两行往前提


Question: 这边人多问个问题

引用 6 楼 zhao4zhong1 的回复:[quote=引用 5 楼 DelphiGuy 的回复:] 只读只是对用户操作，文件系统层面还是有写的。 比如更新文件的上次访问时间……[/quote]  还有log之类的，除了FAT、FAT32这种过于简单的文件系统，稍微复杂点的都支持log，linux上一般叫journal。

你用diff比较一下两个md5不同的文件就知道哪里不同了。

引用 5 楼 DelphiGuy 的回复:只读只是对用户操作，文件系统层面还是有写的。  环境我没描述清楚，我dd的mtd分区只是一个uboot分区，系统起来后不该去读写里面的数据，而且该mtd分区也没有挂载，只是奇怪dd 同一个分区的数据 到 ramdisk上面 结果 md5sum 值可能不同，或许真的是在ramdisk上生成的时间不同 导致md5sum值有差异

引用 5 楼 DelphiGuy 的回复:只读只是对用户操作，文件系统层面还是有写的。 比如更新文件的上次访问时间……

只读只是对用户操作，文件系统层面还是有写的。

引用 1 楼 DelphiGuy 的回复:很正常啊，分区还包括文件访问时间之类的数据，当然可能发生变化。  不会 dd 的读取对象是flash的一个分区，flash是用的mtd的形式，那个分区是ro的，所以不会有改变，只是奇怪为什么读出来放到ramdisk上面  多读几次 然后就会出现MD5sum的结果不同

如果你用软件监控NTFS分区的访问就会发现，$MFT、$BITMAP、$LOG之列的系统文件读写是非常频繁的，一天写成千上万次很正常。Linux的文件系统也应该差不多。

dd可能不适用于ramdisk

很正常啊，分区还包括文件访问时间之类的数据，当然可能发生变化。


Question: 数字排列次数

这个功能应该用组合，不是排列，C(33, 6)=1107568

引用 5 楼 u013043254 的回复:如果要是要顺序输出  你那个有可能出现  12 13 9 15 10 11 这种不顺序的可能，建议在 i++前再加一个判断大小的语句 好提议，这个真没想到。

a b c d e f 初值都是0就好了，如果按1 2 3 4 5 6 赋初值的话 会少很多可能，因为也可能是6 5 4 3 2 1的结果

2楼这个代码很多我看不懂，应该是在指定的每组数字中选入几个数字，执行后结果存放于cp.txt这个文件中，而结果是选中的这些数字的排列。是这样吧！

仅供参考：//要求1:从给出来的不同的六组数字中，从每组任意挑选一个数字，最后组成一个六个数字的数组。 //将所有的数组全部列出来。 //同时，排除全部为偶数、全部为奇数的数组。 //排除四个数字递增连续（比如8、9、10、11）的数组。 //如下： //第一个数字从这12个数字中挑选：,1,3,2,4,5,6,7,8,9,10,11,12 //第二个数字从这17个数字中挑选：,8,7,5,9,6,4,11,10,12,13,3,14,17,2,16,15,18 //第三个数字从这21个数字中挑选：,13,10,15,16,18,11,14,12,7,19,21,17,8,22,9,20,6,23,5,24,25 //第四个数字从这20个数字中挑选：,22,23,18,20,16,17,15,21,14,26,19,24,27,25,12,13,11,10,28,29 //第五个数字从这19个数字中挑选：,26,25,27,29,30,28,23,24,20,22,19,31,21,17,18,32,13,15,16 //第六个数字从这14个数字中挑选：,32,33,30,31,29,28,27,26,25,24,23,22,18,21 //要求2: //请输入第1个数字的选择范围：（可以手动输入任意几个空格间隔的数字,最多30个） //请输入第2个数字的选择范围：（可以手动输入任意几个空格间隔的数字,最多30个） //请输入第3个数字的选择范围：（可以手动输入任意几个空格间隔的数字,最多30个） //请输入第4个数字的选择范围：（可以手动输入任意几个空格间隔的数字,最多30个） //请输入第5个数字的选择范围：（可以手动输入任意几个空格间隔的数字,最多30个） //请输入第6个数字的选择范围：（可以手动输入任意几个空格间隔的数字,最多30个） //然后回车，输出结果到cp.txt //要求3: //保证同一组数据的数都不相同。 //比如，第一个数为6时，第二个数或其他的数都不能再为6；第二个数为10时，第三个数或其他的数都不能再为10，以此类推…… //要求4: //增加一个条件：在产生的每个数组A1A2A3A4A5A6中，要求A1<A2<A3<A4<A5<A6 #include <stdio.h> #include <stdlib.h> #include <string.h> int v[6]; int n[6]={12,17,21,20,19,14}; int d[6][30]={       {1,3,2,4,5,6,7,8,9,10,11,12},       {8,7,5,9,6,4,11,10,12,13,3,14,17,2,16,15,18},       {13,10,15,16,18,11,14,12,7,19,21,17,8,22,9,20,6,23,5,24,25},       {22,23,18,20,16,17,15,21,14,26,19,24,27,25,12,13,11,10,28,29},       {26,25,27,29,30,28,23,24,20,22,19,31,21,17,18,32,13,15,16},       {32,33,30,31,29,28,27,26,25,24,23,22,18,21}, }; int i,j,i0,i1,i2,i3,i4,i5,s; char ln[100],*t; FILE *f; int main() {     for (i=0;i<6;i++) {         printf("请输入第%d个数字的选择范围：",i+1);         fgets(ln,100,stdin);         j=0;         t=strtok(ln," ");         while (1) {             if (NULL==t) break;             if (0==t[0]) continue;//跳过多个空格间隔时取出的空串             d[i][j]=atoi(t);             j++;             if (j>=30) break;             t=strtok(NULL," ");         }         n[i]=j;     }     f=fopen("cp.txt","w");     if (NULL==f) {         printf("无法生成cp.txt!\n");         return 1;     }     printf("正在生成cp.txt...");     for (i0=0;i0<n[0];i0++) {     for (i1=0;i1<n[1];i1++) {     for (i2=0;i2<n[2];i2++) {     for (i3=0;i3<n[3];i3++) {     for (i4=0;i4<n[4];i4++) {     for (i5=0;i5<n[5];i5++) {         v[0]=d[0][i0];         v[1]=d[1][i1];         v[2]=d[2][i2];         v[3]=d[3][i3];         v[4]=d[4][i4];         v[5]=d[5][i5];         if (0==(v[0]%2)          && 0==(v[1]%2)          && 0==(v[2]%2)          && 0==(v[3]%2)          && 0==(v[4]%2)          && 0==(v[5]%2)) continue;//排除全部为偶数         if (1==(v[0]%2)          && 1==(v[1]%2)          && 1==(v[2]%2)          && 1==(v[3]%2)          && 1==(v[4]%2)          && 1==(v[5]%2)) continue;//排除全部为奇数         for (i=0;i<5;i++) {             for (j=i+1;j<6;j++) {                 if (v[i]==v[j]) goto NEXT;//保证同一组数据的数都不相同             }         }     NEXT:         if (i>=5) {             for (i=0;i<5;i++) for (j=i+1;j<6;j++) if (v[i]>v[j]) {s=v[i];v[i]=v[j];v[j]=s;}//从小到大排序             if ((v[0]+1==v[1]               && v[1]+1==v[2]               && v[2]+1==v[3])              || (v[1]+1==v[2]               && v[2]+1==v[3]               && v[3]+1==v[4])              || (v[2]+1==v[3]               && v[3]+1==v[4]               && v[4]+1==v[5])) continue;//排除四个数字递增连续             fprintf(f,"%2d,%2d,%2d,%2d,%2d,%2d\n",v[0],v[1],v[2],v[3],v[4],v[5]);         }     }}}}}}     fclose(f);     printf("\n生成cp.txt完毕\n");     return 0; } //如果文件in.txt的内容为 //1 3 2 4 5 6 7 8 9 10 11 12 //8 7 5 9 6 4 11 10 12 13 3 14 17 2 16 15 18 //13 10 15 16 18 11 14 12 7 19 21 17 8 22 9 20 6 23 5 24 25 //22 23 18 20 16 17 15 21 14 26 19 24 27 25 12 13 11 10 28 29 //26 25 27 29 30 28 23 24 20 22 19 31 21 17 18 32 13 15 16 //32 33 30 31 29 28 27 26 25 24 23 22 18 21 //可以在cmd窗口里面输入命令 //cp <in.txt //得到要求1对应的结果 //BTW:中了一定要分我六成啊！嘿嘿！(^=^)

不懂那规则，看你代码是在 a b c d e f全不相等的时候累加i，应该没问题


Question: 求解答pclint检查文件没关闭的问题

印象中PCLINT是静态检测C语言语法问题 没有关闭打开的文件属于动态问题，所以检测不出来

pclint能检查出内存没释放，能检查出死锁。按理说应该能检查出文件没关闭。


Question: DOS窗口颜色问题，找不出代码的问题，但编译不出预想的结果

引用 7 楼 zhao4zhong1 的回复:[quote=引用 6 楼 u010165006 的回复:] [quote=引用 4 楼 zhao4zhong1 的回复:] char cmdstr[40]; ... sprintf("color %c%c",b,w); system(cmdstr);  老赵sprintf目标漏了[/quote] 谢谢斧正！ sprintf(cmdstr,"color %c%c",b,w);[/quote]  什么叫斧正

引用 6 楼 u010165006 的回复:[quote=引用 4 楼 zhao4zhong1 的回复:] char cmdstr[40]; ... sprintf("color %c%c",b,w); system(cmdstr);  老赵sprintf目标漏了[/quote] 谢谢斧正！ sprintf(cmdstr,"color %c%c",b,w);

char b, w; /*背景色文字色*/ while (1) {     printf("请输入背景颜色：\n");     rewind(stdin);     scanf("%c", &b);     if (b!='0' && b!='1' && b!='2' && b!='3' && b!='4' && b!='5' && b!='6' && b!='7' ){         printf("背景颜色输入不匹配，请重新输入：\n");     } else break; } while (1) {     printf("请输入文字颜色：\n");     rewind(stdin);     scanf("%c", &w);     if (w!='8' && w!='9' && w!='A' && w!='B' && w!='C' && w!='D' && w!='E' && w!='F'){         printf("文字颜色输入不匹配，请重新输入：\n");     } else break; }

引用 4 楼 zhao4zhong1 的回复:char cmdstr[40]; ... sprintf("color %c%c",b,w); system(cmdstr);  老赵sprintf目标漏了

printf里面的%和变量的一一对应关系 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];

引用 2 楼 kljj0301 的回复:谢谢大神，我通过你的代码，我已经找到了问题，应该是scanf("%c"),而不是%s，但是会出现识别回车的问题，直接跳到下一个while判断，还有就是system（“”），括号里面只能放color 1A这样的字符串，不能用变量吗？  1、那可以在scanf("%c") 后加上getchar()接收了缓冲区中的换行符  2、 括号里可以用变量


Question: 32位转换为16进制，怎么解决大数long long int (64位）

char buf[1024]; 	sprintf(buf, "%I64X", 300234062048960ULL);

谢谢大家了！

Collapse AllExpand All      Code: All Code: Multiple Code: Visual Basic Code: C# Code: Visual C++ Code: J# Code: JScript   Visual Basic C# Visual C++ J# JScript Run-Time Library Reference  Format Specification Fields: printf and wprintf Functions  See Also  Send Feedback     This topic describes the syntax for format specifications fields, used in printf, wprintf and related functions. More secured versions of these functions are available, see printf_s, _printf_s_l, wprintf_s, _wprintf_s_l. For details on the individual functions, see the documentation for those specific functions. For a complete listing of these functions, see Stream I/O.  A format specification, which consists of optional and required fields, has the following form:  %[flags] [width] [.precision] [{h | l | ll | I | I32 | I64}]type  Each field of the format specification is a single character or a number signifying a particular format option. The simplest format specification contains only the percent sign and a type character (for example, %s). If a percent sign is followed by a character that has no meaning as a format field, the character is copied to stdout. For example, to print a percent-sign character, use %%.  The optional fields, which appear before the type character, control other aspects of the formatting, as follows:  type Required character that determines whether the associated argument is interpreted as a character, a string, or a number (see the "printf Type Field Characters" table in printf Type Field Characters).  flags Optional character or characters that control justification of output and printing of signs, blanks, decimal points, and octal and hexadecimal prefixes (see the "Flag Characters" table in Flag Directives). More than one flag can appear in a format specification.  width Optional number that specifies the minimum number of characters output (see printf Width Specification).   precision Optional number that specifies the maximum number of characters printed for all or part of the output field, or the minimum number of digits printed for integer values (see the "How Precision Values Affect Type" table in Precision Specification).  h| l| ll| I| I32| I64 Optional prefixes to type-that specify the size of argument (see the "Size Prefixes" table in Size and Distance Specification).  Security Note:  Ensure that format specification strings are not user-defined. For example, consider a program that prompts the user to enter his name and stores the input in a string variable called name. To print name, do not do this:     Copy Code  printf( name ); // Danger!  If name contains "%s", program will crash   Note:  Instead, do this:     Copy Code  printf( "%s", name );    See Also Concepts printf, _printf_l, wprintf, _wprintf_l printf_s, _printf_s_l, wprintf_s, _wprintf_s_l printf_p Positional Parameters Send feedback on this topic to Microsoft.


Question: 关于指向数组的指针动态创建问题

引用 4 楼 paschen 的回复:因为你这里用到了C99中的变长数组VLA  VS很多C99标准都不支持的，所以VS下目前是没办法的   to 楼主，win下面也可以有GCC的。

extern "C" { ... }

引用 1 楼 user-4 的回复:C++本来就没有VLA，MSVC也不完全支持C99，所以你这个可能只能改代码了。。 不过Windows下也有GCC吧 代码怎么改，请问

引用 2 楼 a130098300 的回复:[quote=引用 1 楼 user-4 的回复:] C++本来就没有VLA，MSVC也不完全支持C99，所以你这个可能只能改代码了。。 不过Windows下也有GCC吧 代码怎么改，请问[/quote]  你可以把指针就当做一个float *，然后要访问比如arr[i][j]的时候用ptr[i * m + j]，其中m是第二维度的大小，相当于自己实现二维数组。。 /* 输出: arr[0][2] = 3.000000 arr[2][1] = 10.000000 */ #include <stdio.h> // float (*ptr)[][m] static float get_value(float *ptr, int m, int i, int j) { 	return ptr[i * m + j]; } static void foo(float *ptr, int n, int m) { 	printf("arr[0][2] = %f\n", get_value(ptr, m, 0, 2)); 	printf("arr[2][1] = %f\n", get_value(ptr, m, 2, 1)); } int main() { 	float arr[3][4] = 	{ 		{1, 2, 3, 4}, 		{5, 6, 7, 8}, 		{9, 10, 11, 12} 	}; 	foo((float *)&arr, 3, 4); }

引用 4 楼 paschen 的回复:因为你这里用到了C99中的变长数组VLA  VS很多C99标准都不支持的，所以VS下目前是没办法的 改为new或malloc


Question: 请教一个如下C语言的问题

我猜是因为要把a强制转换成int，而a又是一个未知的

(int) a 是强制转换式！


想将收到的数据缓存到一个buffer里，接下来要根据协议（数据协议）逐个字节或者逐块解析（要根据协议而定）。

仅供参考：//循环向a函数每次发送200个字节长度（这个是固定的）的buffer, //a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理， //在处理的时候每次从新buffer中取两个字节打印 #ifdef _MSC_VER     #pragma warning(disable:4996) #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef _MSC_VER     #include <windows.h>     #include <process.h>     #include <io.h>     #define  MYVOID             void     #define  vsnprintf          _vsnprintf #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  MYVOID             void * #endif //Log{ #define MAXLOGSIZE 20000000 #define MAXLINSIZE 16000 #include <time.h> #include <sys/timeb.h> #include <stdarg.h> char logfilename1[]="MyLog1.log"; char logfilename2[]="MyLog2.log"; static char logstr[MAXLINSIZE+1]; char datestr[16]; char timestr[16]; char mss[4]; CRITICAL_SECTION cs_log; FILE *flog; #ifdef _MSC_VER void Lock(CRITICAL_SECTION *l) {     EnterCriticalSection(l); } void Unlock(CRITICAL_SECTION *l) {     LeaveCriticalSection(l); } void sleep_ms(int ms) {     Sleep(ms); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } void sleep_ms(int ms) {     usleep(ms*1000); } #endif void LogV(const char *pszFmt,va_list argp) {     struct tm *now;     struct timeb tb;      if (NULL==pszFmt||0==pszFmt[0]) return;     vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,"%03d",tb.millitm);     printf("%s %s.%s %s",datestr,timestr,mss,logstr);     flog=fopen(logfilename1,"a");     if (NULL!=flog) {         fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);         if (ftell(flog)>MAXLOGSIZE) {             fclose(flog);             if (rename(logfilename1,logfilename2)) {                 remove(logfilename2);                 rename(logfilename1,logfilename2);             }         } else {             fclose(flog);         }     } } void Log(const char *pszFmt,...) {     va_list argp;      Lock(&cs_log);     va_start(argp,pszFmt);     LogV(pszFmt,argp);     va_end(argp);     Unlock(&cs_log); } //Log} #define ASIZE    200 #define BSIZE    240 #define CSIZE      2 char Abuf[ASIZE]; char Cbuf[CSIZE]; CRITICAL_SECTION cs_HEX; CRITICAL_SECTION cs_BBB; struct FIFO_BUFFER {     int  head;     int  tail;     int  size;     char data[BSIZE]; } BBB; int No_Loop=0; void HexDump(int cn,char *buf,int len) {     int i,j,k;     char binstr[80];      Lock(&cs_HEX);     for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%03d %04x -",cn,i);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             Log("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         Log("%s\n",binstr);     }     Unlock(&cs_HEX); } int GetFromRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      lent=0;     Lock(cs);     if (fbuf->size>=len) {         lent=len;         if (fbuf->head+lent>BSIZE) {             len1=BSIZE-fbuf->head;             memcpy(buf     ,fbuf->data+fbuf->head,len1);             len2=lent-len1;             memcpy(buf+len1,fbuf->data           ,len2);             fbuf->head=len2;         } else {             memcpy(buf     ,fbuf->data+fbuf->head,lent);             fbuf->head+=lent;         }         fbuf->size-=lent;     }     Unlock(cs);     return lent; } MYVOID thdB(void *pcn) {     char        *recv_buf;     int          recv_nbytes;     int          cn;     int          wc;     int          pb;      cn=(int)pcn;     Log("%03d thdB              thread begin...\n",cn);     while (1) {         sleep_ms(10);         recv_buf=(char *)Cbuf;         recv_nbytes=CSIZE;         wc=0;         while (1) {             pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);             if (pb) {                 Log("%03d recv %d bytes\n",cn,pb);                 HexDump(cn,recv_buf,pb);                 sleep_ms(1);             } else {                 sleep_ms(1000);             }             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef _MSC_VER     pthread_exit(NULL); #endif } int PutToRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      Lock(cs);     lent=len;     if (fbuf->size+lent>BSIZE) {         lent=BSIZE-fbuf->size;     }     if (fbuf->tail+lent>BSIZE) {         len1=BSIZE-fbuf->tail;         memcpy(fbuf->data+fbuf->tail,buf     ,len1);         len2=lent-len1;         memcpy(fbuf->data           ,buf+len1,len2);         fbuf->tail=len2;     } else {         memcpy(fbuf->data+fbuf->tail,buf     ,lent);         fbuf->tail+=lent;     }     fbuf->size+=lent;     Unlock(cs);     return lent; } MYVOID thdA(void *pcn) {     char        *send_buf;     int          send_nbytes;     int          cn;     int          wc;     int           a;     int          pa;      cn=(int)pcn;     Log("%03d thdA              thread begin...\n",cn);     a=0;     while (1) {         sleep_ms(100);         memset(Abuf,a,ASIZE);         a=(a+1)%256;         if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop         send_buf=(char *)Abuf;         send_nbytes=ASIZE;         Log("%03d sending %d bytes\n",cn,send_nbytes);         HexDump(cn,send_buf,send_nbytes);         wc=0;         while (1) {             pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);             Log("%03d sent %d bytes\n",cn,pa);             HexDump(cn,send_buf,pa);             send_buf+=pa;             send_nbytes-=pa;             if (send_nbytes<=0) break;//             sleep_ms(1000);             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef _MSC_VER     pthread_exit(NULL); #endif } int main() { #ifdef _MSC_VER     InitializeCriticalSection(&cs_log);     InitializeCriticalSection(&cs_HEX);     InitializeCriticalSection(&cs_BBB); #else     pthread_t threads[2];     int threadsN;     int rc;     pthread_mutex_init(&cs_log,NULL);     pthread_mutex_init(&cs_HEX,NULL);     pthread_mutex_init(&cs_BBB,NULL); #endif     Log("Start===========================================================\n");      BBB.head=0;     BBB.tail=0;     BBB.size=0;  #ifdef _MSC_VER     _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);     _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2); #else     threadsN=0;     rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);     rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1); #endif      if (!access("No_Loop",0)) {         remove("No_Loop");         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     while (1) {         sleep_ms(1000);         if (No_Loop) break;//         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     sleep_ms(3000);     Log("End=============================================================\n"); #ifdef _MSC_VER     DeleteCriticalSection(&cs_BBB);     DeleteCriticalSection(&cs_HEX);     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_BBB);     pthread_mutex_destroy(&cs_HEX);     pthread_mutex_destroy(&cs_log); #endif     return 0; }


Question: 蛇形填数 题目 求解答！！

Do not let me think!#include <stdio.h> #define MAXN 100 int m[MAXN+2][MAXN+2]; char d; int x,y,k,n,w; char str[10]; void main() {     while (1) {         printf("Input n(1..%d):",MAXN);         fflush(stdout);         rewind(stdin);         if (1==scanf("%d",&n)) {             if (1<=n && n<=MAXN) break;         }     }     y=0  ;for (x=0;x<=n+1;x++) m[y][x]=1;     y=n+1;for (x=0;x<=n+1;x++) m[y][x]=1;     x=0  ;for (y=0;y<=n+1;y++) m[y][x]=1;     x=n+1;for (y=0;y<=n+1;y++) m[y][x]=1;     for (y=1;y<=n;y++) {         for (x=1;x<=n;x++) {             m[y][x]=0;         }     }     x=1;     y=1;     k=0;     d='D';     while (1) {         k++;         if (k>n*n) break;         m[y][x]=k;         switch (d) {             case 'D':                 if (0==m[y+1][x])  y++;                 else              {x++;d='R';}             break;             case 'R':                 if (0==m[y][x+1])  x++;                 else              {y--;d='U';}             break;             case 'U':                 if (0==m[y-1][x])  y--;                 else              {x--;d='L';}             break;             case 'L':                 if (0==m[y][x-1])  x--;                 else              {y++;d='D';}             break;         }     } 	w=sprintf(str,"%d",n*n);     for (y=1;y<=n;y++) {         for (x=1;x<=n;x++) {             printf(" %0*d",w,m[y][x]);         }         printf("\n");     } }

根据您提供的内容写了一个小文章 http://blog.csdn.net/hou09tian/article/details/70889235 还请多指教

不同颜色对应不同代码

其中while循环条件语句中&&后面的表达式，比如 !a[x + 1][y] 的含义是判断当前位置的值是否是0，如果是0则说明该位置没有被赋值，可以继续赋值，如果该位置上的值不是0，则说明之前已经赋过值，就不能再赋值了。比如上图中紫色部分，在赋值完16之后，按照顺序还要继续赋值1所在的位置，如果不加判断，则会把1的值覆盖，加了该判断之后，发现该位置的值不为0，所以不会对该位置进行赋值。同理，在赋值完16之后，应该竖起继续赋值17、18、19,在赋值19之后，按照程序应该继续赋值6所在的位置，但是判断该位置的值不是0，说明之前已经赋值过了，所以不会再次赋值，而是继续从右向左赋值20、21、22

明白了，感谢！！！

while(0)结束循环 while(!0)一直循环     1&&1 =1  1&&0  = 0  0&&1 = 0  0&&0 = 0  你在仔细想想运行过程就理解了

Do not let me think! //n=1, //1 //n=2, //12 //34 //n=3, //126 //357 //489 //n=4, //  1  2  6  7 //  3  5  8 13 //  4  9 12 14 // 10 11 15 16 //n=5, //  1  2  6  7 15 //  3  5  8 14 16 //  4  9 13 17 22 // 10 12 18 21 23 // 11 19 20 24 25 //之字形 //模仿蚂蚁爬的过程 #include <stdio.h> #define MAXN 9 int m[MAXN][MAXN]; int i,x,y,dx,dy,n,n2,k; void main() {     for (i=1;i<=MAXN;i++) {         n2=i*i;         k=1;         if (n2>9) k=3;         x=0;         y=0;         dx=1;         dy=-1;         n=1;         m[y][x]=n;         while (1) {             if (n>=n2) break;             n++;             x=x+dx;             y=y+dy;             if (y>=i) {                 x=x+2;                 y=i-1;                 dx=1;                 dy=-1;             }             if (x>=i) {                 y=y+2;                 x=i-1;                 dx=-1;                 dy=1;             }             if (y<0) {                 y=0;                 dx=-1;                 dy=1;             }             if (x<0) {                 x=0;                 dx=1;                 dy=-1;             }             m[y][x]=n;         }         for (y=0;y<i;y++) {             for (x=0;x<i;x++) {                 printf("%*d",k,m[y][x]);             }             printf("\n");         }         printf("-------------%d--------------\n",i);     } } //1 //-------------1-------------- //12 //34 //-------------2-------------- //126 //357 //489 //-------------3-------------- //  1  2  6  7 //  3  5  8 13 //  4  9 12 14 // 10 11 15 16 //-------------4-------------- //  1  2  6  7 15 //  3  5  8 14 16 //  4  9 13 17 22 // 10 12 18 21 23 // 11 19 20 24 25 //-------------5-------------- //  1  2  6  7 15 16 //  3  5  8 14 17 26 //  4  9 13 18 25 27 // 10 12 19 24 28 33 // 11 20 23 29 32 34 // 21 22 30 31 35 36 //-------------6-------------- //  1  2  6  7 15 16 28 //  3  5  8 14 17 27 29 //  4  9 13 18 26 30 39 // 10 12 19 25 31 38 40 // 11 20 24 32 37 41 46 // 21 23 33 36 42 45 47 // 22 34 35 43 44 48 49 //-------------7-------------- //  1  2  6  7 15 16 28 29 //  3  5  8 14 17 27 30 43 //  4  9 13 18 26 31 42 44 // 10 12 19 25 32 41 45 54 // 11 20 24 33 40 46 53 55 // 21 23 34 39 47 52 56 61 // 22 35 38 48 51 57 60 62 // 36 37 49 50 58 59 63 64 //-------------8-------------- //  1  2  6  7 15 16 28 29 45 //  3  5  8 14 17 27 30 44 46 //  4  9 13 18 26 31 43 47 60 // 10 12 19 25 32 42 48 59 61 // 11 20 24 33 41 49 58 62 71 // 21 23 34 40 50 57 63 70 72 // 22 35 39 51 56 64 69 73 78 // 36 38 52 55 65 68 74 77 79 // 37 53 54 66 67 75 76 80 81 //-------------9--------------

如果a的值是0，那么！a就是1；如果a的值不是0，那么！a的值就是0。

还有一点 ，memset(a, 0, sizeof(a));这条语句不是已经把数组清零了吗，也就是说给数组赋了0 的值，那么下面的 !a[x][y+1] 不应该是1 吗，就是这一点想不清！，希望大神给小弟点思路，先谢过了！！！

感谢大家！！非常感谢！！！！

1.是判断a[x][y]下面是否赋值，如果没有值即0则运行while下的公式进行赋值，while (top < n*n)第一次循环用不上判断a[x][y]的上下左右，第二次判断才会用到，因为已经有一圈值被确定， 例如n=3 while第一次运行之后是 7 8 1 6     2 5 4 3 因为在最后一个while时a[x][y+1] ＝1  ，!a[x][y+1] ＝0  while (y + 1 < n && !a[x][y+1]) 就停止了。 2.a[x + 1][y] ==0  就是还没有被赋值。


Question: 二叉树有50个叶子结点，计算度为2的结点

参考你🐎呢参考，来个文字思路

引用 2 楼 zhujinqiang 的回复:参考 http://blog.csdn.net/u013227200/article/details/37992463

百度搜相关关键字。