Question: 为什么运行正确但是oj平台不给过嘞！！？？

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

整数的范围没有规定，建议用数组存

#include<stdio.h> #include <stdlib.h> #include<math.h>  const char *digits[] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve"};  int main() {     int n, t, cnt;     int i;     int digit_list[12];      while(scanf("%d",&n)!=EOF)     {         if(n < 0)             t = abs(n);         else             t = n;          if (n == 0) {             printf("0 has %s number, is 0\n", digits[n+1]);             continue;         }          cnt = 0;         while (t) {             digit_list[cnt++] = t % 10;             t /= 10;         }          i = 0;         printf("%d has %s %s ", n, digits[cnt], cnt > 1 ? "numbers, are":"number, is");         while (i < cnt - 1) {             printf("%d,", digit_list[i]);             i++;         }         printf("%d\n", digit_list[i]);         /*         count = 0;         while(t)         {             t/=10;             count++;         }         printf("%d have %d numbers,are ",n,count);          for(i=0;i<count;i++)         {             a=n1%10;             n1=n1/10;             if(i<count-1)                 printf("%d,",a);             if(i==count-1)                 printf("%d\n",a);         }         */     }      return 0; } 参考一下吧

引用 2 楼 mxway 的回复:输入测试用例如下： 99999999999999999999999999999999999999999999999999999999999999 0123456 看下你的结果还对不？ 012345这个不是个整数吧·······还有这个巨大的999··怎么处理啊请问！··

引用 1 楼 hdt 的回复:是one不是1 那这个咋处理呢，总不能列举吧·····


Question: C++错误问题  新手问题

引用 4 楼 a875052544 的回复:再补充一下 我是想做一个寻找最大节点的程序的#include <iostream>  using namespace std; struct linklist {     linklist(): shuju(0), next(0) {}     int shuju;     linklist *next; };  void creating(linklist*& p_linklist, int count)//创建链表 {     linklist *p_head = 0;     linklist *p_current = 0;     int data = 0;     for(int i = 0; i < count; i++)     {         printf("请输入你的数据：");         scanf("%d",&data);         linklist * tmp = new linklist();         tmp->shuju = data;         tmp->next = 0;         if (!p_head)         {             p_head = tmp;             p_current = p_head;         }         else         {             p_current->next = tmp;             p_current = tmp;         }     }     p_linklist = p_head; }  int main() {     int count;     printf("请输入你想要输入的数字数目:\n");     scanf("%d",&count);      linklist* p_linklist = 0 ;     creating (p_linklist, count);      linklist* p_max = p_linklist;     linklist* p_comp = p_linklist->next;     while (p_comp)     {         if (p_max->shuju < p_comp->shuju)             p_max = p_comp;         p_comp = p_comp->next;     }      printf("最大的数：%d\r\n", p_max->shuju);     return 0; }  随便改了一下，你凑合用吧

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

#include <iostream> #include <cstdio> #include <cstdlib>  using namespace std;  struct linklist {     int data;     linklist *next; };   void creating(linklist *&phead,int b)//创建链表 {     int i;     linklist*p;     phead = (linklist*)malloc(sizeof(struct linklist));     phead->next=NULL;      for(i = 0;i <= b; i++)     {         p = (linklist*)malloc(sizeof(struct linklist));         scanf("%d", &p->data);         p->next = phead->next;         phead->next = p;     } }  static void visit_link(linklist *phead) {     linklist *pcur = phead->next;      while (pcur) {         printf("%d ", pcur->data);         pcur = pcur->next;     }     putchar(10); }   int main() {     int result,d,i, max;     printf("请输入你想要输入的数字数目:\n");     scanf("%d", &d);     printf("请输入你的数据：");     linklist*q;     creating(q,d);     visit_link(q);      linklist*z;//用来暂时代替q     z = q->next;     max = z->data;      while (z) {         if (max < z->data)             max = z->data;         z = z->next;     }     /*     for(i=0;i<=d;i++)     {         if(max<z->data)         {z++;             max=z->data;}     }     */     printf("最大的数：%d\n", max);      return 0; } 参考一下吧  问题比较多了，小问题： scanf("%d",d);    //少一个& 函数名不能有两个： void creating b(linklist*zhizheng,int b)//创建链表 还有，链表节点的字节数，为什么要申请1个字节呢？int类型的数据本身就需要4个字节（32位系统）； creating函数参数也有问题，建议使用引用&，因为不能返回头指针。  对比一下，找找自己的问题。

再补充一下 我是想做一个寻找最大节点的程序的

引用 2 楼 h553690677 的回复:还是不行 #include <iostream>  using namespace std; struct linklist {     int shuju;     linklist *next; };   void creating(linklist*zhizheng,int b)//创建链表 {     int i;     linklist*p;     zhizheng=(linklist*)malloc(1);     zhizheng->next=NULL;      for(i=0;i<=b;i++)     {         p=(linklist*)malloc(1);         scanf("%d",&p->shuju);         p->next=zhizheng->next;         zhizheng->next=p;     } }   int main() {     int result,d,i,max;     printf("请输入你想要输入的数字数目:\n");     scanf("%d",d);     printf("请输入你的数据：");     linklist*q;     creating (q,d);     linklist*z;//用来暂时代替q     z=q->next;     max=z->shuju;     for(i=0;i<=d;i++)     {         if(max<z->shuju)         {             z++;             max=z->shuju;         }     }     printf("最大的数：%d,max");     return 0; }   还是不行

说明一下 错误提示都是11行的


Question: 刚了解到栈 不知道咋做 有点懵

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

百度搜相关关键字。

大佬还是帮我写一个吧 我研究下

以下的定義要改成char型  int contents[STACK_SIZE];//定义数组用作栈  然後push和pop的相關參數也要改成char，其餘按提示做就好


Question: 键盘模拟程序不行

从哪里看出不行的，你这是实现“徽标”+E，是打开我的电脑，vc6+xp下测试通过

多谢，就是因为没关360

引用 5 楼 wenyuqilin 的回复:我的是WIN7，自己按windows+e可以实现打开的，但是这个程序就不行 关闭UAC、防火墙、杀毒软件、…… 重启电脑 ……

我的是WIN7，自己按windows+e可以实现打开的，但是这个程序就不行

void SendKey(char Key) {   keybd_event(Key, MapVirtualKey(Key, 0), KEYEVENTF_EXTENDEDKEY, 0);   keybd_event(Key, MapVirtualKey(Key, 0), KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0); }

百度搜“SendInput”


Question: 内核USB跑着跑着就挂了

http://blog.csdn.net/zhao4zhong1/article/details/53078924 老司机找bug的十年心路历程

两点小建议： 1. 增加问题复现场景描述 2. 检查硬件连接状态 3. 检查usb设备节点是否还存在


Question: c语言中 scanf的疑问

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

只要不是解引用、加减，不会有什么严重后果的。不过最好不要靠运气编程

