Question: 如何剔除相同的数据

仅供参考：//文件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; }

正则表达式  http://www.zhihu.com/question/19861963


Question: 这种情况用c语言如何实现

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

引用 1 楼 lgbxyz 的回复:读取一行，然后每一行比较   #define NODE_SIG "node number      "  while (!feof(fp)) { fgets(line, line_size, fp); char* token; token = strstr(line, NODE_SIG ); if (token) printf("node number=%d\n". atoi(token+strlen(NODE_SIG))); }  额，能不能给出全代码啊


Question: 线索二叉树的二叉链表存储,三种遍历都可以访问前驱和后继吧??

Talk is cheap,show me the code!

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


Question: 新手遇到问题，求指教

应该是跟编译环境的配置有关，函数调用的没有问题；在Linux 测试没发现问题； 建议重新配置一下编译环境；或者找一下编译环境上的问题；

Visual C++ 2010 Express简体中文版http://pan.baidu.com/s/1bnwRVLt

修复或者重装试试


Question: 求一个C语言的编程

是阶乘吗？？？

好腻害 好腻害

你的描述也是屌的不行，一会儿 55 个，一会儿 5 个的。

引用 4 楼 黄黄k的回复:[quote=引用 1 楼 bailong_yu 的回复:] 每次都是乘1到5这五个数吗？ 不是1到55除（乘）1到55，我把他们放到数组里了。。。[/quote] 恭喜楼主+++++++++++

引用 1 楼 bailong_yu 的回复:每次都是乘1到5这五个数吗？ 不是1到55除（乘）1到55，我把他们放到数组里了。。。

已解决，谢谢各位，给你们代码参考 #include <stdio.h> #include<stdlib.h> int main() {     float a[55];     float b[55][55];           for (int i = 0; i < 55; i++)     {         scanf("%f",&a[i]);               }       for (int i = 0; i < 55; i++)     {         for (int j = 0; j < 55; j++)         {             b[i][j] = a[i] / a[j];         }     }       //输出结果     for (int i = 0; i < 55; i++)     {         for (int j = 0; j < 55; j++)         {             printf("%0.2f ", b[i][j]);         }         printf(";\n");     }        system("pause");     return 0; }

假设你55个数存在num[55]变量里：   	int i, j; 	for(i = 0; i < 55; ++i) 		for(j = 0; j < 55; ++j) 			printf("%d\n", i * j);

每次都是乘1到5这五个数吗？


Question: 杭电acm2017统计字符串的数字数

引用 1 楼 qq423399099 的回复:scanf里第一个参数加上\n是为了过滤空格、制表符、回车等输入，也就是说 scanf("%d\n", &i); printf("%d\n", i); 你输入一个数后，它是不会立即显示的，要等再接收到一个非（空格、制表符、回车）的输入scanf语句才结束。 但请注意的是，最后输入的那个非（空格、制表符、回车）的东西是不会被这个scanf读进来的，而是留在输入流里。 PS：这里的效果和后面加一个getchar的效果是一样的，只不过getchar只能过滤一个空白符， 而"%d\n"可以过滤掉多个连续的空白符，在有些场合下是不一样的嗯，明白了，多谢


Question: 类型问题

int shu = (*p)[i]-'0';这样才行

我用了这个方法然而报错了是什么原因？

*(p+i)对于的应该是个数字型的字符，楼主可以通过*(p+i) - ‘0’得到int型的数字

直接强制转换么好了。  本来char型的 就是int型的


#include<stdio.h> #include<stdlib.h> #include<math.h> int cmp(void *a, void *b){ 	return abs(*(int *)b) - abs(*(int *)a); } int main(int argc, char const *argv[]) { 	int i,j,n; 	while(~scanf("%d",&n)&&n){ 		int s[100]={0}; 		for(i=0;i<n;i++) 			scanf("%d",s+i); 			 		qsort(s,n,sizeof(s[0]),cmp); 		for(i=0;i<n-1;i++) 			printf("%d ", s[i]); 		printf("%d\n", s[i] ); 	} 	return 0; } 已经解决，return里要这样写


Question: 大神，求救哈夫曼树编码问题中的strcpy问题

引用 4 楼 qq_34471305 的回复:[quote=引用 2 楼 cfjtaishan 的回复:]  #include<iostream>                                                                                2 #include<string.h>   3     4 using namespace std;   5     6 #define n 8//此n为叶子的个数   7     8 typedef    char**    HuffmanCode;//表示HuffmanCode是char**的别名   9    10 typedef struct  11 {  12     int weight;  13     int parent, lchild, rchild;  14 }HTNode, *HuffmanTree;  15    16 //初始化数组  17 void Initial_HT(HTNode a[])  18 {  19     for (int i = 1; i < 2 * n; i++){  20     |   a[i].weight = a[i].parent = a[i].lchild = a[i].rchild = 0;  21     }  22 }  23    24    25 //挑选其中两个权值最小的  26 void Select_HT(HTNode a[], int K, int &M, int &N)//这个函数有问题  27 {  28     int min = 99999;  29     //这个赋值要满足不是原来的最小值，这就难办了，也可以这样说，这个最小值其父母一定是为零的,这个范围必定是在  30     for (int i = 1; i < K + 1; i++)  31     |   if (a[i].weight < min&&a[i].parent == 0){  32     |   |   min = a[i].weight;  33     |   |   M = i;  34     |   }  35     int min2 = 99999;  36     for (int j = 1; j < K + 1; j++){  37     |   if (min2> a[j].weight&&a[j].parent == 0 && j != M){  38     |   |   min2 = a[j].weight;  39     |   |   N = j;  40     |   }  41     }  42 }  43    44 //创建一哈夫曼树  45 void Create_HT(HTNode a[])  46 {  47     cout << "输进叶子结点的权值:" << endl;  48     for (int i = 1; i < n + 1; i++){  49     |   cin >> a[i].weight;  50     }  51     int M = 0, N = 0;  52     for (int j = n + 1; j < 2 * n; j++){  53     |   Select_HT(a, j - 1, M, N);//其作用将实现的功能有返回最小的两个下标//忘了除去已有的父母的结点了  54     |   a[M].parent = a[N].parent = j;  55     |   a[j].lchild = M;      |   a[j].rchild = N;  45     |   a[j].weight = a[N].weight + a[M].weight;  44     }  43 }  42 void Print_HT(HTNode a[])  41 {  40     for (int i = 1; i < 2 * n; i++){  39     |   cout << a[i].weight << "   ";  38     }  37 }  36    35 void Serect_HT(HTNode a[], HuffmanCode &HC)//求哈夫曼编码  34 {  33     char *cd = NULL;  32     HC = new char*[n + 1];  31     cd = new char[n];  30     cd[n - 1] = '\0';  29     for (int i = 1; i <= n; i++){  28     |   int start = n - 1;  27     |   int f = a[i].parent;  26     |   int c = a[i].weight;  25     |   while (f != 0)  24     |   {  23     |   |   --start;  22     |   |   if (c == a[f].lchild)  21     |   |   |   cd[start] = '0';  20     |   |   else cd[start] = '1';  19     |   |   |   c = a[f].weight;  18     |   |   f = a[f].parent;  17     |   }  16     |   //cout << "sdgsfsd" << endl;  15     |   HC[i] = new char[n - start];  14     |   strcpy(HC[i],&cd[start]);  13     }  12     delete cd;  11 }  10     9     8 void Print_HC(HuffmanCode &HC)   7 {   6     for (int i = 1; i < n + 1; i++)   5     {   4     |   cout << HC[i]<<"  ";   3     }   2 }   1   102 int main(void)                                                                                1 {   2     HTNode a[2 * n];   3     Initial_HT(a);   4     Create_HT(a);   5     Print_HT(a);   6     HuffmanCode HC = NULL;   7     Serect_HT(a, HC);   2     Print_HC(HC);   1     return 0; 112 }  strcpy编译时有问题，还是运行的时候有问题？ strcpy编译时有问题 [/quote] 头文件格式有问题吧，对于系统的函数和变量声明头文件要用<>符号；对于自定义的头文件使用""符号！

仅帮整理代码格式： #include<iostream> #include<string.h>  using namespace std;  #define n 8//此n为叶子的个数  typedef    char**    HuffmanCode;//表示HuffmanCode是char**的别名  typedef struct {     int weight;     int parent, lchild, rchild; }HTNode, *HuffmanTree;  //初始化数组 void Initial_HT(HTNode a[]) {     for (int i = 1; i < 2 * n; i++){         a[i].weight = a[i].parent = a[i].lchild = a[i].rchild = 0;     } }   //挑选其中两个权值最小的 void Select_HT(HTNode a[], int K, int &M, int &N)//这个函数有问题 {     int min1;     min1 = 99999;     //这个赋值要满足不是原来的最小值，这就难办了，也可以这样说，这个最小值其父母一定是为零的,这个范围必定是在     for (int i = 1; i < K + 1; i++)         if (a[i].weight < min1 && a[i].parent == 0){             min1 = a[i].weight;             M = i;         }      int min2;     min2 = 99999;     for (int j = 1; j < K + 1; j++){         if (a[j].weight < min2 && a[j].parent == 0 && j != M){             min2 = a[j].weight;             N = j;         }     } }  //创建一哈夫曼树 void Create_HT(HTNode a[]) {     cout << "输进叶子结点的权值:" << endl;     for (int i = 1; i < n + 1; i++){         cin >> a[i].weight;     }     int M = 0, N = 0;     for (int j = n + 1; j < 2 * n; j++){         Select_HT(a, j - 1, M, N);//其作用将实现的功能有返回最小的两个下标//忘了除去已有的父母的结点了         a[M].parent = a[N].parent = j;         a[j].lchild = M;         a[j].rchild = N;         a[j].weight = a[N].weight + a[M].weight;     } } void Print_HT(HTNode a[]) {     for (int i = 1; i < 2 * n; i++){         cout << a[i].weight << "   ";     } }  void Serect_HT(HTNode a[], HuffmanCode &HC)//求哈夫曼编码 {     char *cd = NULL;     HC = new char*[n + 1];     cd = new char[n];     cd[n - 1] = '\0';     for (int i = 1; i <= n; i++){         int start = n - 1;         int f = a[i].parent;         int c = a[i].weight;         while (f != 0)         {             --start;             if (c == a[f].lchild)                 cd[start] = '0';             else cd[start] = '1';                 c = a[f].weight;             f = a[f].parent;         }         //cout << "sdgsfsd" << endl;         HC[i] = new char[n - start];         strcpy(HC[i],&cd[start]);     }     delete cd; }   void Print_HC(HuffmanCode &HC) {     for (int i = 1; i < n + 1; i++)     {         cout << HC[i]<<"  ";     } }  int main(void) {     HTNode a[2 * n];     Initial_HT(a);     Create_HT(a);     Print_HT(a);     HuffmanCode HC = NULL;     Serect_HT(a, HC);     Print_HC(HC);     return 0; }   我这边试运行了一下： 提示：输进叶子结点的权值: 输入：1 2 3 4 5 6 7 8 输出：1   2   3   4   5   6   7   8   3   6   9   12   15   21   36   11000  11001  1100  110  111  110  10  11

这样是否就对了？ //挑选其中两个权值最小的 void Select_HT(HTNode a[], int K, int &M, int &N) {     int wi[2*n],wt[2*n],t;     for (int i=1;i<K+1;i++) {         wi[i]=i;         wt[i]=a[i].weight;     }      for (int i=1;i<K;i++) {         for (int j=i+1;j<K+1;j++) {             if (wt[i]>wt[j]) {                 t=wt[i];wt[i]=wt[j];wt[j]=t;                 t=wi[i];wi[i]=wi[j];wi[j]=t;             }         }     }     M=wi[1];     N=wi[2]; }

#pragma warning(disable:4996)

