Question: 结构体赋值问题

查找所有ACT_TABLE_T和ACT_TABLE_T_STRU出现在项目中出现的位置，一个一个点开分析。

我想楼主所描述的框架应该就是类似这样的吧 ： //单个事件定义 typedef struct ACT_TABLE_T_STRU { int event; stateEventFun eventFun;/*函数指针*/ }ACT_TABLE_T;  //全局的所有事件枚举定义 static const ACT_TABLE_T g_act_table[] =  { 	{ 		EVENT_1,			//事件的id编号 		EVEVT_1_FUNC_CB,	//事件的处理回调函数	 	}, 	 	{ 		EVENT_2,			//事件的id编号 		EVEVT_2_FUNC_CB,	//事件的处理回调函数	 	}, 	 	... 	 	{ 		EVENT_n,			//事件的id编号 		EVEVT_n_FUNC_CB,	//事件的处理回调函数	 	}, };  main函数处理 { 	while (1) { 		local_event_id = ... //从环形数组中取到对应的事件id 		 		for (....) //遍历g_act_table 		{ 			if (local_event_id == g_act_table[i].event) { //找到对应的事件，并调用它的回调函数 				g_act_table[i].eventFun();  			} 		} 	 	} }  从上面的框架可以发现， event的事件编号应该是在中断中丢入环形数组的。

VS IDE中，在不明白的符号上点鼠标右键，选转到定义。

引用 1 楼 老马何以识途 的回复:不一定要直接賦值，對一個ACT_TABLE_T數組做整體初始化，也可以賦給函數指針的。 像上面的说的一样，需要查找 查找ACT_TABLE_T和ACT_TABLE_T_STRU在项目中出现的位置，逐个分析，

看一下调用的是哪个函数，然后在看看被调用的函数都用到了哪些地方，应该就能找到了

event可能在中断里面赋值。 对应的函数列表初始化时候放到某个全局函数数组或者结构里了吧。 代码应该是没搜全，还有可能是没有按定义的名字赋值，比如 EVENT_A = 1, 赋值的时候不是赋值EVENT_A, 而是直接 赋值 1


Question: c语言按单词逆序输出句子，运行会超时，断点调试运行下来好像没什么问题。。。

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

sdfds fdss hdf!gdh sdfds fdss hdf! -------------------------------- Process exited after 6.152 seconds with return value 15 请按任意键继续. . .   运行结果是这样，调试单步下来是对的，求解

应该是输入的最后没有加上'!', or '?' or '.'，因为只有遇到这三个其中一个就会退出输入循环 可能你在最后没有数组这三个其中一个，所以会出现没有运行结束，因为正在等待你的输入，直到数组这三个符号，或者输够N个字符。  有几个地方可以修改一下： for(i = 0; i < N-1; i++){         ch = getchar();         if(ch=='.'||ch=='!'||ch=='?') {             fin = ch;             break;         }         sentence[i] = ch;     }     sentence[i] = fin; //把终止字符存入句子最后一位 把i < N；改成i < N - 1

问题解决了，我的软件好像有问题，复制到别的电脑上正确运行了。。

后面那个while(1)里面加几句打印，把i, sta,end 都打印几次，可能结果就对了

感觉没什么问题，但句子不是以.!?结尾会有问题的


Question: 用C编写一个简单的搜索引擎

用搜索引擎搜索一下搜索引擎开发不就有了。

引用 1 楼 自信男孩的回复: char *str = "abcd"; char ch;  scanf("%d", &ch); for (i = 0; i < strlen(str); i++)     if (ch == str)         break; if (i >= strlen(str))      return 1; else        return 0;   一个类似的搜索引擎 没想到真的有人回答了，我居然才看到，谢谢啦


Question: 寻求大牛帮助

指数分布，rang试试

产生随机数，用m和n的差求余，最后加上m（两者小的）就OK了

不能用rand，rand产生的是均匀分布

满足指数分布的 这是什么需求？

srand(time(NULL)); rd = M + rand() % (N - M + 1)

建议翻翻常用算法程序集 （C语言版）

参考： https://blog.csdn.net/u012480384/article/details/50838832

起始数+ rand 取余


Question: 指针问题

楼主的代码：//函数声明 void function( int arr[2][3][4]); .................................. int array[2][3][5] = {...}; int (*q)[2][3][5] = &array; //函数调用 function(*q); 实际上这个 q是一个数组指针，但它相当于一个4维数组了，而不是一个3维数组，而 int (*q)[2][3][5] = &array; 实际上就等同于 q = &array = array(它也是表示array数组的地址)； 所以得到输出，array 和 q的值是一样的。  3维数组不好理解，我们先用一个2维数组捋一捋； 假设有一个2维数组， int array[2][3];  我们定义一个数组指针并指向 array，我们会这样写  int (*q)[3] = array; 注意这里是没有[2] 那么这个时候，q就等同于array这个2维数组，q 还是等于 array （数组的首地址）；测试如下： {     int array[2][3];      int (*p)[3] = array; 		     //输出结果4个值都是一样的     printf("%d, %d; %d, %d\n", p, array, *p, &array);     //1453427088, 1453427088; 1453427088, 1453427088 }  回到楼主的定义，对比下就知道原因。分析复杂的问题，建议先由简单点的问题入手，逐步对比，提升理解。

指针问题从来就做不对

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

引用 3 楼 自信男孩 的回复:指针变量p和array的地址不一样，你可以打印一下&p和array的地址看一下。但是指针变量里存放的是地址，这个地址就是array的地址。因此p的值和&array和array是一样的。 &array和array是一样的，那&array怎么理解。

q是不带*的表示的是那一段内存空间，里边存储的内容是arr地址，所以打印结果一样。我的理解

引用 6 楼 赵4老师 的回复:理解和讨论之前请先学会如何观察！ //char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf("typeid(x).name() is %s\n",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]  您好！ printf("typeid(arr).name() is %s\n",typeid(arr).name());---它是int [2][3][5] printf("typeid(&arr).name() is %s\n",typeid(&arr).name());---它是int (*)[2][3][5] printf("typeid(q).name() is %s\n",typeid(q).name());---它是int (*)[2][3][5] printf("typeid(&q).name() is %s\n",typeid(&q).name());---它是int (**)[2][3][5] printf("arr=%x &arr=%x q=%x &q=%x\n",arr, &arr, q, &q);---前三项的值相同 问题：arr, &arr打印出来的值一样这里理解不了。因为我认为&arr存放的是arr的地址是两块不同的内存地址当然不一样， 后面q, &q地址不一样就是证明。求赐教。。。

当然是相等的，步长不一样

数组和指针在去地址符作用下，结果不一样。 其中数组本身和其取址符下的地址是一样的（数组可以理解成别名）。 int a[8], 打印 "%p",a == "%p",&a

是这样的，array是数组的首地址，q是数组的首地址，当然是相等的，不相等是的&q和&array


Question: C语言实现顺序表的直接插入

网上应该有很多这样的答案，或者类似的答案。建议自己动手找一下，然后改一改。

实现两个查找函数，一个轮训，一个二分法。 插入移位用一个函数实现，1,2 就都完成了