引用 3 楼 a34140974 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 加上&的操作是有问题的。之所以编译没问题，是因为scanf("%s", 地址）；cChar和&nChar都是地址值，因此编译没问题。 但是运行就会有问题。因为&nChar和nChar还是有区别的。nChar是10个char空间的首地址。而&nChar是首地址的地址。 [/quote] 地址是一样的，但是类型不一样。nChar的类型和&nChar的类型不一样。&nChar的类型是char (*)[10];

引用 楼主 qq_36744540 的回复:求解！！！ char cChar[10]; scanf("%s",cChar); 这行能理解，数组名代表数组的首地址，可是为什么把上面第二行改成scanf("%s",&cChar);加个取地址符号编译也能通过；有哪位大神能知道这是为什么吗？cChar已经代表首地址了，再加个取地址符是怎么回事？谢谢各位  编译不会有错，运行也应该没问题，但是加不加&的对于cChar来说是不同的，就像1楼所说，cChar的类型是Char*，&cChar的类型是char (*)[10]

引用 1 楼 cfjtaishan 的回复:加上&的操作是有问题的。之所以编译没问题，是因为scanf("%s", 地址）；cChar和&nChar都是地址值，因此编译没问题。 但是运行就会有问题。因为&nChar和nChar还是有区别的。nChar是10个char空间的首地址。而&nChar是首地址的地址。

char a[10] = { 'a' }; printf("%d\n", a); printf("%d\n", &a); 输出是一样的。


Question: 一个C语言的题目...求解

写成fenzi*fmg==fenmu*fzs

实数不能用==判断

兄弟，为啥我感觉你这题目就错啊？我写出来啥也没有啊 #include <stdio.h> int main(void) {     int fenzi,fenmu,fzs,fzg,fms,fmg;     for(fenzi=10;fenzi<100;fenzi++)         for(fenmu=10;fenmu<100;fenmu++)         {             fzs = fenzi/10;             fzg = fenzi%10;             fms = fenmu/10;             fmg = fenmu%10; 			 			if((fmg==0)||(fenzi>=fenmu)) 				continue; 			if((fzg==fms)&&(fenzi/fenmu==fzs/fmg)&&(fenzi%fenmu==fzs%fmg)) 				printf("%d/%d\t",fenzi,fenmu);         }       return 0； }

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

fenzi/fenmu == fzs/fmg需要考虑是小数的部分，实数的判断相等不能直接比较。

引用 4 楼 wldrzx的回复:(fenzi/fenmu == fzs/fmg)转化一下  (float)fenzi/fenmu == (float)fzs/fmg 懂了，谢谢！！！精确度有问题！

在 if((fzg==fms) && (fenzi/fenmu == fzs/fmg))上面加if（fmg！=0） 而且你这个程序应该会有丶问题。精确度的问题。

引用 1 楼 user-6的回复:if((fzg==fms) && (fenzi/fenmu == fzs/fmg))这句话里面，需要判断fmg是否为0 加了个fmg!=0还是运行不出来


Question: 求助，程序编译通过，组建时报错，这是为什么

引用 1 楼 user-3 的回复:mian ?  想撞墙。。。。。犯这么低级的错误，老哥眼睛真毒，佩服啊

int mian(void)   改成：  int main(void)  注意拼写~

mian 修改为 main

mian ?


Question: 【求助】循环完成5局，使用break实现中途退出游戏

for ( i = 0; i < 5; i ++) {     if ( flag == 'n' )          break;   还有，你的第二个scanf里，%c前是不是多打了一个空格？

引用 2 楼 qq_29600891 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 可以直接在for循环外判断i是否为5，若为5则玩完5局，可能会晋级。再循环中判断grade的值，计算>=80分的次数，最后确定是否晋级。 那实现中间不选择玩下去，跳出循环怎么写？ [/quote] 判断一下不想玩下去的条件，然后Break出来就好了

引用 1 楼 cfjtaishan 的回复:可以直接在for循环外判断i是否为5，若为5则玩完5局，可能会晋级。再循环中判断grade的值，计算>=80分的次数，最后确定是否晋级。 那实现中间不选择玩下去，跳出循环怎么写？


Question: memset 报错， Bus error: 10

引用 10 楼 wllabs 的回复:[quote=引用 9 楼 zhao4zhong1 的回复:] 刚用VS2010亲测#8代码无错。  要用gcc啊。 还是不行，貌似真要malloc下。[/quote] gcc/g++或ld也应该有类似编译选项。

刚用VS2010亲测#8代码无错。

VC6下，亲调无错： #pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！ #include <stdio.h> #include <stdlib.h> #include <string.h>  struct _ts {     unsigned int a;     unsigned int b;     unsigned int c;     int d;     char *content; };  typedef struct _ts ts; typedef ts *tsptr;  int main(int argc, char *argv[]) {    ts t = {0, 0, 0, 0, NULL};    t.content = "this is str";    memset(t.content, 0, 6);    memset(&t.content[0], 0, 6);    printf("%s\n", t.content);    return 0; }

t.content = "this is str"  这里t.content指向的是字符串常量，修改字符串常量时出错

t.conent = (char*)malloc(sizeof(char)*strlen("this is str")+1) memset...

引用 2 楼 wllabs 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] memset(&t.content[0], 0, 6); 这句有问题。因为t.content是指向只读数据段的，因此不能修改。现在用memset要把"this is str"修改（修改为0），是会出现错误。  在这里  就报错了，我不明白，我memset都出错了。求解决办法。   memset(t.content, 0, 6); [/quote] 需要分析memset是做什么，它是将某个地址开始的内存空间赋值一个值，memset(t.content, 0, 6);就是将t.content开始的6个字节的内存空间赋值0.既然是赋值，那么肯定是修改了t.content开始6个字节的内存空间。但是t.content指向的内存空间是只读的，因此会出现错误。 解决办法是，t.content = NULL;

引用 3 楼 zhao4zhong1 的回复:#pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！   还是不行，程序还是报错。

引用 1 楼 cfjtaishan 的回复:memset(&t.content[0], 0, 6); 这句有问题。因为t.content是指向只读数据段的，因此不能修改。现在用memset要把"this is str"修改（修改为0），是会出现错误。  在这里  就报错了，我不明白，我memset都出错了。求解决办法。   memset(t.content, 0, 6);

引用 9 楼 zhao4zhong1 的回复:刚用VS2010亲测#8代码无错。  要用gcc啊。 还是不行，貌似真要malloc下。


FltReleaseContext();检查一下打开的设备是否关闭了

这个网站上难道没有问答论坛吗？

up  实在是小白，看了一些资料也没能解决。。

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


Question: 为什么在结构体中打印结构体的地址没有显示

不要企图依赖输出指针相关表达式...的值【比如printf("%p\n",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。

引用 2 楼 Cocoyejintianming 的回复:谢……谢谢哈我也才反应过来没少，我个傻子  能不能再问一下为什么char name[9]数组的字节数为什么不是9哇？37到40是怎么来的？  地址用的16进制表示， 0x40 = 64 ， 0x37 = 55.  0x40-0x37 = 64 -55 = 9;  没问题哈。

引用 9 楼 bj大白菜的回复:你前面几个printf打印的不是地址哦 啊咧?字符数组不是用数组名打印咩？

引用 7 楼 赵4老师的回复:[quote=引用 6 楼 Cocoyejintianming 的回复:] [quote=引用 5 楼 user-6的回复:]没少啊，我ide没问题 不好意思，我数错了[/quote] 谁都有瞬间脑子短路的时候。[/quote] Σ(ﾟ∀ﾟﾉ)ﾉ谢谢老师理解

引用 11 楼 Cocowangkeke的回复:[quote=引用 9 楼 bj大白菜的回复:]你前面几个printf打印的不是地址哦 啊咧?字符数组不是用数组名打印咩？[/quote] emmm我指的是打印地址

引用 6 楼 Cocoyejintianming 的回复:[quote=引用 5 楼 user-6的回复:]没少啊，我ide没问题 不好意思，我数错了[/quote] 谁都有瞬间脑子短路的时候。

你前面几个printf打印的不是地址哦

引用 2 楼 Cocoyejintianming 的回复:谢……谢谢哈我也才反应过来没少，我个傻子  能不能再问一下为什么char name[9]数组的字节数为什么不是9哇？37到40是怎么来的？ 16进制的37和40之间相差的就是9.。。。

额，你数一下有几个printf，然后有几行的输出。  如果不好判断，建议在输出birthday打印里加个记号。比如加一些****或+++

引用 5 楼 user-6的回复:没少啊，我ide没问题 不好意思，我数错了

没少啊，我ide没问题

谢谢老师

http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素 http://edu.csdn.net/course/detail/2455 C语言指针与汇编内存地址-二.函数 http://edu.csdn.net/course/detail/2516 C语言指针与汇编内存地址-三.数组和二维数组 http://edu.csdn.net/course/detail/2517 C语言指针与汇编内存地址-四.三维数组


Question: C语言oj题，关于字符串中的数字怎么相加的问题，求指教！

先把字符串转成整数，用atoi，然后直接相加就行，最后输出  后面加上一条语句：printf("%d", atoi(s) + atoi(t));


Question: 程序没有错，但是运行出错。

一元二次方程是二次函數與x軸的交點，當判別式b*b-4a*c小於零時，此抛物綫與x軸無交點，換句話説此時方程無解。 所以你應該先判斷b*b-4a*c的值，如果小於零，輸出“方程無解”，大於或等於0時才求解。

d = sqrt(fabs(b*b - 4 * a * c)); 取绝对值。注意加上头文件<math.h>

你的b*b-4a*c小于零，结果肯定不对啊


Question: 为什么我运行的时候多了一个问号

引用 3 楼 user-1 的回复:你CreateList_L函数中，(*L) = (LinkList)malloc(sizeof(LNode));这个结点对应的data没有初始，你可以加上(*L)->data = '\0'; 或者输出时从第2个节点开始输出 版主大佬，你回答问题真快。 感谢你的回答，代码已经修改能正常运行了

运行结果如图

还有一个问题是，这个插入元素的函数。在i=1时会不会有问题


Question: [c语言] 跪求大佬帮忙分析代码

void f(struct node a,struct node b) 你想在这个函数中改变a的内容，参数应该是地址才是，写成 void f(struct node *pa,struct node b) 后面函数体中，以及mian中的调用部分做相应修改，再试试


Question: 关于C语言二重动态数组的问题。

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

代码建议多加注释, 方便查看.   有疑问的地方, 就将 存疑的变量打印出来, 观察变量的值.

#include <stdio.h> #include <stdlib.h>  int main() {     int **a,n,m,i,j;     n=2;     m=3;     a = (int **)malloc(sizeof(int*)*n);     if (!a)         exit(0);     for(i=0;i<n;i++)     {         a[i]=(int *)malloc(sizeof(int)*m);         if (!a[i])             exit(0);     }     for(i=0;i<n;i++)     {         for(j=0;j<m;j++)         {             a[i][j] = i+j;         }     }      printf("finished");      for(i=0;i<n;i++)     {         //for(j=0;i<m;j++)         for(j=0;j<m;j++)         {             printf("%d\n",a[i][j]);         }     }     for(i=0;i<n;i++)     {         free(a[i]);     }     free(a);     return 0; } 参考一下吧 注意注释掉的部分和新的部分的区别。循环判断条件i < m；应该改成j < m；


Question: 关于运算符号的问题

通常 先算ch/i,接着在算f*d,然后才是ch/i+f*d，然后才是f+i  为什么是通常，因为编译器优化时可以随心所欲，甚至如果有能在编译期就计算出的编译期就给你计算出了，伦不到运行期计算，更谈不上顺序了

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

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

ch/i、f*d、f+i，先算哪个都对，看编译器高兴哪个了。如果由于顺序改变导致结果不同，那么这个表达式就是有问题的，UB问题

ch/i+f*d-(f+i); 乘除与加减，先算乘除：这个规则应该没有异议的。 右括号先算括号里的，这个也是没问题的。但是右括号的在最后。 计算方法是从坐向右：先算ch / i，然后计算f * d，在然手f + i。然后再从左向右依次计算加减。

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


Question: 求助，帮我看看这个程序

引用 1 楼 cfjtaishan 的回复:这个很正常，第一个程序，是调用2次，第二次的赋值49覆盖了第一次调用赋值的73。 第二个程序，虽然也调用了2次，但是在第一次调用之后就马上输出，此时还没被新的值覆盖。  总之原因，通过输出的地址，我们可以发现2次操作是对于同一内存区域赋值。因此，只要不被覆盖，就会打印之前，否则就会输出最新的。 可以这么理解，arr认为是一个容器，第一个程序是先往容器里放73值，紧接着再放49值，因此输出的肯定是49，因为第二次覆盖了73. 第二个程序，先往容器里放73，然后输出，那么输出的是73，此时再往里放49，则输出的是49.   谢谢，这下弄明白了

引用 2 楼 shiyanbo_1006 的回复:核心在于int*指针始终指向的都是static int arr[6]这块公共地址，理解了这个，对于输出你也就没有疑问了 在提点建议，为什么要起int * vector这么个名字，开始我还以为是在对vector操作呢  这个是书上的一个例程，照着敲的哈哈，谢谢解答！！！！

引用 3 楼 paschen 的回复:虽然vector与vector2是两个指针，但它们指向的内存都是同一块（因为是static变量），第一个程序int * vector2= arrallocate(6,49);执行 修改了内存中的数据，输出vector时也是输出修改后的（因为它们都指向同一块内存）；第二个程序输出vector时数组中的值还没有被vector2改变   这么一说我就明白了，看来还是我自己对于static的理解不深，感谢解答！！！


Question: 菜鸟请教c primer plus示例程序问题。

引用 1 楼 jianwen0529 的回复:这两个关键字含义就不一样：continue是跳过本次循环进行下一次循环，break是直接中断（跳出）最内层循环，不会再次进行循环！ 相同的是这两个都是仅仅对最近的循环有效  41 42行是要跳过一行剩余字母，用break直接直接跳出不是更好吗？

有两个continue，你要将那个continue换成break还是将两个都换成break; 将第一个continue换成break后会增加一个退出while循环的出口，遇到‘\n'就会退出循环。 而第二个continue是子循环中，换成break只是跳出自循环，而不能跳出外循环。

引用 3 楼 zhao4zhong1 的回复:代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。 谢谢！  41 42行是丢弃一行中其它字符，continue会跳转到关系表达式继续比较，用break直接 跳出当前循环不是更好吗？

引用 4 楼 Monchhichi_2018 的回复:[quote=引用 1 楼 jianwen0529 的回复:] 这两个关键字含义就不一样：continue是跳过本次循环进行下一次循环，break是直接中断（跳出）最内层循环，不会再次进行循环！ 相同的是这两个都是仅仅对最近的循环有效  41 42行是要跳过一行剩余字母，用break直接直接跳出不是更好吗？[/quote] break只能跳出内层while，外层的while还会继续执行，那么作为#进行结束判断就失效了。 因为这个程序是持续性的，可以连续判断多个以#结束的串（多次输入）  其实你只要编译运行下就知道怎么回事了！


Question: 怎么给0x40020000地址的值初始化？

是裸机程序还是Linux？是gpio的设置寄存器吗？Linux要ioremap的，不可能直接访问物理地址

Windows下使用WinIO.sys

GPIOA->MODER=1；这种方法赋值不行。出现错误，0xC0000005: 写入位置 0x40020000 时发生访问冲突

比如： GPIOA->MODER = 1;  前提你要保证0x40020000是块合法有效的内存

GPIOA->MODER = xxx; //你需要的值


Question: 这个程序老是异常，不能正常运行，大佬们帮我看看

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

引用 4 楼 自信男孩的回复:#include<stdio.h> #include<stdlib.h> #include<stdbool.h>  typedef  struct LNode{ 	char data; 	struct LNode*  next; }LNode, *LinkList;  void CreateList_L(LinkList *L, int n );                //逆序构造链表  bool GetElem_L(LinkList L, int i, char* elem);        //查找链表的第i个元素   int main(char* argv[], int argc) { 	LinkList L = NULL;                        //定义了一个头结点的指针  	CreateList_L(&L,5);  	char* elem = (char *)malloc(sizeof(char));                        //用于返回第i个元素  	if (!elem) 		exit(0); 	//char elem; 	GetElem_L(L,3,elem); 	printf("链表的第3个元素是%c\n",*elem);   	return 0; }  //逆序构造链表,L->next永远指向NULL,L永远指向上一个结点  void CreateList_L(LinkList *L, int n ) { 	*L = (LinkList)malloc(sizeof(LNode)); 	(*L)->next = NULL; 	LinkList p = NULL;    //暂时指向NULL,用于申请结点  	for(int i = n; i>0; i--) 	{ 		p = (LinkList) malloc (sizeof(LNode)); 		if (!p) 			exit(0); 		scanf(" %c",&p->data); 		p->next = (*L)->next; 		(*L)->next = p;  	}  }   //查找链表中的第i个元素  bool GetElem_L(LinkList L, int i, char* elem){ 	LinkList q = L->next; 	int j = 1; 	while( q && j<i ){ 		q = q->next;                 //p指向下一个元素  		j++;  	} 	if( !q || j>i ) 		return false; 	else 		*elem = q->data; 	return true;  }  参考一下吧  两个地方都可能导致段错误： 1.创建链表时，因为形参定义的是一重指针，因此不能从创建函数里将新的链表节点带到main函数内。需要使用二重指针。另外一个办法，可以不改形参和实参，将哨兵节点的申请空间操作放在main函数内。 2. elem是指向NULL的指针，因此不能在GetElem_L函数内使用*elem = p->data；因为这样相当于*(NULL) = p->data;因此需要给elem申请空间，或者直接定义char变量，然后传递&elem进去 感谢大佬的耐心解答，并给出代码。 两点都指正的很好。 第一个因为按值传递确实应该传指针的地址进去； 第二点对NULL进行引用也确实不对，之前程序崩溃原因也应该在这吧。 再次感谢

引用 1 楼 user-3的回复:你的CreateList_L函数的参数是按值传递的，也就是说主函数中的L和CreateList_L中的L是两个不同的变量，后者是前者复制得到的，你malloc申请的内存给了后者，但不会影响前者，也就是你主函数中的L仍然是个未初始的值，并没指向你申请到的内存，后面使用将导致你程序崩溃 感谢版主大佬解惑，是传递指针出了问题

在构造链表的函数中，L->next永远指向头结点。这个在备注里面写错了

要解决这个问题，你函数参数要传递指针的地址，而不是指针本身


Question: 跪求大佬指导。帮忙分析一下我的代码

void find(Lnode &head,int n,int m,int k) 参数head 前加&，是表示引用，它的效果同地址传递，但形式上不是地址。当然，具体它的工作原理，我还真不知道，由于平时没有涉及到相关的问题，还真没有研究过它和指针的本质区别  这样写的好处是，变量的内存不在函数中分配，表面上方便管理，而且减少传递指针的指针这种比较bt的行为，从形式上更容易理解一些罢了

引用 14 楼 weixin_40884861的回复:[quote=引用 8 楼 jszj 的回复:] 可以在main()中定义头结构，其成员data不用而只用其指针，此时两个子函数可以传递结构的引用，这样对参数的指针成员附值即可 void creat(LinkList head,int n) 改为 void creat(Lnode &head,int n) {   ...   head.next = p;   ... }  void find(LinkList head,int n,int m,int k) 改为 void find(Lnode &head,int n,int m,int k) {    LinkList p=head.next,q=head.next;    .... }  main()函数定义： int main() { int i,n,m,k; Lnode head; LinkList q; ... creat(head,n); q=head.next; ... find(head,n,m,k); ... }鹅妈妈木木木木木。。请问有什么区别吗0-0。。是程序员习惯吗。。  引用 12 楼 paschen 的回复:[quote=引用 10 楼 weixin_40884861的回复:][quote=引用 3 楼 paschen 的回复:] 要解决这个问题，你函数参数要传递指针的地址，而不是指针本身 额，大神，请问一下哈，指针不就是地址吗？？为啥这个不能传递过去呢？我有写head=p啊，不是传过去了吗[/quote] 指针可以表示地址，但指针本身也占用内存，也有自己的地址  如果函数中要修改指针指向的地址中的值，你可以传递指针  你是如果要改变指针本身，需要传递指针自身的地址  你malloc函数改变的是指针自身的值，还有一个办法就是你把malloc放在主函数中[/quote] 恩。。。这样就OK了，但还不是很懂QAQ 怎样传递指针自身的地址呢？我传过去的其实是未初始化的随机地址，对吗？ emmmfind函数我再改改吧，应该有逻辑错误，不可以运行。 谢谢大佬，好像你还帮过我QAQ[/quote] 使用&取指针地址，相当于传递二级指针  函数参数类型实际是LinkList* head  函数中使用*head对指针进行操作

引用 8 楼 jszj 的回复:可以在main()中定义头结构，其成员data不用而只用其指针，此时两个子函数可以传递结构的引用，这样对参数的指针成员附值即可 void creat(LinkList head,int n) 改为 void creat(Lnode &head,int n) {   ...   head.next = p;   ... }  void find(LinkList head,int n,int m,int k) 改为 void find(Lnode &head,int n,int m,int k) {    LinkList p=head.next,q=head.next;    .... }  main()函数定义： int main() { int i,n,m,k; Lnode head; LinkList q; ... creat(head,n); q=head.next; ... find(head,n,m,k); ... }鹅妈妈木木木木木。。请问有什么区别吗0-0。。是程序员习惯吗。。  引用 12 楼 paschen 的回复:[quote=引用 10 楼 weixin_40884861的回复:][quote=引用 3 楼 paschen 的回复:] 要解决这个问题，你函数参数要传递指针的地址，而不是指针本身 额，大神，请问一下哈，指针不就是地址吗？？为啥这个不能传递过去呢？我有写head=p啊，不是传过去了吗[/quote] 指针可以表示地址，但指针本身也占用内存，也有自己的地址  如果函数中要修改指针指向的地址中的值，你可以传递指针  你是如果要改变指针本身，需要传递指针自身的地址  你malloc函数改变的是指针自身的值，还有一个办法就是你把malloc放在主函数中[/quote] 恩。。。这样就OK了，但还不是很懂QAQ 怎样传递指针自身的地址呢？我传过去的其实是未初始化的随机地址，对吗？ emmmfind函数我再改改吧，应该有逻辑错误，不可以运行。 谢谢大佬，好像你还帮过我QAQ

引用 10 楼 weixin_40884861的回复:[quote=引用 3 楼 paschen 的回复:] 要解决这个问题，你函数参数要传递指针的地址，而不是指针本身 额，大神，请问一下哈，指针不就是地址吗？？为啥这个不能传递过去呢？我有写head=p啊，不是传过去了吗[/quote] 指针可以表示地址，但指针本身也占用内存，也有自己的地址  如果函数中要修改指针指向的地址中的值，你可以传递指针  你是如果要改变指针本身，需要传递指针自身的地址  你malloc函数改变的是指针自身的值，还有一个办法就是你把malloc放在主函数中

引用 4 楼 user-6 的回复:#ifndef josephuskill_h #define josephuskill_h  class node{     public:         int value;         node *next;         node(int value);         static const node* josephuskill(node *head, const int m = 2);         static const int getlive(int len, const int m); };  node::node(int value)     :value(value),      next(null) { }  const node* node::josephuskill(node *head, const int m) {     if(m <= 1)         return head;     if(!head || !head->next)         return head;     node *cur = head;     static int length = 0;     while(cur)     {         ++length;         cur = cur->next;     }          length = getlive(length, m);     cur = head;     while(--length)     {         cur = cur->next;     }      head = cur;     head->next = head;          return head; }   const int node::getlive(int len, const int m) {     if(len == 1)         return 1;      return (getlive(len - 1, m) + m -1) % len + 1;  }  #endif大佬，你这个是啥啊，我有点看不懂。。。是c吗？QAQ

说说结构定义的风格 typedef struct Lnode { int data; struct Lnode *next; }Lnode,*LinkList; 通常，第一行的struct后面的名字，和最后一行的名字不相同，比如改成如下： typedef struct _Lnode { int data; struct Lnode *next; }Lnode,*LinkList;

引用 3 楼 paschen 的回复:要解决这个问题，你函数参数要传递指针的地址，而不是指针本身 额，大神，请问一下哈，指针不就是地址吗？？为啥这个不能传递过去呢？我有写head=p啊，不是传过去了吗

脑子短路了。。改了改find函数 void find(LinkList head) { 	LinkList p=head,q=head; 	int i,k=3,m=2; 	while(p->next->data!=m) 		p=p->next; 	while(q->next->next->data!=m) 		q=q->next; 	while(p->next!=p) 	{ 		for(i=1;i<=k;i++) 		{ 			p=p->next; 			q=q->next; 		} 		printf("%d ",p->data); 		q->next=p->next; 		p->next=NULL; 		p=q->next; 	} } 但还是不对

环链表传递的是二级指针

要解决这个问题，你函数参数要传递指针的地址，而不是指针本身

你的creat函数的参数是按值传递的，也就是说主函数中的head和creat中的head是两个不同的变量，后者是前者复制得到的，你malloc申请的内存给了后者，但不会影响前者，也就是你主函数中的head仍然是个未初始的值，并没指向你申请到的内存，后面使用将导致你程序崩溃


Question: 请问各位高手这代码哪里错了，急，谢谢

#include <stdio.h>  void afunctionoflongname(int x) { 	printf("%d\n",x); }  int main() { 	int a=1,b=2,c=3;  	void (*pt)(int); 	pt=afunctionoflongname; 	pt(a); 	pt(b); 	pt(c);  	return 0; }  参考一下吧  考虑afunctionoflongname函数没有返回值，建议将其返回值定义为void类型。另外，pt（函数指针）在指向afunctionoflongname函数时，需要去掉后面的一对小括号。因为函数名本身就是地址，它是函数栈开始的位置。

主函数中pt = afunctionoflongname(); 改成 pt = afunctionoflongname;  void(*pt)(int); 改成 int(*pt)(int);  因为你要指向的函数的返回值是int类型的   #include <stdio.h> int afunctionoflongname(int x) { 	printf("%d\n", x); } int main() { 	int a = 1, b = 2, c = 3; 	int(*pt)(int); 	pt = afunctionoflongname; 	pt(a); 	pt(b); 	pt(c); }


Question: 请问这代码哪里错了,急，谢谢

error C2660: 'findmaxscore' : function does not take 0 parameters

#include <stdio.h>  #define N 5  int findmaxscore(int score[N], int n) { 	int i,max;  	max=score[0]; 	for (i=1;i < n;i++) 	{ 		//if(score[i]<score[i+1])    //i+1可能会导致数组元素越界或者遍历未使用的元素 		if(max < score[i]) 		{ 			max = score[i]; 		} 	} 	printf("maxscore=%d\n",max); }  int findmaxhaoma(int haoma[N], int n) { 	int i,max; 	max=haoma[0]; 	for (i=1;i<n;i++) 	{ 		//if(haoma[i]<haoma[i+1])//i+1可能会导致数组元素越界或者遍历未使用的元素 		if(max < haoma[i]) 		{ 			max = haoma[i]; 		} 	} 	printf("maxhaoma=%d\n",max); } int main() { 	int n,i, maxscore,score[N], haoma[N]; 	//long haoma[N], maxhaoma; 	printf("how many students\n"); 	scanf("%d",&n); 	for (i=0;i<n && i < N;i++)    //加上i < N防止越界 	{ 		printf("input every student's haoma and score"); 		scanf("%ld,%d",&haoma[i],&score[i]); 	} 	findmaxscore(score, n); 	findmaxhaoma(haoma, n);  	return 0; } 参考一下吧 自定义函数findmaxhaoma和findmaxscore建议定义成2个参数。否则若n输入的是3，则在这两个函数里会遍历到未使用的元素，即下表是3和4 另外，若函数不想定义为有返回值的，建议直接定义为void类型。

其次还有一个小问题，你的两个find...函数没有返回一个值，可以最后加上return max;

你主函数里定义了两个haoma变量，可这样改：    int main() { 	int n, i, haoma[N], maxscore, score[N]; 	printf("how many students\n"); 	scanf("%d", &n); 	for (i = 0; i < n; i++) 	{ 		printf("input every student's haoma and score"); 		scanf("%ld,%d", &haoma[i], &score[i]); 	} 	findmaxscore(score); 	findmaxhaoma(haoma); }


Question: 请问：有什么好的办法，写if语句分支语句

看不过来就是代码太长。  了解一下 表驱动法。那么多if 很可能适合表驱动。  另外就是楼上说过的、封装函数。代码控制在100行以内就可以了

如果你多个分支语句都会用到相近的功能，你可以做个接口，如果代码行色各异，建议注意缩进，注意命名，做好注释，是否需要用‘return’返回，不建议为每个分支写单独的函数，方便以后的维护，只要有良好的编码风格，百八十行是在一个if里也没啥。

请牢记：源代码本身的书写是否结构化或面向对象或符合设计模式或敏捷…并不重要，重要的是你是否使用结构化或面向对象或符合设计模式或敏捷…的方法命名标识符、阅读、修改、检查、测试源代码。  意思是你程序结构看上去再合理，再简洁，也不一定比看上去一团乱麻的程序结构在运行或修改时更不易出错，更方便修改，出错了更容易找到哪里出错和具体出错的原因，更容易改正错误。  试对比 图书馆（对图书的分类够结构化了吧） 和 搜索引擎（可看作是扁平化任何结构数据，仅支持全文检索） 哪个处理信息更方便、更高效。  所以 与其费劲去重构代码让其看上去更简洁、更合理 不如费劲学习grep、sed、awk、……这类全文搜索和批处理编辑的工具。  结构越复杂，越难修改，越难除错。 有时（甚至大多数时候），看上去越合理、越简洁的代码，运行起来性能越差，出错时查找原因越难，找到出错原因后改正越费劲。  程序员要做的不是尽力避免错误，而是聚焦在快速发现并改正错误。真正以快速方式轻易解决错误，“快速的失败”远胜过“预防错误”。Fred George  前微软C#编辑器的开发主管Jay Bazuzi列出的一些有助于找到正确方向的问题；他觉得前同事们应该用这些问题来问自己；实际上不管在哪里工作的开发者们都应该经常问问自己这些问题： ◆“要保证这个问题不会再出现，我该怎么做？” ◆“要想少出些Bug，我该怎么做？” ◆“要保证Bug容易被修复，我该怎么做？” ◆“要保持对变化的快速响应，我该怎么做？” ◆“要保证我的软件的运行速度，我该怎么做？” 如果大多数团队都能不时问一下自己，必定会从中得益，因为这些都是真正强而有力的问题。

看到大量的if else 容易想到 switch case  看到大量的switch case 容易想到 多态

{     if(1)     {     (1)     (2)     return  xx     }     (3)     (4)     ...     (50)     return xx }

若在一个函数体内只有两种情况，建议设置成这样： if(1) {     (1)     (2)     return  xx     }     (3)     (4)     ...     (50)     return xx } 若函数定义的是void，那么直接return;，若有返回值则返回对应的。

有缩进的话再加上注释还是比较清晰的，当然你也可以将if后的条件改成反命题，然后把原if块和else块的内容互换

定义新的函数，不要让每个函数代码太长

讲个最简单的方式，那你把那些分支语句封装成几个函数写，然后在else语句中调用，加上几个备注，这样看起来不就清楚了嘛

引用 2 楼 leetow2006 的回复:if(1) ... retrun; ====================== 返回？这样可以吗？但是感觉这样写程序不规范 当然可以返回，不过这里的return应该是包含在if的大括号里面的。 一百行内数量的代码在一个函数里面很正常的，如果你有能力也可以重构成多个小函数，但是概念上最好要能支撑代码逻辑的分割。 不要为了分而分，而是为了提高重用性和维护性进行的分割。

if(1) ... retrun;  ... ...  或者： 把else里面的分解成小函数，如果逻辑和概念上成立的话


Question: POSIX消息队列需要增加信号量保护么

百度搜相关关键字。


Question: 请求c语言大佬教授知识，如何自定义函数求圆面积

double era（int r) {     return  3.14*r*r; }

补基础知识！

引用 3 楼 cfjtaishan 的回复: #define PI 3.1415926 double get_area(int r) {     return PI * r * r; }  #define PI 3.1415926 double get_area(float r) {     return PI * r * r; }


Question: 划横线的在这有什么用 啊。。

typedef是定义别名。即MyType是struct tag的别名，而MyPtr是struct tag *的别名。

typedef typedef type-declaration synonym;  The typedef keyword defines a synonym for the specified type-declaration. The identifier in the type-declaration becomes another name for the type, instead of naming an instance of the type. You cannot use the typedef specifier inside a function definition.  A typedef declaration introduces a name that, within its scope, becomes a synonym for the type given by the decl-specifiers portion of the declaration. In contrast to the class, struct, union, and enum declarations, typedef declarations do not introduce new types — they introduce new names for existing types.  Example  // Example of the typedef keyword typedef unsigned long ulong;  ulong ul;     // Equivalent to "unsigned long ul;"  typedef struct mystructtag {    int   i;    float f;    char  c; } mystruct;  mystruct ms;   // Equivalent to "struct mystructtag ms;"  typedef int (*funcptr)();  // funcptr is synonym for "pointer                            //    to function returning int"  funcptr table[10];   // Equivalent to "int (*table[10])();"

定义别名：即MyPtr 是类型 tag* 的别名


Question: C语言，oj上提交一直wrong answer 不知道错在哪里···求指正

#include<stdio.h> #include<math.h>  int main() {     char a[200];     int i, cnt;      while (scanf("%s", a)) {         if (a[0] == '0')             break;          cnt = 0;         while (a[cnt++])             ;          cnt--;         printf("cnt = %d\n", cnt);         for (i = 0; i < cnt / 2; i++)             if (a[i] != a[cnt - i - 1])                 break;         if (i >= cnt / 2)             printf("Yes\n");         else             printf("No\n");     } #if 0     int n,a[200],i,t,count,m,s;     while(scanf("%d",&n)!=EOF)     {         count=0;         m=0;         s=n;         if(n==0)             break;         while(s)         {             count++;             s=s/10;         }         t=n;         for(i=0;i<count;i++)         {             a[i]=t%10;             t=t/10;             m=m+a[i]*pow(10,count-i-1);         }         if(m==n)             printf("Yes.\n");         else             printf("No.\n");     } #endif      return 0; } 参考一下吧

仅供参考：#include <iostream> #include <string> using namespace std; inline int compare(string str1,string str2) {//相等返回0，大于返回1，小于返回-1          if (str1.size()>str2.size()) return 1; //长度长的整数大于长度小的整数     else if (str1.size()<str2.size()) return -1;     else                              return str1.compare(str2); //若长度相等，则头到尾按位比较 } string SUB_INT(string str1,string str2); string ADD_INT(string str1,string str2) {//高精度加法     int sign=1; //sign 为符号位     string str;     if (str1[0]=='-') {         if (str2[0]=='-') {             sign=-1;             str=ADD_INT(str1.erase(0,1),str2.erase(0,1));         } else {             str=SUB_INT(str2,str1.erase(0,1));         }     } else {         if (str2[0]=='-') {             str=SUB_INT(str1,str2.erase(0,1));         } else { //把两个整数对齐，短整数前面加0补齐             string::size_type L1,L2;             int i;             L1=str1.size();             L2=str2.size();             if (L1<L2) {                 for (i=1;i<=L2-L1;i++) str1="0"+str1;             } else {                 for (i=1;i<=L1-L2;i++) str2="0"+str2;             }             int int1=0,int2=0; //int2 记录进位             for (i=str1.size()-1;i>=0;i--) {                 int1=(int(str1[i])-'0'+int(str2[i])-'0'+int2)%10;                 int2=(int(str1[i])-'0'+int(str2[i])-'0'+int2)/10;                 str=char(int1+'0')+str;             }             if (int2!=0) str=char(int2+'0')+str;         }     }     //运算后处理符号位     if ((sign==-1)&&(str[0]!='0')) str="-"+str;     return str; } string SUB_INT(string str1,string str2) {//高精度减法     int sign=1; //sign 为符号位     string str;     int i,j;     if (str2[0]=='-') {         str=ADD_INT(str1,str2.erase(0,1));     } else {         int res=compare(str1,str2);         if (res==0) return "0";         if (res<0) {             sign=-1;             string temp =str1;             str1=str2;             str2=temp;         }         string::size_type tempint;         tempint=str1.size()-str2.size();         for (i=str2.size()-1;i>=0;i--) {             if (str1[i+tempint]<str2[i]) {                 j=1;                 while (1) {//zhao4zhong1添加                     if (str1[i+tempint-j]=='0') {                         str1[i+tempint-j]='9';                         j++;                     } else {                         str1[i+tempint-j]=char(int(str1[i+tempint-j])-1);                         break;                     }                 }                 str=char(str1[i+tempint]-str2[i]+':')+str;             } else {                 str=char(str1[i+tempint]-str2[i]+'0')+str;             }         }         for (i=tempint-1;i>=0;i--) str=str1[i]+str;     }     //去除结果中多余的前导0     str.erase(0,str.find_first_not_of('0'));     if (str.empty()) str="0";     if ((sign==-1) && (str[0]!='0')) str ="-"+str;     return str; } string MUL_INT(string str1,string str2) {//高精度乘法     int sign=1; //sign 为符号位     string str;     if (str1[0]=='-') {         sign*=-1;         str1 =str1.erase(0,1);     }     if (str2[0]=='-') {         sign*=-1;         str2 =str2.erase(0,1);     }     int i,j;     string::size_type L1,L2;     L1=str1.size();     L2=str2.size();     for (i=L2-1;i>=0;i--) { //模拟手工乘法竖式         string tempstr;         int int1=0,int2=0,int3=int(str2[i])-'0';         if (int3!=0) {             for (j=1;j<=(int)(L2-1-i);j++) tempstr="0"+tempstr;             for (j=L1-1;j>=0;j--) {                 int1=(int3*(int(str1[j])-'0')+int2)%10;                 int2=(int3*(int(str1[j])-'0')+int2)/10;                 tempstr=char(int1+'0')+tempstr;             }             if (int2!=0) tempstr=char(int2+'0')+tempstr;         }         str=ADD_INT(str,tempstr);     }     //去除结果中的前导0     str.erase(0,str.find_first_not_of('0'));     if (str.empty()) str="0";     if ((sign==-1) && (str[0]!='0')) str="-"+str;     return str; } string DIVIDE_INT(string str1,string str2,int flag) {//高精度除法。flag==1时,返回商；flag==0时,返回余数     string quotient,residue; //定义商和余数     int sign1=1,sign2=1;     if (str2 == "0") {  //判断除数是否为0         quotient= "ERROR!";         residue = "ERROR!";         if (flag==1) return quotient;         else         return residue ;     }     if (str1=="0") { //判断被除数是否为0         quotient="0";         residue ="0";     }     if (str1[0]=='-') {         str1   = str1.erase(0,1);         sign1 *= -1;         sign2  = -1;     }     if (str2[0]=='-') {         str2   = str2.erase(0,1);         sign1 *= -1;     }     int res=compare(str1,str2);     if (res<0) {         quotient="0";         residue =str1;     } else if (res == 0) {         quotient="1";         residue ="0";     } else {         string::size_type L1,L2;         L1=str1.size();         L2=str2.size();         string tempstr;         tempstr.append(str1,0,L2-1);         for (int i=L2-1;i<L1;i++) { //模拟手工除法竖式             tempstr=tempstr+str1[i];             tempstr.erase(0,tempstr.find_first_not_of('0'));//zhao4zhong1添加             if (tempstr.empty()) tempstr="0";//zhao4zhong1添加             for (char ch='9';ch>='0';ch--) { //试商                 string str;                 str=str+ch;                 if (compare(MUL_INT(str2,str),tempstr)<=0) {                     quotient=quotient+ch;                     tempstr =SUB_INT(tempstr,MUL_INT(str2,str));                     break;                 }             }         }         residue=tempstr;     }     //去除结果中的前导0     quotient.erase(0,quotient.find_first_not_of('0'));     if (quotient.empty()) quotient="0";     if ((sign1==-1)&&(quotient[0]!='0')) quotient="-"+quotient;     if ((sign2==-1)&&(residue [0]!='0')) residue ="-"+residue ;     if (flag==1) return quotient;     else         return residue ; } string DIV_INT(string str1,string str2) {//高精度除法,返回商     return DIVIDE_INT(str1,str2,1); } string MOD_INT(string str1,string str2) {//高精度除法,返回余数     return DIVIDE_INT(str1,str2,0); } int main() {     char ch;     string s1,s2,res;      while (cin>>s1>>ch>>s2) {         switch (ch) {             case '+':res=ADD_INT(s1,s2);break;             case '-':res=SUB_INT(s1,s2);break;             case '*':res=MUL_INT(s1,s2);break;             case '/':res=DIV_INT(s1,s2);break;             case '%':res=MOD_INT(s1,s2);break;             default :                   break;         }         cout<<res<<endl;     }     return(0); }

n不超过200位，你用int读入肯定爆炸了

哎，这位同学，都没人理你的，好嘛！自己再使劲看看啊

n最多不超过200位

我记得pow()的参数是浮点数来着，我试了一下输出m,n的值，确实有误差不如自己写一下pow函数，就一个简单的循环你试试。


大问题没有，就是没有释放内存。不过代码太啰嗦了，合并成一个不就完了。还搞一个 template，但是 TYPE 还要强行转成 int * 是何道理？bool readString(HANDLE hPipe, string &str) { 	DWORD dwBytesRead; 	DWORD dwLength = 0; 	DWORD dwBuffer = sizeof(dwLength); 	BOOL bResult = ReadFile(hPipe, (void *)&dwLength, dwBuffer, &dwBytesRead, NULL); 	if (bResult && dwLength > 0) 	{ 		char *psz = new char[dwLength + 1]; 		bResult = ReadFile(hPipe, (void *)psz, dwLength, &dwBytesRead, NULL); 		str = string(psz); 		delete[] psz; 	} 	return bResult; }

new之后没有对其释放空间吧（delete) 尤其是在大量读的情况下，很有可能导致堆上的空间申请枯竭，导致new申请失败。建议根据需要是否在不需要的时候将new的空间释放掉（delete）

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