引用 5 楼 qq_34471305 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] #pragma warning(disable:4996)    什么意思？[/quote]  引用 2 楼 cfjtaishan 的回复: #include<iostream>                                                                                2 #include<string.h>   3     4 using namespace std;   5     6 #define n 8//此n为叶子的个数   7     8 typedef    char**    HuffmanCode;//表示HuffmanCode是char**的别名   9    10 typedef struct  11 {  12     int weight;  13     int parent, lchild, rchild;  14 }HTNode, *HuffmanTree;  15    16 //初始化数组  17 void Initial_HT(HTNode a[])  18 {  19     for (int i = 1; i < 2 * n; i++){  20     |   a[i].weight = a[i].parent = a[i].lchild = a[i].rchild = 0;  21     }  22 }  23    24    25 //挑选其中两个权值最小的  26 void Select_HT(HTNode a[], int K, int &M, int &N)//这个函数有问题  27 {  28     int min = 99999;  29     //这个赋值要满足不是原来的最小值，这就难办了，也可以这样说，这个最小值其父母一定是为零的,这个范围必定是在  30     for (int i = 1; i < K + 1; i++)  31     |   if (a[i].weight < min&&a[i].parent == 0){  32     |   |   min = a[i].weight;  33     |   |   M = i;  34     |   }  35     int min2 = 99999;  36     for (int j = 1; j < K + 1; j++){  37     |   if (min2> a[j].weight&&a[j].parent == 0 && j != M){  38     |   |   min2 = a[j].weight;  39     |   |   N = j;  40     |   }  41     }  42 }  43    44 //创建一哈夫曼树  45 void Create_HT(HTNode a[])  46 {  47     cout << "输进叶子结点的权值:" << endl;  48     for (int i = 1; i < n + 1; i++){  49     |   cin >> a[i].weight;  50     }  51     int M = 0, N = 0;  52     for (int j = n + 1; j < 2 * n; j++){  53     |   Select_HT(a, j - 1, M, N);//其作用将实现的功能有返回最小的两个下标//忘了除去已有的父母的结点了  54     |   a[M].parent = a[N].parent = j;  55     |   a[j].lchild = M;      |   a[j].rchild = N;  45     |   a[j].weight = a[N].weight + a[M].weight;  44     }  43 }  42 void Print_HT(HTNode a[])  41 {  40     for (int i = 1; i < 2 * n; i++){  39     |   cout << a[i].weight << "   ";  38     }  37 }  36    35 void Serect_HT(HTNode a[], HuffmanCode &HC)//求哈夫曼编码  34 {  33     char *cd = NULL;  32     HC = new char*[n + 1];  31     cd = new char[n];  30     cd[n - 1] = '\0';  29     for (int i = 1; i <= n; i++){  28     |   int start = n - 1;  27     |   int f = a[i].parent;  26     |   int c = a[i].weight;  25     |   while (f != 0)  24     |   {  23     |   |   --start;  22     |   |   if (c == a[f].lchild)  21     |   |   |   cd[start] = '0';  20     |   |   else cd[start] = '1';  19     |   |   |   c = a[f].weight;  18     |   |   f = a[f].parent;  17     |   }  16     |   //cout << "sdgsfsd" << endl;  15     |   HC[i] = new char[n - start];  14     |   strcpy(HC[i],&cd[start]);  13     }  12     delete cd;  11 }  10     9     8 void Print_HC(HuffmanCode &HC)   7 {   6     for (int i = 1; i < n + 1; i++)   5     {   4     |   cout << HC[i]<<"  ";   3     }   2 }   1   102 int main(void)                                                                                1 {   2     HTNode a[2 * n];   3     Initial_HT(a);   4     Create_HT(a);   5     Print_HT(a);   6     HuffmanCode HC = NULL;   7     Serect_HT(a, HC);   2     Print_HC(HC);   1     return 0; 112 }  strcpy编译时有问题，还是运行的时候有问题？ 没用啊

引用 5 楼 qq_34471305 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] #pragma warning(disable:4996)    什么意思？[/quote] 屏蔽提示strcpy不安全提示，如果有。

引用 2 楼 cfjtaishan 的回复: #include<iostream>                                                                                2 #include<string.h>   3     4 using namespace std;   5     6 #define n 8//此n为叶子的个数   7     8 typedef    char**    HuffmanCode;//表示HuffmanCode是char**的别名   9    10 typedef struct  11 {  12     int weight;  13     int parent, lchild, rchild;  14 }HTNode, *HuffmanTree;  15    16 //初始化数组  17 void Initial_HT(HTNode a[])  18 {  19     for (int i = 1; i < 2 * n; i++){  20     |   a[i].weight = a[i].parent = a[i].lchild = a[i].rchild = 0;  21     }  22 }  23    24    25 //挑选其中两个权值最小的  26 void Select_HT(HTNode a[], int K, int &M, int &N)//这个函数有问题  27 {  28     int min = 99999;  29     //这个赋值要满足不是原来的最小值，这就难办了，也可以这样说，这个最小值其父母一定是为零的,这个范围必定是在  30     for (int i = 1; i < K + 1; i++)  31     |   if (a[i].weight < min&&a[i].parent == 0){  32     |   |   min = a[i].weight;  33     |   |   M = i;  34     |   }  35     int min2 = 99999;  36     for (int j = 1; j < K + 1; j++){  37     |   if (min2> a[j].weight&&a[j].parent == 0 && j != M){  38     |   |   min2 = a[j].weight;  39     |   |   N = j;  40     |   }  41     }  42 }  43    44 //创建一哈夫曼树  45 void Create_HT(HTNode a[])  46 {  47     cout << "输进叶子结点的权值:" << endl;  48     for (int i = 1; i < n + 1; i++){  49     |   cin >> a[i].weight;  50     }  51     int M = 0, N = 0;  52     for (int j = n + 1; j < 2 * n; j++){  53     |   Select_HT(a, j - 1, M, N);//其作用将实现的功能有返回最小的两个下标//忘了除去已有的父母的结点了  54     |   a[M].parent = a[N].parent = j;  55     |   a[j].lchild = M;      |   a[j].rchild = N;  45     |   a[j].weight = a[N].weight + a[M].weight;  44     }  43 }  42 void Print_HT(HTNode a[])  41 {  40     for (int i = 1; i < 2 * n; i++){  39     |   cout << a[i].weight << "   ";  38     }  37 }  36    35 void Serect_HT(HTNode a[], HuffmanCode &HC)//求哈夫曼编码  34 {  33     char *cd = NULL;  32     HC = new char*[n + 1];  31     cd = new char[n];  30     cd[n - 1] = '\0';  29     for (int i = 1; i <= n; i++){  28     |   int start = n - 1;  27     |   int f = a[i].parent;  26     |   int c = a[i].weight;  25     |   while (f != 0)  24     |   {  23     |   |   --start;  22     |   |   if (c == a[f].lchild)  21     |   |   |   cd[start] = '0';  20     |   |   else cd[start] = '1';  19     |   |   |   c = a[f].weight;  18     |   |   f = a[f].parent;  17     |   }  16     |   //cout << "sdgsfsd" << endl;  15     |   HC[i] = new char[n - start];  14     |   strcpy(HC[i],&cd[start]);  13     }  12     delete cd;  11 }  10     9     8 void Print_HC(HuffmanCode &HC)   7 {   6     for (int i = 1; i < n + 1; i++)   5     {   4     |   cout << HC[i]<<"  ";   3     }   2 }   1   102 int main(void)                                                                                1 {   2     HTNode a[2 * n];   3     Initial_HT(a);   4     Create_HT(a);   5     Print_HT(a);   6     HuffmanCode HC = NULL;   7     Serect_HT(a, HC);   2     Print_HC(HC);   1     return 0; 112 }  strcpy编译时有问题，还是运行的时候有问题？ strcpy编译时有问题

引用 3 楼 zhao4zhong1 的回复:#pragma warning(disable:4996)    什么意思？

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


Question: c语言二维数组分配

看2楼，优先级问题

引用 9 楼 lin5161678的回复:[quote=引用 6 楼 wjhyxr 的回复:] 其实指针传参时，没必要传指针的地址，直接   fun（ p ）;  void  fun( int**  p ) {          p = ( int **)malloc ( ..........) }醒醒[/quote] 啥意思................

引用 6 楼 wjhyxr 的回复:其实指针传参时，没必要传指针的地址，直接   fun（ p ）;  void  fun( int**  p ) {          p = ( int **)malloc ( ..........) }醒醒

sizeof(sizeof(int)* 3) ??

啥叫“二维数组”？

你创建的并不是二维数组。毕竟，这些malloc是分开调用的。

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

注意*和[]的优先级，另外，多了一套sizeof，括号如果改一下能侥幸过关，但最好还是去掉吧 void fun(int ***p) {     *p= (int**)malloc(sizeof(int*)*2);     for (int i = 0; i < 2; i++)     {         (*p)[i] = (int *)malloc(sizeof(int)* 3);         for (int j = 0; j < 3; j++)         {             (*p)[i][j] = i+j;         }     } }

不要用这么多级指针解决问题，用一维模拟多维就行了，简单，节约内存并且效率高，满满的优点。


Question: 两种Unicode码之间如何转换？

又错了，改为： (高字-d800)<<10+低字+2400

错了，改为： (高字-dc00)<<10+低字+2400

简化一下： (高字-dc00)<<10+低字+e800

U+2C62F这是原生编码UCS-4，d871de2f这是UTF-16编码。 转换方法： d871 - d800 = 0071 de2f - dc00 = 022f (0071 << 16 + 022f << 6) >> 6 = 2c62f

你要自己转换吗? 自己转换的话自己看标准. 库转的话,libiconv


Question: 解释程序方式的过程

参考解释和编译执行C的开源项目。

其实，java 是编译后，解释执行的 .net 上的语言（VB,C#,C++CLI）有两种执行方式 一种是编译成 中间语言，解释执行 一种是编译成中间语言，执行时编译为本地代码，然后执行 此前的语言 Basic 早期是解释执行的，微软后来QBasic,Qick Basic 变为也给他编译执行了， 他有两种执行方式，IDE内调试时，可以解释执行， 也可以脱离环境 编译为 exe 执行 Pacal 是编译执行的，但是也有人研制出解释执行的pascal  怎么执行，其实是和编译系统，或者解释器的实现相关的。 和语言的关系，只是方便不方便处理成 编译，或者解释执行而已。 方便的难度小，否则难度大， 但是都是可以，编译或者解释执行的 很多系统，是编译和解释都有的  例如，MS 的VB6 虽然是编译执行为主， 但是 可能会编译成p-code 解释执行一部分代码。  MS VB 不是完全的编译执行的。

引用 6 楼 user-3 的回复:解释程序也要翻译成中间码 可能需要，也可能不要 看如何实现这个解释器 加括号，表示可能不会有这一步

语义分析会有的 代码生成，可能会有，也可能不会有 不生成代码的，（虚拟机）直接解释执行了， 大概就是调用内置函数（过程）执行， 简单的也可以直接处理，比如加减乘除这种数学计算。 生成代码的。虚拟机解释 生成的中间代码执行。 简单的语义分析 和解释执行可能就一步到位了  例如VB6 就可以将 程序生成 p-code 然后解释执行 但不是完全都是生成 p-code 执行的

引用 1 楼 lm_whales 的回复:语法分析，不可能没有词法分析 但是语法分析和词法分析可以结合到一起，不加区分（如果词法很简单的话）  谢谢，那解释程序情况下有咩有语义分析？语义分析也是不是语法分析前必要的环节？

解释程序也要翻译成中间码

解释器一次处理，大约是这个样子： 读取程序代码----> 出错处理      |      v 词法分析----> 出错处理      |       v 语法分析  ---> 出错处理     |    v 语义分析  --->出错处理       |    V （代码生成）-->出错处理    |    V   执行------>出错处理    |   V   得出结果

语义分析 是词法，语法分析之后做的事情。 解释器，如果不做代码生成的话。 语义分析以后， 就开始执行 了。  象 a + b  这是个表达式，结果是二者之和  这是语义分析部分要做的 如果是生成 p 代码 a,b + 这两个操作数，一个运算符，都要用 p 代码表示出来 那就成了代码生成了 如果不做代码生成，那么就会调用内部函数，处理这个表达式求出结果来 语义分析，这一步得出 这个表达式是合法的，这个+ 号如何处理 a,b如何处理 复杂表达式如何处理 这就是语义分析了 如果是词法分析 就可以分解出 a,+ ,b 三个符号，判断他们是否是合法的标识符（以及符号） 语法分析 判断出表达式 a+b 是否合法的表达式 运算符是+,a ,b 是操作数 语义分析 a+b 这个表达式各个元素，对应的p代码的那些元素。 或者对应内部那些 函数，过程 如何处理操作数 对于不带 代码生成的，下一步就是执行 对于带代码生成，下一步生成代码（p代码），执行代码（p代码）