引用 1 楼 老马何以识途的回复:直接插入排序就是從無序表中依次取出元素，插入到有序表中，關鍵有2：查找在有序表中的位置，有序表移位。 查找位置最簡單的就是從頭到尾了，移位則一般是位置之後的元素後移，其實就是從尾到頭依次複製到后一個位置。以下代碼演示了這種方式：  void insert_sort(int a[], int n) 21 { 22     int i, j, k; 23  24     for (i = 1; i < n; i++) 25     { 26         //为a[i]在前面的a[0...i-1]有序区间中找一个合适的位置 27         for (j = i - 1; j >= 0; j--) 28             if (a[j] < a[i]) 29                 break; 30  31         //如找到了一个合适的位置 32         if (j != i - 1) 33         { 34             //将比a[i]大的数据向后移 35             int temp = a[i]; 36             for (k = i - 1; k > j; k--) 37                 a[k + 1] = a[k]; 38             //将a[i]放到正确位置上 39             a[k + 1] = temp; 40         } 41     } 42 }  但是這個查找效率比較低。問題2是折半查找，即每次對比綫性表的中間位置，以確定查找目標是在前一半還是後一半，時間效率比較高。於是這個代碼中的查找部分可以簡化爲調用Search函數，而在該函數中實現折半算法。 我说的是针对上述结构的插入排序，数组的代码我懂，我就想看看针对上述代码的格式


Question: C语言实现顺序表的插入排序

还搞了两份啊？


Question: a[j]为何不能得到倒叙的c[i]

楼上解释的很清楚

memcpy(c,str1,100); 这里有问题， C里存贮的是值为123的一个字符， 你可以看一下中间值。  char c[100];  //memcpy(c,str1,100);  itoa(m_num1, c, 10);     // 用这个， 别用CString了

char a[100]={0};          char b[100]={0}；         char m[100]={0}; char n[100]={0};


Question: 串的填空！求大佬告知代码段的详细作用真没看懂这些代码的目的    要求：采用定长顺序存储表示，由用户创建串s和串t，实现在串s中下标为pos的字符之前插入串t。

引用 1 楼 霸气侧漏de影子 的回复:#include <stdio.h> #include <stdlib.h> #define MAXLEN 10  typedef struct {          /*串结构定义*/     char ch[MAXLEN];     int len; }SString;  void createstring(SString *s) { int i,j; char c; printf("input the length of the string:"); scanf("%d",&j); for(i=0; i<j; i++) { printf("input the %d:",i+1); fflush(stdin); scanf("%c",&c); ____s->ch[i]=c______  ;} s->len = j; }  void output(SString *s) { int i; for ( i=0;i<s->len;i++) printf("%c   ",s->ch[i]); printf("\n"); }  int StrInsert(SString *s, int pos, SString *t) /*在串s中下标为pos的字符之前插入串t */ { int i; if (pos<0 || pos>s->len) /*插入位置不合法*/ return(0);  if (s->len + t->len<=MAXLEN) /*插入后串长≤MAXLEN*/ { for (i=s->len + t->len-1;i>=t->len + pos;i--) ____s->ch[i]=s->ch[i-t->len]___ ;                 for (i=0;i<t->len;i++)  _____________s->ch[pos+i]=t->ch[i]__; s->len=s->len+t->len; return(1); } else { if (pos+t->len<=MAXLEN) /*插入后串长>MAXLEN,但串t的字符序列可以全部插入*/ { for (i=MAXLEN-1;i>t->len+pos-1;i--)    s->ch[i]=s->ch[i-t->len]; for (i=0;i<t->len;i++)  ___s->ch[pos+i]=t->ch[i]; s->len=MAXLEN; } else /*插入后串长>MAXLEN,并且串t的部分字符也要舍弃*/ {  for (i=0;i<MAXLEN-pos;i++)  __s->ch[pos+i]=t->ch[i]__ ; s->len=MAXLEN; } return(1); } }   void main() { SString *str1; SString  *str2; int i,j,k,pos; int flag=0; str1 = (SString *)malloc(sizeof(SString)); str1->len = 0; printf("creat the string 1:\n"); createstring(str1); printf("creat the string 2:\n"); createstring(str2); printf("input the insert local:"); scanf("%d",&pos); flag=StrInsert(str1,pos,str2); if(flag == 0) printf("insert error!"); else { printf("after insert:\n"); output(str1); }  }   为啥无法执行

#include <stdio.h> #include <stdlib.h> #define MAXLEN 10  typedef struct {          /*串结构定义*/     char ch[MAXLEN];     int len; }SString;  void createstring(SString *s) {     int i,j;     char c;     printf("input the length of the string:");     scanf("%d",&j);     for(i=0; i<j; i++)     {         printf("input the %d:",i+1);         fflush(stdin);         scanf("%c",&c);         s->ch[i]=c;     }     s->len = j; }  void output(SString *s) {     int i;     for (i=0;i<s->len;i++)     printf("%c   ",s->ch[i]);     printf("\n"); }  int StrInsert(SString *s, int pos, SString *t) /*在串s中下标为pos的字符之前插入串t */ {     int i;     if (pos<0 || pos>s->len) /*插入位置不合法*/     return(0);     if (s->len + t->len<=MAXLEN) /*插入后串长≤MAXLEN*/     {         for (i=s->len + t->len-1;i>=t->len + pos;i--)             s->ch[i]=s->ch[i-t->len];         for (i=0;i<t->len;i++)             s->ch[pos+i]=t->ch[i];             s->len=s->len+t->len;             return(1);     }     else     {         if (pos+t->len<=MAXLEN) /*插入后串长>MAXLEN,但串t的字符序列可以全部插入*/         {             for (i=MAXLEN-1;i>t->len+pos-1;i--)                 s->ch[i]=s->ch[i-t->len];             for (i=0;i<t->len;i++)                 s->ch[pos+i]=t->ch[i];                 s->len=MAXLEN;         }         else /*插入后串长>MAXLEN,并且串t的部分字符也要舍弃*/         {             for (i=0;i<MAXLEN-pos;i++)                 s->ch[pos+i]=t->ch[i];             s->len=MAXLEN;         }         return(1);     } }   int main() {     SString *str1;     SString *str2;     int pos;     int flag=0;     str1 = (SString *)malloc(sizeof(SString));     str1->len = 0;     str2 = (SString *)malloc(sizeof(SString));     str2->len = 0;     printf("creat the string 1:\n");     createstring(str1);     printf("creat the string 2:\n");     createstring(str2);     printf("input the insert local:");     scanf("%d",&pos);     fflush(stdin);     flag=StrInsert(str1,pos,str2);     if(flag == 0)     {        printf("insert error!");        return(0);     }      else     {         printf("after insert:\n");         output(str1);         return(1);     } }

引用 3 楼 霸气侧漏de影子 的回复:因为有错呗。你这题目没问题？你看看那个main函数里： str2没分配内存（error），i,j,k没使用（warning）。 SString *str1; SString *str2; int pos; int flag=0; str1 = (SString *)malloc(sizeof(SString)); str1->len = 0; str2 = (SString *)malloc(sizeof(SString)); str2->len = 0;那怎么改


Question: C语言连接sql server的方法

C/C++可以通过ADO方式连，网上资料很多，还是挺方便的。

刚刚查了一下资料，又说是C语言通过ODBC连接sql server 数据库，然后再通过嵌入式sql操作数据库。 有点晕乎了


Question: 数据结构二叉树

仅供参考：#include <locale.h> #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int nn=0; int CreateBiTree(BiTree *T) {//按先序序列创建二叉树     char data;     scanf("%c",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         *T = NULL;     } else {         *T = (BiTree)malloc(sizeof(BiTNode)); nn++;         (*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的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             printf("%c ",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             p = p->rchild;          //访问右子树         }     }     free(stack); } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             printf("%c ",p->data);             p = p->rchild;          //访问右子树         }     }     free(stack); }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     BiTreePost *stack=(BiTreePost *)malloc(nn*sizeof(BiTreePost));     int sp=0;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || sp) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack[sp]=BT;sp++;       //存入栈中             p = p->lchild;         }         while (sp && (stack[sp-1])->tag == 'R') {//左右子树访问完毕访问根节点             sp--;BT=stack[sp];        //退栈             printf("%c ",BT->biTree->data);             free(BT);         }         if (sp) {//遍历右子树             BT=stack[sp-1];             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     }     free(stack); } void LevelOrder(BiTree T) {//层次遍历     BiTree p;     BiTree *queue;     int h=0,t=0,n=0;      if (T == NULL) return;     p=T;     queue=(BiTree *)malloc(nn*sizeof(BiTree));     queue[t]=p;t=(t+1)%10;n++;//根节点入队     while (n) {    //队列不空循环         p=queue[h];             //对头元素出队         printf("%c ",p->data);  //访问p指向的结点         h=(h+1)%10;n--;         //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue[t]=p->lchild;t=(t+1)%10;n++;         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue[t]=p->rchild;t=(t+1)%10;n++;         }     }     free(queue); } 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: 为什么if(flag=1)执行了if()语句，if(flag==1)反而没有计算if()里的语句

优先级，=表赋值，==表关系

flag==1才是判断语句，是不是flag不是整数

“=”是赋值运算符，“==”是逻辑运算符

if(flag=1 && ...) ==== if(1 && ...) 。日常写代码过程中，为避免发生类似错误，一般将常量放至左边 ----> if(1 == flag && ...)

在if判断前你flag 为0，如果是flag = 1, 这个是赋值语句，该语句返回TRUE,并且flag修改为1， 如果 flag == 1, 则进行判断，因为前面flag为0，所以返回FALSE，同事flag不改变。

flag=1的表达式值为1，也就是表达式恒为真，没有起到判断的作用

if (flag = 1) 这是一条赋值加判断语句，先将flag赋值为1，然后判断flag的真假，既然是1，那肯定是真，因此不论上面的结果flag为0，还是为1，sum = sum+1；是必执行的。

=是赋值，==是判断两边内容是否相等不能计算的

这种问题加几个printf就能自己搞懂，你问别人反而印象不深，时间长就忘了

flag=1是个赋值语句。。。

引用 13 楼 weixin_43794582的回复:额，看来我们大学老师确实教的好。 非计算机专业只学c，就知道在c里，非零即一

额，看来我们大学老师确实教的好。

一直以为优先级&&和||优先级最低了，没想到=这些赋值操作更低 所以更正一下 if (flag = 1 && month > 2) 等值于 if (flag = (1 && month > 2)) 等值于 flag = (1 && month > 2); if (flag) 还是判断flag是否为0

首先：2018年不是闰年，所以 if(year%400==0 || (year%4==0 && year%100!=0))     {          flag=1;     }     else         flag=0; 明显可以知道flag的值为0 接着: if (flag == 1 && month > 2) flag明显不等于1，所以判断通不过，结果不+1 至于： if (flag = 1 && month > 2) 这样写的话flag = 1是一个赋值操作，可以等价于 flag = 1; if(flag) 只要flag的值不为0，if语句都能通过 还有： 操作符&&或者||之类的必然是最后执行的，所以关优先级屁事 优先级高的操作符是&和|，不是&&和||

优先级，，还有==与=意义不一样，优先级也不一样。多试几遍就理解了。

C没有布尔类型，所以一般会使用整数标识，0为假，1为真(实际只要是非0都是真)。 int flag; //判断标识，0为假，1为真 if(flag) 这种写法更简洁，当flag为1时才执行，flag为0时不执行，这样可以避免赋值=和判断符号==混用。 if(flag)等价于if(flag == 1)的情况，这里假定了flag要么是0，要么是1的情况 为了避免=和==混用，可以将if(flag == 1)改写为if(1 == flag) 这样如果将==写成=，编译器会直接报错 另外，if(flag = 1)的执行顺序是，先flag = 1;再if(flag); 关于&&，搞清楚基本用法，1&&1=1,1&&0=0,0&&1=0;0&&0=0。这里的1可以是数字，也可以是表达式，最好用(表达式)；  关于你的疑惑，你可以判断添加printf()语句查看。 if(flag = 1){} printf("%d\n", flag); if(flag == 1){} printf("%d\n", flag);  在此之前，你可以将flag分别赋值为0或1。  我个人比较倾向于if(flag)类型语句。  if(flag1 && flag2)   if((flag1 || flag2) && (flag3 || flag4)) 类似的条件判断

应该就是楼上所说的优先级问题 ！ > 算术运算符 > 关系运算。&符 > && > || > 赋值运算符 如果是flag=1的话，他会先看“1&&month>2”结果是1“真”，然后再把1（真）赋值给flag，所以之前一步的flag是1或0都没有用了，只要二月以后就都会+1，楼主可以输出flag的值看看变化

优先级问题，&&两边加括号

flag=1这个表达式的值为1


Question: 为什么第二次calloc不分配物理内存？

Linux不是开源的吗？

引用 5 楼 amei113 的回复:Linux 下 calloc 分配内存时，并没有分配实际物理内存，只是分配了虚拟内存，这些虚拟内存在页表中对应同一个物理地址，且标记为只读。当读calloc分配的地址时，读到的是同一个物理地址，当写calloc的分配的地址时，发生page fault,然后重新映射一个物理地址，这个时候才真正分了物理地址。这段代码两个calloc分配的地址，都没写操作，按理物理内存是基本没用到，但你说第一次分配占用了1g物理内存，我觉得还要再实验确定一下  从top命令看是这样的~~

引用 4 楼 死国之神 的回复:一次申请1G的连续空间，是一件比较困难的事情，判断一下返回值，为NULL 则是操作系统没有批准你的申请，故而没有给你分配内存。  Windows和Linux分别加了指针判断，两次calloc的内存都不做任何访问，结果如下：  Windows下，根据任务管理器，两次calloc都不会分配物理内存，两次calloc貌似都会根据实际内存是否足够决定返回结果：     我机器内存是12G的，两次calloc分配8G的空间的话，显示都返回非空指针；两次9G，则第一次成功、第二次失败；两次10G，则都失败。。。 Linux下测试，根据top命令结果，第一次calloc如果实际内存足够，则分配物理内存，否则分配失败返回空指针；第二次calloc不分配物理内存，但是会根据实际内存是否足够，返回非空指针或空指针。

引用 2 楼 zcphoenix 的回复:[quote=引用 1 楼 死国之神 的回复:] Linux 不是一个保守的操作系统，你申请了多少内存，并不意味着你会用到多少内存，所以系统也不会立即给你分配多少内存，而且当所有程序申请的内存超过最大物理内存和swap的总和后，Linux还是会允许别的程序申请内存，所以Linux能够用最少的资源干最多的事情，这也是Linux设计的初衷。 Windows是一个保守的操作系统，你申请了多少内存，不管你用不用得到，系统都会立即给你分配，且当所有内存已经到达最大物理内存和虚拟内存总和后，Windows不会再允许别的程序申请内存。  我在Windows下做了同样的测试，和Linux结果确实不一样，但是Windows不是立即分配物理内存，而是连续两次“calloc”都不分配物理内存~~ 此外，还有一个不同点是，Linux对于“calloc”的内存进行读操作时，依然不分配物理内存；但是Windows在对“calloc”的内存进行读操作时，则分配物理内存了，而且是“按需分配”~~[/quote] 判断一下返回值

引用 1 楼 死国之神 的回复:Linux 不是一个保守的操作系统，你申请了多少内存，并不意味着你会用到多少内存，所以系统也不会立即给你分配多少内存，而且当所有程序申请的内存超过最大物理内存和swap的总和后，Linux还是会允许别的程序申请内存，所以Linux能够用最少的资源干最多的事情，这也是Linux设计的初衷。 Windows是一个保守的操作系统，你申请了多少内存，不管你用不用得到，系统都会立即给你分配，且当所有内存已经到达最大物理内存和虚拟内存总和后，Windows不会再允许别的程序申请内存。  我在Windows下做了同样的测试，和Linux结果确实不一样，但是Windows不是立即分配物理内存，而是连续两次“calloc”都不分配物理内存~~ 此外，还有一个不同点是，Linux对于“calloc”的内存进行读操作时，依然不分配物理内存；但是Windows在对“calloc”的内存进行读操作时，则分配物理内存了，而且是“按需分配”~~


n维数组下标从0至n-1

一般来说，数组越界会引发未知的行为，数组下标从0开始，到n-1结束，这里应该是引发你程序崩溃的原因。

很可能是楼上说的原因，需要确认下你数组的定义，到底多少元素。 pow函数本身应该没啥问题。


Question: 调用函数改变了地址后为什么还能将改变的地址返回给主函数

swapp只是修改了形参指针的地址值，而没有修改实参的地址值。参数的传递是实参向形参传递，形参是函数内部的局部变量。

void SortString(char *ptr[], int n); void swapp(int *pa, int *pb);  两者的区别在于： SortString传入的ptr是一个指针数组，在SortString内部进行ptr[i]/ptr[j] 做赋值操作，相当于对这个数组进行了修改，这跟以下例子： void modify_array_data(int data[5]) { 	a[0] = 0; 	a[1] = 1; 	.... } modify_array_data调用： int a[5] = {0}; modify_array_data(a); 函数返回后a数组的值自然就改变了；这里的道理是一样的。  而swapp内部仅仅是对pa/pb（局部的指针变量）进行操作，并不是对*pa / *pb操作，自然函数内部的运算对外面是没有影响的。  重点理解C语言的【值传递】

pa,pb,temp都是局部变量，返回后就被释放，对调用函数没任何影响。这里不管字符串还是其他类型，都不会对调用函数有影响

简单说，这个子函数不是返回而是执行

理解和讨论之前请先学会如何观察！  电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素  计算机组成原理→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执行停在该断点处的时候。


Question: 结构体指针输出问题

你的指针mes没有初始化，运行时一般会出错（如闪退）。使用指针前，应该先初始化。 初始化指针，可以使其指向相应变量的地址，也可以动态申请内存的方式。 下面在手机上用易历知食软件里的微C程序设计来演示修改后的代码，供参考。 手机上修改后的代码如下图所示：  手机上运行该程序的效果如下图所示：

楼上正解！！

问题很多，学好基础吧

如果只支持c语言，第一种方法需要改用2楼的写法。  引用 7 楼 @风轻云淡_ 的回复: MES* mes = new MES; //不要忘了用delete mes释放  mes->fromIP = a; mes->toIP = b; mes->Con = c; mes->En = d; 或者 MES mes;   mes.fromIP = a; mes.toIP = b; mes.Con = c; mes.En = d;  还有一个你的结构体定义应该在main函数上面，不然会报使用未定义类型错误。

要么给指针分配内存，要么不用指针： MES mes;   mes.fromIP = a;

兄弟，你这是指向结构体的指针吗

没有定义 应该会出现段错误

mes變量都沒分配内存，怎麽可以操作呢。

mes是野指针，这样操作很容易出现段错误。 建议使用MES mes; 当然下面的就是->改成. 要么使用 MES *mes = (MES *)malloc(sizeof(MES));

mes 野指针  不能->


Question: 【求解答】关于.c和.cpp的区别

引用 1 楼 user-1的回复:block(se)  int se; 这样的格式是最老的c的格式，应该比这个论坛上99%的人年纪都大了，实在是没有必要再写这样格式的代码了 不用管什么原因了，就按新格式写就可以了 你应该不会遇上只接受老格式的编译器 也就是说这种是老格式对吧？可为什么编译器不接受呢？就像我说的，.cpp应该能接受所有c特性吧，可.cpp确实是无法编译


Question: C语言控制台无法打开包括文件问题。

附加包含目录就行

这种情况就是找不到文件啊，如果确实存在参考2楼做法

看看是否在cspider下存在spider.h这个文件，没有的话建立一个cspider这个文件夹，把spider.h添加进去。然后把文件夹放在.sln的目录

项目->属性->配置属性->C/C++->附加包含目录


Question: c语言结构体的定义

C 语言需要加上struct，除非加上typedef，也就是第二种写法

引用 4 楼 自信男孩 的回复:C 语言需要加上struct，除非加上typedef，也就是第二种写法 谢谢

引用 2 楼 霸气侧漏de影子 的回复:#define MAXSIZE 100 struct ElementType {     int n;     char a, b, c; };   struct Stack {    struct ElementType data[MAXSIZE];     int top; }; 前面不用typedef就在后面把红字部分加上 谢谢，我懂了 c是这样的

引用 1 楼 focuslight 的回复:ElementType未定义---------应该不会出这个提示， 你用的什么IDE  vs

你前面定义的是struct ElementType，不是ElementType； 第二次你用typedef把某个结构体定义成了ElementType，当然也就没报错。


Question: warning C4047: '=' : 'char ' differs in levels of indirection from 'void *'

token[m++]=NULL; 将指针赋值给字符了

百度warning 4047就能知道告警的意思 你这个问题就是有个地方char类型的变量赋值为void *了 告警一般不会影响到实际运行，但初学者建议都消除掉

token[m++]=NULL; 这个怎么理解呢？ 这个token是一个字符数组，用NULL赋值给字符？  scaner(); 函数的返回值类型是否要加一下？即使没有返回值，那也应该用void的。定义也是。 case '\\': 注意转义符  还需要继续努力呢

这个是个词法分析程序，老师要求实现文件的读入和读出 但是不知道怎么调用后面的读入和读出类 希望大神指点


Question: 三维数组问题

3×5 不等于 2×3×5

引用 6 楼 真相重于对错 的回复:[quote=引用 5 楼 flcnrcn 的回复:] [quote=引用 4 楼 自信男孩 的回复:] [quote=引用 3 楼 flcnrcn 的回复:] [quote=引用 2 楼 霸气侧漏de影子的回复:]int arr[2][3][5]，定义一个int类型的三维数组，arr即为该三维数组的首地址； int (*q)[2][3][5]，优先级为先（）后[ ]，所以是定义一个指针q，该指针指向一个维度为三维的int数组; q=&arr，则使q指向了arr这个数组，所以最后打印q和arr都是打印同一个三维数组的首地址。 数组名代表的是首元素的地址，很明显首元素是个二维数组（正如二维数组的首元素是个一维数组一样）不是三维，所以arr和&arr应该是不同的地址才对。[/quote] 建议实践一下，猜测是解决不了问题的。  &arr和arr只是类型不一样，即&arr + 1和arr + 1偏移的长度是不一样的，但地址是一样的。[/quote]  您好！ 既然地址一样，那存在如下函数调用： void function（int  a[2][3][5]）； .............................. int arr[2][3][5] ={....}; int (*q)[2][3][5] =&arr; function(*q);----问题：既然地址一样为什么这里的实参不用q而用*q呢，这个*q的值是什么呢？ [/quote] 类型不一样，一个是指向数组的指针，一个是数组。所以不能替换 ×q对这个指针解引用，是数组， [/quote] 您好！数组做函数参数时都被编译器解释为指针了。那定义如下指针：int （*p）[3][5] = arr; function(p);这里的实参为什么有p不用*p呢。

数组和指针在取地址符下操作不一样的。 定义int a[x] ，打印 a, &a是一样的。 定义int *a, 打印a , &a是不一样的。 作为参数传递时就要注意了

引用 5 楼 flcnrcn 的回复:[quote=引用 4 楼 自信男孩 的回复:] [quote=引用 3 楼 flcnrcn 的回复:] [quote=引用 2 楼 霸气侧漏de影子的回复:]int arr[2][3][5]，定义一个int类型的三维数组，arr即为该三维数组的首地址； int (*q)[2][3][5]，优先级为先（）后[ ]，所以是定义一个指针q，该指针指向一个维度为三维的int数组; q=&arr，则使q指向了arr这个数组，所以最后打印q和arr都是打印同一个三维数组的首地址。 数组名代表的是首元素的地址，很明显首元素是个二维数组（正如二维数组的首元素是个一维数组一样）不是三维，所以arr和&arr应该是不同的地址才对。[/quote] 建议实践一下，猜测是解决不了问题的。  &arr和arr只是类型不一样，即&arr + 1和arr + 1偏移的长度是不一样的，但地址是一样的。[/quote]  您好！ 既然地址一样，那存在如下函数调用： void function（int  a[2][3][5]）； .............................. int arr[2][3][5] ={....}; int (*q)[2][3][5] =&arr; function(*q);----问题：既然地址一样为什么这里的实参不用q而用*q呢，这个*q的值是什么呢？ [/quote] 类型不一样，一个是指向数组的指针，一个是数组。所以不能替换 ×q对这个指针解引用，是数组，

引用 4 楼 自信男孩 的回复:[quote=引用 3 楼 flcnrcn 的回复:] [quote=引用 2 楼 霸气侧漏de影子的回复:]int arr[2][3][5]，定义一个int类型的三维数组，arr即为该三维数组的首地址； int (*q)[2][3][5]，优先级为先（）后[ ]，所以是定义一个指针q，该指针指向一个维度为三维的int数组; q=&arr，则使q指向了arr这个数组，所以最后打印q和arr都是打印同一个三维数组的首地址。 数组名代表的是首元素的地址，很明显首元素是个二维数组（正如二维数组的首元素是个一维数组一样）不是三维，所以arr和&arr应该是不同的地址才对。[/quote] 建议实践一下，猜测是解决不了问题的。  &arr和arr只是类型不一样，即&arr + 1和arr + 1偏移的长度是不一样的，但地址是一样的。[/quote]  您好！ 既然地址一样，那存在如下函数调用： void function（int  a[2][3][5]）； .............................. int arr[2][3][5] ={....}; int (*q)[2][3][5] =&arr; function(*q);----问题：既然地址一样为什么这里的实参不用q而用*q呢，这个*q的值是什么呢？

引用 3 楼 flcnrcn 的回复:[quote=引用 2 楼 霸气侧漏de影子的回复:]int arr[2][3][5]，定义一个int类型的三维数组，arr即为该三维数组的首地址； int (*q)[2][3][5]，优先级为先（）后[ ]，所以是定义一个指针q，该指针指向一个维度为三维的int数组; q=&arr，则使q指向了arr这个数组，所以最后打印q和arr都是打印同一个三维数组的首地址。 数组名代表的是首元素的地址，很明显首元素是个二维数组（正如二维数组的首元素是个一维数组一样）不是三维，所以arr和&arr应该是不同的地址才对。[/quote] 建议实践一下，猜测是解决不了问题的。  &arr和arr只是类型不一样，即&arr + 1和arr + 1偏移的长度是不一样的，但地址是一样的。

引用 2 楼 霸气侧漏de影子的回复:int arr[2][3][5]，定义一个int类型的三维数组，arr即为该三维数组的首地址； int (*q)[2][3][5]，优先级为先（）后[ ]，所以是定义一个指针q，该指针指向一个维度为三维的int数组; q=&arr，则使q指向了arr这个数组，所以最后打印q和arr都是打印同一个三维数组的首地址。 数组名代表的是首元素的地址，很明显首元素是个二维数组（正如二维数组的首元素是个一维数组一样）不是三维，所以arr和&arr应该是不同的地址才对。

建议将arr和&arr的地址打出来，就知道为什么arr和q的地址为什么一样了。&arr是数组的地址，而数组名就是数组的首地址。


Question: 文本输入

在我的IDE上运行了你的程序，能写入

引用 6 楼 Slzde_sub 的回复:[quote=引用 5 楼 lin5161678 的回复:] [quote=引用 1 楼 Slzde_sub 的回复:] wt是什么。。第一次见到  wb吧。。  你得判断fp是否被正确赋值了呀。。t 表示文本模式打开 可以省略 写出来也不是问题 wb是二进制模式  你别乱改呀[/quote]   改成wb  换成这句写入看看  fwrite(&n,1,4,fp);[/quote]回复错人了? 另外 你的修改后的代码 和 题主原先的代码 行为是不一样的 题主原先的代码 相当于转换为字符串写入文件 你的代码完全是另一回事

引用 1 楼 Slzde_sub 的回复:wt是什么。。第一次见到  wb吧。。  你得判断fp是否被正确赋值了呀。。t 表示文本模式打开 可以省略 写出来也不是问题 wb是二进制模式  你别乱改呀

我怀疑你这程序执行完了没。。。。 中间搞个pause 是几个意思？

我还是怀疑抄错程序了，把pause放最后return前应该没啥问题的。

试了你的代码，能写入文件。按照你的代码逻辑，程序运行起来需要按一次回车，然后输入内容，再回车。而且要注意，你写的是%d，输入字母是写入不进去的，写入一个数字就能看到效果

引用 2 楼 自信男孩 的回复:建议判断一下fopen的返回值，即fp是否为NULL，即判断文件是否打开成功。  我看过返回值是7426696，

建议判断一下fopen的返回值，即fp是否为NULL，即判断文件是否打开成功。


Question: C语言值传递问题

引用 楼主 我不是大神_ 的回复:问题如下： 现有三个函数，  //返回会话句柄   void* connect_();  //handle会话句柄 int disconnect_(void *handle);   //重连会话句柄， //handle  输入/输出 int  reconnect_(void *handle);   在不做任何改变的情况下， reconnect_(void *handle);如何做到将新的会话句柄通过handle回传出来？一直没想通，connect函数返回的就是void *的句柄，为什么reconnect_函数参数不是void **  ，使用void *能够回传新的句柄出来？该咋处理谢谢！ 试一下，把一个NULL 传给reconnect函数不就清楚了

引用 5 楼 真相重于对错 的回复:[quote=引用 4 楼 niiiloc 的回复:] 接口定义是不太合理啊，我理解reconnet应该返回void *比较好一点 reconnect字面意思就是重新连接，为何要返回一个新的，我理解只不过把一个已经关闭的资源，传进去，重新而已。[/quote]  这位兄弟理解是对的，我陷入误区了。void *handle就是入参不存在传出的情况，三个函数在内部维护一个连接的结构，所有的void *handle都是形参，可以看做内部维护的结构体的地址，这样就不存在重新连接时，需要传新的handle出来的情况，只用在内部维护连接的结构即可。感谢各位指导！

引用 4 楼 niiiloc 的回复:接口定义是不太合理啊，我理解reconnet应该返回void *比较好一点 reconnect字面意思就是重新连接，为何要返回一个新的，我理解只不过把一个已经关闭的资源，传进去，重新而已。

接口定义是不太合理啊，我理解reconnet应该返回void *比较好一点

引用 1 楼 自信男孩 的回复:那就用传入传出参数，即定义一个会话句柄变量，注意是普通变量，而不是指针变量。然后传入到reconnect_中，这样这个变量（实参）就是传入传出参数的实参了。  重新定义个输入输出变量放到reconnect中确实可以回传的，但是这个参数无法去接收connect返回的void *呀，除非将connect的返回强转为int；定义个int 变量，将connect的返回强转为int，但是这样很别扭啊。所以这个函数的定义很别扭？？？


Question: Linux C大神们帮忙 erno 11的问题现象

Linux - 非阻塞socket编程处理EAGAIN错误 在linux进行非阻塞的socket接收数据时经常出现Resource temporarily unavailable，errno代码为11(EAGAIN)，这是什么意思？ 这表明你在非阻塞模式下调用了阻塞操作，在该操作没有完成就返回这个错误，这个错误不会破坏socket的同步，不用管它，下次循环接着recv就可以。 对非阻塞socket而言，EAGAIN不是一种错误。在VxWorks和Windows上，EAGAIN的名字叫做EWOULDBLOCK。 另外，如果出现EINTR即errno为4，错误描述Interrupted system call，操作也应该继续。 最后，如果recv的返回值为0，那表明连接已经断开，我们的接收操作也应该结束。


Question: 请问VC下FILE结构体中_flag的值里有一个宏定义_IOSTRG有人知道是什么意思吗？

艺海拾贝

VC6EN http://pan.baidu.com/s/1jImOtAe

引用 8 楼 赵4老师 的回复:VC6EN http://pan.baidu.com/s/1jImOtAe 好东西呀！非常感谢赵老师！_IOSTRG的问题已经搞清楚了。请问赵老师是从哪里找到这个的？

引用 7 楼 zjq9931 的回复:http://computer-programming-forum.com/47-c-language/0ca9fef414ff0312.htm 这里有一段，说是用于非文件的，字符串模拟的伪流（大于32K）会用到。例如sprintf,scanf。 和缓冲区默认32K有关。 我看了后不是很懂，我自己做过测试，单独改变这个位后，原本fgetc读到文件尾后就不再读了，即记录剩余字节个数的_cnt一直为0，但_IOSTRG位置1后，读完文件后_cnt开始往负值增加。所以我看了你发的这个帖子不是很明白，光是这个“假流”都不明所以，更别说与我的实验结果似乎毫无关系。不过帖子里说的跟fclose相关的说法比较贴近。

提醒，FILE处理相关函数都是开源的。

引用 楼主 六道佩恩 的回复:经测试发现，如果此位为0，那么读到文件尾后_cnt一直为0，但如果该位为1，那么读到文件尾后再读cnt会变成-1、 我在MSDN中没有找到这个啊，在fcntl.h中也没有找到这个值，你是在哪个文件里面找到的？

引用 5 楼 赵4老师 的回复:比如： C:\glibc-2.25\stdlib\abs.c C:\Program Files\Borland\CBuilder6\Source\Rtl\Source\math\abs.c C:\Program Files\Microsoft Visual Studio\VC98\CRT\SRC\ABS.C C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\abs.c C:\Program Files\Microsoft Visual Studio 9.0\VC\crt\src\abs.c C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\abs.c 谢谢。不过我下了glibc发现是linux下是实现方式，不是windows下的，FILE的结构不一样。VS我有安装，在VC98目录下没找到CRT目录，通过脚本搜索文本也没找到有标准库的实现代码。求支招

引用 2 楼 赵4老师 的回复:提醒，FILE处理相关函数都是开源的。 请问在哪里能看到这些开源代码？

引用 1 楼 zjq9931 的回复:[quote=引用 楼主 六道佩恩 的回复:] 经测试发现，如果此位为0，那么读到文件尾后_cnt一直为0，但如果该位为1，那么读到文件尾后再读cnt会变成-1、 我在MSDN中没有找到这个啊，在fcntl.h中也没有找到这个值，你是在哪个文件里面找到的？[/quote] stdio.h


Question: 在Microsoft VS中遇到的一个问题

选中后不能enter要tab

插件有问题吧，我遇到过必选使用上下箭头选中才行，不然就会回车的情况，和楼主差不多，选一下就行了

关于自动补齐插件？

帮结帖＋蹭分

已经解决了！


Question: C语言中字符串与数组的问题

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

进来看看。。

首先我在输入aaa时，str[0:3]都存这97，在我第二次输入bbb时，str[1:4]都存的是98，同理在第三第四次时输入也存着；只是在第三次输入时，电脑将你的最后一个c直接存入str[5]也就是访问了数组外的第一个地址，如果我访问了不该访问的地方，则这一位会保持不变（保持原有的数据）。在我申请str[5]时我只是申请了5个长度，没说我要用多长。打印时，我打印的是str[0:(我输入并留下的多少)]，若我访问了不可访问的地址则会有一定的乱码

C 语言中并不存在字符串这个数据类型，而是使用字符数组来保存字符串。那么，字符数组就一定是字符串吗？  对于这个问题，大多教科书中的回答是“是”。其实不然，字符数组和字符串是完全不相同的两个概念，千万不要混淆。分析如下所示的示例代码。 #include <stdio.h> #include <string.h> int main(void) {     /*字符数组赋初值*/     char cArr[] = {'I','L','O','V','E','C'};     /*字符串赋初值*/     char sArr[] = "ILOVEC";     /*用sizeof（）求长度*/     printf("cArr的长度=%d\n", sizeof(cArr));     printf("sArr的长度=%d\n", sizeof(sArr));     /*用strlen（）求长度*/     printf("cArr的长度=%d\n", strlen(cArr));     printf("sArr的长度=%d\n", strlen(sArr));     /*用printf的%s打印内容*/     printf("cArr的内容=%s\n", cArr);     printf("sArr的内容=%s\n", sArr);     return 0; } 运行结果为： cArr的长度=6 sArr的长度=7 cArr的长度=7 sArr的长度=6 cArr的内容=ILOVEC' sArr的内容=ILOVEC 从代码及其运行结果中可以看出如下几点。 首先，从概念上讲，cArr 是一个字符数组，而 sArr 是一个字符串。因此，对于 sArr，编译时会自动在末尾增加一个 null 字符（也就是'\0'，用十六进制表示为 0x00）；而对于 cArr，则不会自动增加任何东西。 记住，这里的 sArr 必须是“char sArr[7]="ILOVEC"”，而不能够是“char sArr[6]="ILOVEC"”。 其次，“sizeof()”运算符求的是字符数组的长度，而不是字符串长度。因此，对于“sizeof(cArr)”，其运行结果为 6；而对于 sizeof(sArr)，其运行结果为 7（之所以为 7，是因为 sArr 是一个字符串，编译时会自动在末尾增加一个 null 字符）。因此，对于以下代码： /*字符数组赋初值*/ char cArr[] = {'I'，'L'，'O'，'V'，'E'，'C'}; /*字符串赋初值*/ char sArr[] = "ILOVEC"; 也可以写成如下等价形式： /*字符数组赋初值*/ char cArr[6] = {'I'，'L'，'O'，'V'，'E'，'C'}; /*字符串赋初值*/ char sArr[7] = "ILOVEC"; 最后，对于字符串 sArr，可以直接使用 printf 的 %s 打印其内容；而对字符数组，很显然使用 printf 的 %s 打印其内容是不合适的。 通过对以上代码的分析，现在我们可以很简单地得出字符数组和字符串二者之间的区别： • 对于字符数组，其长度是固定的，其中任何一个数组元素都可以为 null 字符。因此，字符数组不一定是字符串。 • 对于字符串，它必须以 null 结尾，其后的字符不属于该字符串。字符串一定是字符数组，它是最后一个字符为 null 字符的字符数组。

单个字符用 c%. 输出时候不用取地址符。 另外你这缩进格式。。。。

应该是越界了.%s和%c的区别，建议查一下。  %s是输入字符串，而%c是字符。字符串需要关注一下'\0'  %s输入已经导致越界了

你是想挨个读取字符吧，那样需要将%s改成%c，%s是读取整个字符串

引用 7 楼 qq_42786437的回复:scanf读取单个字符是%c,输出也用%c因为是一个一个字符输出的 而且不用地址符，否则他会

scanf读取单个字符是%c,输出也用%c因为是一个一个字符输出的

输入的是 char 单个字符, 而不是 "%s"


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: %31[^\n]",s.NAME)) st=1;         } else if (st==1) {             if (1==sscanf(ln,"DIMENSION: %d",&s.DIMENSION)) st=2;         } else if (st==2) {             if (0==strcmp(ln,"DATA\n")) st=3;         } else if (st==3) {             if (3==sscanf(ln,"%d%d%d",&s.DATA[n].NO,&s.DATA[n].X,&s.DATA[n].Y)) {                 n++;                 if (n>=MAXCITY || n>=s.DIMENSION) break;             }         }     }     fclose(f);     printf("s.NAME=[%s]\n",s.NAME);     printf("s.DIMENSION=%d\n",s.DIMENSION);     for (i=0;i<n;i++) {         printf("s.DATA[%d].NO,X,Y=%d,%d,%d\n",i,s.DATA[i].NO,s.DATA[i].X,s.DATA[i].Y);     }     return 0; } //s.NAME=[essaie bla bla] //s.DIMENSION=8 //s.DATA[0].NO,X,Y=1,14,15 //s.DATA[1].NO,X,Y=2,11,10 //s.DATA[2].NO,X,Y=3,6,4 //s.DATA[3].NO,X,Y=4,7,13 //s.DATA[4].NO,X,Y=5,9,21 //s.DATA[5].NO,X,Y=6,19,3 //s.DATA[6].NO,X,Y=7,1,5 //s.DATA[7].NO,X,Y=8,8,8

綫性表就是字符串咯，字符數組。


提醒：FILE相关处理函数都是开源的。


Question: 请教一个算法问题，魔法师排队

才100万个，Long类型（4字节数据）就够了吧。 100万个Long值，才约4MB空间呢。 不过就算 Long Long类型，也才不到8MB吧。  按楼上说的，“从尾部向前扫描”，100万个数据，恐怕要不到0.3秒吧。

就像我刚刚传的那样 如果你想要自己输入 把rand函数改一下就好了

#include<iostream> 	#include<stdio.h> 	#include<stdlib.h> 	#include<time.h> 	using namespace std;  	long long a[1000001];  	int main() 	{     	int n,sum = 0;     	srand((unsigned)time(NULL));      	scanf("%d",&n);     	for(int i = 0; i < n; i++) 		{         	a[i]=rand()%100000000+1;     	}     for(int j=n-1;j>0; j--) 	{         for(int i = j-1;i>=0;i--) 		{             if(a[j]>a[i]&&i!=0) 			{                 sum++;             }             else if(i==0)             {	             	sum++;             	j=0;             	break; 			} 			else             {	             	j=j-(j-i)+1;             	break; 			}         }     }     for(int i=0;i<n;i++)     {     	printf("%d\n",a[i]); 	}      printf("%d",sum);     return 0; }

从队尾扫描一次就可以了 从最后一个开始，向前扫描，如果发现有小的就传送，如果发现有大的，则从这个大的开始继续向前扫描

这不是找队伍中最大数问题吗（就是一段一段找最大数） 从头到尾找最大数(因为最大数会把它之前数全扫掉)，然后再从最大数后一位开始再找最大数，一直重复到这个过程直到结束

从队尾开始判断，如果前面小于后面则传送走


Question: C#一维数组转二维数组请教

出门左拐，.NET技术，C#论坛。


Question: 小白求助  C 语音读TXT文件，数据不完整的问题

fscanf(fpts,"%s %d %d\n",&some[i].uname,&some[i].age,&some[i].year);  把some[i].uname前面的&去掉。uname就是数组名，本身就是地址，为啥还要加&

引用 3 楼 greenjia0 的回复:读文件部分代码 m 是记录txt文件里的总行数，是全局变量，当前m=3 struct someting { 	char uname[50];  //姓名         int  age//年龄 	int year;//年 }some[10];  1.txt 内容如何 4 a001    20          1998 b002    19          1997 c003     19          1997  ---------------------------------------------- fpts=fopen("1.txt","r"); 			if ( !fpts ) 			{ 				printf("open file error\n"); 				return -1; 			 } 			if((fpts=fopen("1.txt","r"))!=NULL) 			{ 				 setbuf(fpts,NULL);    				fscanf(fpts,"%d\n",&m); 				for(i=0;i<m;i++) 				{  					fscanf(fpts,"%s %d %d\n",&some[i].uname,&some[i].age,&some[i].year); （这句跟踪的时候第二行开始，第一个字段读取数据不完整） 					fflush(fpts); 				} 			} 			fclose(fpts);  首先你确定你fopen两次同一个文件没问题？ 然后fscanf(fpts,"%d\n",&m); 这个你咋来的，前面文件示例里没这个玩意吧 接着for循环读取前，你那行标题处理了么？ 另外你setbuf/flush在这也没啥意义 98年比97年的还大一岁的问题我就不说了，嘿嘿

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

贴出你的代码吧

建议，使用 fgets一次读一行，而后用 sscanf 从字符串读取


Question: 关于scanf()函数的问题，小菜鸡求帮助~~~

%c处理一个字符，所以只处理了+，没有把2也处理（2也可以做为字符被%c接收），getchar()不只能接收数字符号，键盘的按键回车，方向键，esc都可以接收的到，其他的可以按你的理解。

scanf上面已经解释的很清楚了。 读入一行用readline。

完全可以自己写一个例子来测试就明白了

你按了enter键getchar()就会收到回车符。

引用 5 楼 阿惹一号的回复:#include<stdio.h> #include<math.h> void main() { 	double a,b,c,d; 	printf("输入一元二次方程a= , b= , c=\n"); 	scanf("%lf , %lf , %lf",&a,&b,&c); 	d=b*b-4*a*c; 	if(a==0){ 		if(b==0){ 			if(c==0) 				printf("0==0参数对方程无意义!"); 			else 				printf("c!=0方程不成立"); 		} 		else 			printf("x=%.2lf\n",-c/b); 	} 	else { 			if(d>=0){ 				printf("x1=%.2lf\n",(-b+sqrt(d))/(2*a)); 				printf("x1=%.2lf\n",(-b-sqrt(d))/(2*a)); 			} 				else { 					printf("x1=%.2lf+%.2lfi\n",-b/(2*a),sqrt(-d)/(2*a)); 					printf("x1=%.2lf-%.2lfi\n",-b/(2*a),sqrt(-d)/(2*a)); 				} 				} } 请大家看下哈怎么错了，就是求不出方程的根啊。

请大家看下怎么错了，求不出根啊

scanf将1存入b，将+存入x,再将2存入a,输出再从将数据从变量对应的内存中取出送往stdout文件中

请判断scanf函数的返回值。

%d就对应了数字，然后%c对应字符，你如果是%d%d,那么两个输入数字中间还得用空格断开，而%d和%c本来就是不同类，所以可以一起输入

多个scanf 都是从stdin获取数据的 你输入 1+2 stdin里面的数据就是 1+2\n %d只处理整型的数据  从stdin里面读取了 1  遇到+的时候停止获取数据 用1完成赋值 stdin里面剩下 +2\n 后面的scanf 就从 +2\n获取数据 依此类推


Question: 二叉树的基本运算（调式输出和运行输出不同）

仅供参考：#include <locale.h> #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int nn=0; int CreateBiTree(BiTree *T) {//按先序序列创建二叉树     char data;     scanf("%c",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         *T = NULL;     } else {         *T = (BiTree)malloc(sizeof(BiTNode)); nn++;         (*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的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             printf("%c ",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             p = p->rchild;          //访问右子树         }     }     free(stack); } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             printf("%c ",p->data);             p = p->rchild;          //访问右子树         }     }     free(stack); }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     BiTreePost *stack=(BiTreePost *)malloc(nn*sizeof(BiTreePost));     int sp=0;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || sp) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack[sp]=BT;sp++;       //存入栈中             p = p->lchild;         }         while (sp && (stack[sp-1])->tag == 'R') {//左右子树访问完毕访问根节点             sp--;BT=stack[sp];        //退栈             printf("%c ",BT->biTree->data);             free(BT);         }         if (sp) {//遍历右子树             BT=stack[sp-1];             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     }     free(stack); } void LevelOrder(BiTree T) {//层次遍历     BiTree p;     BiTree *queue;     int h=0,t=0,n=0;      if (T == NULL) return;     p=T;     queue=(BiTree *)malloc(nn*sizeof(BiTree));     queue[t]=p;t=(t+1)%10;n++;//根节点入队     while (n) {    //队列不空循环         p=queue[h];             //对头元素出队         printf("%c ",p->data);  //访问p指向的结点         h=(h+1)%10;n--;         //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue[t]=p->lchild;t=(t+1)%10;n++;         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue[t]=p->rchild;t=(t+1)%10;n++;         }     }     free(queue); } 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: C语言数据结构

这个if(q==z==h) ，编译器会翻译成啥样啊？

if(q==z==h) 这条语句有问题，建议根据自己的需求改一下。C语言里没有这么写的语句；  不建议使用goto语句，goto语句可以改成循环（for/while/do...while）

用递归为什么不用函数调用而是用goto呢？ goto在这种场景可读性太差了


Question: 链表不知道怎么哪错了？

引用 6 楼 自信男孩 的回复:#include<stdio.h> #include<stdlib.h>  typedef struct Student *PtNode;  struct Student {     int num;     float score;     PtNode Next; };  PtNode Creat (void) {     PtNode P, head, temp;      head = NULL;     temp= (PtNode)malloc (sizeof(struct Student));     scanf("%d%f", &temp->num, &temp->score);     while (temp->num != 0){         if(head==NULL)             head=temp;         else             P->Next=temp;         P=temp;         temp = (PtNode)malloc(sizeof(struct Student));          scanf("%d%f", &temp->num, &temp->score);     }     free(temp);   //free the node which not used     //P->Next==NULL;     P->Next = NULL;      return head; }  int main() {     PtNode pt;     pt = Creat();      while (pt!=NULL){         printf("\n%d %4.1f\n", pt->num, pt->score);         pt = pt->Next;     }      return 0; }  参考一下吧，除了==导致的不能退出之外，还有一个重要问题，那就是把最后一个temp释放了，因为这个temp没有加入到你的链表里，需要释放掉，防止内存泄露谢谢兄弟的提醒

我已经找到问题了，在创建链表结束时赋值运算=写成了==，改回就好了，谢谢大家。

引用 2 楼 niiiloc 的回复:死循环问题的关键就是看准退出循环的条件  是的，但是我不知道代码的输出部分有什么问题，能麻烦兄弟讲解一下么？

引用 1 楼 King_of_Kindom 的回复:你的运行结果可以发一下吗  运行结果如下图，而且还在一直循环下去 麻烦兄弟帮忙看看，谢谢了

死循环问题的关键就是看准退出循环的条件

你的运行结果可以发一下吗

数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633


Question: windows C语言读取注册表获取已安装软件信息与控制面板中的信息不一致的问题

引用 1 楼 user-2 的回复:有时候信息可能存放在\HKEY_USERS中 HKEY_USERS中安装程序的信息很少，就算加上都不够

引用 2 楼 qaz952727 的回复:楼主要注意32和64位的区别就可以了 我从这两个位置取的数据：HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall 和HKEY_LOCAL_MACHINE\\SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall 32位和64位的安装位置都有吧，还有其他的位置么

楼主要注意32和64位的区别就可以了


用试试吧 可能是不同的c编译程序起的名不一样 51这些年基本的寄存器没啥变化，直接用多半是可以的


Question: CreateProcess为什么很多命令都不能正确执行？而system却可以？！

最后使用createprocess调用cmd完成了

CreateProcess相当于在“运行”里面输入命令 system相当于运行cmd后在控制台界面输入命令。


Question: 求解大佬，这段代码，改了下变量声明的顺序，就会出现完全不一样的结果

引用 楼主 qq_40952763 的回复:今天测试strcpy溢出时候发现的 1. void main(void){ char outputvalue[16]; char inputvalue[21] = {"12345678901234567890"}; strcpy(outputvalue,inputvalue); printf("%s\n",&inputvalue); printf("%s\n",&outputvalue); } 2. void main(void){ char inputvalue[21] = {"12345678901234567890"}; char outputvalue[16]; strcpy(outputvalue,inputvalue); printf("%s\n",&inputvalue); printf("%s\n",&outputvalue); }  就改了下声明时间的顺序，就会导致结果不一样。。。    我思考的结果是，先声明的变量，占用了后面的内存，而后声明的变量，内存却在先声明的前面。。。 内存越界导致覆盖了附近声明的其他变量，讨论具体覆盖了谁没有意义。

今天了解到的，x86栈向下生长，大概就是这个原因了

要不怎么说strcpy不安全呢！

写法是错的，内存越界 打印不一样只是栈内存被覆盖罢了

你这个strcpy涉及到了非法内存操作（源字符串大于目标字符串长度），在不知名的内存上保存东西，本来就存在风险性，当打印这个字符串时，也会有不定的错误存在，自然而然有时结果就不一样了

另外，在我的Linux系统下，交换声明的前后顺序结果还是一样的。都是第一种输出，这个跟编译器可能还是有一定关系的

printf("out: %p, in: %p\n", outputvalue, inputvalue); 加上这样一条语句（在strcpy之前加上这条语句）你就能理解为什么结果不一样了。另外，需要了解的strcpy是遇到'\0'停止拷贝，而不关心目标串的长度


Question: 静态变量

static 的i是程序刚运行时创建的，作用范围是{ }以内，所以最后的 i 的值3是main里经过循环得出的3，而不是循环里的。而循环里的 i 在循环期间一直存在，所以值不断累加，第一次 1+1*1得2，第二次2+2*2得6，第3次6+6*6得42。至此，所有结果已经明了。

写这样的程序莫不是想不开吧，干嘛好几层作用域都定义i

最好不要重名变量，作用域不一样，直接观察有时候会没注意

int i = 0; static int i=1;  你这是估计测试作用域的么？没有困难制造困难也要上。。。

for里面的静态变量只初始化一次

谁这么写代码必然会被开除

这么给你说吧，for循环外边的i是个定义在栈上的变量，for里面的i是定义在静态储存域上的变量，所以两个i的内存域就不同，for内部的以局部静态变量来运行，外部以局部临时变量来运行

这个是一个变量作用域和生命周期的一个问题，建议不要同一个变量名出现在同一个函数内或语句块内？

for循环里面的i把外面的i给屏蔽了，所以外面循环的i从0加到3，最后输出3，代表了循环次数。里面的i声明为静态变量，只初始化一次，第一次循环结果1+1*1=2，第二次2+2*2=6，第三次6+6*6=42，跳出循环，结束。这里面注意两个点，一是作用域小的变量会屏蔽作用域大的变量，二是静态变量只初始化一次。

fot局部静态变量i和全局变量

注意下命名。


Question: 关于异或的问题，小菜鸡求助~~~~

拆成3部分看就明白了a＝a^b； b＝a^b； a＝a^b;最后a和b交换了数值

从左至右，而不是从右至左。

理解和讨论之前请先学会如何观察！  计算机组成原理→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执行停在该断点处的时候。

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

如果不懂这样的表达式，建议分开写（如果自己去写的话）。写出的代码除了自己懂以外，也是需要让别人看懂才行的。

首先 这种写法 又蠢又恶心  然后 你忘记了 考虑 最右边的操作 a^=b 这里 a已经不是a了 是a^b的结果 后面 你说的 b = 原来的a  这里没问题  最后是 a ^= b 这里是 a = a^b a是 最开始a^b的结果 b你前面说了是 原来的a 原来a^原来b^原来a a 结果原来b

a^=b^=a^=b  1. a^=b     a=a^b  b=b 2. b^=a     a=a^b b=b^(a^b)=a 3. a^=b     a=(a^b)^a=b  b=a


Question: 关于求完数的一题，小菜鸡求大神帮帮忙~~~

引用 5 楼 小丫么小菜鸡 的回复:引用 3 楼 niiiloc 的回复：你就不能学学调试么？你问的所有问题都能自己调试解决我用的dev++工具，如何调试呀  请在关键节点加入printf打印，这就是一种调试方式：通过打印来调试

24不是完数。  1+2+3+4+6+8+12 != 24。。  问题原因在于，下面这个部分。。不是把约数加到等于原数字。。而是把所有约数相加，如果等于原数字。才是完数。  if(sum==i) {   flag=1;   break;  }    改了一下程序（简单改了一下，规范性，健壮性什么的没有改），运行后（100以内的约数），就是正确的了。   #include<stdio.h> int main(){   int n,m,count=0;   int sum;   int flag;   int a[20];   scanf("%d",&n);   scanf("%d",&m);   for(int i=n;i<=m;i++){     for(int z=0;z<=19;z++){       a[z]=0;     }      count =0;     flag = 0;     sum = 0;      for(int j=1;j<i;j++){       if((i%j) == 0){         a[count]=j;         sum+=j;         count++;       }     }      if(sum == i){       flag = 1;     }      if(flag==1){       for(int z=0;z<=count;z++){           printf("%d,%d",sum,a[z]);           printf("\n");       }     }   } }

#include <stdio.h> #include <string.h> int isPerfectNum(int value); int main(){ 	for(int i=1;i<1001;i++){ 		if(!isWanshu(i)){ 			printf("%d\n",i); 		} 	} 	getchar(); 	return 0; } int isPerfectNum(int value){ 	int iRet=0; 	int sum=0; 	for(int i=1;i<value/2+1;i++){ 		if(value%i==0){ 			sum+=i; 		} 	} 	if(sum==value){ 		iRet=0; 	}else{ 		iRet=1; 	} 	return iRet; }

你就不能学学调试么？你问的所有问题都能自己调试解决

#include<stdio.h>  int main() {     int n,m,cnt=0;     int sum;     int a[20];     scanf("%d",&n);     scanf("%d",&m);      for(int i = 0; i <= 19; i++)         a[i] = 0;      for(int i = n; i <= m; i++) {         if (i % 10 != 6 && i % 10 != 8)    //根据完全数的特质，必须是6/8结尾的数；             continue;          sum = 0;         for(int j = 1; j <= i / 2; j++) {    //除于2，来减少循环次数，提高效率             if(i%j == 0)                 sum += j;         }         if(sum == i)             a[cnt++] = i;      }      for(int i = 0; i < cnt; i++){         printf("%d ", a[i]);     }     printf("\n");      return 0; }  参考一下吧；  根据完全数的特质可以提高程序的运行效率；


Question: 小白求助~~ C语言基础题目~~

t = pow(10,i);改成t = pow(10,i-1);就可以了

可以试着用单步调试和设断点调试找出问题。

#include<stdio.h> void main() {     int a,n;     printf("请分别输入a和n的值：\n");     scanf("%d %d",&a,&n);     int i,r=0, d=1;     for(i=n;i>0;i--)     {                      r=r+a*i*d;          d=d*10;     }     printf("a+aa+aaa+...+aa...a=%d\n",r);  }可以看一下我写的，比较简单

引用 26 楼 weixin_43775585的回复:我用JAVA做出来的，前段时间我弟才问的我这个题……用了两个for循环，等我拿出电脑给你发源码 表示没学过c，直接学的JAVA。。

引用 5 楼 xueyu人生的回复:int fn(int a,int n){     int t,b,sum,result=0;     for(int i=n;i>=1;i--){         t = pow(10,i);//很明显这里错误，假如输入5和1，那么你的答案是5*10+5=55,修改为：pow(10,i-1)就可以了         sum = 0;         while(t!=0){             b = t*a;             sum = sum +b;             t = t/10;         }         result = sum + result;     }     return result; 说的没错，指数大了1的。

自己调试然后慢慢成长

我做的这样#include<stdio.h> int main() { 	int n,a,j,i,sum=0; 	scanf("%d%d",&a,&n); 	for( i=1;i<=n;i++) 	{ 		for(j=1;j<i;j++) 		{ 			a=a*10+a; 		} 		sum=sum+a; 	} 	printf("%d\n",sum); 	return 0; }

我觉得可以用循环结构

#include<stdio.h> #include<math.h> int main() {     int a,n,m,s=0,i;     scanf("%d %d",&a,&n);     m=a;     for(i=1;i<=n;i++)         {          s=s+a;          a=a+m*pow(10,i);}     printf("%d",s);     return 0;  }

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

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

引用 9 楼 niiiloc的回复:请在几个关键点加上printf，以后这类问题你再也不用到论坛上问 做一个硬件软件能够把 （某种情况下自动输入的数据发送到指定用户的手机上）  第一种…短信方式 第二种…关注的公众号上  譬如产品（共享纸巾机的工作）

这个你可以尝试下另n和a都取个较小的值，然后和人工计算对比验证，看看是否正确，不正确的话，可以逐步调试，看看哪一步和自己想的不一致。 我也是个新手，归根结底码代码自己动手收获更大些。

请在几个关键点加上printf，以后这类问题你再也不用到论坛上问

这种问题，需要自己找到问题，你才能成长。编译器找错误---->调试找错误---->打日志（包括但不限于输出到屏幕）找错误---->演算思考找逻辑错误

#include <iostream>  #include<math.h> using namespace std;     void f(int n,int a,int *p) {     int i;     if(n==1) *p=a;     else      {*p=a;     for(i=1;i<n;i++)     {          *(p+i)=*(p+i-1)+(int)(a*pow(10.0,i));     }     } } int main() {     int a1,n1,i;     long sum=0;     int *p;     p=(long*)malloc(n1*sizeof(long));     cin>>a1>>n1;     f(n1,a1,p);     for(i=0;i<n1;i++)     cout<<p[i]<<'\t';     cout<<endl;     for(i=0;i<n1;i++)     sum+=p[i];     cout<<sum<<endl; }

#include<stdio.h> #include<math.h>  int fn(int a,int n);  int main() {     int a,n;     scanf("%d",&a);     scanf("%d",&n);      if (a > 9 && a < 0)         return 0;     if (a == 0) {         printf("%d\n", 0);          return 0;     }      printf("%d\n",fn(a,n)); } int fn(int a,int n) { #if 0     int t,b,sum, result=0;      for(int i = n;i>=1;i--) {         t = pow(10,i);         sum = 0;         while(t!=0){             b = t*a;             sum = sum +b;             t = t/10;         }         result = sum + result;     } #else     int i, tmp, result;      tmp = a;     result = 0;      for (i = 0; i < n; i++) {         result = result + a;         a = (10 * a) + tmp;     }  #endif     return result; } 参考一下吧

勒索木马是用这个语言写的吗


Question: 关于对指针进行&运算

C语言的核心灵魂就是指针，这是其他语言所没有的。

引用 28 楼 qq_43807092的回复:[quote=引用 3 楼 jiaoyun007的回复:][quote=引用 1 楼 qq_40260025 的回复:] 定义一个指针: char *p;  它此时代表一个地址，因为你没有对它初始化，所有它指向的地方可能非法，但你仍然可将它看作一个地址。 而   &p 就是对指针取地址，即地址的地址。 p已经是内存区间一个具体地址了，那它地址的地址，指的什么呢？[/quote] P为0*00000000作为指针时是一个地址。[/quote] 对p取地址时，这时p是一个数，相当于对这个数取地址。

引用 3 楼 jiaoyun007的回复:[quote=引用 1 楼 qq_40260025 的回复:] 定义一个指针: char *p;  它此时代表一个地址，因为你没有对它初始化，所有它指向的地方可能非法，但你仍然可将它看作一个地址。 而   &p 就是对指针取地址，即地址的地址。 p已经是内存区间一个具体地址了，那它地址的地址，指的什么呢？[/quote] P为0*00000000作为指针时是一个地址。

引用 3 楼 jiaoyun007的回复:[quote=引用 1 楼 qq_40260025 的回复:] 定义一个指针: char *p;  它此时代表一个地址，因为你没有对它初始化，所有它指向的地方可能非法，但你仍然可将它看作一个地址。 而   &p 就是对指针取地址，即地址的地址。 p已经是内存区间一个具体地址了，那它地址的地址，指的什么呢？[/quote] *是指向的意思?，求解

你就把char*看作数据类型，取地址是一种运算，p本身存储的是一个字符串的首地址，而对p取地址之后，得到的就是p对应存储单元的地址，是char**类型

*p 是一个指针，所指向的存储空间的地址存在p中。&p的话就是p的地址，也即存 指向存储空间地址 的存储空间的地址。

感谢分享，小白刚好学到指针

char *p;    这是定义一个变量；既然是定义变量那么这个变量（变量名是p,类型是char*)就有一个内存空间,这个内存空间就有一个地址，这个地址就是变量p的地址，即&p.        p的类型是char*也就是说p是个指向char类型数据的指针，p中存放的数据是一个char类型数据的地址，而&p，也就是p的地址，p是char*类型，&p类型就是char**, 所以如果要存放&p应该用char **pointer;来存放，意思是pointer是个指针，  存放的地址类型是char*类型数据（p）的地址（&p）。    或者简单地说p这个指针是来存放别人的地址的，&p是p自身的地址（因为p也是个变量，也有内存空间）。

插嘴一句，指针搞不明白，，，，学习c很艰辛

指针取地址就是二维指针，再取地址就是三维了，嘿嘿

char *p 相当于定义一个变量p的指针（可以理解同时做了定义变量p和变量p的指针两件事），可以是值或者字符串之类的，而&p表示这个获得变量p在内存中的存储地址，是一个固定的值，也就是获得*p所指向的地址值。 所以你的函数中&p1,&p2作为一个地址值一直没变，而p1与p2则随着你的定义与赋值而变。 仅个人理解，有问题请指出。

p1对应的是指针变量里的值，&p1是指变量p1的地址，这个地址是栈上的地址，因为p1是局部变量。 由于p1指向0，即指向NULL，那就是0地址；&p1就是一个函数func3栈上的地址； p2指向的地址是随机的，所以输出p1的地址是一个随机的地址，&p2和&p1一样是局部变量，并且是挨着的，所以地址值相差4(32位系统）；   下面p1, p2都指向了"abc"的首地址，因此输出的p1, p2是相同的，同样&p1, &p2的地址没有变化那也是上面一样的值。

引用 3 楼 jiaoyun007 的回复:[quote=引用 1 楼 qq_40260025 的回复:] 定义一个指针: char *p;  它此时代表一个地址，因为你没有对它初始化，所有它指向的地方可能非法，但你仍然可将它看作一个地址。 而   &p 就是对指针取地址，即地址的地址。 p已经是内存区间一个具体地址了，那它地址的地址，指的什么呢？[/quote] 形成了一个临时变量。

指针实质是一段数字 对指针取地址就是获取这段数字在内存中的位置

结贴了，谢谢各位！

引用 18 楼 zhao4zhong1 的回复:十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495 好好看看！！

引用 12 楼 sinat_37764097 的回复:这个问题的确能让初学者头疼，  多谢画图！！

引用 16 楼 jiaoyun007 的回复:[quote=引用 11 楼 zhao4zhong1 的回复:] http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素 您是大鳄，哈哈！[/quote]


Question: 求助   关于C# byte数组转化为image的相关问题！

好的 谢谢楼上的大佬

c#的论坛在这： https://bbs.csdn.net/forums/CSharp

今天回来测试了一下  连上了开发板（含有stm32单片机和ov7670）进行测试，一开始由于忘记修改图像像素大小（之前改了下写的是240X320）导致图像显示模糊，而且显示的图像大小也有问题：      经过调整后（将显示的bitmap像素大小修改为120X160） 用摄像头对准二维码：   上位机显示部分居然能显示出部分的二维码：   而且清晰度也还是可以的：   目前为止 最主要的问题就是 采集的图像不能完整的显示出来，有大神知道这个是什么问题么？


Question: 请教大家C语言可变参数 stdarg.h的实现问题

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

(sizeof (X) + (bnd) & ~(bnd)) 不确定优先级就百度下吧 + 的优先级比 位与高（不是取址符啊） 所以没问题了吧 4+3 & 0xfffffffc = (4+3) & 0xfffffffc = 4

看错了，(sizeof (X) + (bnd) & ~(bnd))是先加再取与，不是先取与算成0再加sizeof(char)

没看懂你的问题，sizeof（char）不是1么，所以结果是1+0=1，有啥不对的么？

谢谢  永远的追梦人  niiiloc  英雄@末路  还有多次解答我问题的赵4老师 。 我自己没看清楚优先级 ---瞄了一眼看到 ～取反的优先级在很靠前，然后看到一个 &也在前面，然后没想到按位 与的 &在后面，然后就拍脑袋想当然了以为&优先级比+ 要高。 谢谢大家。

+号的运算顺序高于&?


Question: 求助：结构体使用不知道哪里出了错，打.或者->都没有那个展开的选项

引用 3 楼 自信男孩 的回复：[quote=引用 2 楼 cfjtaishan 的回复:] #include<stdio.h>  #define M 10 typedef struct{     int key; //}HashTable[m]; }HashTable;  #define NULLKEY 0  int H(int key){     return key % M; } int SearchHash(HashTable *HT,int key){     int H0,Hi;     H0=H(key);     if(HT[H0].key==NULLKEY)         return -1;     else if(HT[H0].key==key)         return H0;     else{         for(int i=1;i<M;i++){             Hi=(H0+i) % M;             if(HT[Hi].key==NULLKEY)                 return -1;             else if(HT[Hi].key==key)                 return Hi;         }         return -1;     }      return 0; } void InsertHT(HashTable *HT,int key,int n) {     int a;     a=key % M;     //if(HT[n].key) }  void CreateHT(HashTable *HT,int x[]){     int i;     for(i=0;i < M+1;i++){         HT[i].key=-1;     }     for(i=0;i<M+1;i++){         InsertHT(HT, x[i], i);     } }  int main() {     HashTable HT[M];     int x[]={65,22,74,13,28,89,41,85,93,40,27};     H(1);     SearchHash(HT,1);     return 0; } 对比一下，建议注意一下typedef的使用[/quote]谢谢^_^

引用 2 楼 cfjtaishan 的回复:#include<stdio.h>  #define M 10 typedef struct{     int key; //}HashTable[m]; }HashTable;  #define NULLKEY 0  int H(int key){     return key % M; } int SearchHash(HashTable *HT,int key){     int H0,Hi;     H0=H(key);     if(HT[H0].key==NULLKEY)         return -1;     else if(HT[H0].key==key)         return H0;     else{         for(int i=1;i<M;i++){             Hi=(H0+i) % M;             if(HT[Hi].key==NULLKEY)                 return -1;             else if(HT[Hi].key==key)                 return Hi;         }         return -1;     }      return 0; } void InsertHT(HashTable *HT,int key,int n) {     int a;     a=key % M;     //if(HT[n].key) }  void CreateHT(HashTable *HT,int x[]){     int i;     for(i=0;i < M+1;i++){         HT[i].key=-1;     }     for(i=0;i<M+1;i++){         InsertHT(HT, x[i], i);     } }  int main() {     HashTable HT[M];     int x[]={65,22,74,13,28,89,41,85,93,40,27};     H(1);     SearchHash(HT,1);     return 0; } 对比一下，建议注意一下typedef的使用

这个没事，看你使用的软件规定的书写格式


Question: 如果 va_end只是把 指针指向0位置, 那实际这行代码不是必须的?!

得看堆栈是否平衡。

引用 2 楼 weixin_41724510 的回复:va_end(argptr); 这行代码的作用是清理工作，相当于释放动态分配的内存，也就是free(); 只有在调用va_end(argptr); 之后，再使用va_start重新初始化argptr后，才能使用变量argptr。 当然，自己试试去掉有没有影响即可。   试过了，自己有个可变参数的函数，短时间内重复调用这个函数没毛病。 但是长时间不知道会不会有隐患

引用 1 楼 zhao4zhong1 的回复:去掉试试不就知道了。   试过了，自己有个可变参数的函数，短时间内重复调用这个函数没毛病。 但是长时间不知道会不会有隐患

去掉试试不就知道了。


Question: win7下运行的控制台程序，如何设置ctrl+v来输入字符串？

用鼠标是可以粘贴，至于复制，就不清楚了。

不支持快捷键而已，可以鼠标左键选择，用鼠标右键的快捷菜单操作。

快速编辑模式下，点击鼠标右键粘贴；按住鼠标左键拖动选择，单击鼠标右键拷贝。


Question: C语言十进制转二进制

使用除2取余

#include <cstdio> #include <cstdlib>  int main() { 	int nums[1000];  	int c; 	int len = 0; 	printf("请输出一个十进制数字，以#号键结束(例如 9527# )\n: "); 	while ((c = getchar()) != '#') 	{ 		nums[len++] = c - '0'; 	}  	printf("十进制: "); 	for (int i = 0; i < len; ++i) 		printf("%d", nums[i]); 	printf("\n");  	int bins[3322]; 	int blen = 0;  	int beg = 0; 	while (beg != len) 	{ 		int mod = 0; 		bool z = true; 		for (int i = beg; i < len; ++i) 		{ 			int s = mod * 10 + nums[i];  			mod = s % 2; 			nums[i] = s / 2;  			if (z) 			{ 				if (nums[i] == 0) 					++beg; 				else 					z = false; 			} 		}  		bins[blen++] = mod; 	}  	printf("二进制: "); 	for (int i = blen - 1; i >= 0; --i) 	{ 		printf("%d", bins[i]);  		//if (i % 4 == 0) 		//	printf(" "); 	} 	printf("\n");  	system("pause");  	return 0; }

有个库函数   itoa，你搜搜。

引用 4 楼 htttw 的回复:不是这个意思，是n本身就是1000位长度的，用一个int肯定放不下啊 http://blog.51cto.com/9492221/1564392，这是超长10进制转16进制的例子。稍微改改就可以了

引用 2 楼 housecarl 的回复:#include<iostream> using namespace std; void main() {    int n,i,j=0;    int a[1000];    cin>>n;    i=n;    while(i)    {     a[j]=i%2;     i/=2;     j++;         }    for(i=j-1;i>=0;i--)     cout<<a[i];    cout<<endl; }  https://blog.csdn.net/qq_41446560/article/details/80034932 网上都有，自己搜一下。   不是这个意思，是n本身就是1000位长度的，用一个int肯定放不下啊

引用 1 楼 zhouqunhai 的回复:使用除2取余  1000位长度的十进制数怎么除2？


Question: c语言多人开发，配置文件以及代码合入流程请教，感谢。

引用 13 楼 hjwang77 的回复:不建议在头文件中定义变量 可以在a.c中定义，在a.h中extern下，那所有包含a.h的c文件都可以用 或者可以仿照c++,a.c中定义变量和所有访问此变量的函数，将其包到头文件a.h中，所有包含a.h的都可以通过此函数来获取变量。 谢谢您了，感觉你说的C++就是面向对象的那种getter和setter方法了吧？？呵呵，我这里不是定义变量是想声明一个常量，应该是 #define AAA "HELLO WORLD"这种格式，按照您说的，我这个应该放到A.c中吧？？A.h中只放置A.c中相关函数的声明。然后其他人include A.h,就可以使用A.c中定义的方法了。

引用 6 楼 sys0613 的回复:[quote=引用 1 楼 sinat_37764097 的回复:] 对于同一个机能模块：一个头文件，无数个C文件。 对于不同的机能模块：不同的头文件。 您好，我是按照模块分的，按照您的机能理解，就是不存在跨机能调用函数？？？如果存在跨机能调用，那这个.H文件应该如何部署？谢谢[/quote]  一个机能包含了很多模块，比如dev.h 包含了：lcd.c key.c usart.c。换言之lcd.c key.c usart.c共用一个dev.h。所有的机能模块会受到一个事件循环的控制，不存在跨机能调用，换言之，所有的事件处理都是这个循环中，机能甲要想调用机能乙中某个模块的函数，必须经过这个事件循环的同意，并且由事件循环去代为调用，然后把结果还给甲。这是我见过个人觉得比较不错的嵌入式上面的一个方案，各个模块之间耦合很低，各个机能之间几乎没有耦合。

引用 1 楼 sinat_37764097 的回复:对于同一个机能模块：一个头文件，无数个C文件。 对于不同的机能模块：不同的头文件。 您好，我是按照模块分的，按照您的机能理解，就是不存在跨机能调用函数？？？如果存在跨机能调用，那这个.H文件应该如何部署？谢谢

引用 2 楼 xian_wwq 的回复:1.通用模块开发，首先定义模块的接口。    然后再完成功能代码。也就是常说的模块之间松耦合。    具体来说，多个模块并行开发，不同开发人员先要定义好自己的.h。 某个模块修改，其他相关人员一定要及时同步.h.  2.不管是多人开发，还是单人开发 仅仅从代码管理来说 Git都是不二之选 您好，git已经使用，主要问题就是这个h文件有点蒙圈了，现在情况是A.c用A的A.h文件,B要用A.c的函数，也要include A.h文件，经常报错就是A.h里面有的东西被定义了2遍，您说是不是应该A.c中不应该#include A.h呢？？谢谢了

引用 3 楼 sinat_37764097 的回复:在我印象中，VS开发，main函数的会默认一个有一个参数，这个参数就是argv[0]，他是这个程序的绝对路径。你可以顺着这个思路看看Linux下是不是一样，可不可以通过这个方法，找到config文件夹。 您好，我明白您这个意思，谢谢，程序关键是合作开发，可能调用的就是对方的一个函数，如果从我的main函数开始传递路径到对方，有点太远了。您这个建议非常好，我别的程序里，会用到，万分感谢

引用 12 楼 sys0613 的回复:[quote=引用 11 楼 xian_wwq 的回复:] [quote=引用 5 楼 sys0613 的回复:] [quote=引用 2 楼 xian_wwq 的回复:] 1.通用模块开发，首先定义模块的接口。    然后再完成功能代码。也就是常说的模块之间松耦合。    具体来说，多个模块并行开发，不同开发人员先要定义好自己的.h。 某个模块修改，其他相关人员一定要及时同步.h.  2.不管是多人开发，还是单人开发 仅仅从代码管理来说 Git都是不二之选 您好，git已经使用，主要问题就是这个h文件有点蒙圈了，现在情况是A.c用A的A.h文件,B要用A.c的函数，也要include A.h文件，经常报错就是A.h里面有的东西被定义了2遍，您说是不是应该A.c中不应该#include A.h呢？？谢谢了[/quote]  既然报错是重复定义，那就避免重复定义 把  #define LEN 50         //bbb.c中使用 static char ARRAY[]="HELLO"        //bbb.c中使用的常量数组  相关定义放在 bbb.c中不就可以了吗？ [/quote]  谢谢您，是不是这些定义放到aaa.c中更好呢？不放在aaa.h中了，因为是B用A，这些东西是A的东西，是不是直接放到aaa.c中更合理 。。抱歉，我真的是想弄清这个规范性的东西，有些较真了哈，谢谢。我看 您写的是放在bbb.c中了，所以就较真了。因为b是用a的函数，所以希望应该是所有东西都让A处理好吧？也不知道这个协同开发有没有业界规范。真得好好学学。谢谢您[/quote]  不建议在头文件中定义变量 可以在a.c中定义，在a.h中extern下，那所有包含a.h的c文件都可以用 或者可以仿照c++,a.c中定义变量和所有访问此变量的函数，将其包到头文件a.h中，所有包含a.h的都可以通过此函数来获取变量。

引用 11 楼 xian_wwq 的回复:[quote=引用 5 楼 sys0613 的回复:] [quote=引用 2 楼 xian_wwq 的回复:] 1.通用模块开发，首先定义模块的接口。    然后再完成功能代码。也就是常说的模块之间松耦合。    具体来说，多个模块并行开发，不同开发人员先要定义好自己的.h。 某个模块修改，其他相关人员一定要及时同步.h.  2.不管是多人开发，还是单人开发 仅仅从代码管理来说 Git都是不二之选 您好，git已经使用，主要问题就是这个h文件有点蒙圈了，现在情况是A.c用A的A.h文件,B要用A.c的函数，也要include A.h文件，经常报错就是A.h里面有的东西被定义了2遍，您说是不是应该A.c中不应该#include A.h呢？？谢谢了[/quote]  既然报错是重复定义，那就避免重复定义 把  #define LEN 50         //bbb.c中使用 static char ARRAY[]="HELLO"        //bbb.c中使用的常量数组  相关定义放在 bbb.c中不就可以了吗？ [/quote]  谢谢您，是不是这些定义放到aaa.c中更好呢？不放在aaa.h中了，因为是B用A，这些东西是A的东西，是不是直接放到aaa.c中更合理 。。抱歉，我真的是想弄清这个规范性的东西，有些较真了哈，谢谢。我看 您写的是放在bbb.c中了，所以就较真了。因为b是用a的函数，所以希望应该是所有东西都让A处理好吧？也不知道这个协同开发有没有业界规范。真得好好学学。谢谢您

引用 5 楼 sys0613 的回复:[quote=引用 2 楼 xian_wwq 的回复:] 1.通用模块开发，首先定义模块的接口。    然后再完成功能代码。也就是常说的模块之间松耦合。    具体来说，多个模块并行开发，不同开发人员先要定义好自己的.h。 某个模块修改，其他相关人员一定要及时同步.h.  2.不管是多人开发，还是单人开发 仅仅从代码管理来说 Git都是不二之选 您好，git已经使用，主要问题就是这个h文件有点蒙圈了，现在情况是A.c用A的A.h文件,B要用A.c的函数，也要include A.h文件，经常报错就是A.h里面有的东西被定义了2遍，您说是不是应该A.c中不应该#include A.h呢？？谢谢了[/quote]  既然报错是重复定义，那就避免重复定义 把  #define LEN 50         //bbb.c中使用 static char ARRAY[]="HELLO"        //bbb.c中使用的常量数组  相关定义放在 bbb.c中不就可以了吗？

引用 9 楼 user-4 的回复:用svn . 谁提交谁修改。 谢谢您，但svn只是项目管理，我懂您意思，但您没懂我的需求。。因为第二个人开发的代码是具有独立功能的，不想把.h文件都和别人的混合到一起，这样第三个人，想用第二个人的功能，无法单独抽取头文件了。谢谢

用svn . 谁提交谁修改。

[/quote] 您好，我是按照模块分的，按照您的机能理解，就是不存在跨机能调用函数？？？如果存在跨机能调用，那这个.H文件应该如何部署？谢谢[/quote]  一个机能包含了很多模块，比如dev.h 包含了：lcd.c key.c usart.c。换言之lcd.c key.c usart.c共用一个dev.h。所有的机能模块会受到一个事件循环的控制，不存在跨机能调用，换言之，所有的事件处理都是这个循环中，机能甲要想调用机能乙中某个模块的函数，必须经过这个事件循环的同意，并且由事件循环去代为调用，然后把结果还给甲。这是我见过个人觉得比较不错的嵌入式上面的一个方案，各个模块之间耦合很低，各个机能之间几乎没有耦合。[/quote] 收到，收到，特别感谢。其实像您说的，情况1，我要就是去把循环事件搞懂，情况2，要不就是一个机能内，例如lcd.c由用户A开发，key.c 由用户B开发，但通过版本管理系统GIT或者svn。用户A和用户B共同维护一个头文件，dev.h。 其实我想用的场景是模块化开发，例如密码校验功能，有开发者A写，他写一个AA.c和AA.h，这样用户B需要使用密码校验功能时，直接把A的代码拿来就能用，拿来一个AA.h文件将AA.c拷贝到用户B中，就可以了。您说的事件循环应该比我这个想法复杂吧？


Question: strcpy函数中为什么不能直接return strDest呢？而使用另外的一个指针address？

strDest已经在循环中不断++走远了，已经不是原来的strDest了

因为这个操作：strDest++，这个操作就是已经将strDest指向了目标串的末尾，返回目标串的末尾没有意义，应该返回的是目标串的首地址

函数传递，strDest只是局部变量发生变化了

优先级是 ++ > * 的，所以，strDest的地址已经发生偏移了，指向的不是原来的地址了，建议这种问题直接调试，观察地址和内存的变化

strDest 已经++了啊，当然如果你不关心这个函数的返回值，那返回啥都没关系的，不影响拷贝的结果。

strDest 指针已经被不断++ 赋值 了。地址已经飘远了。不是字符串首地址了


Question: 调和级数

这是c和Java。当初一起写的，所以就一起放出来了。

enmm其实就是一道题，然后我给代码直接放出来了。

问题是什么？不同语言计算结果不一样？那可能是精度的关系

展示下c++, c, java的实现差别？

楼主的问题是什么？

有什么问题吗？结果呢？


Question: 求问该算法题，小白不会代码，求大佬的代码！要能运行的（C语言）

要么自学问点重点问题，要么给钱叫人帮忙做。

看不了这么长的问题，估计有时间回答问题的人也不多吧

福大的吧。

每次过来求作业答案，累不累啊

我靠，打星际的时候，如果神族的水晶塔都让人拆了，就直接gg了，还修啥啊。。。。

不好意思，输入样例有误，第二组最后一行输入1 6，是不需要的，可以忽略！！


Question: 问道算法题，求能运行的代码，各位大佬！（C语言）

还好不是后羿，不然我们都该同情嫦娥了。。。 这题可能的解法： 1. 算出n个箭支的总长度，代码用for循环累加就行了。 2. 找出总长度的所有可能的约数/因子，貌似还是for循环 3. 找出n个箭支的最大长度，没必要排序，还是for 循环一个个比下去 4. 列出所有大于等于最大长度的约数就是结果吧  这个貌似就是考验for循环的使用？


Question: 奇怪的 指针转换，求解

1. 编译没问题，就是运行出错。 2. short_t 这个结构体，就是用于强制字节序的。  3. 单独gcc 跑了一下，一点问题没有，也不存在越界 #include <stdio.h>   2 #include <stdint.h>   3    4 typedef struct {   5     int8_t low  ;   6     int8_t hig   ;   7 }short_t ;   8    9 void main()  10 {  11     short_t data[10] ;  12     data[0].low = 1 ;  13     data[0].hig = 2 ;  14     data[1].low = 3 ;  15     data[1].hig = 4 ;  16   17     int i ;  18     for( i = 2; i < 10; i++ )  19     {  20         data[i] = *(short_t*)&i ;  21     }  22   23     for(i = 0 ; i < 10 ; i++ )  24     {  25         printf("%x \n", (*(int16_t*)((int8_t*)((char*)&(data[i])))) );  26     }  27 }  输出： 201  403  2  3  4  5  6  7  8  9  总结： 一点问题没有，也许嵌入式端编译器的锅？？

注意下类型长度以及偏移

这个参考下前面的一个帖子，指针和数组在取地址符时候结果并不一样

前面说的方法, 都有一个前提.  字节序相同哈.  字节序不同, 是不能这样直接拿的.

取个值需要这么复杂吗?  char buf[0x100];  short val =  *(short*)&buf[4]; //可以直接把第5个字节起的2个字节,解析成一个short类型.  其它类型, 都可以参考这样来取值.  int val =  *(int*)&buf[4];  doubble val =  *(doubble *)&buf[4];  .......

求解为什么会这样

你把类型定义里面的low和high位置交换一下试试。


Question: opencv像素相减后，如何保存图片使多余部分透明？


Question: 求一段C语言的遍历中英文组合的char方法！

引用 6 楼 smwhotjay 的回复:分割含有中英文的字符串  字符串 中文分割 汉字分割 是否有开放的c语言工具类直接使用。

分割含有中英文的字符串  字符串 中文分割 汉字分割

这个问题 应该叫 中文分割。

引用 3 楼 cfjtaishan 的回复:char s = "ABC123你好"; 这句如果是依据代码是有问题，s是一个字符，后面是一个字符串； 改成如下，是可以的 const char *s = "ABC123你好";  接下来就是另一个问题了：ABC123是都可以输出的，对于中文不是用一个字符表示的 对的，我尝试过wchar等方法，一直没能实现。

引用 1 楼 baiywcwttfln 的回复:这要看你char 是什么编码，gbk 还是utf8 您好，char的声明方式上是可以指定编码方式吗？按照以上的声明方式是什么编码

这要看你char 是什么编码，gbk 还是utf8


Question: 二阶互补滤波器原理是什么啊？？

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

不难，基础要好一点就能推出来！

http://www.doc88.com/p-2819102704066.html 看看这篇文章，多加了一层积分

引用 1 楼 user-4 的回复:https://blog.csdn.net/seek97/article/details/81294097?utm_source=blogkpcl6  看看这篇 一阶互补我理解了，就是二阶的不懂


Question: 求大神看看我最大公约数错在哪了~

返回0其实也是没问题的，仔细看，楼主的gcd函数里面是有个输出的，所以说返回什么都无所谓，只要保存了结果就好，重点是在那个if上。从另一方面说，这种子函数里面不建议直接打印值，可参考楼上代码。

#include <stdio.h>  int gcd(int x,int y);  int main() {     int x;     int y;     int z;     scanf("%d",&x);     scanf("%d",&y);     z=gcd(x,y);     printf("%d\n",z); }  int gcd(int x,int y) {     int t;     while (y != 0){         t=x%y;         x=y;         y=t;     }      return x; } 参考一下吧

两个问题，  函数gcd 里面if 改成while 返回值是x ，而不是直接返回0

gcd函数永远返回0 ？ 我总感觉这里贴代码的人在害楼主而不是帮他

#include<stdio.h> int main() {     int m, n, temp, i;     printf("Input m & n:");     scanf("%d%d", &m, &n);     if(m<n)  /*比较大小，使得m中存储大数，n中存储小数*/     { /*交换m和n的值*/         temp=m;         m=n;         n=temp;     }     for(i=n; i>0; i--)  /*按照从大到小的顺序寻找满足条件的自然数*/         if(m%i==0 && n%i==0)         {/*输出满足条件的自然数并结束循环*/             printf("The GCD of %d and %d is: %d\n", m, n, i);             break;         }         return 0; }

将两个数a，b相除，如果余数c不等于0，就把b的值给a，c的值给b，直到c等于0。


Question: 关于调用函数的一题，我小白，求大神帮帮忙~！

#include <stdio.h> #include<math.h>  double funcos(double e,double x);  int main(int argc, char **argv) {     double x;     double e;     scanf("%lf", &e);     scanf("%lf", &x);     double cos;     cos=funcos(e, x);     printf("%lf\n",cos);      return 0; }  double funcos(double e,double x) {     double sum = 0;     double t;     int den = 0, flag = 1;     int result = 1, i;      do {         t = 1.0 * flag * pow(x, den)/result;         sum += t;         den += 2;          result = 1;         for(i = 1; i <= den; i++)             result *= i;         flag = -flag;     } while(fabs(t) < e);      return sum; }  参考一下吧， 注意每次result的值每次都要复位（赋值1）

这个函数不对吧，这个。。。cos转换成啥式子来这？

书上写的是错的

学他的语法结构就行了 至于算法结果  确实错了


Question: C程序填空  关于栈和队列的基本操作  求详细解释！！！！

我想问一下 linklist *creatlist() {     linklist *p,*q;     int n=0;      q = p = (struct node *)malloc(sizeof(linklist));     head = p;     p->next = NULL;     p = (struct node *)malloc(sizeof(linklist));     scanf("%d", &p->data);     while(p->data!=-1)     {         n = n+1;         q->next = p;         q = p;         p = (struct node *)malloc(sizeof(linklist));         scanf("%d", &p->data);     }     q->next = NULL;      return(head); } 里面的int n 有什么用嘛？每次循环还要n+1?

gdb调试，

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

#include<stdio.h> #include<stdlib.h> #include<malloc.h>  typedef int SElemType;  typedef struct node {     int  data;     struct node *next; }linklist;  linklist *head;  #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10  typedef struct  {     SElemType       *base;     SElemType       *top;     int     stacksize; } SeqStack;  SeqStack *S;  linklist *creatlist() {     linklist *p,*q;     int n=0;      q = p = (struct node *)malloc(sizeof(linklist));     head = p;     p->next = NULL;     p = (struct node *)malloc(sizeof(linklist));     scanf("%d", &p->data);     while(p->data!=-1)     {         n = n+1;         q->next = p;         q = p;         p = (struct node *)malloc(sizeof(linklist));         scanf("%d", &p->data);     }     q->next = NULL;      return(head); }  void print(linklist *head) {     linklist *p;      p = head->next;     if(p==NULL)  {         printf("this is an empty list.\n");         return;     }         do {             printf("%6d",p->data);             p = p->next;         }while(p);          printf("\n"); }   int InitStack(SeqStack **S ) {     *S = (SeqStack *)malloc(sizeof(SeqStack));     if (!(*S))         return 0;      (*S)->base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));     if ((*S)->base == NULL)         return 0;     (*S)->top = (*S)->base;     (*S)->stacksize = STACK_INIT_SIZE;      return 1; }  int push(SeqStack *S,SElemType e) {     if(S->top - S->base >= S->stacksize)     {         S->base = (SElemType *)realloc(S->base,                 (S->stacksize + STACKINCREMENT)*sizeof   (SElemType));         if (!S->base )             return 0;         S->top = S->base + S->stacksize;         S->stacksize += STACKINCREMENT;     }      *(S->top++) = e;      return 1; }    int Pop (SeqStack *S ) {      if(S->top == S->base)         return 0;      S->top--;     return  *S->top ; }   int stackempty(SeqStack *S) {     if (S->top == S->base)         return 1;     else return 0; }    linklist *backlinklist(linklist *head) {     linklist *p;     p = head->next;     InitStack (&S);      while(p)     {         if( push(S, p->data));         p = p->next;     }     p = head->next;      while(!stackempty(S))     {          p->data = Pop(S);         p = p->next;     }     return(head); }  int main() {     linklist *head;     head=creatlist();     print(head);     head = backlinklist(head);     print(head);      return 0; }  参考一下吧


Question: 求树的高度/深度（非二叉树）

大佬能给个解答啊   刚刚也遇到这个问题了

和二叉树区别不大。就是从2变成了x（0<x<某个正整数》）

算了，我弄出来了

m度树 求树高应该怎么编写啊


Question: 关于一道数组循环问题，求大神帮帮忙看看.

引用 6 楼 cfjtaishan 的回复:#include <stdio.h>  int main(int argc, char **argv) {     int n;     int m;     int flag;      scanf("%d",&n);     int num1[n];     for(int i=0;i<n;i++){         scanf("%d", &num1[i]);     }      scanf("%d",&m);     int num2[m];     for(int i=0;i<m;i++){         scanf("%d",&num2[i]);     }      for(int i=0;i<n;i++) {         flag=0;         for(int j=0;j<m;j++){             if(num1[i]==num2[j]){                 flag = 1;                 break;              }         }         for(int k=0;k<i;k++){             if(num1[k]==num1[i]){                 flag=1;                 break;             }         }         if(flag==0){             printf("%d  ",num1[i]);         }       }      printf("\n");      for(int i=0;i<m;i++){         flag=0;         for(int j=0;j<n;j++){             if(num1[j]==num2[i]){                 flag=1;                 break;             }         }         for(int k=0; k<i;k++){             if(num2[k]==num2[i]){                 flag=1;                 break;             }         }         if(flag==0){             printf("%d  ",num2[i]);         }     } }  不过，建议把n作为循环变量的地方改成k，这样可能会更好理解一些，不然代码看着不易理解。 改成k之后，测试过，能得到预期的结果。 ------------------------------------------------------------------------------------------------- 不好意思啊，我刚用dev++，运行无异常，所以我结贴了。。。。 突然间一分钟后你回复了，不然我就给你分了.  不好意思了 大神

编译就有问题吧 你代码问题在for循环里面的局部变量混乱不清 29/52行都有问题，你的n已经用作数组长度，为什么还拿来做循环递增的变量？

引用 3 楼 qq_36790578 的回复:int num[n]; 怎么编译通过的 c99以后数组定义都可以用变量定义长度

int num[n]; 怎么编译通过的

把 n  m 都改为4， i 去掉重复初始化，  运行输出就是   5 7 2 3  逻辑好像没 问题

第8\24行能编译过么


Question: 关于求解一个递归函数的时间复杂度的问题

算时间复杂度是可以作简化的，题目没要求求Tn的值

T(n) = n + T(n-1) / 2，将n和/2都看成是常量

递归次数是n次，没毛病


Question: C语言网--进制转换（C）

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

也有其他的方案，只不过这个更简单而已。这是很久之前写的了，因为最近带新生才想起来发。

简单，但不一定高效。

printf/scanf是格式话输出和输入函数。既然可以格式化操作，那么就可以按照格式输出不同的数据

没毛病啊，简单高效

没毛病，printf格式化可以搞定

可以啊，可是一些特殊的进制是没有格式符的，而写成进制转换的通用代码是无所谓什么进制的

本身就可以输出啊。


Question: 哇 智障儿童求教

#include <stdio.h> #include <stdlib.h> #include <time.h> #include <conio.h>  #define NUMBER_COUNT 2  int main() { 	int   numbers[NUMBER_COUNT]; 	int   i, value, input; 	char  key = '\0'; 	char* opt = "+-*/"; 	printf("请输入相应数字选择运算方式(ESC退出)：\n1.加法运算\n2.减法运算\n3.乘法运算\n4.除法运算\n"); 	while ((key = _getch()) != 0x1b) //0x1b: ESC  	{ 		srand(time(NULL)); 		for(i = 0; i < NUMBER_COUNT; i++) 			numbers[i] = rand() % 100 + 1; 		switch (key) 		{ 		case '1': 			value = numbers[0] + numbers[1]; 			break; 		case '2': 			value = numbers[0] - numbers[1]; 			break; 		case '3': 			value = numbers[0] * numbers[1]; 			break; 		case '4': 			value = numbers[0] / numbers[1]; 			break; 		default: 			continue; 		} 		printf("\n%d%c%d\n请输入结果：\n", numbers[0],opt[key - '1'],numbers[1]); 		scanf_s("%d",&input); 		fflush(stdin); 		printf("%s", value == input ? "你很棒！\n" : "有点遗憾，继续加油！\n"); 		printf("\n请再次选择运算方式(ESC退出)：\n"); 	} 	system("pause"); 	return 0; }

单步调试很重要，能直观看到问题所在

写好代码就好了，对自己要有自信。 其实你的代码没多大问题，就需要对编程一些细节或者说是编程的陷阱也要多了解一些。这样能让我们更好的运用编好程序。

#include<stdio.h> #include<stdlib.h> #include<time.h>  int main() {     int n1, n2, answer, input,flag1;     char flag, c;     flag = 'y';      printf("请输入相应数字选择运算方式：\n1.加法运算\n2.减法运算\n3.乘法运算\n4.除法运算\n我的选择是：");     while (flag != 'N')     {         flag1 = 1;         if (flag == 'y' || flag == 'Y')         {             printf("请再次选择运算方式：\n");         }         srand(time(NULL));         n1 = rand() % 100 + 1;         n2 = rand() % 100 + 1;         scanf_s("%d",&c);         switch (c)         {             case 1:{                        answer = n1 + n2;                        c = '+';                        break;                    }             case 2:    {                            answer = n1 - n2;                            c = '-';                            break;                        }             case 3:    {                            answer = n1 * n2;                            c = '*';                            break;                        }             case 4:    {                            answer = n1 / n2;                            c = '/';                            break;                        }             default:{                         printf("输入有误！\n");                         flag1 = 0;                     }         }          if (flag1) {             printf("%d%c%d\n请输入结果：\n",n1,c,n2);             scanf_s("%d",&input);             if (input == answer)                 printf("你很棒！\n");             else                 printf("有点遗憾，继续加油！\n");         }         printf("继续游戏输入Y，退出输入N\n");         //scanf_s("%c",&flag);         getchar();    //for '\n'         flag = getchar();     }     system("pause");     return 0; } 参考一下吧  解决你的方法就是再加一个getchar();这个操作是为了“吸收”残留在输入缓冲区里的'\n'换行符。 建议flag判断'y'， 'Y'，详见上面的代码

scanf_s("%d",&c); 你这个输入能输出case 里面的内容 而不是“输入有误”才奇怪 c是char   应该会转为ascii输出

1. 没有处理回车字符 2. flag1始终为1，没有清零

做题前嘲笑题目智障 结果像狗屎求教大佬鸭


Question: 嵌入式C，char*字符串组合的问题

引用 3 楼 英雄@末路 的回复:可能的错误多了 temp没分空间 temp没有记录首地址 temp是函数里临时变量，从函数返回就没了 。。。。 没代码不好猜  最后的结果是没有分配空间。 是我对堆栈的理解还不太到位。

提问题 也至少把需要的都贴出来   你的char* 有没有\0 都不一定

你是不是返回的是temp呢，这只是函数体，建议将整个函数贴出来。如果输出不出来，应该是返回的地址不对

我也怀疑直接返回temp，要知道temp++后指针（地址）会增加，temp已经不是字符串的首地址了


Question: snmpagent

有一套net-snmp的代碼應該可以做到的

网上有snmp源码，建议找一下～


Question: 菜鸟问题？？？

为什么等于12？说一下具体的过程

引用 7 楼 ZiYang1024 的回复:为什么等于12？说一下具体的过程    把这段代码放到编译运行，就能看到答案了。。。

引用 8 楼 cfjtaishan 的回复:#include <stdio.h> #include <stdlib.h>  int *p; void P(int *x) {     int m,n,t;     printf(" ");     scanf("%d%d",&m,&n);      t=*(x+m);     *(x+m)=*(x+n);     *(x+n)=t;  } void R(int *x,int y) {     for(int i=0;i<y/2;i++)         *(x+i)=*(x-y-i);  }  void D(int *x,int y) {     int t;     printf(" ");     scanf("%d",&t);     for(int i=0;i<y;i++)         *(x+i)=*(x+i)/t; }  void M(int *x,int y) {     int t;     printf(" ");     scanf("%d",&t);     for(int i=0;i<y;i++)         *(x+i)=*(x+i)*t; }  void S(int *x,int y) {     int t;     printf(" ");     scanf("%d",&t);     for(int i=0;i<y;i++)         *(x+i)=*(x+i)+t; }  void caozuo(int *x,int y) {     char a;     scanf("%c",&a);     switch(a)     {         case 'S':S(x,y);break;         case 'M':M(x,y);break;         case 'D':D(x,y);break;         case 'R':R(x,y);break;         case 'P':P(x);break;     }  }   int main() {     int n,m;     scanf("%d%d",&n,&m);     printf("\n");      p = (int *)malloc(sizeof(int) * n);     if (!p)         return -1;     for(int i=0;i<n;i++)         scanf("%d",p+n);     getchar();     printf("\n");     for(int j=0;j<m;j++)         caozuo(p,n);     for(int l=0;l<n;l++)         printf("%d ", *(p+l));       free(p);      return 0; }   参考一下吧 使用NULL指针导致的段错误 抱歉发错了

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

这里面i干什么了？没用了吧~~

等差数列算一下就好了，忽略循环里的打印

建议自己试一下，编程不是只靠看而不靠动手的


Question: c#冒泡程序用了个类怎么return整个数组哇，谁能救救我55555555

public int[] maopao(int[] arr)     {         for (int i = 0; i < arr.Length - 1; i++)         {             if (arr[i] > arr[i + 1])             {                 int k = arr[i];                 arr[i] = arr[i + 1];                 arr[i + 1] = k; ///这里还差个return数组              }         } return arr; }

像第一个类函数定义那样，如果是new的数组，是可以通过返回数组首地址（其实就是指针）； 返回数组就是返回数组名，因为数组名就是数组的首地址

c#不懂，到 .Net 分区里面的c# 论坛去问吧。

可以发到这里面 https://bbs.csdn.net/forums/CSharp

有这么多人找不到C#论坛么


Question: 数据结构中的关于*&的用法

指针引用。

http://www.cppblog.com/doing5552/archive/2010/09/28/127994.html 看下这个帖子, 你就明白了

中的*&L不就是等于L吗？  在定义变量的时候,  这个叫指针变量的引用SqList*&L 相当于 SqList **L   一般是用在函数内部会修改指针的情况下. 比如 void  CreateList( SqList** L) {      *l = new SqList; }  一般不建议这些指针与引用的混用,  有指针的地方, 最好全部用指针, 给后面填坑的兄弟少点障碍.

还没学到C++吧

*&是直接引用L，**是用指针间接引用L

这里的& 是引用的意思，并不是取地址的意思。引用是C++中专用的，可以去看一下。

建议看一下C++中的引用。这里是使用&引用。而不是C语言的&然后在SqList *强制类型转换一下。


Question: 关于循环问题.有一题没思路，求大神帮帮忙~~！！

由于数字全部为互质数，为了减少运算量，可以找出符合   11   7 【最大数】条件的数字32，每次累加77【为了减少运算量】。 然后整除 5 和 6 查看余数。 效率有一定优化，但不是最好的算法。

最笨的方法 就整除的问题

这个感觉挺简单，假设人数是n，n-1能被5整除，n-5能被6整除，n-4能被7整除，n-10内被11整除，找到这个数字就行了，这个数字肯定比10大，从11开始找，参考代码如下：  #include<stdio.h> void main() { 	int n=11;  	while(!((n-1)%5==0&&(n-5)%6==0&&(n-4)%7==0&&(n-10)%11==0)) 	{ 		n++; 	}  	printf("%d\n",n);    }

韩信，在点兵时，为了知道有多少兵，同时又能保住军事机密，便让士兵排队报数：      按从1至5报数，记下最末一个士兵报的数为1；      再按从1至6报数，记下最末一个士兵报的数为5；      再按1至7报数，记下最末一个士兵报的数为4；      最后按从1至11报数，最末一个士兵报的数为10； 5、6、7、11的最小公倍数是2310。 所以楼主写个循环，for (i=0;i<2310;++i) 如果i同时满足：除以5余1、除以6余5、除以7余4、除以11余10，那么i就是答案。  如果用数学方法求解，用n表示要求算的结果。 n/5余数是1，那么令n=5a+1(a以及后面用到的b、c、d都是非负整数) 从1至6报数，记下最末一个士兵报的数为5，也就是说n/6的余数是5，a=2、8、14、20... 令a=6b+2，并代入n，得到n=30b+11。 按1至7报数，记下最末一个士兵报的数为4；换言之n/7余数是4 n=30b+11=(28b+7)+(2b+4)。其中(28b+7)/7是不会有余数的，所以要保证n/7余数是4，就必须保证(2b+4)/7余数是4 b=0、7、14、21...，所以令b=7c，并代入n，得到n=210c+11。 “最后按从1至11报数，最末一个士兵报的数为10”，也就是说n/11余数是10。 n=210c+11=(209c+11)+c。其中(209c+11)/11不会有余数，所以要保证n/11余10，就必须保证c/11余10。 c=10、21、32、43...所以记c=11d+10。并代入n，得到n=2310d+2111。 所以韩信至少有2111名士兵。

引用 3 楼 ckc的回复:笨办法。 1到11报数，最后一个是10，那么这个数除11余数是10 设置一个循环，从10开始，每次加11， 判断除5是不是余1 判断除6是不是余5 判断除7是不是余4 如果全部都符合，就是答案 不过这个问题数学上有更好的解法 请问还有什么更好的解答，求告诉

这个其实是数学思想，没有数学思想，很难转化成编程语言 从之前楼主三天打鱼两天晒网的问题看，楼主对这类模的问题没啥思路，建议可以从找规律搞起

请参考：中国剩余定理 额外参考：《射雕英雄传》郭靖背着黄蓉去找南僧求医遇阻

从数学上解决这个题应该不难，先从数学上把这个题解决了，然后你的思路就来了，把数学上的解决方法再移植到C++/C

#include<iostream> #define SIZE 1000000 using namespace std; int main(void) {     int soldier_num;     for(soldier_num=21;soldier_num<SIZE;soldier_num++)     {         if(soldier_num%5==1&&soldier_num%6==5&&soldier_num%7==4&&soldier_num%11==10)         {             cout<<"the number of the soldier is:"<<soldier_num;             break;         }     } }

效率高，要从数学角度考虑： 由第一个条件可知，该数个位只能是1或者6，第二三条件可以排除6，从第四条件可知该数能表达为11n+10的形式，又因个位数必须是1，所以这个n只能是1、11、21... 所以：  #include <stdio.h>  int main() {   for (int i = 1, j; (j = 11 * i + 10); i += 10)     if (j % 5 == 1 && j % 6 == 5 && j % 7 == 4 && j % 11 == 10)       {printf("%d\n", j); break;}    return 0; }   只需要测试19个数就能得出答案，而不需要测试200多或者2000多个数。

引用 3 楼 ckc 的回复:笨办法。 1到11报数，最后一个是10，那么这个数除11余数是10 设置一个循环，从10开始，每次加11， 判断除5是不是余1 判断除6是不是余5 判断除7是不是余4 如果全部都符合，就是答案 不过这个问题数学上有更好的解法 这个好，比++效率高多了。

直接弄个循环，上限1000000，挨个除，设置条件都满足时跳出，条件为对5取余为1，且 对6取余为5....   简单粗暴。

n = 10; while(1） {     if(n%5==1 && n %6 == 5 && n %7 == 4 %% n % 11 = 10)       break;     n++ } printf("%d\r\n",n);  求一个最小的出来就行了，这个如果数大小没限制，应该不止一个答案


Question: 关于HDMI。

你是要找跟这个类似的吗？ https://github.com/Digilent/Nexys-Video-HDMI  https://reference.digilentinc.com/learn/programmable-logic/tutorials/nexys-video-hdmi-demo/start

这个去阅读hdmi 文档比较好点

要建立连接，遵从J具体版本HDMI协议，与网络不太一样。 具体查HDMI吧，这可不是一两句说的清的。


Question: algraph agraph graph有什么区别呢

图的存储结构不一样，如ALGraph是表示图以领接表方式存储。

VS IDE中，在不明白的符号上点鼠标右键，选转到定义。

建议用一下，试一下看看结果是怎样的


Question: c\c++读取二进制文件，出现行数错误，求解！

仔细看二进制。。0a，表示换行。。fgets读到这里，相当于一行结束了。。后面的000000，都是补上去的。  然后下一行以 1c开始了。

不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了

引用 2 楼 Forward__J 的回复:[quote=引用 1 楼 sinat_37764097 的回复:] 代码问题，不用想了。  那为什么前18行正常，甚至18行到1c之前也是正常的，而1c就输出到了下一行，原1c位置自动补零？请问这个哪方面有问题呢？[/quote] 你得贴代码啊

引用 5 楼 hjwang77 的回复:二进制文件读取，用fread挺好的，为什么换成fgets，是不是换成fgets之后出现问题的？ fgets是按行读取，由于判断换行符问题，不知道在读你这个文件时候会有啥问题。  谢谢大佬，是真的fgets问题，用fread就没问题了，非常感谢！

引用 3 楼 hjwang77 的回复:你上面的需求不是在某处断开，自动补零的么？ “然后在某行某处出现断开，断开外置自动补零”  这难道不是你代码的需求？如果不是的话，把read/write那几句贴出来看看吧，是不是缓冲分配有问题   我的需求是从bat文件里按每行读取16进制的数据，bat文件里用UE打开是每行16个16进制的数，文件读取的代码如下

引用 1 楼 sinat_37764097 的回复:代码问题，不用想了。  那为什么前18行正常，甚至18行到1c之前也是正常的，而1c就输出到了下一行，原1c位置自动补零？请问这个哪方面有问题呢？

代码问题，不用想了。


Question: c语言问题求助

楼主自问自答，666666

问题解决，是杀毒软件问题……

printf( "%s\n", string ); 这样也可以显示结果。


会C后，再学会Matlab还不是洒洒水嘛。

这不是C语言

arri=[]; for i=1:len     subplot(len,1,i);     arri(i)=esmd.yImfsR.get(i-1);     plot(t, arri(i));     %xlabel('t');     if i==1         ylabel('Y');     elseif i==len         ylabel('R');     else         ylabel(strcat('Imf',num2str(i-1)));     end end for i=1:len     fprintf('arri(i:%d):%f\n',i,arri(i)) end


Question: 学习C语言碰到了一个问题

考虑实际你的逻辑问题是，else是无条件执行一次的，理论上，你什么都不输入都会输出。

你的回车被读取了，所以计算机以为你输入了两个字符

我的IDE没问题

大概是你自己不小心加了个空格?

估计你可能是不小心碰到空格了，我在2015里是没有问题的，运行并正确输出结果，建议你多试几次，确认下是不是真的有问题。

引用 2 楼 qq_17755271 的回复:我用VS2017就这样显示，我用我同学VC6.0可以正常显示，怎么回事啊 我也加上conio.h了 不显示在控制台，这个重点，你之前已经录入一个空格了，只不过控制台没显示 不过你的那个1怎么显示出来的

getch():  所在头文件:conio.h  函数用途:从控制台读取一个字符，但不显示在屏幕上  函数原型:int getch(void)


Question: c语言数组

size of是计算长度的

a,b是数组名，使用scanf时不用加&, 因为在C语言中数组名就代表该数组的起始地址。代码如下 scanf("%s",a); scanf("%s",b); 另外a，b，store的定义需要初始化0。

数组最后一个元素之后要再加一个元素设为‘\0’，就是a[strlen(a)+1]='\0'

记得使用\0结束符

你应该养成一个好习惯，声明变量的时候同时初始化。strlen（）是用来结算字符个数的，从第一个地址开始往后计数，遇到0('\0',NULL)结束结束。

a,b, store没有初始化，里面存随机数字 ，存字符串时候如果不是0（\0），会对你的字符串判断有影响。 用for循环上来先都初始化成0在用。

应该是缺少'\0'导致的。在拷贝字符串时，注意一下字符串的结束标记'\0'

记得使用\0结束符

strlen不是用来计算数组长度的。


Question: 计算YUV图像的PSNR遇到的编译问题

memcpy(src1, hfile1, HAN_SOURCEDATA_Y + HAN_SOURCEDATA_UV); memcpy(src2, hfile2, HAN_DSTDATA_Y + HAN_DSTDATA_UV);  拿文件句柄做内存拷贝？ 这里是不是有啥误解啊，呵呵。


Question: GDB无法调试

能通过啊。。

我按你们说的做了，还是没用 在使用run命令时，会跳出这些错误。 [New Thread 21252.0x1930] warning: Can not parse XML library list; XML support was disabled at compile time  [New Thread 21252.0x3790] asdffdsfgdb: unknown target exception 0x4000001f at 0x401490  Thread 1 received signal ?, Unknown signal. 0x0009df88 in ?? () 我设置了断点 接下来都不可以查看变量的值

gcc helloworld.c  -o hellowrold -g3  gdb hellowrld.exe  //-g3 写入Debug信息 //.exe可选

需要编译生成可执行文件，而不是.o文件  gdb +可执行文件

不行


Question: 共享内存映射到进程空间的什么位置？

VMMap不是已经显示出了每块内存是否是Shareable了吗？

还没有得到满意的答复

引用 6 楼 bandaoyu 的回复:引用 5 楼 zhao4zhong1 的回复:理解和讨论之前请先学会如何观察！哎 还是不太明白 要是能做你的小弟就好了 可以整天围着你学习 在这里天天发帖求助也可以。

理解和讨论之前请先学会如何观察！

引用 1 楼 zhao4zhong1 的回复:VMMap 是进程虚拟和物理内存分析实用工具。http://technet.microsoft.com/zh-cn/sysinternals/dd535533呃 看不懂耶 老大

共享内存不是进程内的地址空间，而是进程外的。  https://blog.csdn.net/skyroben/article/details/72625028


Question: 请教C语言问题

感谢以上大佬不吝赐教，谢谢大家！ 我排序出错了，还望看到此贴的新手引以为戒。

引用 5 楼 weixin_38885956 的回复:虽然这种问题属于最优解问题，但就这题而言直接比较单价也是可行的。 你在降序的时候犯了个小错误，你没加循环。。。。。  for(int i = 0; i < n; i++) 	    if(cake[i].price<cake[i+1].price){//降序排列  	        temp = cake[i].price; 	        cake[i].price = cake[i+1].price; 	        cake[i+1].price = temp; 	         	        temp = cake[i].sell; 	        cake[i].sell = cake[i+1].sell; 	        cake[i+1].sell = temp; 	         	        temp = cake[i].store; 	        cake[i].store = cake[i+1].store; 	        cake[i+1].store = temp; 	    }   一层循环能做到降序？我记得需要2层循环吧

#include<stdio.h>  struct mooncake {     double store;     double sell;     double price; }cake[1010];  int main() {     int n;//月饼种类     int i, j;     double D;//市场最大需求量      scanf("%d%lf",&n,&D);     for(i = 0;i < n;i++){         scanf("%lf", &cake[i].store);//某种月饼库存量     }     for(i = 0;i <n;i++){         scanf("%lf",&cake[i].sell);//某种月饼总售价         cake[i].price = cake[i].sell/cake[i].store;//单价     }     struct mooncake  temp;     for (j = 0; j < n; j++)         for (i = 0; i < n - j - 1; i++)             if (cake[i].price < cake[i+1].price){//降序排列                 temp = cake[i];                 cake[i] = cake[i+1];                 cake[i+1] = temp;             }     double ans = 0;     for(i = 0;i<n;i++){         if(cake[i].store<=D){             D-=cake[i].store;             ans+=cake[i].sell;         }         else{             ans+=cake[i].price*D;             break;         }     }     printf("%.2f\n",ans);     return 0; }  参考一下吧  排序是有问题的

引用 3 楼 yz_555 的回复:我理解的题目的意思是：将(最大需求量)分成(月饼种类)的份数有多少种分法，并取出其中最赚钱的一种。你的代码里好像没有对价格排序的部分，最后的结果是怎么得出来的？ 额。抱歉，我理解错了，只要尽量把最值钱的月饼卖出去就能得到最优解。

//降序排列 排序没成功

我的运行结果是错的


Question: 0x010C1AD8 处有未经处理的异常(在 Project1.exe 中):  0xC0000005:  读取位置 0xCDCDCDCD 时发生访问冲突

int main() {     int i, j;     double data[4][4] =     { { 1, 2, 3, 4, },         { 2, 1, 4, 5, },         { 5, 4, 3, 5, },         { 7, 6, 5, 4 } };     //double ** p = new double *[100];     double **p = (double **)malloc(sizeof(double *) * 4);     for (i = 0; i < 4; i++)         p[i] = (double *)malloc(sizeof(double));     matrix_inv(p, 4);     for (i = 0; i < 4; i++)     {         for (j = 0; j < 4; j++)         {             printf("p[i][j]\r");         }         printf("\n");     }      system("pause");     return 0; } 参考一下吧。  主要是你申请的p也是申请了100个指针，而这些指针还都是野指针。并没有给这些指针申请指定的空间

运行捕捉异常，看断在哪句上。

0xCDCDCDCD  debug模式。野指针。也可以说空指针，指针没有初始化为空。

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

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


Question: 懵了，我一直以来feof的用法错了？

feof判断文件结束是通过读取函数fread/fscanf等返回错误来识别的，故而判断文件是否结束应该是在读取函数之后进行判断。


Question: 有一道c语言题目，想请教一下如何做

B101 = 5 n 从3 到20（小于3不用考虑）， 系数就是(5<<0), (5<<1),,, （5 <<(n-3)） 然后逐个去位与，结果不为0就+1，看最后个数呗

递归来做比较方便，分为末两位是00/01/11/10四种来计算

確實如此，多謝指正！ 引用 4 楼 user-4 的回复:[quote=引用 2 楼 hzy_76 的回复:] 仔細思考其實這些字符串是什麽？就是位數為n的所有二進制數的集合！ 所以答案就出來了：循環計算2的0次方到n次方，然後轉換成二進制數，再轉換成字符串。 生成每一個字符串時，去判斷其中有沒有101子串，有則剔除，這個思路最直接了。 循环计算的应该是0到[(2^n)-1]吧，需要考虑全0或全1。[/quote]

引用 2 楼 hzy_76 的回复:仔細思考其實這些字符串是什麽？就是位數為n的所有二進制數的集合！ 所以答案就出來了：循環計算2的0次方到n次方，然後轉換成二進制數，再轉換成字符串。 生成每一個字符串時，去判斷其中有沒有101子串，有則剔除，這個思路最直接了。 循环计算的应该是0到[(2^n)-1]吧，需要考虑全0或全1。


Question: 求大佬指点，一个二叉树删除所有叶结点算法如下:

理解对象这个概念，C语言中的树形结构在C++中会变得非常简单，简单到你可能无法想象。

这个函数的目的就是删除整棵树，不是删一个节点。 删除时候不考虑前后序，必然先叶子后根，不然就丢了

这好像是前序遍历吧，你得先判断这个节点是否为空，是否含有子节点，没有的话 就删除，他是在没有左右节点的情况下被删除，所以他的优先级是最高的，其次是进左子节点，然后是右子节点，不过好像也不是很严谨。


Question: 遇到一个不会的题目

已经想明白了！


Question: C语言数组问题

右边本来就是地址，你初始化的数组的指针，他一定是地址喽！

引用在初始化时，是运算

引用 2 楼 qq_41297918 的回复:数组名在做运算或者是传递参数时， 会自动退化为指针，这也是为什么传数组首地址时，可以直接用数组名的原因  按照你的解释，好像能解释通。引用并不属于运算

p 这里是数组名，sizeof(p)出来的是20， 而不是4 你说的p是数组的首地址，这个只是在做赋值或运算时，由数组名退化为地址， int *q = p; int *q = p + 1; 这样的，这时你 sizeof(q) 就是4


Question: RPC远程调用和C/S的区别

我一直也不懂。rpc远程call 远程函数干嘛。

引用 1 楼 hzy_76 的回复:我的理解，其實RPC就是一種C/S。 通常C/S框架都不會自己編寫，因爲一個優秀的C/S框架要處理很多事情，比如中斷重連，比如重複請求，雙向的信息交換等等，編寫出這麽一套C/S架構所耗費的可能遠高於業務系統，而大多數公司只是想做一套業務系統而已。


Question: notepad++和MinGW配置C编译环境，notepad++插件nppexce配置时老是是出错，显示找不到目录，请问这个怎么解决

不要把文件放在复杂的路径下，做好放在根目录下，桌面是最不应该的

你可以参考下面这篇博文，讲的还是很详细的，有问题再一起交流https://blog.csdn.net/qq_37113207/article/details/56956682


Question: 关于看图像压缩的时候遇到的一个问题

也就是图像处理一般分块，宏块之类的原因。

引用 2 楼 hjwang77 的回复:图像相关性，即相邻的像素点之间有一定的相关性。 比如一个像素点作为计算单元，那他的比重就是100%，也就算一下完事 两个像素的时候，第一个像素除了他本身，还要考虑另外一个像素的因子（比如自己占90%，另外一个占了10%，总共是100%），那他的计算就是 A = a*0.9+ b*0.1, B = a*0.1+b*0.9，需要四次运算（因子根据算法不同而不同）。 以此类推（因子随便定义啦,一般是2的n次幂分支几，好运算）：A = a*0.8+b*0.1+c*0.05+d* 0.05 , B = ....  差不多这个意思吧。  谢谢！

是通过什么原理


Question: 好诡异，void*指针强转后发生诡异偏移

那这个问题无非是踩内存导致的，建议gdb watch看下哪里被串改了 引用 6 楼 mumufan05 的回复:[quote=引用 4 楼 colinfang2006 的回复:] 你是说类型转换后是对的？但是到调用函数内部了就有问题？  [quote=引用 3 楼 mumufan05 的回复:] [quote=引用 2 楼 colinfang2006 的回复:] 你贴的代码不会有这个问题，我怀疑会不会是代码和运行的程序不匹配？ 或者你可以从便宜0x50=80字节来入手，结构体大小是不是刚好是80字节 并加一些调试打印，最好是刚刚转换类型后就打印两个指针的值 这两个方法我都试过了，结构体大于80个字节，前后加printf，打印的数据没问题，但实际调用的数据还是不对，所以说很诡异，而且目前只在一台机器上有这个问题，其他机器都没事，怀疑是硬件问题，但具体怎么回事想不明白[/quote][/quote] 不是，用printf打印是对的，但用gdb看就是错的[/quote]

需要重新构建项目

学会使用数据断点。

把所有的obj文件删除，全部重新编译一次看看 makefile写的不好有时候会有这个问题

建议看一下反汇编。

引用 4 楼 colinfang2006 的回复:你是说类型转换后是对的？但是到调用函数内部了就有问题？  [quote=引用 3 楼 mumufan05 的回复:] [quote=引用 2 楼 colinfang2006 的回复:] 你贴的代码不会有这个问题，我怀疑会不会是代码和运行的程序不匹配？ 或者你可以从便宜0x50=80字节来入手，结构体大小是不是刚好是80字节 并加一些调试打印，最好是刚刚转换类型后就打印两个指针的值 这两个方法我都试过了，结构体大于80个字节，前后加printf，打印的数据没问题，但实际调用的数据还是不对，所以说很诡异，而且目前只在一台机器上有这个问题，其他机器都没事，怀疑是硬件问题，但具体怎么回事想不明白[/quote][/quote] 不是，用printf打印是对的，但用gdb看就是错的

确实诡异呀，同求答案。

用printf打印是对的，但用gdb看就是错的 你相信哪个是对的？

我感觉你你的函数破坏了堆栈的原因。 你尝试不要调用里面的函数，直接检测试试看。 或者把断点设置在进入 EvoSdtpFieldsGetBCD 函数之前。

引用 2 楼 colinfang2006 的回复:你贴的代码不会有这个问题，我怀疑会不会是代码和运行的程序不匹配？ 或者你可以从便宜0x50=80字节来入手，结构体大小是不是刚好是80字节 并加一些调试打印，最好是刚刚转换类型后就打印两个指针的值 这两个方法我都试过了，结构体大于80个字节，前后加printf，打印的数据没问题，但实际调用的数据还是不对，所以说很诡异，而且目前只在一台机器上有这个问题，其他机器都没事，怀疑是硬件问题，但具体怎么回事想不明白

你是说类型转换后是对的？但是到调用函数内部了就有问题？  引用 3 楼 mumufan05 的回复:[quote=引用 2 楼 colinfang2006 的回复:] 你贴的代码不会有这个问题，我怀疑会不会是代码和运行的程序不匹配？ 或者你可以从便宜0x50=80字节来入手，结构体大小是不是刚好是80字节 并加一些调试打印，最好是刚刚转换类型后就打印两个指针的值 这两个方法我都试过了，结构体大于80个字节，前后加printf，打印的数据没问题，但实际调用的数据还是不对，所以说很诡异，而且目前只在一台机器上有这个问题，其他机器都没事，怀疑是硬件问题，但具体怎么回事想不明白[/quote]

道行太浅，还真没看出什么毛病。