出错时中断下来分析原因，检查内存有没申请成功，size的值是否正常之类

bool ret=read(hPipe,(int &)size);建议改成：bool ret=read(hPipe,size);，检查read函数里检查读到的值等是否有问题

引用 1 楼 user-4 的回复:出错时中断下来分析原因，检查内存有没申请成功，size的值是否正常之类  bool ret=read(hPipe,(int &)size);   这行size不正常 c=new char[size+1];    //这里报错0xC0000005   导致这行不正常  但是问题是，大部分情况下都是正常的

引用 1 楼 user-4 的回复:出错时中断下来分析原因，检查内存有没申请成功，size的值是否正常之类 size不正常，但是该怎么解决呢朋友，因为我主要是用C#编程，也是偶尔用c，所以比较糊涂


Question: 请问输入两个字符串，找到相同的字符并输出，不能重复输出？

这个简单嘛，两个数组st1和str2,两个指针 p1 p2 一个计数器。p1指向str1[0],p2指向st2[0]。p2指向str2[0],时指针p1遍历str1中的所有字符，若有相同的，则p1 p2与计数器同时+1，再次判断两个指针指向的字符是否相同，若还是相同p1 p2和计数器+1；遇到不同字符的时候利用计数器把改字符输出，这样循环直到遍历完str1中的所有字符，此时p2指向str2[1],而p1则是继续指向str1的开头str1[0]，往复循环·········大概意思就是这样，代码怎么实现就看楼主自己了。