Question: 怎么用C语言实现多个文件进行汇总到一个文件功能

import os smailfilels=[] fw=open("result.txt","w") for root, dirs, files in os.walk(os.getcwd()):     for i in files:         if i[-5:]=="smail":             smailfilels.append(root+"/"+i)              for i in smailfilels:     fr=open(i)     for line in fr:         fw.write(line)     fr.close() fw.close()

纠正上帖第4行：sprintf(cmdstr,"%s xxxx.txt",cmdstr);

static char cmdstr[32768]; sprintf(cmdstr,"copy /b 0001.txt"); for (i=1;i<100;i++) sprintf(cmdstr,"%s+%04d.txt",cmdstr,i); sprintf(cmdstr,"%s xxxx.txt",cndstr); system(cmdstr); //以上实现将0001～0099.txt合并到文件xxxx.txt

import os  filenames=os.listdir(os.getcwd()) fw=open("result.txt","w") for name in filenames:     if name!="result.txt" and name[-3:]=="txt":         fr=open(name,"r")         for line in fr:             fw.write(line)         fr.close() fw.close()  python简单写了下，怎么运行就不用说了吧

引用 10 楼 Ysniper 的回复:明天有空帮你写写   谢谢大神！！！！

windows平台下有copy命令  copy source*.file  dest.file (用通配符或 file1+file2+file3 格式)  linux平台下有concat

引用 6 楼 lm_whales 的回复:如果没有冲突。 系统的copy命令，就可以把若干文件合成为一个文件 恩？我明白你的意思 可是要人工的输入命令啊 我的意思是写个程序出来让它自己合并 大神你知道该怎么做么？

如果没有冲突。 系统的copy命令，就可以把若干文件合成为一个文件

引用 3 楼 lm_whales 的回复:好多方法，不用代码的话，用rar 之类的压缩工具，一下子就行了  如果需要按照某些信息，加以筛选，那就要编点代码了  是这样的 大神 你说的 我不太懂  我向你介绍一下啊 就是我分析一个东西得到多个文件，我想做的就是把多个文件汇总在一起。然后在用另一个程序把这个总文件里我想要的东西提取出来

引用 1 楼 Ysniper 的回复:用Python 求大神指导~~~大神能帮写下么？可以拿下载积分换 求大神帮忙~

把文件1.txt,2.txt,3.txt,4.txt放到linux系统下，执行 cat 1.txt 2.txt 3.txt 4.txt >> all.txt

估计20行代码就够了

用Python

明天有空帮你写写