因为你改变了指针的指向，所以不能重复输出。你应该每次定义一个临时指针变量指向这两个字符串，然后用这两个临时指针变量偏移。

用 int 的高低位分别统计字母在两个字符串中的数量：#include <stdio.h>  void fuck(const char *s1, const char *s2) {         int count[0x7f] = { 0 };         unsigned int mask1 = 0x0000ffff;         unsigned int mask2 = 0xffff0000;         while (*s1) {                 char c = *s1++;                 int n = count[c];                 count[c] = (n & mask2) | ((n & mask1) + 1);          }         while (*s2) {                 char c = *s2++;                 int n = count[c];                 count[c] = (((n >> 16) + 1) << 16) | (n & mask1);         }         int length = sizeof(count) / sizeof(*count);         for (int i = 0; i < length; i++) {                 int cnt = count[i];                 if ((cnt & mask1) && (cnt & mask2)) {                         printf("%c\n", i);                  }         } }  int main() {         fuck("abcddeeff", "defghi");         return 0; }

引用 2 楼 finalcsdn 的回复:假如全是小写英文字母，那么就可以开两个26的数组，a～z对应0～26，两个字符串中出现过的字符就把对应的位置设置为1，没有出现过得就是0。这样输入结束后，输出两个数组中都是1的位置对应的字符就行了。不是小写英文字母也可以实现的，只需要把数组开大一点然后还是按ASCII码映射 我正好看到一个这样写的，还是都是小写字母方便，如果算上数字和大写字母，映射起来不太得劲

引用 1 楼 qq_40698466 的回复:可以直接在二重循环里进行判断然后直接输出，不需要再定义一个字符数组 就是在里面判断这个，搞不明白判断的方法

可以直接在二重循环里进行判断然后直接输出，不需要再定义一个字符数组


Question: 大神们求助啊，菜鸟一枚，做自动量程电压表，仿真的时候数码管就是不显示数字，看不出程序哪里有问题，求助啊！

最好不要用仿真，直接在开发板上调，连接逻辑分析仪抓信号，打开IAP执行单步调试，打断点，就知道你的寄存器状态，程序怎么跑的。

应该是没有从0808获得数据，你单步调试看看吧

万用表、示波器、逻辑分析仪、观音菩萨。


Question: 将数组a的字符复制到b数组中出现的问题

在b[i] = '\0'; 处下断点，通过“监视”可以发现字符数组a和字符数组b的地址分别是0x004ffa78和0x004ffa68，如图1所示。  在“内存”中查看这两个地址的内容，如图2所示：  具体内容请参考《C++中字符数组》https://blog.csdn.net/hou09tian/article/details/79858007 希望能够帮到你

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

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

还有  sizeof  判断数组大小是怎样判断的  明明a的内容变了，但数组的大小并没有变化

能有大神用图的方式表明下b怎样破坏a的值吗，谢谢 我还是想不懂是怎样的

void test() {     char a[] = "abcdefghijk";     char b[] = "zxcvbnc";     int i = 0;     for(i=0; i<strlen(b)-1; i++)     {         b[i] = a[i];     }     b[i] = '\0';     printf("%s\n",a);     printf("%s\n",b); }

strlen()函数产测字符串长度

不是最多多覆盖一个字节吗，但为什么会整个都覆盖了    引用 2 楼 qq_38204686 的回复:数组越界了 ............  引用 1 楼 tomsoft 的回复:越界，您数一下数组b的长度，再数一下数组a的长度；及对b的赋值会破坏紧跟b后面的局部变量，具体是哪个局部变量取决于编译器

那怎么解决？？

数组越界了 ............


Question: 输入华氏温度F的值，输出摄氏温度C的值，这段代码哪里出错？求各位大神帮帮忙。

常量也有类型！ C++ Integer Constants Integer constants are constant data elements that have no fractional parts or exponents. They always begin with a digit. You can specify integer constants in decimal, octal, or hexadecimal form. They can specify signed or unsigned types and long or short types.  Syntax  integer-constant :  decimal-constant integer-suffixopt octal-constant integer-suffixopt hexadecimal-constant integer-suffixopt 'c-char-sequence'  decimal-constant :  nonzero-digit decimal-constant digit  octal-constant :  0 octal-constant octal-digit  hexadecimal-constant :  0x hexadecimal-digit 0X hexadecimal-digit hexadecimal-constant hexadecimal-digit  nonzero-digit : one of  1 2 3 4 5 6 7 8 9  octal-digit : one of  0 1 2 3 4 5 6 7  hexadecimal-digit : one of  0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F  integer-suffix :  unsigned-suffix long-suffixopt long-suffix unsigned-suffixopt  unsigned-suffix : one of  u U  long-suffix : one of  l L  64-bit integer-suffix :  i64  To specify integer constants using octal or hexadecimal notation, use a prefix that denotes the base. To specify an integer constant of a given integral type, use a suffix that denotes the type.  To specify a decimal constant, begin the specification with a nonzero digit. For example:  int i = 157;   // Decimal constant int j = 0198;  // Not a decimal number; erroneous octal constant int k = 0365;  // Leading zero specifies octal constant, not decimal  To specify an octal constant, begin the specification with 0, followed by a sequence of digits in the range 0 through 7. The digits 8 and 9 are errors in specifying an octal constant. For example:  int i = 0377;   // Octal constant int j = 0397;   // Error: 9 is not an octal digit  To specify a hexadecimal constant, begin the specification with 0x or 0X (the case of the “x” does not matter), followed by a sequence of digits in the range 0 through 9 and a (or A) through f (or F). Hexadecimal digits a (or A) through f (or F) represent values in the range 10 through 15. For example:  int i = 0x3fff;   // Hexadecimal constant int j = 0X3FFF;   // Equal to i  To specify an unsigned type, use either the u or U suffix. To specify a long type, use either the l or L suffix. For example:  unsigned uVal = 328u;             // Unsigned value long lVal = 0x7FFFFFL;            // Long value specified                                    //  as hex constant unsigned long ulVal = 0776745ul;  // Unsigned long value  C++ Floating-Point Constants Floating-point constants specify values that must have a fractional part. These values contain decimal points (.) and can contain exponents.  Syntax  floating-constant :  fractional-constant exponent-partopt floating-suffixopt digit-sequence exponent-part floating-suffixopt  fractional-constant :  digit-sequenceopt . digit-sequence digit-sequence .  exponent-part :  e signopt digit-sequence E signopt digit-sequence  sign : one of  + –  digit-sequence :  digit digit-sequence digit  floating-suffix :one of  f l F L  Floating-point constants have a “mantissa,” which specifies the value of the number, an “exponent,” which specifies the magnitude of the number, and an optional suffix that specifies the constant’s type. The mantissa is specified as a sequence of digits followed by a period, followed by an optional sequence of digits representing the fractional part of the number. For example:  18.46 38.  The exponent, if present, specifies the magnitude of the number as a power of 10, as shown in the following example:  18.46e0      // 18.46 18.46e1      // 184.6  If an exponent is present, the trailing decimal point is unnecessary in whole numbers such as 18E0.  Floating-point constants default to type double. By using the suffixes f or l (or F or L — the suffix is not case sensitive), the constant can be specified as float or long double, respectively.  Although long double and double have the same representation, they are not the same type. For example, you can have overloaded functions like  void func( double );  and   void func( long double );

#include<stdio.h> int main() {     int F;     float C;      printf("Please input F:");     scanf("%d", &F);     C = 5.0/9*(F-32);     printf("C=%f\n", C);     return 0; } 参考一下吧 需要将C变量定义为浮点数；另外，在计算中要按照浮点数计算规则来，所以要用5.0/9,当然也可以5 * 1.0 / 9 * (F-32);

变量定义为浮点数吧，省事

应该回顾一下整数除法的相关

C = (F-32)*5/9.0;

C=5/9*(F-32); 你这里是转数除法，即5/9=0，可能不是你希望的  如果你要浮点数除法，写成C=5.0/9*(F-32);


Question: 不知道为什么  求大佬解答而命名、

#include "stdio.h"  #define N 3 #define M 100  int main(void) {     char sz[N][M];//二维字符数组，可以存放10个字符串      for(int i=0;i<N;i++)     {         gets(sz[i]);     }     int i,j;     //for(i=0;i<M;i++)     for(i=0;i<N;i++)     {         char *p1=sz[i];         j=0;         while(*(p1+j)!='\0')         {             if (j >= M -1)                 break;             if(*(p1+j)=='a'&&*(p1+j+1)=='n')             {                 puts(sz[i]);             }             j++;         }     }     return 0; } 参考一下吧 有两个地方会导致越界，第一个是sz[i]，下表应该是从0~N-1,而M远大于N，因此会导致越界访问。 第二个地方，若输入的字符串正好是M-1个，那么在判断'a', 'n'时也会导致越界： if(*(p1+j)=='a'&&*(p1+j+1)=='n') 因此除了改sz的下表之外，也应该加上对p1+j的保护。

for (i = 0; i < M; i++)   是否应改为：  for (i = 0; i < N; i++)

越界了，sz第一维范围是0~N，但你for循环访问的范围是0~M，M比N大，所以越界了


Question: 谁帮忙调试这段c代码 编译环境c-free

#include <stdio.h>  #define NUM 30  typedef struct { //日期结构体     int year;     int month;     int day; }DATE;  typedef struct{//学生信息结构     int num;     char name[24];     DATE birthday;  //结构体嵌套     char department[48];     char major[32]; }STUDENTINFO;  void inputInfo(STUDENTINFO s[]);  //函数声明 void outputInfo(STUDENTINFO s[]); //函数声明 void searchInfo(STUDENTINFO s[],DATE); //函数声明  int main() {     STUDENTINFO s[NUM]; //学生结构体变量     DATE date; //日期结构体变量      inputInfo(s);     outputInfo(s);     printf("\n Enter a date(month,day)");     scanf("%d%d",&date.month,&date.day);     searchInfo(s,date);      return 0; }  //输入全部学生的信息 void inputInfo(STUDENTINFO s[]) {     int i;     printf("\nEnter %d student's information(name,birthday,department,major)\n",NUM);     for(i=0;i<NUM;i++){         s[i].num=i+1;         scanf("%s",s[i].name);         scanf("%d%d%d", &s[i].birthday.year,&s[i].birthday.month,&s[i].birthday.day);         scanf("%s", s[i].department);         scanf("%s", s[i].major);     } }  //输出全部学生的信息 void outputInfo(STUDENTINFO s[]) {     int i;     printf("\n NUM Name Birthday Department Major\n");     for(i=0;i<NUM;i++){         //printf("\n%4d%14s %4d%2d%2d%16s%16s",s[i].NUM,s[i].name,s[i].birthday.year,s[i].birthday.month,s[i].birthday.day,s[i].department,s[i].major);         printf("\n%4d%14s %4d%2d%2d%16s%16s",s[i].num,s[i].name,s[i].birthday.year,s[i].birthday.month,s[i].birthday.day,s[i].department,s[i].major);     } }  //查找并输出date之后过生日的学生信息 void searchInfo(STUDENTINFO s[],DATE date) {     int i;     for(i=0;i<NUM;i++){         if(s[i].birthday.month > date.month){             printf("\n%16s %4d %2d%2d",s[i].name,s[i].birthday.year,s[i].birthday.month,s[i].birthday.day);             continue;         }         if(s[i].birthday.month== date.month && s[i].birthday.day>date.day){             printf("\n%4d%16s %2d%2d",s[i].num,s[i].name,s[i].birthday.month,s[i].birthday.day);         }     } } 参考一下吧 问题1：inputInfo函数定义两次，第二次应该改成outputInfo 问题2：s[i]没有NUM结构体元素，应该改成小写； 问题3：searchInfo函数中，s[i].name应该对应的是%s，而不是%d 对比一下吧；写程序建议细心一些～

#include <stdio.h>  #define NUM 30 typedef struct { //日期结构体  	int year; 	int month; 	int day; }DATE;  typedef struct {//学生信息结构  	int num; 	char name[24]; 	DATE birthday;  //结构体嵌套  	char department[48]; 	char major[32]; }STUDENTINFO;  void inputInfo(STUDENTINFO* s,int count);  //函数声明  void outputInfo(STUDENTINFO* s,int count); //函数声明 void searchInfo(STUDENTINFO* s,int count, DATE date); //函数声明    int main() { 	STUDENTINFO s[NUM]; //学生结构体变量  	DATE date; //日期结构体变量  	inputInfo(s, NUM); 	outputInfo(s,NUM); 	printf("\n Enter a date(month,day)"); 	scanf("%d%d", &date.month, &date.day); 	searchInfo(s,NUM, date); }  //输入全部学生的信息 void inputInfo(STUDENTINFO* s,int count) { 	int i; 	printf("\nEnter %d student's information(name,birthday,department,major)\n", count); 	for (i = 0; i<count; i++) { 		s[i].num = i + 1; 		scanf("%s", s[i].name); 		scanf("%d%d%d", &s[i].birthday.year, &s[i].birthday.month, &s[i].birthday.day); 		scanf("%s", s[i].department); 		scanf("%s", s[i].major); 	} }  //输出全部学生的信息 void outputInfo(STUDENTINFO* s, int count) { 	int i; 	printf("\n NUM Name Birthday Department Major\n"); 	for (i = 0; i<count; i++) { 		printf("\n%4d%14s %4d%2d%2d%16s%16s", s[i].num, s[i].name, s[i].birthday.year, s[i].birthday.month, s[i].birthday.day, s[i].department, s[i].major); 	} }  //查找并输出date之后过生日的学生信息  void searchInfo(STUDENTINFO* s,int count, DATE date) { 	int i; 	for (i = 0; i<count; i++) { 		if (s[i].birthday.month>date.month) { 			printf("\n%4d%16s %2d%2d",  s[i].birthday.year, s[i].name, s[i].birthday.month, s[i].birthday.day); 			continue; 		} 		if (s[i].birthday.month == date.month&&s[i].birthday.day>date.day) { 			printf("\n%4d%16s %2d%2d", s[i].num, s[i].name, s[i].birthday.month, s[i].birthday.day); 		} 	} }


Question: c文件指针和文件的打开与关闭

1. 不知道你所谓的“产生关联”要多关联才算？按我的理解，(1)最低程度的关联是你只知道文件名，也就是只有一个字符串；(2)再高一点是你知道文件名，并且检查过文件是能打开的，也就是打开以后马上关闭；(3)再高一点就是打开文件。  2. 可以再赋值，因为aaa也不过是指向一个携带有一些信息的变量。如果你不关闭in，在程序运行期间in就一直是被打开、占用的，外在表现就是与in有关的内存得不到释放，其他程序也不能再修改in文件。但程序退出后in仍然会被释放。  3. aaa指向的那个携带有文件信息的变量，类型是struct FILE，里面记录有你当前的位置。每次发生读写，记录的位置都会自动变化。例如你读/写了4个字节，它就会+4。你要是想知道你现在所处的位置，可以随时调用ftell(aaa)来查看。当然你也可以调用fseek修改你的位置。