system ("copy ....);


Question: c基础小程序——统计单词频率 出错求解答

linux gdb 足以

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

48行 puts(word);  用来验证get word函数正确用的


Question: C语言

直接声明就可以吧

小心别大于1MB

在栈上开辟一个二维数组，即在函数内申请一个局部变量（如：type array[2][4]）即可；

类型说明符 数组名[常量表达式1][常量表达式2]，如int a[3][4]; GCC编译器还支持动态数组定义，即常量表达式1和常量表达式2可以是个变量

vs可以int a[10][10]; gcc可以int a[n][n];


Question: 问一下哪错了

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

//循环变量建议使用i, j, k; 函数名建议使用非拼音（可以通过英汉翻译软件或在线的做一下翻译） //算法没问题，只是输出时有一点小问题；%s换成%c     4 void intersection(struct jihe *a,struct jihe *b)//两个集合求交集     5 {         6     struct jihe *c,*d,*e,*s;     7     char q[20];     8     int i, j;     9     e = a;    10     i = 0;    11     while(e)    12     {    13     |   d = b;    14     |   while(d)    15     |   { >> 16     |   |   if(e->c == d->c)    17     |   |   |   break;    18     |   |   else >> 19     |   |   |   d = d->next;    20     |   }    21     |   if(d != NULL)    22     |   { >> 23     |   |   q[i] = e->c;    24     |   |   i++;    25     |   } >> 26     |   e = e->next;    27     }    28          29     for(j = 0; j < i; j++)    30     {    31     |   printf("%c", q[j]);   //此处改成%c    32     }    33 }        34

对你的代码做了修改,自己分析自己的代码,理解一下。 #include <stdio.h> #include <stdlib.h>  struct jihe { char c; struct jihe *next; }; struct jihe *qjiaoji(struct jihe *a,struct jihe *b)//两个集合求交集 { struct jihe *c,*d,*r; c = r = (struct jihe*)malloc(sizeof(struct jihe)); r->next = NULL; while(a) { d=b; while(d) { if(a->c==d->c) { r->c=a->c; r->next=(struct jihe*)malloc(sizeof(struct jihe)); r=r->next; r->next=NULL; } d=d->next; } a=a->next; }     return c; } struct jihe *write(int m)//这是个建立集合的过程 {     int q;     char o; struct jihe *sa,*sb,*sc; sa=NULL; for(q=0;q<m;q++) { sc=(struct jihe*)malloc(sizeof(struct jihe));         scanf("%c",&o);         sc->c=o;         if(sa==NULL)         {          sa=sc;          sb=sc;         }         else         {          sb->next=sc;          sb=sc;         } } sc->next=NULL; return sa; }  int main (void) { 	struct jihe * t = qjiaoji(write(5),write(5)); 	while(t->next) 	{ 		printf("%c\t",t->c); 		t=t->next; 	} 	return 0; } 测试:

顶。。。。。。。。。。。。。。。。。

返回的交集 应该申请内存,  建立集合的函数名不能用wirte这与系统API重复命令 输入的时候scanf不能用%s只能用%c, %s会有字符串结尾字符溢出的问题   #include <stdio.h> #include <stdlib.h>  struct jihe { 	char c; 	struct jihe *next; };  struct jihe *qjiaoji(struct jihe *a, struct jihe *b)//两个集合求交集 { 	struct jihe *c = NULL, *d, *tmp = NULL, *tail = NULL; 	 	while(a) { 		d = b; 		while(d) { 			if(a->c == d->c) { 				tmp = (struct jihe *)malloc(sizeof(struct jihe)); 				tmp->c = a->c; 				tmp->next = NULL; 				if (!c) { 					c = tmp; 					tail = tmp; 				} 				tail->next = tmp; 				tail = tmp; 			} 			d = d->next; 		} 		a=a->next; 	} 	return c; }  struct jihe *jihe_write(int m)//这是个建立集合的过程 {     int i;     char o; 	struct jihe *head = NULL, *tail = NULL, *tmp; 	 	fflush(stdin);//only work in VC 	for(i = 0;i < m; i++) { 		tmp = (struct jihe*)malloc(sizeof(struct jihe)); 		scanf("%c", &(tmp->c)); 		tmp->next = NULL; 	    if (NULL == head) { 	        head = tmp; 	        tail = tmp; 	    } 	    else { 	        tail->next=tmp; 	        tail = tmp; 	        } 	} 	 	return head; }  void jihe_print(struct jihe* head) { 	while (head) { 		printf("%c ", head->c); 		head = head->next; 	} 	printf("\n"); }  void jihe_free(struct jihe* head) { 	struct jihe* tmp; 	 	while (head) { 		tmp = head; 		head = head->next; 		free(tmp); 	} }  int main(int argc, char** argv) { 	struct jihe * jihe1 = NULL; 	struct jihe * jihe2 = NULL; 	struct jihe * jiaoji = NULL;	 	 	jihe1 = jihe_write(5); 	printf("jihe1 is:\n\t"); jihe_print(jihe1); 	jihe2 = jihe_write(6); 	printf("jihe2 is:\n\t"); jihe_print(jihe2); 	 	jiaoji = qjiaoji(jihe1, jihe2);  	printf("jiao ji is:\n\t"); jihe_print(jiaoji); 	 	jihe_free(jihe1); 	jihe_free(jihe2); 	jihe_free(jiaoji); 	 	return 0;	 }

void jiaoji(struct jihe *a,struct jihe *b)//两个集合求交集 { 	struct jihe *c,*d,*e,*s; 	char q[20]; 	int y,u; 	e=a; 	y=0; 	while(e) 	{ 		d=b; 		while(d) 		{ 			if(e->c==d->c) 			    break; 			else 			d=d->next; 		} 		if(d!=NULL) 		{ 			q[y]=e->c; 			y++; 		} 		e=e->next; 	}     for(u=0;u<y;u++) 	{ 		printf("%s",q[u]);     } }   是这个，不好意思


Question: int fputc ( int character, FILE * stream );为什么第一个参数为int型

因为char的默认范围是-128..127，而ASCII的范围可以是0..255

这应该是类型隐式提升，char类型提升为int类型；

因为这是C函数 int 可以表示比 char 更多的信息 例如写入文件结束标志

以前的cpu处理int比char快，刚好等于cpu的字长。  另外还很多函数都是这样，如getchar返回值

char类型的话最多只能表示256个字符，是不是太少了点呢

中文字符因为编码gb2312,gbk,ucs-2不一样，可不是一个字节啊，考虑扩展

fputc() writes the character c, cast to an unsigned char, to stream.


Question: 打印三个数字(0 - 9)的组合可能(组合成三位数)

package test;  import java.util.*;  public class test1 {     private static List<String> resultList = new ArrayList<>();     private static int total = 3;//一共要取三个数      public static void main(String[] args) {         Integer[] arr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};         List<Integer> numList = Arrays.asList(arr);         getAll(numList, total, "");         System.out.println(resultList);     }      /**      * @param refList      源数组：用于取数的      * @param count        用于取几个数      * @param resultString 结果字符串：比如“103”      * @return      */     public static List<String> getAll(List<Integer> refList, int count, String resultString) {         for (int i = 0; i < refList.size(); i++) {             /*                       每一次循环要初始化 数组 和 结果字符串              */             String tempString = resultString;             List<Integer> tempList = new ArrayList<>(refList);             String resultNum = tempList.remove(i).toString();             tempString += resultNum;             if (count == total && resultNum.equals("0")) {//代表第一次取数为0的情况                 continue;             }             if (count != 1) {                 getAll(tempList, count - 1, tempString);             } else {                 resultList.add(tempString);             }         }         return resultList;     } }

for(int i=1;i<=9;i++) for(int j=0;j<=9;j++) if(i==j) continue; else for(int k=0;k<=9;k++) if(i==k||j==k) continue; else printf("%d%d%d\n",i,j,k);

for(int i=1;i<=9;i++) {       for(int j=0;j<=9;j++)      {              if(i==j)              continue;                     for(int k=0;k<=9;k++)                     {                               if(i==k||j==k)                               continue;                               printf("%d%d%d\n",i,j,k);

for (int i = 100; i < 1000; i++) {        std::cout << i << std::endl; }

1~3位，带前导0 的十进制数ASCII表示中， 扣掉，三个字符中出现重复数字的组合就是他了

一个简单粗暴，效率不高的算法 就是0~999 转换为带前导0 的3位字符串 然后过滤掉 有重复数字的数 优点是，天生就是升序或者降序排列的 不需要其他技巧

可以写出来吗

先用子集生成算法生成三个数字然后枚举排列每个子集，用到两个比较简单的算法你可以百度


Question: 二级指针分配在不同的IDE中有不同的用法吗？

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

引用 4 楼 under_tackle 的回复:[quote=引用 3 楼 paschen 的回复:] 怀疑是你其他代码导致堆破坏而产生的不确定行为，建议先注释掉无关代码，判断出错原因   是的，发现了是其他的原因，已经解决了，我在这个分配语句前进行了对另一块区域的读写操作，然后越界了。不过我很奇怪为什么调试的时候会调试到在这一句出现错误……这也会延迟吗？还有，我把错误的程序写在WIN10上却可以运行，是不是说WIN10运行越界写数据？[/quote]  所以我上面说了，叫不确定行为，包括你预想的和未想到的

malloc 呼叫 HeapAlloc 操作。 该操作在分配内存之前需要检测堆是否正确。 看看函数 _heapchk 。 所以如果分配内存函数错误，那么表示在此之前，堆操作曾经有过错误。

引用 2 楼 qq423399099 的回复:我试了下VS2012是可以的，楼主代码贴全看看  谢谢回复，已经解决了

引用 3 楼 paschen 的回复:怀疑是你其他代码导致堆破坏而产生的不确定行为，建议先注释掉无关代码，判断出错原因   是的，发现了是其他的原因，已经解决了，我在这个分配语句前进行了对另一块区域的读写操作，然后越界了。不过我很奇怪为什么调试的时候会调试到在这一句出现错误……这也会延迟吗？还有，我把错误的程序写在WIN10上却可以运行，是不是说WIN10运行越界写数据？

我试了下VS2012是可以的，楼主代码贴全看看

自己下了个VC试了试，发现居然不行……………………好吧，我也不清楚为什么程序是一模一样的，在同学电脑上就是可以执行的，在自己电脑上不论换了什么IDE都没有办法执行


Question: 结构里的联合，可以省掉联合的名字吗？

引用 7 楼 lm_whales 的回复:C++ struct 其实可以和class一样。 可以定义 构造函数，析构函数，静态成员变量和函数， 可以定义私有，公有，或者保护成员变量和函数 可以继承，被继承 C++ union 据说也可以定义的跟 class 一样， 而且成员也不限于内部类型，以及内部类型组成C式样的 struct C 式样的 union  的组合 这种其实跟 这里讨论的无名结构，联合无关，可以忽略  无名结构或者联合并且没有定义变量，也没有用typedef 定义别名 则 它定义的变量，相当于在他的外部作用域定义的同名变量。 只是存储上，受到 结构或者联合 的影响，不属于自由定义的变量  自由定义的变量，存储不受任何限制， 编译器可以不必安排连续区域存储。  结构或者联合内部定义的变量，受结构或者联合的约束  早期的C似乎不支持，无名结构 C99,C11 不知道支持不 C11 有 匿名struct和union C++只有匿名union  不过一般编译器都支持匿名struct和union

理解和讨论之前请先学会如何观察！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！

一个很现实的问题，如果没有名字，你如何去使用联合里的数据元素，如何赋值或者获取联合里的数据元素；

引用 10 楼 akirya 的回复:[quote=引用 7 楼 lm_whales 的回复:] 。。。。 C11 有 匿名struct和union C++只有匿名union  不过一般编译器都支持匿名struct和union[/quote]  就是说C新标准已经支持了，C++ 标准还是犹抱琵琶半遮面 虽然C++出来以后，通常 C标准，显然不如C++标准更有执行力 但实际上，各大编译器 在这个问题上，匿名 struct,union 已经是事实上标准了  C++标准，不如顺水推舟，来得更好。。。。。。。。。

struct {         int a;         union         {                 struct                 {                         int x;                         int y;                  }log;                    struct                 {                         int m;                         int n;                  }chat;      }; }send;  这个定义 log 和 chat 在同一位置 因此 log.x ,chat.m 也就在同一位置了         log.y，chat .n 也就在同一位置了 注意，这两个结构没有名字，但定义了变量，所以 x,m 这两名名字，必须要跟 log,chat 这两个名字联系起来，才可以 不能单独用   union 没有名字 所以 log，chat 这两个名字，可以算作 send 的一个成员。只是他们是 union定义的，所以共用同一块内存 同样， 最外层的stuct 没有名字 因此，这个结构定义是一次性的 除了定义 send 这个变量外，别无作用了，不能再拿来定义别的变量了。

2）内层为的结构，联合，不定义变量，且没有名字

当然在同一个位置, log 和chat 的结构完全相同,又使用同一块内存

引用 2 楼 lm_whales 的回复:都可以，类，结构，联合 内部定义的结构，联合都可以没有名字 没有名字分两种情况 1）同时定义变量（1～n个,也可以定义数组） 2）内成为南方的结构，联合，不定义变量，且没有名字 3) typdef 为没有名字的类型，定义一个名字 第一种情况，这个匿名类型定义的变量，就是外层 类结构，联合的成员。内层的结构，联合 都不能定义变量，因为没有名字。  第二种情况。这个匿名类型，是外层类型的一部分，他的成员，就是外部类型的成员 如果外层为联合， 内层为结构 则结构视为一个整体， 他的成员，并不具有，联合成员的共享内存特性。  第三种情况，实际上，给结构联合起个别名 成员，跟外围类型无关。可以用别名定义对象。，，，， C这么做不很合适，因为C没有作用域运算符，不能在外部，找到内部typedef 定义的别名。  那么请问，假如我定义这样的：  struct {         int a;         union         {                 struct                 {                         int x;                         int y;                  }log;                    struct                 {                         int m;                         int n;                  }chat;      }; }send;  变量x和m是存储在同一位置吗？

这样的匿名类不是太标准，所以建议不要这样，不过不少编译器都支持了，所以实地测试一下编译器支持情况就行了.


Question: 一道程序设计的高中数学问题

如果是任意4个点组成的四边形，可将问题转换成计算三角形面积  1、AB与CD相交，非四边形 2、ABC组成的三角形面积，与ABD、ACD、BCD三个三角形面积之和比较，如果相等，为凸四边形，面积为ABC和ADC之和，如果大于，为两者之差 3、比较ABP、BCP、CDP、DAP四个三角形面积之和与四边形面积，若大于P在四边形ABCD之外，否则之内

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

2D的转变需要3x3矩阵，最右一列没有影响。 矩阵 A B 0 C D 0 E F 1 然后用坐标(x, y, 1)相乘能得到新的坐标，把矩形转换为2D转变然后转换那个点就行了。


Question: 字符串求解

用strtok分割成数组，然后分别用atoi/atof转换成数值。

楼主意思，输入没有格式可言 你就char* p = start，p++碰到连续数字（0-9），记录下来，atoi转换成整数

#include <iostream>  using namespace std;  int main() {       char buf[10] = "12,234";       char *p = buf;       int i = 0;       int len = sizeof(buf) / sizeof(*buf);        for (i = 0; i < len; i++)       {             if (p[i] == ',')             {                  p[i] == '\0';                  break;             }       }        cout << "str1 =  " << p << " ";       cout << "str2 = " << p + i + 1;         cin.get();   }

如果是输入  strname=（1,2）（4,5）（1,1） 这个样子呢  我要取出它的名字 strname 和1，2，4，5，1，1这一些数据，能大概讲讲算法吗？

假设char*str="12,234",将字符串遍历，找到‘，’将‘，‘赋值成’\0',则str=“12”，str+3=“234”。

如果格式比较固定，不妨考虑sscanf


Question: typedef 的用法求解

int  是整个类型定义的一个局部 int (*PFI)(char *,char *); 为一个完整的函数指针定义， 指针为 PFI， 类型为 int (*)(char *,char *); 所以 typedef  int (*PFI)(char *,char *); 定义PFI为 函数指针类 int (*)(char *,char *); 指向    返回值为 int，两个参数都是 char * 类型 的函数指针。  去掉 typedef 后，定义类型就变成定义对象，这里是函数指针 加回  typedef  这就变成定义类型了，对象名就变成类型名了（别名），  typedef类型。就是 去掉typedef 后，所定义的对象的类型。

一般一个带返回值的函数肯定是这样写的：  int  func(char*, char*)    那么我们要定义这个函数的指针，下面的内容就好理解了。  typedef  int  (*PFI)(char *, char *);  PFI  fun; fun = func;

typedef  int  (*PFI)(char *, char *)

typedef  int  (*PFI)(char *, char *);这是一个指针函数的声明，这个指针函数有两个形参，类型为char型指针，指针函数的返回值是int型 可以将任意符合上述行参和返回值的函数赋值给这个PFI。

引用 2 楼 qq423399099 的回复:那楼主把PFI前面的int理解成什么？就是后面的会把 int 替换掉 不会再用到  int 了

就是后面的会把 int 替换掉 不会再用到  int 了

那楼主把PFI前面的int理解成什么？


Question: 求大神帮帮忙啊！！！关于N维数组排序的

唉，我用结构体写的。通过了。

如果n已知，"China"放最后，排序前n-1个国家可以了 否则，要用链表排序的

哎呀，失误了，楼主在else if分支里加下别的成员变量也交换的几行代码

引用 3 楼 小灸舞的回复: #include<stdio.h> #include<stdlib.h> #include<string.h>  typedef struct infomation { 	int no; 	char country[16]; 	int people; 	char continents[16]; }Info;  int main() { 	int n, i, j; 	scanf("%d", &n); 	Info *info = (Info *)malloc(n * sizeof(Info)); 	//循环输入数据 	for(i = 0; i < n; i++) 		scanf("%d %s %d %s", &info[i].no, info[i].country, &info[i].people, info[i].continents);  	//冒泡排序 	for(i = 0; i < n; i++) 	{ 		for(j = 0; j < n - i - 1; j++) 		{ 			if(strcmp(info[j + 1].country, "China") == 0)//如果第二个字符串是China则跳过 				continue; 			else if(strcmp(info[j].country, info[j + 1].country) > 0 || strcmp(info[j].country, "China") == 0)             {  //前面的字符串比后面的小或者前面的字符串是China 				char temp[16] = {0}; 				strcpy(temp, info[j].country); 				strcpy(info[j].country, info[j + 1].country); 				strcpy(info[j + 1].country, temp);             }  		} 	}  	//打印结果 	printf("\n"); 	for(i = 0; i < n; i++) 		printf("%d %s %d %s\n", info[i].no, info[i].country, info[i].people, info[i].continents); }  不对啊，你这样只是把国家的顺序排了一下。序号跟国家是匹配的，还有后面的信息跟国家也是匹配的。

引用 1 楼 初奋斗的回复:如果强调N维数组的话，那么也就是加点循环罢了。一维排序总会吧。 如果就题而论，不如你输完我就比，一个strcmp函数搞定。然后直接选择插前面还是插后面。 #include<stdio.h> #include<string.h> int main() { 	int n,i,j,t; 	char a[100][20],b[20]; 	while(scanf("%d",&n)!=EOF) 	{ 		t=0; 		for(i=0;i<n;i++) 		scanf("%s",&a[i]); 		for(i=0;i<n;i++) 		if(strcmp(a[i],"China")==0) 		for(j=i;j<n;j++) 		strcpy(a[j],a[j+1]); 		strcpy(a[n-1],"China"); 		for(i=0;i<n-1;i++) 		for(j=i+1;j<n-1;j++) 		{ 		if(strcmp(a[i],a[j])>0) 		{ 			strcpy(b,a[i]); 			strcpy(a[i],a[j]); 			strcpy(a[j],b); 		} 	} 		for(i=0;i<n;i++) 		printf("%s\n",a[i]); 	} 	return 0; }


Question: C语言错误提示

同学，你好可爱

对喔！！ 眼花了

你是不是在逗我，你看看你的main写成什么了


Question: C语言中的参数默认值

name + 0 如果 name 为空 变成 +0 正0 也就是 0 如果没有+0 如果为空 就成  “”[0]?:defval  ?表达式，缺少了一个表达式，当然就错了 这是一种技巧  #name[0]的意思是将name转换为字符串，然后再取出它的第一个元素？对的 注意空字符串，也有一个元素'\0'  字符串化运算符 # 用于宏定义语句，它的作用如下： #abc --->"abc" #1--->"1" #x--->"x"   字符串 可以当作数组用 “abc”[0] --->‘a’ “abc”[1] --->‘b’ "abc"[2]---->'c' "abc"[3]---->'\0' 一个只有三个字符，两边加上引号的字符串（其中不包含转义字符，转义字符另有计算法）， 一共有四个字符，最后一个是字符串结束符 ‘\0’ ，也就是值为0的字符

引用 2 楼 lm_whales 的回复:#name  ---->"name" #是字符串化运算符 可以把一个符号，转换为对应的字符串（两端加上引号）  #define DEFARG(name, defval) ((#name[0]) ? (name + 0) : defval) 如果 name 不是空格 ,例如  name 是1 那么么 #name[0] 也就是 “1”[0] 是字符‘1’为真 这个问号表达式的值就是 name + 0 也就是 name 本身 ，这里就是1 如果是 x 那么值就是 x 这样不论是变量，还是常量 都得到他本身  如果 name 是空格，则#name 是 "" 空串，“”[0] 就是'\0' 是值为 0 的字符，为假 此时问好表达式的值为  defval  所以这个宏的意思就是 name 为空，取缺省值defval，不为空取 name的值 这对于指针，整型数据，浮点数据等等都有效  #define f1(arg0) _f1(DEFARG(arg0, 0)) 相当于，给无缺省值的函数（C式样的函数），针对某一个参数增加一个缺省值， 相当于 inline int f1 (int a=0){ return _f1(a); } 但是比C++缺省值，更加好用些，可以给任何一个参数加上缺省值。  #define f2(arg0, arg1) _f2(DEFARG(arg0, 0), DEFARG(arg1, 1)) 给 _f2的每个参数，都加个缺省值，分别为0，1  函数调用方式没有参数的地方，就是有缺省值的 为什么要name + 0呢？不加0就出错，还有#name[0]的意思是将name转换为字符串，然后再取出它的第一个元素？这个理解正确吗

#，预编译时会作为连接字符，将#name当成字符串

其实这个宏定义是带参数的宏定义： #define DEFARG(name, defval) ((#name[0]) ? (name + 0) : defval) /*这里，DEFARG是宏名，(name,defval)是他的两个参数名。后面的括号内容是参数的定义方式。这里可以把这个宏看作一个函数，不过他是与处理的： 当#name[0]为真时（无参数），返回name+0； 当#name[0]为假时（有参数），返回defval（默认值） */ 比如： #define f1(arg0) _f1(DEFARG(arg0, 0)) /*对于f1()的调用，因为#name[0]为真（没有传递参数），所以返回name+0=0； 对于f1(1)的调用，因为#name[0]为假（有参数传递），所以返回defval=1； */ 又比如： #define f2(arg0, arg1) _f2(DEFARG(arg0, 0), DEFARG(arg1, 1)) /*对于f2(，)的调用，因为#name[0]为真（没有传递arg0参数），所以返回arg0+0=0； 因为#name[1]为假（有传递arg1参数），所以返回arg1=1； 所以输出为1；  对于f2(2,0)的调用，参考上面分析：结果为2+1=3； */   下面这篇文章有很详细的介绍，可以了解一下 blog.163.com/xuwenqiang_1989/blog/static/49074935201132433318770/


Question: C语言  linux  如何构造满足execv()的以NULL结尾的字符串数组参数表？

malloc、realloc、free

char argv_1[args][MAX_SIZE];                //其中args是前面参数分割后的个数，已知。 int i=0; while(i<args) {         strcpy(argv_1[i],argv[1]);         i++; } argv_1[args]=NULL;      //此处改成argv_1[i] = NULL;

引用 3 楼 user-3 的回复:与上面第2点的区别在于在于什么。。。

与上面第2点的区别在于

再补充以下，如果循环使用，第一次有m个参数，第二次有n个参数，m>n时，就会因为没有初始化字符串数组而出现内容字符串多出并重复（因为第二次NULL实际上是在第m+1个位置上，大于n+1） 不知道有没有描述清楚 char *argv_1[BUF_SIZE]; int k=0; while(k<args) {     argv_1[k]=argv[k];     k++; } argv[k]=NULL;//这句不可以少，否则会有被前面覆盖的可能（初始化的问题）

好吧，我想了半天就在刚发帖后发现下面做法可以： char *argv_1[BUF_SIZE]; int k=0; while(k<args) { 	argv_1[k]=argv[k]; 	k++; }  与上面第2点的区别在于新声明的字符串数组的声明方式不同。 具体原因我其实也不理解，可以明确是我对字符串数组理解不够深入，如果大家看到这里有想法说说自己的想法吧～谢谢～


Question: Dev C++多文件编译问题

Bll.h 可以包含任何你想包含的东西，包括 stdio.h 然后由于项目不大，所有文件都包含 Bll.h 就可以了

为什么main.c包含了stdio.h头文件,iMainMenu.c就不能包含stdio.h? 头文件本来就是用来包含的，头文件只是一些函数的声明，宏定义什么的，并没有函数的实现 楼主既然那么不想重复包含头文件那就都写在一个文件里好了，没必要分多个文件


Question: 用数组输出菱形之莫名其妙问题

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

与编译器有关吧，vs2015运行结果如下：

在屏幕上打印 '\0' 的效果是由实现定义的。与编译环境、运行环境有关。如果非要打印它不可，那就认命。要不就改成     for(i=0; i<5; i++)     {         for(j=0; j<5; j++)         {             if (c = diamond[i][j])                 printf("%c", c);         }         printf("\n");     }

全部25个字符都初始化一下试试？


Question: 数据写入文本 出现乱码  大神求教

引用 1 楼 qq423399099 的回复:main函数里if("x==1")改为if(x==1) writetoFile函数里for(i=0;i<=n;i++)改为for(i=0;i<n;i++)这里多循环了一次 上面两处改掉以后我运行出来的结果是对的我重新试了下 这次好了 ，可能上次弄错了。但是如果输入的数字过长的话，还是有点问题；

引用 6 楼 小灸舞的回复:fprintf不是存的二进制，存的是ASCII，即文本文件 fwrite才是存的二进制 受教了，我当时就是用fwrite写的，打开也是乱码，实际上没问题的

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

乱码一般都是编码格式的问题  试试GB2312

没问题，采取的二进制记录，所以文本打开有问题，实际上是保存成功的。 建议:写完查询记录模块，和显示模块。最后写读取文本数据模块。

int    x    ,      i       ,    n  ,j     ;　　把这一行　定义全局变量　　， 比如 ｉｎｔ　ＩｎＮｕｍ，ＰｅＮｕｍ； 试一试

楼主输入截个图 并且楼主是用什么方式打开文件的，换一下编码方式看看

引用 1 楼 小灸舞的回复:main函数里if("x==1")改为if(x==1) writetoFile函数里for(i=0;i<=n;i++)改为for(i=0;i<n;i++)这里多循环了一次 上面两处改掉以后我运行出来的结果是对的 这个改了，还是乱码啊。。。。


Question: 新手提问，char msg[]和 char *msg  使用区别？

可以这样理解

多谢！～～～

多谢！ 是说char mesg[]这种数组声明方式，数组在栈上开辟空间，重新复制了一份字符串？

char mesg[] = "Hold on to your hats,hackers. "; 这样写，数组是在栈上开辟的空间，是可以进行读写操作的 char *mesg = "Hold on to your hats,hackers. "; 这样写，mesg指向的是常量区的一个常量字符串“Hold on to your hats,hackers. ” 该内存区域是禁止进行写操作的，所以执行到fit函数的 *(string + size) = '\0';会报错


Question: 新手求教

这是一个未定义行为，无论你怎么写都是错的，即使答案对了，那过程也是错的，因为你会发现换个编译器答案又不一样了。

另外，这样的代码可读性比较差，不建议使用；

对于模棱两可的问题，能避免就避免；不能避免那就不要这样传参嘛

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

ff 函数的参数中，各个参数表达式运算顺序没有不确定，不要写这样的代码

答案当然是8. ff(c+1,c++,c)函数运行完之后对主函数无变化，需要有变化的话，需要将ff函数改为int ff(int a,int b,int c)，然后在分函数的最后加一个return c;然后再在主函数中改为d=ff(c+1,c++,c)。  #include<stdio.h> #include<stdlib.h>  int ff(int a,int b,int c){  printf("%d%d%d\n",a,b,c); //得出的答案是 9 7 8 c=a+b; printf("%d\n",c);  return c; }   void main(){   int d=7;    d=ff(d+1,++d,d); printf("%d",d);  system("pause"); }

压栈顺序从右往左，这点可以确定 大多数环境栈都是从高地址往低地址用的，如果从左压，不定参数往后取在内存里就成往前走了。 而栈从高往低用是很久很久以前为了尽量不和别的内存使用打架，而复杂指令集CPU压栈出栈逻辑是写死的，所以虽然现在没这个必要了，但是为了兼容还保留了这个逻辑。 从右向左压栈可以保证生成汇编语言时这些参数相对于BP指向的栈位置的偏移量是固定的，因为程序员有时为函数传递的参数会或多或或少，如果从左向右压栈，则从BP指向的位置到参数的偏移量就会根据用户传入的参数数量而发生改变，这时编译器的识别难度就会大大增加，因此才会从右向左压栈。  至于输出的结果，因为有++的存在，会依赖编译器，不同的编译器结果很可能不同

我运行了一下你的代码，答案是8 7 7 是同时传递值的。

还有为什么最后的答案是8


Question: 为什么无法读取到txt文件数据

另外，fgets是一次读一行，还要确认一下源文件的每行是否超过11个字节，否则会内存泄漏吧； fputs同理；

缓存是11个字节，你要读12个字节进去；这儿是矛盾的；所以，建议你查看读写函数返回值，即判断是否出错；另外，确认从源文件读到的数据；

fgets, fgetws Get a string from a stream.  char *fgets( char *string, int n, FILE *stream );  wchar_t *fgetws( wchar_t *string, int n, FILE *stream );  Function Required Header Compatibility  fgets <stdio.h> ANSI, Win 95, Win NT  fgetws <stdio.h> or <wchar.h> ANSI, Win 95, Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  Each of these functions returns string. NULL is returned to indicate an error or an end-of-file condition. Use feof or ferror to determine whether an error occurred.  Parameters  string  Storage location for data  n  Maximum number of characters to read  stream  Pointer to FILE structure  Remarks  The fgets function reads a string from the input stream argument and stores it in string. fgets reads characters from the current stream position to and including the first newline character, to the end of the stream, or until the number of characters read is equal to n – 1, whichever comes first. The result stored in string is appended with a null character. The newline character, if read, is included in the string.   fgets is similar to the gets function; however, gets replaces the newline character with NULL. fgetws is a wide-character version of fgets.   fgetws reads the wide-character argument string as a multibyte-character string or a wide-character string according to whether stream is opened in text mode or binary mode, respectively. For more information about using text and binary modes in Unicode and multibyte stream-I/O, see Text and Binary Mode File I/O and Unicode Stream I/O in Text and Binary Modes.  Generic-Text Routine Mappings  TCHAR.H Routine  _UNICODE & _MBCS Not Defined _MBCS Defined _UNICODE Defined  _fgetts fgets fgets fgetws    Example  /* FGETS.C: This program uses fgets to display  * a line from a file on the screen.  */  #include <stdio.h>  void main( void ) {    FILE *stream;    char line[100];     if( (stream = fopen( "fgets.c", "r" )) != NULL )    {       if( fgets( line, 100, stream ) == NULL)          printf( "fgets error\n" );       else          printf( "%s", line);       fclose( stream );    } }   Output  /* FGETS.C: This program uses fgets to display     Stream I/O Routines  See Also   fputs, gets, puts

#include <stdio.h> int main() {     FILE *fp1,*fp2;     unsigned char ch[11];      if((fp1=fopen("D:\\test.txt","r"))==NULL) {         printf("Can't open file D:\\test.txt\n");         return 1;     }     if((fp2=fopen("D:\\z.txt","w"))==NULL) {         fclose(fp1);         printf("Can't open file D:\\z.txt\n");         return 2;     }     while(1) {         if (NULL==fgets(ch,11,fp1)) break;         fputs(ch,fp2);     }     fclose(fp2);     fclose(fp1);     return 0; }

把         unsigned char ch[11];     int num=12; 改成     unsigned char ch[12];     int num=11;  原因嘛，     fgets(ch,num,fp1);//读取一个数据帧 能造成缓冲区溢出

ch数组大小设置的是不是太小，也没有清零，每次读写文件后ch数组都清零

fgets函数，参数s是缓冲区的首地址，size是缓冲区的长度，该函数从stream所指的文件中读取以'\n'结尾的一行（包括'\n'在内）存到缓冲区s中，并且在该行末尾添加一个'\0'组成完整的字符串。 fgets()函数中，第一个参数指针需要我们事先分配好大小。另外，fgets()函数不适合取二进制的文件，这样，容易发生错误。  注：fgets从指定的文件中读一行字符到调用者提供的缓冲区中，gets从标准输入读一行字符到调用者提供的缓冲区中。 1.当遇到换行符或者缓冲区已满，fgets就会停止，返回读到的数据，值得注意的是不能用fgets读二进制文件，因为fgets会把二进制文件当成文本文件来处理，这势必会产生乱码。 2.每次调用，fgets都会把缓冲区的最后一个字符设为null，这意味着最后一个字符不能用来存放需要的数据，所以如果有一行，含有LINE_SIZE个字符(包括换行符)，要想把这行读入缓冲区，请把参数n设为LINE_SIZE+1

用二进制读写文件好点。


Question: 大神们，求救，关于数据结构树的出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-> //

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

出错时中断下来，通过调用堆栈确定变量位置，然后观察分析原因


Question: 为什么新的领域都不用c了

一般我们写算法的时候也会先用matlab测试，测试成功后再转成c艹代码。

引用 6 楼 CharlesSimonyi 的回复:搞算法用什么语言都可以，别人觉得python方便就用python了 当python遇到缩进乱了的时候……

搞算法用什么语言都可以，别人觉得python方便就用python了

引用 4 楼 akirya 的回复:其他语言效率也上来了，可选余地比较大了，机器性能也上来了。 绝大多数时候不那么苛求运行效率了，反而开发成本维护成本是主要考虑的因素。  相对来说C 和 C++ 性价比都不高，所以就越来越少了。  看了看那些领域的相关书，都是些算法，和编程有什么关系，有库c不是一样编，看来背后水很深啊

引用 1 楼 CharlesSimonyi 的回复: Orz

引用 1 楼 CharlesSimonyi 的回复:  什么意思，用python来学算法啊，那些算法之类的库为什么不直接提供c版本的


Question: c语言没见过的一种写法，求解释

VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898

#ifdef 标识符  程序段1  #else  程序段2  #endif 它的作用是：当标识符已经被定义过(一般是用#define命令定义)，则对程序段1进行编译，否则编译程序段2。

一般在接口处，我们都会用这几个宏，没有实际用途，但是方便阅读  #ifndef IN #	define IN #endif  #ifndef OUT #	define OUT #endif  #ifndef INOUT #	define INOUT #endif  #ifndef OPTIONAL #	define OPTIONAL #endif

引用 7 楼 lm_whales 的回复:C51 可以有一下标志，表示数据定义在不同区域 code data xdata idata 学到了

这不是宏定义吗

#define _xxx _xxx int* _name; 等同于 int* _name;  这里的_xxx没有实际作用，是给人看的或者是给特殊编译器做一些特殊处理的

引用 2楼user-9 的回复:一般这种都是用在预编译的  防止重复定义的确，我看ucos就是这种写法。

#define _xxx short  //或unsigned或long或long long或signed…… #ifndef _xxx #define _xxx #endif _xxx int* _name;

_xxx int* _name; 主要是这个　 与int* _name; 有什么区别

一般这种都是用在预编译的  防止重复定义

这样一般都是编译器需要特殊处理的， 特定性质的标识符 也可能是某个库定义的 定义一个符号作为识别标志 这样有几个好处  1)可读性 有了这个 _xxx 我们知道 这是个特别的标识符 2）符合标准，对于处理不了这个 _xxx 标志的编译器，也能正常编译程序，不至于出错


Question: 关于正规式

本人计算机专业，这是我编译原理中学的，来考古，顺便考前练练手

引用 11 楼 calen_ 的回复:您有没有好好想想.... 你看看 00011101 这个字符串 '_>`  非常感谢谢，明白了，也就是说C答案其实跟A答案不是等价，因为C答案规定了10结尾的前面是连续的1再接连续的0，但是这个自动机可能会出现连续的0再接连续的1，所以C答案不正确， 谢谢

这好像是编译原理吧，记得之前有学过

您有没有好好想想.... 你看看 00011101 这个字符串 '_>`

hello，有人帮忙看一下吗

hello，有人能帮忙看看吗，谢谢

引用 7 楼 qnmdcsdn 的回复:看标题我还以为是正则式，进来就懵逼了。看着眼熟，我只能说我应该是学过的  应该就是正规式吧，从有限自动机推算正规式

看标题我还以为是正则式，进来就懵逼了。看着眼熟，我只能说我应该是学过的

HI，请问有人帮忙解答一下吗

引用 1 楼 qq_28224387 的回复:郁闷，看了好大一会儿看不懂，多年前教材上见过这玩意儿 我想你发错地方了， 我的本来专业是电子信息工程，看到这图有点眼熟，我想你应该把这贴发到，硬件/嵌入式版块里有个，单片机/工控子版块。   哦，这个是软件设计师考试的题目，所以我想应该放在这里也可以吧

支持一个，支持支持

HI，请问有人帮忙解答一下吗


Question: fwrite函数失败，代码已给出，求帮助。

帮结贴

rb+

已自行解决：http://ask.csdn.net/questions/252446 希望能帮到后来人。


应该是没有带编译器

WIN10可以装VC6.0，但你要改一个文件名，然后在兼容模式下运行，具体可百度

可以使用安装cygwin，用gcc来玩

Dev挺适合新手学习的

引用 6 楼 赵4老师的回复:Visual C++ 2010 Express简体中文版http://pan.baidu.com/s/1bnwRVLt 谢谢，，我去试试，，，，

VC应该可以使用。你尝试改下兼容性。 找到安装目录。如： D:\Program Files (x86)\Microsoft Visual Studio\Common\MSDev98\Bin 有个 MSDEV.exe  右击－〉属性－〉兼容性 可以选 Windows XP(WIN 8 之前应该都行，你可以多试试) 最后，在以管理员身份运行 前 打勾。 确认 后，再次打开就应该能用了。

使用新版VS吧，新手可以用VS2010

源文件没找到吧，看看路径对不

建工程,在功能里编译, 不能建一个文件就编译

Dev C++是完全安装吗，建议重新安装。


Question: 求解C一个关于scanf拿不拿到值得问题

我刷新输入缓冲区

引用 8 楼 louis_green 的回复:[quote=引用 5 楼 cyfcsd 的回复:] [quote=引用 2 楼 louis_green 的回复:] [quote=引用 1 楼 cyfcsd 的回复:]  scanf( "%c", &end ) ;把回车接收了， 把这句话写两次就可以了  第一次节回车，第二次接你的输入 按你这么做，先给1，num拿1，第一个scanf拿回车，再输9，是第二个scanf拿9，还是，头一个scanf（num语句下面的）拿9？[/quote] 中间都要有两回车，如果只想要一个 scanf( "%c", &end ) ;，输入之间用空格隔开[/quote] 不行唉，中间都要俩回车，程序运行直接是一直输入的状态，输入啥也结束不了，包括q，也不行。[/quote] 不会吧，要退出的话第一个是回车第二是q

引用 5 楼 cyfcsd 的回复:[quote=引用 2 楼 louis_green 的回复:] [quote=引用 1 楼 cyfcsd 的回复:]  scanf( "%c", &end ) ;把回车接收了， 把这句话写两次就可以了  第一次节回车，第二次接你的输入 按你这么做，先给1，num拿1，第一个scanf拿回车，再输9，是第二个scanf拿9，还是，头一个scanf（num语句下面的）拿9？[/quote] 中间都要有两回车，如果只想要一个 scanf( "%c", &end ) ;，输入之间用空格隔开[/quote] 不行唉，中间都要俩回车，程序运行直接是一直输入的状态，输入啥也结束不了，包括q，也不行。

引用 4 楼 qq423399099 的回复:你输入9，输入缓冲区是9\n,然后scanf( "%d", &num ) ;读走9,输入缓冲区还遗留下\n 然后scanf( "%c", &end ) ;会直接读取掉回车而不需要等待用户输入（此时输入缓冲区为空了） 然后又跳到while  ( end != 'q' )判断，之后是 scanf( "%d", &num ) 谢谢，你讲的很清楚，那如果接下来我希望程序结束，输入q，那这个q是转化为对应的ascii码整型数113给了num，还是跳过第一个scanf，直接给了字符型的end？

引用 2 楼 louis_green 的回复:[quote=引用 1 楼 cyfcsd 的回复:]  scanf( "%c", &end ) ;把回车接收了， 把这句话写两次就可以了  第一次节回车，第二次接你的输入 按你这么做，先给1，num拿1，第一个scanf拿回车，再输9，是第二个scanf拿9，还是，头一个scanf（num语句下面的）拿9？[/quote] 中间都要有两回车，如果只想要一个 scanf( "%c", &end ) ;，输入之间用空格隔开

引用 1 楼 cyfcsd 的回复:scanf( "%c", &end ) ;把回车接收了， 把这句话写两次就可以了  第一次节回车，第二次接你的输入 按你这么做，先给1，num拿1，第一个scanf拿回车，再输9，是第二个scanf拿9，还是，头一个scanf（num语句下面的）拿9？

引用 7 楼 qq423399099 的回复:当楼主某次输入q的时候，是 scanf( "%d", &num ) ;先读取的，但由于类型无法匹配，所以读取失败，楼主可以通过scanf返回值得知此次读取失败了，输入缓冲区还是q\n 然后就执行到了scanf( "%c", &end ) ;end成功读取了q字符，之后while  ( end != 'q' ) 跳出循环  谢谢舞哥，用scanf的返回值一检查，果然了然，果断关注！

引用 3 楼 zhao4zhong1 的回复:在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 int c; scanf("%c",&c); //时，都改为 char s[2]; int c; scanf("%1s",s); c=s[0];  大神这一席话，我将受用终身！


Question: atoi函数的一点疑惑，新手求助

因为字符不是字符串，不会有结束符的 你的两个字符，被当成一个字符串处理了 这只是在特定情况才会出现的 不是总是这样的 这种错误，很麻烦，千万别这样做

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

使用函数前，得清楚函数参数

atoi需要的参数是以\0结尾的字符串，而不是一个字符

atoi的传入参数应该是以空白符结尾的字符串，你传入的是字符指针，但atoi仍把其当作字符串指针对待，直到遇NULL为止。至于打印出来是43，这跟栈的变量存放顺序有关。

这个跟编译环境和内存环境有关了，栈分配是从高地址向低地址分配的，如果ch1和ch2的地址相邻，因ch1在高地址，ch2在低地址，如果ch1后面又刚好是一个终止符，那么num2就可能是34. atoi的参数是一个c风格的字符串，即以终止符结束的字符串。 我在VS上得不到你这样的结果，这样的将一个单字符的地址传给atoi是未定义行为

应为你写错了

引用 12 楼 kuaileguyue 的回复:cheshi.exe  　　　ｆａｙｉｎ　　不准 扯屎 发音哪儿不准了？

cheshi.exe  　　　ｆａｙｉｎ　　不准

二楼应该说的对

atio的参数是字符串，如果第一个非空格字符存在，是数字或者正负号则开始做类型转换，之后检测到非数字(包括结束符 \0) 字符时停止转换，返回整型数。否则，返回零。  &ch2的字符串在你的电脑中被认为成 "43"了。

为什么num2变成了43而不是3？？？


Question: 有没有哪一款IDE有联想功能？

你可以用VisualStudio+ visual assist x插件来写C代码，写完后再用CCS编译

很多时候，使用的工具越先进，人越笨；得到得越轻松，人越懒。

下载 visual assist x 插件，非常强大！

带代码补全的很多  atom什么都可以

vi + 一个控件 控件名忘了，搜索一下吧

source insight 3.5，包含进去，内核都可以提示啊。

如果只是变量的话notepad++都支持的，你可以用vs编辑代码啊，然后再用嵌入式的c编译器编译代码


Question: 这个程序运行时总是停止工作，搞不清为什么

给一个字符串，请将其中的英文字母的大小写进行转换。 输入 第一行是一个整数N，表示样例的个数，以后每行一个字符串。字符串可能由英文字母，数字，各种标点（包括空格）组成，长度不超过200。 输出 每行输出一个转换后的结果。

我也是，我试试运行

33 #include <stdio.h>     32 #include<string.h>     31 #include<malloc.h>     30 int main()             29 {                      28     int n, l, t=0, i=0;    27     char s[200];       26     scanf("%d",&n);    25     char *ptd[100];    //here you should use char for the follow using    24                        23     while(i < n && i < 100)    //the value could not cross the value of 100    22     {                  21     |   scanf("%s",s);  //gets(s);    20     |   l = strlen(s);    19     |   for(t = 0; t < l; t++)    18     |   {              17     |   |   if('A' <= s[t] && s[t] <= 'Z')    //include capital 'Z'    16     |   |   |   s[t] = s[t]+32;    15     |   |   else if('a' <= s[t] && s[t] <= 'z')    //include lowercase letter 'z'    14     |   |   |   s[t] = s[t]-32;    13     |   }           >> 12     |   ptd[i] = malloc(sizeof(128));     11     |   if (NULL == ptd[i]) {    10     |   |   fprintf(stderr, "malloc error!\n");     9     |   |   return -1;     8     |   }               7     |   //ptd[i] = s;    //pointer the first address of the string called s     6     |   memcpy(ptd[i], s, l+1);     5     |   i++;            4     }                   3     for(t = 0; t < n; t++)     2     |   printf("%s\n", ptd[t]);    //here use the address because the format %s     1     return 0;         34  }                                                                                ~

谢谢，好久没上，抱歉啊！

由于本人也是菜鸟，不太清楚楼主这段程序的实现功能。所以将楼主的程序作了点修改，仅供楼主参考：  #include <stdio.h> #include <string.h> #include <malloc.h> int main() {     int n,l,t=0,i=0;     char s[200];     char* ptd[100];     scanf("%d",&n);      for (t=0; t<100; t++)         ptd[i] = (char *)malloc(100 * sizeof(char));     while(i<n)     {         scanf("%s",s);         l = strlen(s);         for(t=0;t<l;t++)         {             if('A'<=s[t]&&s[t]<'Z')             s[t] = s[t]+32;             else if('a'<=s[t]&&s[t]<'z')             s[t] = s[t]-32;         }         ptd[i]=s;         printf("ptd[%d] = [%s]\n",i,ptd[i]);         i++;         memset(s, 0x00, sizeof(s));     }     for (t=0; t<100; t++)         free(ptd[i]);     return 0; }

楼上正解你使用了一个 指针数组，然后给指针进行了赋值，类型是从char转换成int* 这里都三符合语法的，但是你*ptd[t]这里对一个非法地址进行*操作，是不可以的

#include <stdio.h>  #include<string.h>  #include<malloc.h>  int main()  {      int n,l,t=0,i=0;      char s[200];      scanf("%d",&n);      int* ptd[100];//这是个指针数组，你没给出具体的空间，就是说没初始化，可以写 int ptd[100][200];      while(i<n)      {          scanf("%s",s);  //gets(s);          l = strlen(s);          for(t=0;t<l;t++)          {              if('A'<=s[t]&&s[t]<'Z')              s[t] = s[t]+32;              else if('a'<=s[t]&&s[t]<'z')              s[t] = s[t]-32;          }          ptd[i]="s";//这里你他们赋值了。          i++;      }      for(t=0;t<n;t++)      printf("%s",*ptd[t]);      return 0;  }


Question: 作业求助！

#include <stdio.h>  static const char* g_mon_str[] = { 	NULL, "January", "February",  	"March","April", "May", "June",  	"July", "August", "September",  	"October","November", "December" };  static const char* g_daysuffix_str[] = { 	"th", "st", "nd", "rd", "th" };  int main(void) { 	int year, month, day; 	const char* mon_str, *day_sfx; 	 	//get input 	printf("please input the date: "); 	if (scanf("%d,%d,%d", &year, &month, &day) != 3) { 		printf("invalid input, example:2003,12,31\n"); 		return -1; 	} 	 	//check date 	if ((month > 12) || (month < 1) || (day > 31) || (day < 1)) { 		printf("%d-%d-%d is not a valid date.\n", year, month, day); 		return -1; 	} 	 	//print result 	mon_str = g_mon_str[month]; 	day_sfx = g_daysuffix_str[(((day % 10) > 3) ? 4 : (day % 10))]; 	printf("%d %s %d%s\n", year, mon_str, day, day_sfx); 	 	return 0;	 }

char month[12][10]={" january ",........} char day[4][3]={"st","nd","rd","th"} 这两段用的是字符串吧?能给我简单的解释一下吗?谢谢!我只用过单个字符申明,这个好像没有学到.

char month[12][10]={" january ",........} char day[4][3]={"st","nd","rd","th"} if(ri%10==1)   printf(\n 日期为：%d %s %d \n",nian,month[yue-1],dat[0]) if(ri%10==2)   printf(\n 日期为：%d %s %d \n",nian,month[yue-1],dat[1]) if(ri%10==3)   printf(\n 日期为：%d %s %d \n",nian,month[yue-1],dat[2]) else   printf(\n 日期为：%d %s %d \n",nian,month[yue-1],dat[3])

大概思路，请参考


Question: 关于C语言分支结构规范性的问题

比用什么风格更重要的是在任何地方，任何时候都坚持用一种风格。 比爱哪种美眉更重要的是在任何地方，任何时候都坚持爱一个美眉。

第一种如果嵌套层次过多会比较乱，Linux内核编码规范建议缩进不要超过三级，当然这只是一个建议，不同公司应该有自己的规范，如果没有，那就随你喜欢了

两种方式差不多的，也都比较易读，易维护,从效率上来考虑： 如果用第二种方式，假设有8个分支，如果全部用if...else if来写，那么每次调用平均是要判断4次的 如果用第一种方式，嵌套在里面，只要判断3次  PS:也可以考虑用switch case多的时候switch用跳转表，性能好些 建议能用switch就用，编译器会选用较优的方式

只要逻辑表达清楚就行了


Question: 变量值莫名改变

引用 1 楼 Rewen 的回复:文件里面的内容是什么呢？  读出来的是文件的内容啊。  另外: fread如果写成  fread(&counter, sizeof(int), 1, fp); 扩展性和可读性都会好些。 文件第一位嘛是里面数据项的个数，紧接着是数据。二进制的文件结束不好判断所以直接记数据项数来读。 我是懒省事，int就4位嘛，不想写辣么多。。。不过你说得对。

请学会使用数据断点。参考下面： #include <time.h> #include <stdlib.h> #include <windows.h> int main() {     int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]      srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。     while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。         b[(a=rand()%11)]=0;         Sleep(100);         b[(a=rand()%11)]=1;         Sleep(100);         b[(a=rand()%11)]=2;         Sleep(100);         b[(a=rand()%11)]=3;         Sleep(100);         b[(a=rand()%11)]=4;         Sleep(100);     }     return 0; }


Question: 关于频繁fwrite的问题

引用 15 楼 LubinLew 的回复:没问题的啊,如果你觉得不好,可以自己搞一套buff,buff满了再写文件, 之前使用tcpdump抓过光纤接口的包,分分钟几个GB的数据量,没有问题的. 在linux上吗？ tcpdump 写文件导致kworker占用cpu，数据却写不了多少的问题有没有遇到呢？

你硬盘有那么快写入速度吗

fwrite 是带缓冲的，write是不带缓冲的，也就是说fwrite在调用完后会先写入缓冲区，不会立即写入磁盘，而write是每次调用完后就直接写入磁盘了。两者的区别是，fwrite的IO效率更高，fwrite对磁盘的“损伤”更低。另外fwrite是库函数，write是系统函数，从可移植性来说 fwrite也更强

我就是关心这样处理会不会出问题

应该够  每秒写入大概60mb   ssd写入可以上百

磁盘总线的带宽够吗？

为什么不先往缓存里面写呢

这两个函数对于文件描述符是不一样的；对于文件打开方式也是不一样的； 对于使用什么样的读写方式，要根据文件类型（文本文件，二进制文件），还有文件数据格式来定的吧；当然，使用什么样的读写方式，还跟文件的打开方式和关闭方式有关；这是分不开的；

我是获取的网络数据包  直接写到2进制文件中

我用的是电子盘   会有qq兄这种影响吗

对于一个正常的硬盘,如果仅仅是软件频繁地fwrite/fread,那么: 1. 磁头臂在寻道时有可能频繁移动(当fread在读缓冲命中时会好过fwrite),这属于机械磨损. 2. 不断变化的电流会影响磁头的老化速度. 3. fwrite时盘片上的磁介质会被不断地改变磁化状态. 那么对硬盘的影响是有的,但是非常有限的,至少不会对硬盘造成损坏.

那还是用fwrite 这C库函数带有缓冲区，write 是unix 平台的api，频繁调用要在用户空间和内核空间切换，io效率低

对电子盘有寿命影响吗

再供参考：//循环向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; }  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！

请判断每个函数的返回值。 请写尽量详细的日志。  参考下面：#include <sys\stat.h> #include <io.h> #include <fcntl.h> #include <share.h> #include <stdlib.h> #include <stdio.h> #include <conio.h> #include <string.h> #define MAX_CLU_BYTES 65536 FILE *fo; int fh; __int64 offs,offs1; __int64 rvi64; int rv,wrv; unsigned char buf[MAX_CLU_BYTES]; char ofn[_MAX_PATH]; char offstr[80]; char drive[_MAX_DRIVE]; char dir[_MAX_DIR]; char fname[_MAX_FNAME]; char ext[_MAX_EXT]; char fullpath[_MAX_PATH]; void strcpybutcomma(char *t,char *s) {     char c;      while (1) {         c = *s++;         if (','!=c) *t++ = c;         if (0==c) break;     } } int main(int argc,char **argv) {     if (argc<3) {         printf("Copy File Tail.\n");         printf("Usage:\n");         printf("    cft filename.ext {Offset_Begin|-Offset_End|Offset_Begin-Offset_End}\n");         printf("Copy filename.ext {OB|-OE|OB-OE} to {OB|~OE|OB-OE}-filename.ext\n");         printf("Note: Byte at OE is NOT included.\n");         printf("Example:\n");         printf("    cft abc.rar 12345\n");         printf("Copy abc.rar offset 12345-end to 12345-abc.rar\n");         printf("    cft abc.rar -12345\n");         printf("Copy abc.rar offset -12345-end to ~12345-abc.rar\n");         printf("    cft abc.rar 123-12345\n");         printf("Copy abc.rar offset 123-12345 to 123-12345-abc.rar\n");         printf("    cft abc.rar 0xAB-0xCD\n");         printf("Copy abc.rar offset 0xAB-0xCD to 0xAB-0xCD-abc.rar\n");         return 1;     }     strcpybutcomma(offstr,argv[2]);     rv=sscanf(offstr,"%I64i-%I64i",&offs,&offs1);     if (rv==0) {         printf("offset %s is not number\n",argv[2]);         return 2;     }     if (NULL==_fullpath(fullpath,argv[1],_MAX_PATH)) {         printf("Can not get fullpath of %s\n",argv[1]);         return 10;     }     fh=_sopen(fullpath,_O_BINARY|_O_RDONLY|_O_RANDOM,_SH_DENYNO);     if (fh==-1) {         printf("_sopen %s errno=%d %s\n",fullpath,errno,strerror(errno));         return 3;     }     if (rv==1) {         offs1=_filelengthi64(fh);         if (offs1==-1i64) {             printf("%I64d=_filelengthi64 errno=%d %s\n",offs1,errno,strerror(errno));             _close(fh);             return 4;         }         if (offs<0i64) {             offs=offs1+offs;             if (offs<0i64) offs=0i64;         }     } else {//rv==2         if (offs>offs1) {             printf("%s offset_begin %I64d > %I64d offset_end error\n",argv[2],offs,offs1);             _close(fh);             return 5;         }     }     rvi64=_lseeki64(fh,offs,SEEK_SET);     if (rvi64!=offs) {         printf("%I64d=_lseeki64 %I64d errno=%d %s\n",rvi64,offs,errno,strerror(errno));         _close(fh);         return 6;     }     _splitpath(fullpath,drive,dir,fname,ext);     if (offstr[0]=='-') offstr[0]='~';     sprintf(ofn,"%s%s%s-%s%s",drive,dir,offstr,fname,ext);     fo=fopen(ofn,"wb");     if (fo==NULL) {         printf("fopen %s errno=%d %s\n",ofn,errno,strerror(errno));         _close(fh);         return 7;     }     cprintf("\n%I64d\r",offs);     while (1) {         rv=_read(fh,buf,(unsigned int)__min(offs1-offs,MAX_CLU_BYTES));         if (rv==0) break;//         if (rv<0) {             printf("_read %s offset %I64d errno=%d %s\n",fullpath,offs,errno,strerror(errno));             fclose(fo);             _close(fh);             return 8;         }         wrv=fwrite(buf,1,rv,fo);         if (wrv!=rv) {             printf("fwrite %s errno=%d %s\n",ofn,errno,strerror(errno));             fclose(fo);             _close(fh);             return 9;         } else {             offs+=rv;             cprintf("%I64d\r",offs);             if (offs>=offs1) break;//         }     }     fclose(fo);     _close(fh);     printf("Copy %s offset %s to %s OK.\n",fullpath,argv[2],ofn);     return 0; }


Question: I 心形 U

#include <stdlib.h> #include <stdio.h> int main() {     system("chcp 437 >NUL");     printf("I\x3U");     getchar();     system("chcp 936 >NUL");     return 0; }

心脏用心形线 绘制

1）用数组 表示，显示数组的内容 2)数据放在文件中 从文件中读出来，显示  不然的话，用 Window  GDI 画出来 读取路径，显示之

引用 3 楼 baidu_34815154 的回复:不要printf输出的，用for语句来写的 用三个for循环？一个控制行，一个控制空格，另一个控制符号？

这个行数太少了，直接printf最方便 不过三个图形都是各自对称的，也是能写的。。。

不要printf输出的，用for语句来写的

直接用printf()输出啊


Question: 图像灰度差直方图输出不完整，代码运行正确，求助！！！

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

顶顶顶顶顶顶顶顶顶


引用 2 楼 u012408019 的回复:跟手机操作系统有关吗 有关。我瞎猜的。

跟手机操作系统有关吗

手机上是抢占式多任务操作系统吗？


Question: 关于c语言编译器问题求助！！

编译器不同对于未初始化的变量的处理不同，有的编译器会初始化成0，所以对于这种不确定的行为，我们一定要记得初始化变量

编译器的实现不同

引用 1 楼 user-2 的回复:sum[]没初始化 引用 2 楼 qq423399099 的回复:你的sum数组需要初始化 for(i=0;i<3;i++)     { 		sum[i] = 0.0;//这里要初始化一下         for(j=0;j<5;j++)         {             sum[i]+=score[j][i];         }         subjectavg[i]=sum[i]/5.0;     }    感谢热心帮助！！！  那为什么在devcpp环境中正常输出结果。。。还是说devcpp不需要初始化....

sum[]没初始化


Question: 用顺序栈判断括号是否配对

运行程序以后，你要从键盘输入你需要测试的字符串。  现在的码农竟然99%都不会在cmd窗口中输入cd命令设置当前目录为程序所在目录，输入程序名运行程序了！

我刚刚大一，老师，用链栈编写一个计算器，计算部分的思路是什么，您当时学习编程也是成天敲代码吗，

引用 9 楼 zhao4zhong1 的回复:void main是vc6可以接受的写法。‘\n’  还有‘\0’是什么意思啊   这个程序在我电脑上执行什么也没有 ，是不是需要加一个字符数组检验呢  ，我试着在main函数加一个str[100]={(3+4)*[5+6]};出现好多错误 ；是加错了吗  。需要加吗

void main是vc6可以接受的写法。

引用 7 楼 qq_34627769 的回复:[quote=引用 6 楼 zhao4zhong1 的回复:] 仅供参考：#include<stdio.h> #include<malloc.h> #include<string.h> #define STACK_INIT_SIZE 10 #define STACK_GROW_SIZE 5 #define ELEMTYPE char #define OK 1 #define ERROR 0 typedef struct { /*建立一个栈的首结点*/     ELEMTYPE * base;     ELEMTYPE * top;     int stacksize; } SpStack; int InitStack(SpStack *s) { /*建立空的栈并返回首地址*/     s->base=((ELEMTYPE*)malloc(STACK_INIT_SIZE*sizeof(ELEMTYPE)));     if (!s->base) return ERROR;     s->top=s->base;     s->stacksize=STACK_INIT_SIZE;     return OK; } int StackEmpty(SpStack *s) { /*判断栈是否为空*/     if (s->top==s->base) return OK;     else                 return ERROR; } int Push(SpStack *s,ELEMTYPE e) { /*往栈顶插入元素即进栈*/     if (s->top-s->base>=s->stacksize) { /*判断是否栈满*/         s->base=((ELEMTYPE*)realloc(s->base,(s->stacksize+STACK_GROW_SIZE)*sizeof(ELEMTYPE)));         if (!s->base) return ERROR;         s->stacksize+=STACK_GROW_SIZE;         s->top=s->base+s->stacksize;     }     *s->top++=e;     return OK; } int Pop(SpStack *s,ELEMTYPE *e) { /*让栈顶元素依次输出即出栈*/     if (StackEmpty(s)) return ERROR;     *e=*(--s->top);     return OK; } int Comp(ELEMTYPE a,ELEMTYPE b) {     if ((a=='('&&b!=')')       ||(a=='['&&b!=']')       ||(a=='{'&&b!='}')) {         return ERROR;     } else return OK; } int Count(SpStack *s) {     ELEMTYPE e[STACK_INIT_SIZE*2];     ELEMTYPE e1;     int i;      InitStack(s);     fgets(e,STACK_INIT_SIZE*2,stdin);     if ('\n'==e[strlen(e)-1]) e[strlen(e)-1]=0;     printf("%s\n",e);     for (i=0;e[i]!='\0';i++) {         switch (e[i]) {         case '(':         case '[':         case '{':             Push(s,e[i]);             break;         case ')':         case ']':         case '}':             if (StackEmpty(s)) {                 printf("%*s↖右括号多余\n",i+1,"");                 return(ERROR);             } else Pop(s,&e1);             if (!Comp(e1,e[i])) {                 printf("%*s↖左右匹配出错\n",i+1,"");                 return(ERROR);             }         }     }     if (!StackEmpty(s)) {         printf("%*s↖左括号多余\n",i,"");         return(ERROR);     } else {         printf("匹配正确\n");         return(OK);     } } void main() {     SpStack s;     Count(&s);     free(s.base); } 最后的main是不是需要返回int 啊    用void 在coldblocks有error，我改成int是正确的 [/quote] 不   对了 刚刚我在那个错吴的text里编译的   换了一个好了，谢谢了老师

引用 6 楼 zhao4zhong1 的回复:仅供参考：#include<stdio.h> #include<malloc.h> #include<string.h> #define STACK_INIT_SIZE 10 #define STACK_GROW_SIZE 5 #define ELEMTYPE char #define OK 1 #define ERROR 0 typedef struct { /*建立一个栈的首结点*/     ELEMTYPE * base;     ELEMTYPE * top;     int stacksize; } SpStack; int InitStack(SpStack *s) { /*建立空的栈并返回首地址*/     s->base=((ELEMTYPE*)malloc(STACK_INIT_SIZE*sizeof(ELEMTYPE)));     if (!s->base) return ERROR;     s->top=s->base;     s->stacksize=STACK_INIT_SIZE;     return OK; } int StackEmpty(SpStack *s) { /*判断栈是否为空*/     if (s->top==s->base) return OK;     else                 return ERROR; } int Push(SpStack *s,ELEMTYPE e) { /*往栈顶插入元素即进栈*/     if (s->top-s->base>=s->stacksize) { /*判断是否栈满*/         s->base=((ELEMTYPE*)realloc(s->base,(s->stacksize+STACK_GROW_SIZE)*sizeof(ELEMTYPE)));         if (!s->base) return ERROR;         s->stacksize+=STACK_GROW_SIZE;         s->top=s->base+s->stacksize;     }     *s->top++=e;     return OK; } int Pop(SpStack *s,ELEMTYPE *e) { /*让栈顶元素依次输出即出栈*/     if (StackEmpty(s)) return ERROR;     *e=*(--s->top);     return OK; } int Comp(ELEMTYPE a,ELEMTYPE b) {     if ((a=='('&&b!=')')       ||(a=='['&&b!=']')       ||(a=='{'&&b!='}')) {         return ERROR;     } else return OK; } int Count(SpStack *s) {     ELEMTYPE e[STACK_INIT_SIZE*2];     ELEMTYPE e1;     int i;      InitStack(s);     fgets(e,STACK_INIT_SIZE*2,stdin);     if ('\n'==e[strlen(e)-1]) e[strlen(e)-1]=0;     printf("%s\n",e);     for (i=0;e[i]!='\0';i++) {         switch (e[i]) {         case '(':         case '[':         case '{':             Push(s,e[i]);             break;         case ')':         case ']':         case '}':             if (StackEmpty(s)) {                 printf("%*s↖右括号多余\n",i+1,"");                 return(ERROR);             } else Pop(s,&e1);             if (!Comp(e1,e[i])) {                 printf("%*s↖左右匹配出错\n",i+1,"");                 return(ERROR);             }         }     }     if (!StackEmpty(s)) {         printf("%*s↖左括号多余\n",i,"");         return(ERROR);     } else {         printf("匹配正确\n");         return(OK);     } } void main() {     SpStack s;     Count(&s);     free(s.base); } 最后的main是不是需要返回int 啊    用void 在coldblocks有error，我改成int是正确的

引用 2 楼 qq423399099 的回复:#include <iostream> #include <string> #include <stdlib.h> using namespace std;  class stack{ private:     int max;     int top;     char* str; public:     stack(int size)     {         max=size;         top=-1;         str=new char[max];     }     stack()     {         top=-1;     }     ~stack()     {         delete []str;     }     void clear()     {         top=-1;     }     bool push(const char item)     {         if(top==max-1)         {              return false;         }         else         {             str[++top]=item;             return true;         }     }     bool pop(char &item)     {         if(-1==top)         {              return false;         }         else         {             item=str[top--];             return true;         }     }     bool empty()     {         if(-1==top)             return true;         else             return false;     } };  int main() {     char c;     string st;     int d=1,j=1;     stack a(25);     while(j){         cout<<"请输入表达式（英文半角）："<<endl;         cin>>st;         for(int i=0;st[i]!='\0'&&d==1;i++)         {             switch(st[i])             {             case'(':             case'[':             case'{':                 a.push(st[i]);                 break;             case')':                 a.pop(c);                 if(c=='(')                     break;                 else                 {                     d=0;                     break;                 }             case']':                 a.pop(c);                 if(c=='[')                     break;                 else                 {                     d=0;                     break;                 }             case'}':                 if(c=='{')                     break;                 else                 {                     d=0;                     break;                 }              }         }         if(a.empty()&&d==1)             cout<<"配对正确！"<<endl;         else             cout<<"配对错误！"<<endl;          cout<<"******************"<<endl;         cout<<"1.继续"<<endl;         cout<<"2.退出"<<endl;         cout<<"******************"<<endl;         cin>>j;         if(2==j)         {             j=0;         }         if(1==j)         {             system("cls");             a.clear();         }     }     system("cls");     cout<<"程序结束！"<<endl;      return 0; }大神 你的程序有error

引用 1 楼 qq423399099 的回复:怎么写看楼主的需求啊 首先栈初始化 入栈的时候要判栈满，出栈要判栈空 之后就因人而异了 引用 1 楼 qq423399099 的回复:怎么写看楼主的需求啊 首先栈初始化 入栈的时候要判栈满，出栈要判栈空 之后就因人而异了#include <stdio.h> #include <stdlib.h> #include <string.h>  #define MAX 100 typedef char ElemType; typedef struct stack {   ElemType a[MAX];   int top; } Stack;  void InitStack(Stack **p) {   *p = (Stack*)malloc(sizeof(Stack));   (*p)->top == -1; }  int StackEmpty(Stack *p) {     return (p->top==-1)?1:0; }  int StackFull(Stack *p) { return (p->top == MAX-1)?1:0; }  void Push(Stack *p, ElemType x) {     if(!StackFull(p)){     p->top++;     p->a[p->top]=x;     } }  void Pop(Stack *p, ElemType *q) {      if(!StackEmpty(p)){       *q=p->a[(p->top)--];      } }/* *q=p->a[p->top]; p->top--;*/  int StackTop(Stack *p, ElemType *q) {       if(!StackEmpty(p)){         *q=p->a[p->top];         return 1;       }else       return 0; }  void StackClear(Stack *p) {      p->a[p->top]==-1; }  int Match(char a, char b) {    if     (a=='('&&b==')'||a=='['&&b==']'||a=='{'&&b=='}')    return 1;    else    return 0; }   int main() {   //char str[100] = "()[]{}";   //char str[100] = "{[()][(()())]}";   //char str[100] = "([)]{}";   char str[100] = "{[)(]{}}";    InitStack(Stack);    int i=0;    for(i;i<100;i++)    {        if (i=='(')             Push(Stack *p,str[i]);    }     return 0; } 我这个只剩下主函数了，我想知道的是如何将str[]与栈联系上