1  做不到 fopen这个函数的作用是 创建一个FILE 并返回指向这个FILE的指针  现在不创建一个FILE 却希望有一个指针指向一个FILE 这就很不符合逻辑了 2  打开了但是不关闭 FILE占用的一些系统资源无法返回给系统  比如 文件描述符 缓冲区 重复太多可能会导致 无法打开文件 内存被大量占用 等问题  3 你打开文件的方式是 "w"  这个模式会清空文件内容 你调用fscanf 的读取不到数据的 这个问题暂略  怎么知道读取数据的位置 FILE结构体里面记录了读取数据的位置  fscanf这个会函数会修改FILE结构体的记录

1. 兄弟，文件指针放在那里不用干嘛，那就干脆不要声明*aaa了 2. 当然可以重新赋值，重新赋值后原来的文件就没法关闭了，相当于系统资源没有释放，这样子肯定不行的 3. fscanf成功的话，返回值是>0的，这时会移动文件游标的


Question: C语言为什么编译不过关

include拼写错误，第一个printf后面没有分号，dogs没定义类型吧

此外，要先定义dog变量

最后那个printf的右双引号应该在逗号的前面

这什么教程... 你打错了吧

include关键字拼写错误吧


Question: 刚开始学就被虐了，小白求助，哪位大佬帮帮忙，指点一下，问题可能有很多

谢谢大佬

#include<stdio.h> #include<stdlib.h> #include<malloc.h>  typedef  int DaType;  #define MaxStackSize 100  typedef struct {     DataType stack[MaxStackSize];     int top; } SeqStack;  void StackInitiate(SeqStack *S) {     S->top = 0; }  int StackNotEmpty(SeqStack S) {     if (S.top<=0)return 0;     else return 1; }  int StackPush(SeStack *S,DataType x) {     if(S->top >= MaxStackSize)     {         printf("堆栈已满无法插入!\n");         return 0;     }     else     {         S->stack[S->top] = x;         S->top++;         return 1;     } }  int StackPop(SeqStack *S,DataType *d) {     if(S->top<=0)     {         printf("堆栈已空无数据元素出栈!\n");         return 0;     }     else     {         S->top--;         *d = S->Stack[S->top];         return 1;     } }  int StackTop(SeqStack S,DataType*d) {     if(S.top<=0)     {         printf("堆栈已空!\n");         return 0;      }     else     {         *d=S.stack[S.top-1];         return 1;     } }    参考一下吧

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


Question: 浙大数据结构最大子列和问题

《算法导论》第三版中，在引入分治策略的算法思想时，用的就是这个 最大子数组的问题 作为例子讲的，书中是使用的分治法，但在课后习题中，提供了一种新的思路，非递归并且在线性时间内求解的算法，算法非常巧妙。  如果如题中所说，不考虑最大值为负数的情况，并且只用求出最大和，不用给出最大子数组的索引下标，那么问题就变得很简单啦。 下面是代码。  #include <algorithm> int MaxSumOfSubArray(int* a, int n) { 	int maxA = 0; 	int maxR = 0;  	for (int i = 0; i < n; ++i) 	{ 		maxR = std::max(a[i], maxR + a[i]); 		maxA = std::max(maxA, maxR); 	}  	return maxA; }

https://www.cnblogs.com/conw/p/5896155.html  参考一下吧

算法就不对，你只考虑了从第一个数据开始的子序列，没有考虑到从第二个、第三个数据...开始的子序列，应该讲所有情况都考虑到

引用 3 楼 qq_30918465 的回复:printf("输入整数组元素个数");没要求输出这个 oj的题要按照要求的输入输出来

你的算法不对

printf("输入整数组元素个数");没要求输出这个

百度搜相关关键字。

请问大神们我错在哪里？


Question: C语言用codeblocks编译出错cannot find -liconv.lib和error: ld returned 1 exit status|

#include <iconv.h> 将这句注释掉再试试。

提示liconv.lib 没有找到

百度搜相关关键字。


Question: 问一个类型转换的问题

就是显示转换成TkWorld*类型，即指向TkWorld类型变量的指针，换句话说，就是按TkWorld去解释相应内存上的数据

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

将一句不懂的复合语句，拆解成多步尽量简单的语句并将每一步的结果的值及其对应的typeid().name显示出来帮助理解。

将一句不懂的复合语句，拆解成多步尽量简单的语句并将每一步的结果对应的typeid().name显示出来帮助理解。 参考下面：//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]   代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

就是强制轉換成TkWorld指針類型啊


Question: 编译成功，但是运行时候exe已停止工作。

你释放内存时先释放了pi2，此时pi2中的name已经无效，你再释放pi2->name导致程序错误，顺序要反过来


Question: 用Dev c++编译这个程序时出错，新手一个，不知道怎么解决

.h文件找不到，编译的时候.h文件的搜索路径检查一下。

代码复制上，编译，结果是这样的

是不是有什么地方操作过程不对，或者有什么遗漏的地方，才导致了编译不成功

wiringPi库文件已经放到如图位置了


Question: 求助关于realloc函数的问题

relloc 后，字符串相当于已经被截断，后面的内存已经不属于你，后面的内存是什么将不确定

百度的 指针名=（数据类型*）realloc（要改变内存大小的指针名，新的大小）。 新的大小可大可小（如果新的大小大于原内存大小，则新分配部分不会被初始化；如果新的大小小于原内存大小，可能会导致数据丢失[1][2]） 可能编译器实现不同。

申请的内存空间缩小，在输出原有的内存的数据是未定义的，内存大小由16变成8，有效的字符是7个。其他的输出或不输出都是未定义，后面输出什么不确定


Question: 求大牛指教：c语言中div是什么怎么用啊？

<< 是位运算，即2进制向左位移，1 << n  =  1*2^n;你可以改成 _div

引用 11 楼 bughyxqk的回复: 都是这个情况 和stdlib.h标准库中的div函数重复了，标准库函数功能参看：http://en.cppreference.com/w/c/numeric/math/div  解决办法，更改一个函数名，如把声明和实现位置均改成my_div

建议把div换个名字，可能和内部的函数名冲突了。

都是这个情况

都改了 没有一个是对的，还是一样的报错， 难道是我的编译器有毒。。。

引用 9 楼 bughyxqk 的回复:都改了 没有一个是对的，还是一样的报错， 难道是我的编译器有毒。。。 编程是一个细节，不能错过每一个点。 建议将你的编译信息贴出来，另外也将改过之后的代码帖出来。

1.函数在使用前需要已经定义或声明过   所以可以将int div(int n)放到main 函数前定义 2.num = div(n)   需先定义num

int div(num);   改成：  int div(int); int num;

引用 5 楼 bughyxqk 的回复:是一模一样的还是错。。。。。 那找一下你的编译器问题。或者提出错误信息～

是一模一样的还是错。。。。。

引用 2 楼 bughyxqk 的回复:还是一样的  这些我都试过了 试过了？对比一下代码，看一下那些地方给你修改了 在我的环境里测试没问题，能正常输出。

还是一样的  这些我都试过了

#include<stdio.h> #include<stdlib.h> int div(int num); int main() {     int n;     long num;       printf("请输入一个整数:\n");     scanf("%d",&n);     num = div(n);     printf("输出%d的阶乘为:%ld\n",n,num);       return 0; } int div(int n) {     //这里用到exit(0),所以需要导入stdlib.h库文件     //作用是:直接退出程序     if(n<0)     {         printf("输入数据有误!\n");         exit(0);     }     if(n==0||n==1)         return 1;     //递归调用函数自身     else         return n*div(n-1); } 把代码粘贴到你的环境里试一下

#include<stdio.h> #include<stdlib.h>  int main() {     int div(int num);     int n;     long num;      printf("请输入一个整数:\n");     scanf("%d",&n);     num = div(n);     printf("输出%d的阶乘为:%ld\n",n,num);      return 0; } int div(int n) {     //这里用到exit(0),所以需要导入stdlib.h库文件     //作用是:直接退出程序     if(n<0)     {         printf("输入数据有误!\n");         exit(0);     }     if(n==0||n==1)         return 1;     //递归调用函数自身     else         return n*div(n-1); } 参考一下吧  函数声明需要指定参数的类型，另外num未定义，需要提前定义


Question: 大一小白第一次发帖，求教一个数据结C语言构链表的问题

typedef struct linkNode{ 	int nExp;  // 指数 	int nCoe;  // 系数 	struct linkNode *pNext; }LINKNODE,*PLINKNODE;  void showLink(linkNode *pHead){ 	if(!pHead){ 		return ; 	} 	 	string strPress = ""; 	linkNode *pTemp = pHead->pNext; 	while(pTemp){ 		char szTemp[500] ={0}; 		sprintf(szTemp,"%dX^%d",pTemp->nCoe,pTemp->nExp);  		if(strPress.empty()){ 		   strPress = szTemp; 		}else{ 			strPress +=(string)"+"+szTemp; 		}  		pTemp=pTemp->pNext; 	}  	printf("%s\n",strPress.c_str()); 	return ; }  void createLink(linkNode * &pHead,int nNumber){ 	if(!pHead){ 		pHead = (PLINKNODE)malloc(sizeof(LINKNODE)); 	}  	linkNode *pTempNode = pHead;  	while(nNumber-->0){ 		LINKNODE *pNode = (PLINKNODE)malloc(sizeof(LINKNODE)); 		memset(pNode,0,sizeof(LINKNODE)); 		 		printf("请输入指数: \n"); 		scanf("%d",&pNode->nExp); 		printf("请输入系数: \n"); 		scanf("%d",&pNode->nCoe); 		pNode->pNext = NULL;  		pTempNode->pNext = pNode; 		pTempNode = pTempNode->pNext; 	} 	 	showLink(pHead);  }  void mergeLink(linkNode *pLeft,linkNode *pRight,linkNode *pResult){  	if(!pResult){ 		pResult = (PLINKNODE)malloc(sizeof(LINKNODE)); 	}  	if(!pLeft || !pLeft->pNext){ 		pResult->pNext = pRight; 	} 	 	if(!pRight || !pRight->pNext){ 		pResult->pNext = pLeft; 	}  	linkNode *pTemp_Left = pLeft->pNext; 	linkNode *pTemp_Right= pRight->pNext; 	 	linkNode *pTemp_Result = pResult; 	 	while(pTemp_Left && pTemp_Right) 	{ 		if(pTemp_Left->nExp >pTemp_Right->nExp){ 			pTemp_Result->pNext = pTemp_Left; 			pTemp_Left = pTemp_Left->pNext; 			pTemp_Result = pTemp_Result->pNext; 			pTemp_Result->pNext = NULL; 		}else if(pTemp_Left->nExp < pTemp_Right->nExp){ 			pTemp_Result->pNext = pTemp_Right; 			pTemp_Right = pTemp_Right->pNext; 			pTemp_Result = pTemp_Result->pNext; 			pTemp_Result->pNext = NULL; 		}else{ 			pTemp_Left->nCoe+= pTemp_Right->nCoe;  			pTemp_Result->pNext = pTemp_Left; 			pTemp_Left = pTemp_Left->pNext; 			pTemp_Result = pTemp_Result->pNext; 			pTemp_Result->pNext = NULL;   			pTemp_Right=pTemp_Right->pNext; 		}  	}  	if(pTemp_Left){ 		pTemp_Result->pNext = pTemp_Left; 	}  	if(pTemp_Right){ 		pTemp_Result->pNext = pTemp_Right; 	} 	 	printf("合并后的表达式：\n"); 	showLink(pResult); 	return ; }    int _tmain(int argc, _TCHAR* argv[]) {  	LINKNODE *pHead_left = NULL; 	 	createLink(pHead_left,4);  	LINKNODE *pHead_right = NULL; 	createLink(pHead_right,4); 	 	LINKNODE *pHead_result = NULL; 	mergeLink(pHead_left,pHead_right,pHead_result);  	return 0; }   写的比较匆忙，内存没有释放，仅供参考

仅供参考：//链表实现一元多项式的加法减法乘法 #include <stdio.h> #include <stdlib.h> typedef struct node {     float coef;   //系数     int expn;     //指数     struct node *next; } PolyNode;      //多项式节点 polynomial node typedef PolyNode* Polynomial; Polynomial createPolynomial() {  //创建多项式     PolyNode *p, *q, *head = (PolyNode *)malloc(sizeof(PolyNode));   //头节点     head->next = NULL;     float coef;     int expn;     printf("输入该多项式每一项的系数和指数，每项一行，输入0 0结束！\n");     while (scanf("%f %d", &coef, &expn) && coef) {   // 默认，按指数递减排列         if (head->next) {             p = head;             while (p->next && expn < p->next->expn)                 p = p->next;             if (p->next) {                 if (expn == p->next->expn) { //有相同指数的直接把系数加到原多项式                     p->next->coef += coef;                     if (p->next->coef > -0.000001 && p->next->coef < 0.000001) { //若是相加后系数为0，则舍弃该节点                         q = p->next;                         p->next = q->next;                         free(q);                     }                 } else {                     q = (PolyNode*)malloc(sizeof(PolyNode));                     q->coef = coef;                     q->expn = expn;                     q->next = p->next;                     p->next = q;                 }             } else {                 p->next = (PolyNode*)malloc(sizeof(PolyNode));                 p = p->next;                 p->coef = coef;                 p->expn = expn;                 p->next = NULL;             }         } else {             head->next = (PolyNode*)malloc(sizeof(PolyNode));             head->next->coef = coef;             head->next->expn = expn;             head->next->next = NULL;         }     }     return head; } Polynomial multiply(Polynomial poly, float coef, int expn) {  //多项式与指定单项式相乘，该单项式为 coefx^expn     PolyNode *p, *q, *Poly = (PolyNode*)malloc(sizeof(PolyNode));     p = Poly;     q = poly->next;     while (q) {         p->next = (PolyNode*)malloc(sizeof(PolyNode));         p = p->next;         p->coef = (q->coef*coef);         p->expn = (q->expn + expn);         q = q->next;     }     p->next = NULL;     return Poly; } void add(Polynomial poly1, Polynomial poly2) {  //把 poly2 加到 poly1 上     PolyNode *p, *q, *r;     r = poly1;     p = poly1->next;  //指向第一个节点     q = poly2->next;     poly2->next = NULL;     while (p && q) {         if (p->expn > q->expn) {             r->next = p;             p = p->next;             r = r->next;         } else if (p->expn < q->expn) {             r->next = q;             q = q->next;             r = r->next;         } else {             PolyNode *t;             p->coef += q->coef;             if (!(p->coef > -0.000001 && p->coef < 0.000001)) //系数不为0             {                 r->next = p;                 r = r->next;                 p = p->next;             } else {                 t = p;                 p = p->next;                 free(t);             }             t = q;             q = q->next;             free(t);         }     }     if (p)         r->next = p;     if (q)         r->next = q; } Polynomial polySubtract(Polynomial poly1, Polynomial poly2) {  //多项式减法 poly1-poly2形成一个新的多项式     //把poly2的系数取相反数，形成一个新的多项式     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode)); //构造头节点     PolyNode *p, *q;     p = poly;     q = poly2->next;     while (q) {         p->next = (PolyNode*)malloc(sizeof(PolyNode));         p = p->next;         p->coef = -(q->coef);  //系数取反         p->expn = q->expn;         q = q->next;     }     p->next = NULL;     add(poly, poly1);  //利用加法     return poly; } Polynomial polyAdd(Polynomial poly1, Polynomial poly2) { //多项式相加 poly1+poly2形成一个新的多项式     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode));  //和多项式的头节点     poly->next = NULL;     PolyNode *p, *q, *r;     r = poly;     p = poly1->next;     q = poly2->next;     while (p&&q) {         if (p->expn > q->expn) {             r->next = (PolyNode*)malloc(sizeof(PolyNode));             r = r->next;             r->coef = p->coef;             r->expn = p->expn;             p = p->next;         } else if (p->expn < q->expn) {             r->next = (PolyNode*)malloc(sizeof(PolyNode));             r = r->next;             r->coef = q->coef;             r->expn = q->expn;             q = q->next;         } else {             float m = p->coef + q->coef;             if (!(m > -0.000001 && m < 0.000001)) {                 r->next = (PolyNode*)malloc(sizeof(PolyNode));                 r = r->next;                 r->coef = m;                 r->expn = p->expn;             }             q = q->next;             p = p->next;         }     }     while (p) {         r->next = (PolyNode*)malloc(sizeof(PolyNode));         r = r->next;         r->coef = p->coef;         r->expn = p->expn;         p = p->next;     }     while (q) {         r->next = (PolyNode*)malloc(sizeof(PolyNode));         r = r->next;         r->coef = q->coef;         r->expn = q->expn;         q = q->next;     }     r->next = NULL;     return poly; } Polynomial polyMultiply(Polynomial poly1, Polynomial poly2) {  //多项式相乘     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode));  //创建多项式和的头节点     poly->next = NULL;     PolyNode *p;     p = poly2->next;     while (p) {         add(poly, multiply(poly1, p->coef, p->expn));         p = p->next;     }     return poly; } void printPoly(Polynomial poly) {  //打印多项式     if (poly && poly->next) {         PolyNode *p = poly->next;  //p指向第一个节点         while (p->next) {             printf("%gx^%d", p->coef, p->expn);             p = p->next;             if (p && (p->coef > 0))                 printf("+");         }         if (p->expn == 0)             printf("%g", p->coef);   //打印常数项         else             printf("%gx^%d", p->coef, p->expn);         printf("\n");     } } void freePoly(Polynomial poly) {  //释放内存     if (poly && poly->next) {         PolyNode *p, *q;         p = poly;         while (p) {             q = p->next;             free(p);             p = q;         }     }     poly = NULL; } int main() {     printf("用链表实现多项式的加减法\n");     Polynomial poly1, poly2, poly3;     printf("创建多项式一\n");     poly1 = createPolynomial();     printf("多项式一：\n");     printPoly(poly1);     printf("创建多项式二\n");     poly2 = createPolynomial();     printf("多项式二：\n");     printPoly(poly2);     printf("两多项式相加，和为：\n");     poly3 = polyAdd(poly1, poly2);     printPoly(poly3);     freePoly(poly3);     printf("两个多项式相乘，积为：\n");     poly3 = polyMultiply(poly1, poly2);     printPoly(poly3);     freePoly(poly3);     printf("两多项式相减，差为：\n");     poly3 = polySubtract(poly1, poly2);     printPoly(poly3);     freePoly(poly1);     freePoly(poly2);     freePoly(poly3);     system("pause");     return 0; }

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

#include<stdio.h> #include<malloc.h> #include<stdlib.h>  typedef struct LNode { 	int coe; 	int exp; 	struct LNode *next; }LNode,*linklist;  void creat(linklist &L,int n); void merge(linklist la,linklist lb,linklist &lc); void format(int coe,int exp); void show(linklist L); int main() { 	linklist ha,hb,hc; 	int Na,Nb;  	printf("请输入多项式ha的项数Na：");  	scanf("%d",&Na);  	printf("请输入多项式ha各项的系数和指数："); 	creat(ha,Na);  	show(ha); 	printf("请输入多项式hb的项数Nb：");  	scanf("%d",&Nb);  	printf("请输入多项式hb各项的系数和指数："); 	creat(hb, Nb);  	show(hb); 	merge(ha,hb,hc); 	printf("合并后的hc为:"); 	show(hc); 	return 0;                                                                                }  void creat(linklist &L,int n) { 	int i; 	linklist q,p; 	L = (linklist)malloc(sizeof(LNode)); 	if (!L) 		exit(0); 	L->next = NULL; 	q = L; 	for(i=1;i<=n;i++) 	{ 		p = (linklist)malloc(sizeof(LNode)); 		if (!p) 			exit(0); 		scanf("%d%d", &p->coe,&p->exp); 		q->next = p; 		q = q->next; 	} 	p->next = NULL; }  void merge(linklist la,linklist lb,linklist &lc) { 	linklist pa, pb, pc, ptmp; 	pa = la->next; 	pb = lb->next; 	lc = la; 	pc = la;  	while(pa && pb) 	{ 		if(pa->exp < pb->exp) 		{ 			pc->next = pa; 			pc = pa; 			pa = pa->next; 		} 		else if(pa->exp > pb->exp)  		{ 			pc->next = pb; 			pc = pb; 			pb = pb->next; 		} 		else 		{ 			pa->coe = pa->coe + pb->coe; 			pc->next = pa; 			pc = pa; 			ptmp = pb->next; 			free(pb); 			pa = pa->next; 			pb = ptmp; 		} 	} 	if(pa)  		pc->next = pa; 	else  		pc->next=pb; }  void format(int coe, int exp) { 	if(coe!=0) 		printf("%dX^%d", coe, exp); }  void show(linklist L) { 	linklist p; 	p = L->next; 	while (p->next) 	{ 		format(p->coe, p->exp); 		if(p->next!=NULL)  			printf("+"); 		p = p->next; 	} 	format(p->coe,p->exp); 	printf("\n"); }  参考一下吧  导致程序异常退出的是hc是野指针，并没有从merge函数里将新链表带到main函数内，因此需要使用引用。 另外merge函数内应将lb中和la相同的删除，防止内存泄露； 其他地方建议对比代码找一下原因。

建议不要对象之间来回赋值 这样容易内存泄漏 而且也容易出错 建议用指针  程序问题 可以设几个断点debug一下

一运行就成这样了，请问这是怎么回事


Question: 为什么.exe已停止工作，求大神帮忙解决啊

#define U 21628//用户数,数组第一行不使用 #define M 41370//电影数+1，数组第一列不使用 #define F 11//语义维数+1 #define lambda 0.14//正规化参数1,过拟合参数 #define T 409158//训练集个数 #define P 174812//测试集个数  //定义全局变量 float train[T][3]; float test[P][3]; float w[U]; float bu[U]; float bi[M]; float user[U][F];//用户矩阵 float movie[M][F];//项目矩阵 你确定要用这么多空间，建议算一下这个程序使用了多少内存：21628 * 11, 41370 * 11, 409158 * 3, 174812 * 3这些也只是一部分。 申请的空间太多，可能是这个原因导致程序异常。建议根据需要申请适量的内存。

引用 2 楼 pandabone1 的回复:亲测无异常，应该是楼上所说的内存问题

亲测无异常，应该是楼上所说的内存问题


Question: C语言getchar()问题

getchar读取输入前需要清空输入缓存，fflush(stdin)加在getchar之前就可以了。

fflush(stdin);

你之前可能有scanf之类输入代码，在输入完成后缓冲区留下了换行符\n，被之后的getchar接收，你可以在这些输入语句后加上getchar接收掉缓冲区中的\n

getchar()是终端得到一个字符，其实这个字符是从输入缓存里得到的。而上次输入之后，会将'\n'留在输入缓存里，因此getchar()得到的是'\n'。如果要想得到想要的，最新输入的字符，建议现将上次输入之后残留在输入缓存里的数据“吃掉”，可以考虑用两个getchar();因为第一个getchar()是用于吃掉'\n'；也可以使用如下方式：   while ((c = getchar()) == '\n')     ;


Question: 各位大佬们，请问一下有什么数据结构与算法的书好推荐？为何推荐呢？

感谢大佬的答复不迷路

各种数据结构算法书 其实都大同小异 推荐还是学校教材->网上热门的书 （因为学校更加注重基础 入门比较简单）但是终归终归还是要先看 不要因为纠结哪一本书而浪费时间 哪一本都可以开始 千里之行 始于足下

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

基本数据结构与算法的书都可以，想不清楚就画下图理解下，实在不懂先往后看，等积累的多了回头就自己发现好懂了，不要有排斥心理

那练习c编程也可以，但是也还是要提高自己的，所以emmm事先问下这类书有哪些好推荐。起初怕自己不懂如何去优化程序

如果刚学C，不建议去读算法导论等复杂的算法；对于数据结构和算法，如果是初学C语言，还是建议去学习课本知识，多去练习C语言的编程。

Algorithms + Data Structures = Programs，图灵奖得主Niklaus Wirth经典著作，ACM推荐教材之一。

先把基础知识吃透，再看数据结构


Question: 萌新请教，求帮助

这种无非是使用无效的内存地址，简单的输入打印。2F基本说明了问题，输入地址引用问题。

把代码贴出来

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

截图只能说很“搞笑”，关键的代码一句也没截到，无关紧要的倒是很多。 建议，将代码贴出来；运行的结果可以考虑用截图的形式。

scanf("%f", radius); 改成：scanf("%f", &radius);

你把代码发出来，没有代码怎么判断


Question: 大伙来看看这是不是假书害人啊？

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

别光看，在IDE上敲一下就知道哪儿错了

建议不要觉得，写一个小的demo程序试一下不就知道了吗？ 写一个简单的程序，调用一下这个函数接口，试一下。然后分析一下程序的流程～

百度搜相关关键字。


Question: 新手小白求问typedef struct问题

TreeNode *nodetemp nodetemp-> TreeNode nodetemp nodetemp.

void RoundBegin(int max_i,Graph *g,int *OTDR_vexs) {     int MaxNum_OTDR=100;  //后期可以限制OTDR的数量，先暂时不限制     int OTDR_Pra=150;  //OTDR的最远可测公里数参数     TreeNode nodetemp;      queue <TreeNode> q;      nodetemp.vex=max_i;     nodetemp.father_vex=NULL;     nodetemp.km_rest=150;      return; } 参考一下吧  TreeNode nodetemp;这儿定义的是结构体变量，而不是结构体指针。对于结构体指针可以用->引用结构体元素，否则要用“."。 另外，father_vex是int类型，而NULL是(void *)0。因此，类型不匹配。


Question: 剥离传过来的两层协议（分二个包发过来）要求：获取第二层协议的数据内容

#include "queue.h" #include "string.h" #include "stdio.h" #include <stdlib.h> QUEUE gstSpQueue; // SP协议 QUEUE gstTpQueue; // 8583协议 TERPACK gstTp; enum { 	SP_STATUS_STX		= 0, 	SP_STATUS_FRAME, 	SP_STATUS_TOTLEN, 	SP_STATUS_TYPE, 	SP_STATUS_CMD, 	SP_STATUS_RETCODE, 	SP_STATUS_DATALEN, 	SP_STATUS_DATA, 	SP_STATUS_CHECKCODE, 	SP_STATUS_ETX, };  enum { 	TP_STATUS_LEN1 =0, 	TP_STATUS_LEN2, 	TP_STATUS_DATA, };    void ClearQueue(QUEUE *Queue) { 	Queue->Head = 0; 	Queue->Tail = 0; 	memset(Queue->Data,0,sizeof(Queue->Data)); }  int IsQueueEmpty(QUEUE *Queue) {     if(Queue->Head == Queue->Tail) {        	return TRUE;     }         else {        	return FALSE;         }	     }  int IsQueueFull(QUEUE *Queue) { 	if(Queue->Head == ((Queue->Tail+1) % QUEUE_SIZE)) {        	return TRUE;     }         else {        	return FALSE;         }	     }  int DelQueue(QUEUE *Queue) { 	if (TRUE == IsQueueEmpty(Queue)){ 		return FALSE; 	}     else { 		//Queue->Data[Queue->Head]= 0; 		Queue->Head = ((Queue->Head+1) % QUEUE_SIZE);        	return TRUE;         }	     }  int InsertQueue(QUEUE *Queue,unsigned char *lpIn,int nLen) { 	int i;  	for(i = 0; i < nLen; i++) { 	    if( !IsQueueFull(Queue) ) { 	    	Queue->Data[Queue->Tail] = lpIn[i]; 	   		Queue->Tail = (Queue->Tail + 1) % QUEUE_SIZE; 	    } 	    else { 			ClearQueue(Queue); 			Queue->Data[Queue->Tail] = lpIn[i]; 	   		Queue->Tail = (Queue->Tail + 1) % QUEUE_SIZE; 	        //break; 	    } 	}	     	return i; }  void SetQueueHead(QUEUE *Queue,int nHead) { 	nHead = nHead % QUEUE_SIZE; 	if( !IsQueueEmpty(Queue) ) { 		if(Queue->Head < Queue->Tail) { 			if(nHead >= Queue->Head &&  nHead <= Queue->Tail) { 				Queue->Head = nHead; 			} 			else { 				ClearQueue(Queue); 			} 		} 		else { 			if(nHead >= Queue->Head || nHead <= Queue->Tail) { 				Queue->Head = nHead; 			}	 			else { 				ClearQueue(Queue); 			} 		}	 	} }  int GetQueueHead(QUEUE *Queue) { 	return Queue->Head; }  int TryQueueData(QUEUE *Queue,int nHead,unsigned char *lpOut) { 	nHead = nHead % QUEUE_SIZE; 	if( !IsQueueEmpty(Queue) ) { 		if(Queue->Head < Queue->Tail) { 			if(nHead >= Queue->Head &&  nHead < Queue->Tail) { 				*lpOut = Queue->Data[nHead]; 				DelQueue(Queue);//出队列 从队列头删除, 				return TRUE; 			} 		} 		else { 			if(nHead >= Queue->Head || nHead < Queue->Tail) { 				*lpOut = Queue->Data[nHead]; 				DelQueue(Queue);////出队列 从队列头删除 				return TRUE; 			}	 		} 	} 	return FALSE; }  int ParseSpData(unsigned char *out_buf, unsigned int *out_len) {    unsigned char Data = 0,CheckSum = 0,ParseStep = 0;                        			     int head, Result_len = 0, DataNum = 0,ret = 0;    int iLen = 0;    int isoNum = 0;    unsigned char *Result_buf = (unsigned char *)malloc(QUEUE_SIZE);    memset(Result_buf,0, QUEUE_SIZE);        head = gstSpQueue.Head;	    while( TryQueueData(&gstSpQueue,head,&Data) ) {	         head = (head + 1) % QUEUE_SIZE;						 		switch( ParseStep )	{             case SP_STATUS_STX:                 if(Data == STX)	{                     ParseStep = SP_STATUS_FRAME;					                     CheckSum = 0; 					DataNum = 0; 					iLen = 0; 					isoNum = 0;                     Result_len = 0;	                 }                 else{                     SetQueueHead(&gstTpQueue,head); 	                 }                 break;             case SP_STATUS_FRAME:                              				ParseStep = SP_STATUS_TOTLEN;                 break;             case SP_STATUS_TOTLEN:  				CheckSum ^= Data; 				if(0 == DataNum) { 					DataNum++; 					iLen =  Data<<8; 				} else { 					iLen += Data; 					DataNum = 0; 					ParseStep = SP_STATUS_TYPE; 				} 				break;		 			case SP_STATUS_TYPE: 				CheckSum ^= Data; 				ParseStep = SP_STATUS_CMD; 				break;             case SP_STATUS_CMD:	  				CheckSum ^= Data; 				ParseStep = SP_STATUS_RETCODE; 				break; 			case SP_STATUS_RETCODE: 				CheckSum ^= Data; 				ParseStep = SP_STATUS_DATALEN; 				break; 			case SP_STATUS_DATALEN: 				if(0 == isoNum) { 					isoNum++; 					Result_len =  Data<<8; 				} else { 					Result_len += Data; 					isoNum = 0; 					if(0 == Result_len) { 						SetQueueHead(&gstSpQueue,head); 						ParseStep = SP_STATUS_STX;     // 8583报文长度=0,就从头再来。 						break; 					}else { 						ParseStep = SP_STATUS_DATA; 					} 				} 				CheckSum ^= Data; 				break; 			case SP_STATUS_DATA: 				Result_buf[isoNum ++] = Data; 				CheckSum ^= Data; 				if(isoNum == 3){ 					printf("\n"); 				} 				if(isoNum == Result_len ) { 					ParseStep = SP_STATUS_CHECKCODE;               				}  				break; 			case SP_STATUS_CHECKCODE: 				if(Data == CheckSum){ 					ParseStep = SP_STATUS_ETX;  				} else { 					SetQueueHead(&gstSpQueue,head);  				} 				break; 			case SP_STATUS_ETX: 				if(0x40 == Data) { 					ParseStep = SP_STATUS_STX;  					InsertQueue(&gstTpQueue, Result_buf, Result_len); 					if(TRUE == ParseTpData(out_buf,out_len)) { 						ret = TRUE; 						goto exit; 					} 				} else { 					SetQueueHead(&gstSpQueue,head);  				} 				break;             default:             	break;     	} 	    	}  exit:    printf("ret  =%d,out_len =%d\n",ret,*out_len);    if(NULL !=Result_buf) 		free(Result_buf);    return ret; }   int ParseTpData(unsigned char *out_buf, unsigned int *out_len) {    unsigned char Data = 0;                        			     int head, Result_len = 0;    int isoNum = 0,ret = 0;    head = gstTpQueue.Head;	    while( TryQueueData(&gstTpQueue,head,&Data) ) {	         head = (head + 1) % QUEUE_SIZE;						 		switch( gstTp.status )	{	 			case TP_STATUS_LEN1: 					gstTp.Data[gstTp.ipos++] = Data<<8; 					gstTp.status = TP_STATUS_LEN2; 					 					break; 			case TP_STATUS_LEN2: 					gstTp.Data[gstTp.ipos++] = Data; 					gstTp.status = TP_STATUS_DATA; 					 					break; 			case TP_STATUS_DATA: 					gstTp.Data[gstTp.ipos++] = Data; 					if( gstTp.ipos  == (gstTp.Data[0]*256 + gstTp.Data[1]) +2 ) { // ipos增加了 datalen[0]+datalen[1] 						*out_len = gstTp.ipos; 						memcpy(out_buf, gstTp.Data, gstTp.ipos); 						gstTp.status = TP_STATUS_LEN1; 						ret = TRUE; 						goto exit;         					}  				break;             default:             	break;     	} 	 	}  exit:    //printf("ret  =%d,8583_len =%d\n",ret,gstTp.ipos);    return ret; }  main.c #include "stdio.h" #include "queue.h" void main() { 	int iRet =-1,i; 	unsigned int iLen = 0; 	unsigned char buffer[1024]={0}, sResultBuff[QUEUE_SIZE] = {0}; 	 	/* 	unsigned char test[]={0x02,0x00,0x00,0x05,0x6C,0x06,0x00,0x00,0x00,0x6F,0x40 };     unsigned char test1[]={0x02,0x00,0x00,0x07,0x6C,0x06,0x00,0x00,0x02,0x00,0x08,0x67,0x40};     unsigned char test2[]={0x02,0x00,0x00,0x0D,0x6C,0x06,0x00,0x00,0x08,0x01,0x02,0x03,0x04,0x05,0x06,0x07, 	   0x08,0x67,0x40};  	InsertQueue(&gstSpQueue, test, sizeof(test)); 	InsertQueue(&gstSpQueue, test1, sizeof(test1)); 	InsertQueue(&gstSpQueue, test2, sizeof(test2)); 	*/ 		 	 	 unsigned char test[]={       0x02,0x00,0x00,0xF7,0xA1,0x12,0x00, 0x00,0xF2,0x00,0xF2,0x60,0x00,0x00,0x09,0x51, 0x90,0x20,0x01,0x00,0x00,0x00,0x39,0x39, 0x30,0x36,0x30,0x35,0x30,0x35,0x35,0x33, 0x33,0x36,0x30,0x30,0x30,0x30,0x30,0x30, 0x30,0x30,0x30,0x31,0x31,0x33,0x30,0x30, 0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30, 0x30,0x30,0x30,0x33,0x30,0x30,0x30,0x30, 0x30,0x30,0x30,0x30,0x39,0x39,0x30,0x36, 0x30,0x35,0x30,0x35,0x35,0x33,0x33,0x36, 0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30, 0x30,0x30,0x30,0x08,0x10,0x00,0x38,0x00, 0x01,0x02,0xC0,0x00,0x14,0x00,0x00,0x02, 0x08,0x43,0x15,0x03,0x30,0x08,0x99,0x99, 0x00,0x01,0x30,0x30,0x30,0x30,0x30,0x30, 0x30,0x30,0x31,0x31,0x39,0x39,0x30,0x36, 0x30,0x35,0x30,0x35,0x35,0x33,0x33,0x36, 0x30,0x30,0x30,0x00,0x11,0x50,0x00,0x00, 0x81,0x00,0x30,0x01,0x04,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x7C,0x4F,0x92,0x62,0x76,0x2C,0xB7, 0xFE,0xC7,0xB9,0x32,0x4D,0x5D,0x42,0x8F, 0xE6,0x85,0x97,0x16,0xE1,0xAC,0x66,0x1E, 0x60,0xBC,0x6C,0x9C,0xFE,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0xA6,0x6D,0xF6, 0xD8,0x43,0xCE,0x13,0x56,0xF7,0xC2,0xBD, 0x59,0x4F,0xEB,0x88,0xD5,0xDE,0x98,0x46, 0x4F,0x7C,0x3D,0xE3,0x40     }; 	     unsigned char test4[]={0x02,0x00,0x00,0x07,0x6A,0x01,0x00,0x00,         0x02,0xB2,0xDA,0x06,0x40 }; 	     InsertQueue(&gstSpQueue, test, sizeof(test));     InsertQueue(&gstSpQueue, test4, sizeof(test4));  	iRet = ParseSpData(sResultBuff, &iLen); 	 	for( i =0;i<iLen;i++) printf("%02x",sResultBuff[i]); 	printf("\n"); 	 	return; }  queue.h #ifndef _QUEUE_H #define _QUEUE_H  #define QUEUE_SIZE		(2*1024)								//队列长度 #define STX				0x02									//头 #define ETX				0x03									//结束标志  #ifndef TRUE  #define TRUE	1 #endif  #ifndef FALSE	 #define FALSE	0 #endif  typedef struct _QUEUE														 { 	int Head; 	int Tail; 	unsigned char  Data[QUEUE_SIZE]; }QUEUE;   typedef struct _tp{ 	unsigned int status; 	unsigned char ipos; 	unsigned char Data[QUEUE_SIZE]; }TERPACK;  extern QUEUE gstSpQueue;               extern QUEUE gstTpQueue;  extern TERPACK gstTp;  void ClearQueue(QUEUE *Queue); int IsQueueEmpty(QUEUE *Queue); int IsQueueFull(QUEUE *Queue); int InsertQueue(QUEUE *Queue,unsigned char *lpIn,int nLen); void SetQueueHead(QUEUE *Queue,int nHead); int GetQueueHead(QUEUE *Queue); int TryQueueData(QUEUE *Queue,int nHead,unsigned char *lpOut); int ParseSpData(unsigned char *out_buf, unsigned int *out_len); int ParseTpData(unsigned char *out_buf, unsigned int *out_len); #endif


Question: Linux C使用execl函数调用/usr/bin/java，输出：Could not create the Java Virtual Machine

引用 1 楼 cfjtaishan 的回复:if(execl("/usr/bin/java", "Main", (char *)0) == -1) { fprintf(stderr, "execl error:%s\n", strerror(2)); } 建议试一下这种形式   试过了，仍是不可以。我的Main.java只是简单的输出三行字符串。

if(execl("/usr/bin/java", “java", "Main", (char *)0) == -1) { fprintf(stderr, "execl error:%s\n", strerror(2)); } 只能多试试了

百度搜相关关键字。


Question: 求最大公约数和最小公倍数的问题，这样写怎么不对呢

scanf_s("%d %d ", &m, &n);改成：scanf_s("%d %d", &m, &n);  也就是去掉后面的空格

算法就不对，最大公约数和最小公倍数不是这样算的，比如算最小公倍数，一般是用两个值中的大值的倍数去取余小值，看是否为0.


Question: 如果a&b=c 或者a|b=c ，已知a和c 怎么求b?

从你给的条件未必是唯一解，很多位运算与数学运算不同，不是已知两个就可以唯一确定剩余的那个

这个解>=一个，所以不能求出唯一解，只能求出其中一组解 比如：1111 | b == 1111，那么b可以是任何解，又1100 & b == 0000，那么所有解：1100,1101,1110,1111


Question: 求最大公约数可以利用函数指针传地址求吗？为什么啊

可能你的问题是“函数的非引用参数” 普通的非引用类型的参数通过复制对应的实参实现初始化。当用实参副本初始化形参时，函数并没有访问调用所传递的实参本身，因此不会改变实参值。 但是，当函数参数是指针时，函数的形参得到的是参数的地址，而在函数内部对形参（地址）保存的内容进行操作，相当于操作了实参。  相关内容请参考《 C++中函数的数组形参》 https://blog.csdn.net/hou09tian/article/details/78046909

第二种方法其实不是函数指针，而是函数参数是变量的地址，就这个程序而言两种方法完全一致，并没有用到传地址的优势

首先你这个不叫函数指针，两种方法的区别在于函数的参数类型不同： 函数1：使用Int型参数，调用时直接传int型值 函数2：使用int* 型参数，调用时传int型参数地址，通过*地址使用 不同点在于函数1对输入值不会影响，函数2会改变输入值

第二个是程序使用利用指针变量，传递的是main函数里的num1, num2的地址，在Max函数内，用*num1，*num2即引用main函数里num1, num2的值，即和传num1, num2的值到Max是一样的。 第二个程序使用指针做形参，即使没有返回值，也可以得到最大公约数，建议在main函数里打印一下num1, num2的值（在调用Max函数之后）num2的值就是最大公约数。因为&num1，&num2除了是传入参数之外，还是传出参数。

函数都是值传递 差别是1传递的是变量的数据，2传递的是变量的地址

你这里面没有用到函数指针 int(*pf)(); pf才是一个函数指针  你是想问形参是值类型或者引用类型的差异吧

函数的副本机制可以复习一下

楼主的第二个实现不叫函数指针，只是函数的形参是指针形式的。


Question: gcc编译错误

#include <stdio.h> #include <stdlib.h>  typedef struct Student {     int num;     char name[20];     float score[3]; }st;  void input(st stu[],int n) {     int i,k;     for(i=0; i<n; i++)     {         scanf("%d", &stu[i].num);         scanf("%s", stu[i].name);         for(k=0; k<3; k++)         {             scanf("%f",&stu[i].score[k]);         }     } }  void print(st stu[],int n) {     int i;     for(i=0; i<n; i++)     {         printf("%d %s %.1f %.1f %.1f",stu[i].num,stu[i].name,stu[i].score[0],stu[i].score[1],stu[i].score[2]);         if(i<n-1)             printf(" ");     } }  int main() {     int n;     scanf("%d",&n);     st *a = (st *)malloc(sizeof(st));     if (!a)         return -1;     input(a,n);     print(a,n);     free(a);     return 0; } 首先用gcc编译没有警告和错误； 对于不确定数组长度的问题，建议使用malloc/free

我就是用GCC啊，没报错  格式： gcc D:/cc.c -o D:/cc.o


Question: DEVC++编译通过无输出结果求解决方法

for (N = 0; c[0][N] != '\0'; L++)  这里应该是 N++ 吧


Question: oj上的肿瘤题，输出结果是对的，但是一直没通过。求指正，先谢过了

不需要整个位图都读进来，可以边读边分析，只用一个char/int读就可以了。

引用 3 楼 weixin_41301438 的回复:为啥嘞！！！！ int a[n][n];  这种语句写出来，让我得到了的结论。

为啥嘞！！！！

是不是有没有0的情况

还是那句话先把语法学好


Question: 一个循环出错的问题

在求个十百每位上的数字时有问题，比如：  /*         a = i / 100;         b = (i - 100) / 10;         c = i - a*100 - b*10;         */         a = i / 100;         b = (i % 100) / 10;         c = i % 10; 按照注释掉的算法：若i = 200;那么a = 200 /100，则a = 2; b = (200 - 100) / 10，即b = 10；c = 200 - 2 * 100 - 10 * 10;则c = -100; 因此，按照你的逻辑，a,b,c的值分别是2,10，-100；其实200的个十百位分别位：0,0,2 可参考未注释部分的代码。

求个 十 百位数的逻辑错了 ，你求出来的a,b,c不是他本来的个十百位数上的数字

建议楼主对自己写的代码单步调试一下，代码较短，会很快能找到问题的。

引用 2 楼 qq_29856789 的回复:output 函数的第二个参数写错了，sizeof(r)和sizeof(int)都是4，所以传递num 的值是1，循环只执行一次 不会啊，sizeof（r）是40，我在那个shuxianshu的函数里用输出检测也是只能得到一个水仙数

#include<stdio.h>   int shuxianshu(int *p); void output(const int *input, int num);  int main (int argc, char *argv[]) {     int r[10] = {0};      shuxianshu(r);     output(shuxianshu(r), (sizeof(r) / sizeof(int)));      return 0; }  int shuxianshu(int *p) {     int a, b, c;     int i, j = 0;      for(i = 100; i <= 999; i++)     {     	''''''''''''''''''         a = i / 100;         b = i / 10 % 10;         c = i % 10;         ''''''''''''''''''          if(a * a * a + b * b * b + c * c * c == i)         {             *(p + j) = i;             printf("%d\n", i);             j++;         }     }      return  p; }   void output(const int *input, int num) {     int a, b, c, i;      for(i = 0; i < num; i++)     {         a = * (input + i) % 10;         b = (* (input + i) / 10) % 10;         c = (* (input + i) / 100) % 10;          if(*(input + i) != 0)         {             printf("%d^3+%d^3+%d^3 = %d\n", a, b, c, * (input + i));         }     } }


Question: 声明变量的位置产生C2143和C2065错误

比较老的编译器有这个要求：将所有的定义/声明放在前，使用放在后面。建议使用最新的（或较新的）编译器。

你用的编译器比较老吧，比较老的编译器采用旧的标准，规定在任何执行语句之前，在块的开头声明所有局部变量。较新的编译器已经没有这个限制了


struct ListNode* partition(struct ListNode* head, int x) {        struct ListNode left, right;        struct ListNode *l = &left, *r = &right;          while(head){             struct ListNode*  ref = head->val < x ? l : r;             ref->next = head;             ref = ref->next;                          head = head->next;         }         l->next = right.next;         r->next = NULL;         return left.next; }  同时这个也需要能得到大家的帮助谢谢啦


Question: 初学C语言编程，，程序运行时停止工作

scanf("%d%d%d",&a,&b,&c);

scanf("%d%d%d",&a,&b,&c);

scanf("%d%d%d",&a,&b,&c); 取地址，加&

忘记加地址符了

scanf("%d%d%d",&a,&b,&c);

scanf("%d%d%d",a,b,c);后面是&a,&b,&c

scanf 后面的参数要加上&

传地址才能输入

scanf函数中的变量要加取地址符&

输入的时候没有打&地址符哦

新手常见错误，将scanf("%d%d%d",a, b, c); 改为scanf("%d%d%d",&a, &b, &c)， 以后写程序要多调试

1.输入三个数时有错误，scanf("%d%d%d",a,b,c);应改为scanf("%d%d%d",&a,&b,&c);,因为在输入数值型的变量时要加上取地址符&，否则会发生错误，但如果要输入一个字符串，只要输入字符数组名即可，因为字符数组名代表数组的首地址。 2.程序最后的retuen 0;不应该放在if...else嵌套结构里面，应把其放在花括号外面。

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字符或回车换行，读取下一个字符。

输入要有地址符

将scanf("%d%d%d",a, b, c); 改为scanf("%d%d%d",&a, &b, &c);   //记住要输地址符号&

scanf("%d%d%d",a,b,c); 输入函数的参数类型问题，改成这样： scanf("%d%d%d", &a, &b, &c);


Question: c语言字符串函数

stycpy(b,c); 函数名拼写错误； 改成 strcpy(b,c);


Question: 条件编译中用@符号扩起的，表示什么意思？

引用 5 楼 kingyo 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] 和代码生成技术有关，我猜。  确实如赵老师所说，这个源代码还需要有一个配置的过程，我没有配置就拿过来了。配置后没有@@了。[/quote] 一般我猜得还是比较准的。

引用 3 楼 zhao4zhong1 的回复:和代码生成技术有关，我猜。  确实如赵老师所说，这个源代码还需要有一个配置的过程，我没有配置就拿过来了。配置后没有@@了。

和代码生成技术有关，我猜。

不是C++的语法吧，是不是用来标记什么东西的

还有这样的写法吗

还真没见过使用@呢，但收尾两个@。可能用于区分一个宏名。或者@本身就是属于宏名的一部分。 不过，在Linux编程这么多年，没见过用@的宏


Question: 关于c语言学习中的问题

百度搜相关关键字。

自己顶一个！！！

不行啊，每次打开都是提示下载，我想在页面显示！！！

1.检查下cgi-bin的配置，是否添加了cgi的后缀  2.C程序里有没有打印content-type信息 printf("Content-type:text/html\n\n"); 在输出之前打印

自己顶一个！！！

自己顶一个！！！


Question: 新手C++链表问题（寻找最大节点）

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

#include <iostream> #include <cstdio> #include <cstdlib> using namespace std;  struct LinkList {     int data;     LinkList *next; };  void CreateList_L(LinkList *&L, int n) {     int i;     LinkList *p;      /*malloc的空间不对，应该是sizeof(LinkList)*/     L = (LinkList*)malloc(sizeof(LinkList));     L->next = NULL;     for (i = n; i > 0; --i)     {         p=(LinkList*)malloc(sizeof(LinkList));         scanf("%d", &p->data);         p->next = L->next;         L->next = p;     }  }  int main() {     int i,g;     // LinkList *ddd;     LinkList *dd;     LinkList *head;     CreateList_L(head,5);     //CreateList_L(ddd,5);     LinkList *p = head->next;     LinkList *q = p;   /*指向最大节点*/      while (p) {         if (p->data > q->data)             p = q;         p = p->next;     }      cout<<"Max node's data is " <<q->data<<endl; #if 0     for(i=1;i<=5;i++)     {         if(p<p->next)             //{g=p->data;}              p=p->next;         g=p->data;      }      cout<<g; #endif     return 0;  }   参考一下吧  malloc申请的空间不对，每个节点至少要2 * sizeof(int)个内存空间，为啥只申请一个字节呢。  求最大值节点，逻辑有点问题。对比代码参考一下吧

#include <iostream>  #include"malloc.h" using namespace std;   struct LinkList {  int data;  LinkList *next; };   void CreateList_L(LinkList *&L,int n) {   int i;  LinkList *p;  L=(LinkList*)malloc(1);   L->next=NULL;   for (i=n;i>0;--i)  {    p=(LinkList*)malloc(1);    scanf("%d",&p->data);    p->next = L->next;   L->next = p;   }    }    int main() { 	int i,result;     // LinkList *ddd;   LinkList *head;  CreateList_L(head,5);  //CreateList_L(ddd,5);  LinkList *p=head->next;    result=p->data;   // *g=p; for(i=1;i<=5;i++)  //循环五次   {  	//p=p->next; 	if(result<p->data)   //当p小于他的下一个的时候  	//{g=p->data;}    {	         	    //向后 跳  	    result=p->data; 		//cout<<result; 		//p=p->next; 		//cout<<result; 	}  	//g=p->data; //	*g=p;  p=p->next;  }  cout<<result;//打印最大值   return 0; } 为什么这样就能成功 不能用p->data 进行比较吗

引用 5 楼 u011261943 的回复:[quote=引用 2 楼 a875052544 的回复:] 还想问一个 如果我要对一个单链表任意一个节点进行访问 我该怎么说 第一天上课 懵逼啊！！ 遍历链表，这个东西也不麻烦，建议找个程序看看就知道了。 [/quote] int main() { 	int i,result;     // LinkList *ddd;   LinkList *head;  CreateList_L(head,5);  //CreateList_L(ddd,5);  LinkList *p=head->next;    result=p->data;   // *g=p; for(i=1;i<=5;i++)  //循环五次   {  	 	if(p->data<p->next->data)   //当p小于他的下一个的时候  	//{g=p->data;}    {	         	    p=p->next;    //向后 跳  	    result=p->data; 	}  	//g=p->data; //	*g=p;     }  cout<<result;//打印最大值   return 0; } 错哪？？想不明白 每次输出都是最后一个

引用 2 楼 a875052544 的回复:还想问一个 如果我要对一个单链表任意一个节点进行访问 我该怎么说 第一天上课 懵逼啊！！ 遍历链表，这个东西也不麻烦，建议找个程序看看就知道了。

引用 3 楼 u011261943 的回复:先说两个问题， 1、排版不好看，看起来费劲，注意缩进对齐 2、变量命名太随意, d   ddd这类的没有含义的命名最好少用，就算只是测试用例，养成良好的编码习惯很有必要。  正题： for(i=1;i<=5;i++) {   if(p<p->next)     p=p->next;    g=p->data; } 再想想这段代码的逻辑，想象这段代码能不能取到链表的最小值 ----》》》想想再往下看--》》》 你的if判断用得不对，怎么能用指针地址作为判断条件？？你要取得是data最小的节点，而不是 地址值最小的节点sorry，是值最大的节点。链表节点里面，一个是成员存的下一个节点的地址，另一个成员存的是当前节点的data。 你要比较的是data，而不是下一个节点的地址。

新手新手 求教


Question: vc++6.0上为什么 有些程序没有错却运行不出正确结果呢。。。。

程序编译没有错误，只能证明你的代码在语法上没有错误，并不能代表你的程序是正确的，算法有错误是可以通过编译，但运行会出错，这道题并不难，仔细的查找其中马虎的地方，下次不要再犯就是一种成长！加油！

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

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

#include<stdio.h>  int main() {     int i=0,n=0;     char c[]="coder\0-pig";   //利用循环求字符串的长度      //while(c[i++]!="\0")     while(c[i++] != '\0')         n++;     printf("输出字符串的长度:%d\n",n);      n = sizeof(c)/sizeof(char);     printf("输出字符数组的长度:%d\n",n);      for(i=0;i<11;i++)         printf("%c", c[i]);     putchar(10);      return 0; } 参考一下吧 第一个，字符串结束标记是'\0'而不是"\0"，后面的是字符串，不是字符；  #include<stdio.h>  int main() {     int i;     double sum=0;     //for(i=1; 1 <= 100;i++)     for(i=1; i<=100;i++)     {         sum +=i;     }     printf("输出前100项的和:%lf\n", sum);     return 0; } 编程是一个细活，写错一个字母都会出现完全不一样的结果。

程序有问题，你需要再检查一下。

#include<stdio.h> int main() { int i; double sum=0; for(i=1;1<=100;i++) //这里写成死循环了，应该是(i=1;i<=100;i++) { sum +=i; } printf("输出前100项的和:%lf\n",sum); return 0; }

第一个while（）里面\0要用单引号，第二个for循环条件写错了不是1<=100而是i<=100


Question: 为什么形参地址值一样

理解和讨论之前请先学会如何观察！  http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素 http://edu.csdn.net/course/detail/2455 C语言指针与汇编内存地址-二.函数 http://edu.csdn.net/course/detail/2516 C语言指针与汇编内存地址-三.数组和二维数组 http://edu.csdn.net/course/detail/2517 C语言指针与汇编内存地址-四.三维数组

void my_point_func(ab，char *pa)  你在函数中再多加个参数ab试试看吧，

1.开始执行my_array_func 函数，进栈假如起始位置0xffff1234，执行过程中可能会定义新的栈变量，因为是函数内的栈地址是递减的，所以会根据定义的变量大小递减。等到函数结束，退栈，此时退到原来位置0xffff1234 2.开始执行my_point_func函数，进栈，又从0xffff1234位置进入，...，退栈 3.ca虽然是数组，但是编译器把它视为指针。pa也是指针。 所以得到这两个指针地址都一样

数组简单的话可以理解为指针的高级版本，那么输出凭什么不一样啊

因为 printf("addr of array param=%x  \n",&ca);   这取的是ca在栈中的地址。

每次编译时值都变化了，但变化后这两个值也都一样。到底是为什么呢？ 我想知道，这两个值为什么一样？

一样也不能说明什么，不代表是同一个变量，最多算一种巧合，因为函数结束后栈顶指针会向栈底移动，销毁了之前栈上的空间，后一个函数调用时，该局部变量刚好也在相同的位置上，你可以试下在其他函数里再调用my_point_func，结果通常就不是一样的了

看看传的是什么，修改形参值，实参是否变化

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

因此ca和pa都是接收的同一个实参。这是第一个原因；第二，ca虽然是定义的是数组，但是编译器也是将其解析成指针(数组不能做左值，既然可以ca++，那么说明编译器对ca没有按照数组处理），因此ca和pa都是指针变量。 ca++, pa++是修改的指向ga空间的下一个数组元素地址，并没有修改ga的地址值。 另外，ga是不会被修改地址值的，因为其是数组名，数组名是数组的首地址，由于数组不能做左值，因此ga不会被修改。

同一个数组，为什么要不一样～

第一个函数调用完，栈指针回到原位，而第二个函数参数结构和第一个又一样，所以使用同样的内存地址。

可以看看汇编


Question: 新手c 语言问题求助

17用c语言编译器 先把 拓展名  改成.c

建议看一下报错信息

支持一下赚点分

#pragma warning(disable:4996) //开头加这句或项目、属性、配置属性、C/C++、预处理器、预处理器定义中添加“_CRT_SECURE_NO_WARNINGS”

是不能运行还是根本就编译不过去呢？ vs2017编译器的库不支持scanf函数，而是支持scanf_s。  #include<stdio.h>  static int n=0;  typedef struct student {     int NNum;     char Cname;     int Nscade; }stu;  void add(stu *p) {     printf("请输入增加学生的姓名，学号，成绩");     scanf_s("%d%c%d",&p[n].NNum, &p[n].Cname, 1, &p[n].Nscade);     n++; } int main() {      stu s[100];     add(s);     return 0; }


Question: 有一个折磨我很久的int和double数据输出结果不一致问题，，求教

引用 4 楼 赵4老师的回复:浮点数格式 http://bbs.csdn.net/topics/390676437 哦，我明白了，谢谢你了～

引用 3 楼 自信男孩的回复:因为m1是int类型，(x - h1) * 60计算之后的浮点数会被去掉小数部分简称取整，即不论小数是多少，只取整数部分。 而t是double类型，计算时不会去除小数部分。 哦，我明白了，谢谢你了～

引用 2 楼 user-3的回复:浮点数转换为整型的时候并不是四舍五入的，是截尾的 计算出来的t因为浮点数计算的误差，应该是略小于24，所以截尾后就是23了 你输出一个t-24的结果看看是不是一个极小的负数 使用 m1=(x-h1)*60+0.5 可以解决这个问题 哦，我明白了，谢谢你了～

哪位大神能帮我解答一下


Question: 关于“为什么一个整型数值不能赋给指针变量”的想法求大佬纠正

引用 2 楼 自信男孩的回复:这样是可以的。p = 1000;是将1000赋值到p的变量里。（指针变量也有空间，空间是固定的，sizeof(int)). 指针变量里存放的数都是固定的，二进制，因为我们的内存里存放的都是二进制，因为计算机只认识二进制不认识16进制，8进制。 那为啥要8进制，16进制，十进制，因为我们看二进制费劲，虽然计算机看它没问题，所以会出现10,8,16等等进制 感谢大佬的教导，感谢感谢

引用 3 楼 赵4老师的回复:电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。 感谢老师的教导。。。

引用 1 楼 考拉一枚的回复:跟进制无关，如果你真想将数值变成指针也是可以的，强制转换即可,与硬件相关的开发经常会用到。 你可以 int *p = (int *)1000 ，你可以 把p打印出来看看是不是1000,  切记不要试图去访问*p的内容，这里只是个例子，*1000不能非法访问 谢谢大佬的教导，我知道了


Question: 项目中如何使用SQLite比较好？

引用 2 楼 bandaoyu 的回复:引用 1楼赵4老师 的回复:百度搜相关关键字。老大，我就是百度了之后发现好几种方案，特来请教一下，哪一种最优 不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  无profiler不要谈效率！！尤其在这个云计算、虚拟机、模拟器、CUDA、多核 、多级cache、指令流水线、多种存储介质、……满天飞的时代！

百度搜相关关键字。


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

首先使用c，读取文件，得到的是一个很长的数据字符串；然后把~作为分割符，分割出来得到很多一段一段的字符串，可以把这些字符串存放放到一个vector<string>容器里面，然后定义一个结构体，对其成员一一赋值，然后再写到文件中。 由于你给的信息太少，我只能讲个我的大概思路。


Question: 【求助帖】新手哭求帮助~~~~这个程序是为了滚动8*8的点阵，但是总是报警告。。。 真的找不到错误的地方了。。。

b,c数组没定义嘛,这不很明显的问题

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

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


Question: 指针数组

第一个要用int*初始，而不是int   第二个"1"字符串本身就可以退化为const char*的指针，可赋值给char*的数组元素  第一个你要写成：int num[2] = { 1,2 };就可以了

明白了，谢谢你们！ nt *num[2]={1,2}; // 定义过程 int *num[2];   //定义指针，在内存中会给指针num[0]和num[1]分配地址的 num[2]={1,2};//这个相当于 给指针num[0]=1，num[1]=2，指针即是地址，给地址赋值，会改变原来指针地址的值，肯定会出错的。  char *ch[2]={“1”,“2”}; char *ch[2]; //定义指针，在内存中会给指针ch[0]和ch[1]分配地址的 ch[2]={“1”,“2”};// 注意，“1”，“2”是字符，存在文字常量区，指针ch[0]会指向字符“1”的首地址，指针ch[1]会指向字符“2”首地址 。 C语言就这么规定，不要问ch[0]="1" 这几句解释好清楚！

你定义的都是指针数组当然初始化的值只能是指针类型，巧的是C语言中字符常量在内存中存的就是字符的地址

int *num[2]={1,2}; // 定义过程 int *num[2];   //定义指针，在内存中会给指针num[0]和num[1]分配地址的 num[2]={1,2};//这个相当于 给指针num[0]=1，num[1]=2，指针即是地址，给地址赋值，会改变原来指针地址的值，肯定会出错的。  char *ch[2]={“1”,“2”}; char *ch[2]; //定义指针，在内存中会给指针ch[0]和ch[1]分配地址的 ch[2]={“1”,“2”};// 注意，“1”，“2”是字符，存在文字常量区，指针ch[0]会指向字符“1”的首地址，指针ch[1]会指向字符“2”首地址 。 C语言就这么规定，不要问ch[0]="1"  不要这样赋值int *num[2]={1,2}; int *num; int a[2]={1,2}; num=a;

定义指针时，除了字符串常量，编译器并不为指针所指向的对象分配空间，只分配指针本身的空间。


Question: 一道考试题，1到25数字按 5x5 格式输出

zhua  引用 1 楼 cfjtaishan 的回复:#include <stdio.h>  #define ROW     5 #define COL     5  int main() {     int a[ROW][COL],num,count;     int i, j, k, kend, lend;      num = ROW;     kend = num / 2;     lend = num;     count=1;     for( i=0,j=0,k=0; k<kend; k++ )     {         a[i][j]=count++;          for(j++;j<lend;j++)             a[i][j]=count++;          for(i++,j--;i<lend;i++)             a[i][j]=count++;          for(i--,j--;j>=k;j--)             a[i][j]=count++;          for(i--,j++;i>k;i--)             a[i][j]=count++;          i++;j++;lend--;     }     if(num%2 != 0) a[i][j]=count;     for( i=0; i<num; i++ )     {         for( j=0; j<num; j++ )             printf("%4d ",a[i][j]);         printf("\n");     }      return 0; } 参考一下吧  https://blog.csdn.net/qq_27183003/article/details/49699463 更多参考 +1  转圈赋值，然后统一输出就行，貌似是大一时候的题

经过修改，本程序支持任意的M，N（除了0以外的正整数）。上面的程序缺不支持，比如6*5 #include <stdio.h> #include <math.h> #define M 6 #define N 5 void fun(); int main() { 	fun(); 	return 0; } //m*m void fun() {    int arry[M][N] = {0};        int i,j,k;    int cnt = 1;//1--M*M    //for(i = 0;i < (int)(M*1.0/2 +0.5);i++){ 	for(i = 0;i < ceil(sqrt(M*M+N*N)/2);i++) {   	   for(j=i,k=i;k < N-i;k++){ 		   arry[j][k] = cnt; 		   cnt++; 	   } 	   for(j=i+1,k=N-1-i;j<M-i;j++){ 		   arry[j][k] = cnt; 		   cnt++; 	   } 	   for(j=M-1-i,k=N-2-i;k>=0+i;k--){ 		   arry[j][k] = cnt; 		   cnt++; 	   } 	   for(j=M-2-i,k=0+i;j>=1+i;j--){ 		   arry[j][k] = cnt; 		   cnt++; 	   }    }    for(i=0;i < M;i++){      for(j=0;j < N;j++) 		 printf("%02d ",arry[i][j]);      printf("\n");    } }

看了一下楼上的，确实没有楼上的好，这只是我临时想起来的，有待优化

#include <stdio.h> #define M 5 //M可以为别的值 void fun(); int main() { 	fun(); 	return 0; } //m*m void fun() {    int arry[M][M] = {0};        int i,j,k;    int cnt = 1;//1--M*M    for(i = 0;i < (int)(M*1.0/2 +0.5);i++){ 	   for(j=i,k=i;k < M-i;k++){ 		   arry[j][k] = cnt; 		   cnt++; 	   } 	   for(j=i+1,k=M-1-i;j<M-i;j++){ 		   arry[j][k] = cnt; 		   cnt++; 	   } 	   for(j=M-1-i,k=M-2-i;k>=0+i;k--){ 		   arry[j][k] = cnt; 		   cnt++; 	   } 	   for(j=M-2-i,k=0+i;j>=1+i;j--){ 		   arry[j][k] = cnt; 		   cnt++; 	   }    }    for(i=0;i<M;i++){      for(j=0;j<M;j++) 		 printf("%02d ",arry[i][j]);      printf("\n");    } }