Question: tcp  使用select 管理客户端

看下思路是这样的吗？？   /////////////////////////////////////////////////////////////////////////// /*          建立一个IPV4服务器， 可以接受  V4和v6 客户端的请求*/ struct sockaddr_in  saddr; struct sockaddr_in  caddr_v4; struct sockaddr_in6 caddr_v6; unsigned int ipaddr[4] = {0}; ipaddr[2] = 0xffff0000;  sockfd = socket(AF_INET, SOCK_DGRAM, 0);  saddr.sin_family = AF_INET; saddr.sin_port = htons(4321); saddr.sin_addr_s_addr = INADDR_ANY;  bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr));   while(1) {     sin_size = sizeof(caddr_v6);     len = recvform(sockfd, rbuff, sizeof(rbuff), 0, (struct sockaddr *)caddr_v6, &sin_size);      if(len >0)     {         if( memcmp(ipaddr,caddr_v6.sin6_addr.s6_addr32,12) == 0)  // ipv4         {             caddr_v4.sin_family = AF_INET;             caddr_v4.sin_port = caddr_v6.sin6_port;             caddr_v4.sin_addr.s_addr = caddr_v6.sin6_addr.s6_addr32[3];                          //...         }         else         {             //...         }     } } ////////////////////////////////////////////// /*       建立一个IPV6服务器，只能接收v6 客户端的请求  */ struct sockaddr_in6 saddr_v6; struct sockaddr_in6 caddr_v6;  sockfd = socket(AF_INET6, SOCK_DGRAM, 0);  saddr.sin6_family = AF_INET6; saddr.sin6_port = htons(4321); saddr.sin6_addr = in6addr_any;  bind(sockfd, (struct sockaddr *)&saddr_v6, sizeof(saddr_v6));  while(1) {     sin_size = sizeof(caddr_v6);     len = recvform(sockfd, rbuff, sizeof(rbuff), 0, (struct sockaddr *)caddr_v6, &sin_size);      if(len >0)     {         //...     } }

创建一个 tcp socket 服务器  IPv4    sockfd = socket(AF_INET, SOCK_STREAM ,0);  他是不是能接收IPv4 和 IPv6类型客户端的连接请求？   创建一个TCP SOCKET 服务器 IPv6    sockfd = socket(AF_INET6, SOCK_STREAM, 0)  他是不是只能接收 IPv6类型客户端的连接请求？

引用 1 楼 user-1 的回复:有listen又有connect。。你这到底是server端还是client端了 额， 这里写错了，，是   accept。。失误。没有编译！！！！


Question: 大神们求帮忙，我这个是撞球程序，在屏幕中加的红色的横杠不能正常的碰撞检测，，，帮忙修改一下屏幕中红色横杠的碰撞检测，顺便在能加几个障碍物更好。

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试是程序员必须掌握的技能之一。


Question: 求大神帮助，C语言考试

我在这里告诉诸位一个秘密，关于选择题的做法，对于史上一切选择题都能搞定：三短一长选最长，三长一短选最短，两短两长选C，不长不短选A。多少次的考试，我们都是靠着这几句必胜秘诀成功度过的！像我还考上了本科学校。

这帖子可以火

引用 楼主 u014283393 的回复:  第五题，1小题写个： #include<math.h> 估计能得1分

提醒：再牛×的老师也无法代替学生自己领悟和上厕所！

好好学吧，最好大学期间弄个2W+行的项目，找工作有点优势。等毕业了面试的时候想学时间都不够了

平时多看看就好了。。。。。。 楼主好运

上课不努力，现在徒伤悲。lz挽尊。。。

是现场么？现场的话现在该来不及了。不是现场的话，我倒是可以回去给你做一下，回味下大学生活。 你们楼上的都不要这样嘛，谁不是这样过来的呢，不要一个C学不好就断送人家学业前程嘛，人家以后说不定是很好的管理者。  顺便说下LZ，这种事就不要召唤大神了，大神对这些题都不屑一顾的，这些题就喊我们这些虾兵蟹将就行了。

我只会   第6题   B

明天亦是未来  唉，估计不会有人回答的

目测不会有人回答

我觉得是问题点数分太少了 至少也要1000分啊 否则没人回答啊

楼主应该举手要求监考或出题老师将电子版的试卷发你手机上一份！

流逼

过时了吧？哈哈

拍的内容太多了，都看不清楚了.

楼主勇气可嘉

当初学习C语言的时候少玩点手机，现在就会做了。

平时不发帖子 ，考试才知道求答案


Question: 关于getchar,一个简单的问题

引用 5 楼 u014194675 的回复:c的值确实每次都会被覆盖，但是每当c接收到一个字符，这个字符就被输出了，输出之后，才被覆盖，然后又输出。。。 最后输出computer而不是r，因为输出代码在循环里面而不是循环外面。 这个例子，不应该说通过循环，getchar()得到字符串，只是通过循环，getchar()得到字符，并输出该字符。。。  for(;(c=getchar())!='\n';)         printf("%c",c); 等价于 for(;(c=getchar())!='\n';) {         printf("%c",c); } 输出语句也是循环的，每次输出一个字符。  这位说得没错

for(表达式1;表达式2;表达式3) {循环体}

getchar()是在你按回车之后才接收输入的字符的

/*getchar()-Note that getchar reads from stdin and is line buffered; this means it will not return until you press ENTER. */

getchar时屏幕是stdin，阻止了printf的输出？

执行printf()时, 把c当参数传入了. 这种传值的方式会复制一份, 后面再修改c的值也没关系了.

getchar肯定不能得到字符串，你这不循环了吗，每次接受都打印了。只是你打印没那么快显示出来，缓冲了。


Question: 麻烦前辈们帮忙看看，如下两段代码，看上去几乎功能一样，为什么结果却大大不同？？

关于malloc再啰嗦两句： 1. 要检查它的返回值是否NULL 2. 用完之后要记得free

引用 1 楼 user-1 的回复:在main里面return之前加一行fclose(fp)再试试？ 大哥，不好意思，这个例子我发错了，不太对，我重开一贴再来问。

在main里面return之前加一行fclose(fp)再试试？


Question: C语言字符转换

一开始就把最终的长度计算出来。然后从最后一个开始向前移位。复杂度较低。

这已经是俩个字符了都 后面的需要移位

图发错了，是这个

仅供参考： #include <stdio.h> #include <string.h> #include <locale.h> char s[256]; char *p; int r,n,i; int main() {     setlocale(LC_ALL,"chs");     while (1) {         printf("请输入一行文字(空行结束),\"%%20\"将替换为\" \",\"你懂得\"将替换为\"XXXXXX\":\n");         fgets(s,256,stdin);         if ('\n'==s[0]) break;         p=s;         while (1) {             p=strstr(p,"%20");             if (p) {                 memmove(p+1,p+3,strlen(p)-3+1);                 p[0]=' ';             } else break;         }         p=s;         while (1) {             p=strstr(p,"你懂得");             if (p) {                 memmove(p+6,p+6,strlen(p)-6+1);                 for (i=0;i<6;i++) p[i]='X';             } else break;         }         printf("%s",s);     }     return 0; } //请输入一行文字(空行结束),"%20"将替换为" ","你懂得"将替换为"XXXXXX": //abcdefg%20helloworld%20something.pdf //abcdefg helloworld something.pdf //请输入一行文字(空行结束),"%20"将替换为" ","你懂得"将替换为"XXXXXX": //这是测试文字你懂得，在这个你懂的地方，就得做你懂得的事 //这是测试文字XXXXX，在这个你懂的地方，就得做XXXXX的事 //请输入一行文字(空行结束),"%20"将替换为" ","你懂得"将替换为"XXXXXX": //

引用 2 楼 SKATE11 的回复:这已经是俩个字符了都 后面的需要移位 什么意思？

std::string::replace


Question: 求大神帮改下C语言程序，问题是排序不成功（请测试），文件读写不成功，如果有什么好点子也可以加进去！

是在visual studio2013的c++上运行的，麻烦可不可以帮我看一下排序还有存储哪里有问题，vc6.0上也可以运行

可以参考一下这个代码（在dos上的字符贪吃蛇），不过只有上下左右、暂停、加速、减速功能 snake.c //#define WIN32_LEAN_AND_MEAN #define HEIGHT 20 #define WIDE 76 #define ICO "*"  int flage; int time_interval;  struct node {     int x;     int y;     struct node* next; };  void getpos(HANDLE hOut,COORD *pos) {     CONSOLE_SCREEN_BUFFER_INFO info;     GetConsoleScreenBufferInfo( hOut , &info );     *pos = info.dwCursorPosition; } void gotopos(HANDLE hOut,COORD pos) {     SetConsoleCursorPosition(hOut, pos); }  void put_logo() {     int i;     for(i=0; i<8; i++)     {         printf("\n");     }     for(i=0; i<35; i++)     {         printf(" ");     }     printf("snake");     Sleep(2000);     system("cls"); }  void start_map() {     int i;     int j;     for(i=0; i<HEIGHT+3; i++)     {         for(j=0; j<WIDE+3; j++)         {             if(i==0||i==HEIGHT+2)             {                 printf("=");             }             else if(j==0||j==WIDE+2)             {                 printf("|");             }             else             {                 printf(" ");             }         }         printf("\n");     } }  struct node* clear_last(HANDLE hOut,COORD pos,struct node* p,int x,int y) {     pos.X = p->x;     pos.Y = p->y;     gotopos(hOut,pos);     printf(" ");     p->x=x;     p->y=y;     return p->next; }  int check_ways(struct node* q,int x,int y,int len) {     int i;     if(x<1||x>WIDE+1)     {         return 1;     }     if(y<1||y>HEIGHT+1)     {         return 1;     }     for(i=0; i<len; i++)     {         if(q->x==x&&q->y==y)         {             return 1;         }         q=q->next;     }     return 0; }  DWORD WINAPI  snake() {     struct node snakes;     struct node* head;     struct node* p;     struct node* q;     HANDLE hOut;     COORD pos;     int i;     int len;     len=10;     snakes.x=1;     snakes.y=1;     snakes.next=NULL;     pos.X=snakes.x;     pos.Y=snakes.y;     start_map();     hOut = GetStdHandle(STD_OUTPUT_HANDLE);     gotopos(hOut,pos);     head=p=q=malloc(sizeof(struct node));     p->x=snakes.x++;     p->y=snakes.y;     printf(ICO);     p->next=q;     for(i=0; i<len-1; i++)     {         q=p;         p=malloc(sizeof(struct node));         p->x=snakes.x++;         p->y=snakes.y;         printf(ICO);         p->next=head;         q->next=p;     }     printf(ICO);     snakes.x=snakes.x-1;     p=head;     for(;; Sleep(time_interval*50))     {         switch(flage)         {         case 1:             snakes.y--;             break;         case 2:             snakes.y++;             break;         case 3:             snakes.x--;             break;         case 4:             snakes.x++;             break;         default :             goto _NEXT;             break;         }         if(check_ways(head,snakes.x,snakes.y,len))         {             goto _END;         }         p=clear_last(hOut,pos,p,snakes.x,snakes.y);         pos.X=snakes.x;         pos.Y=snakes.y;         gotopos(hOut,pos);         printf(ICO);         printf("\b"); _NEXT:         ;     } _END:     ;     pos.X=25;     pos.Y=10;     gotopos(hOut,pos);     printf("game over!you have %d long snakes\b",len); }   main.c #define WIN32_LEAN_AND_MEAN  #include <stdio.h> #include <stdlib.h> #include <windows.h> #include "snake.h"  int main() {     HANDLE hThrd;     DWORD threadId;     flage=4;     time_interval=10;     hThrd=CreateThread(NULL,0,snake,(LPVOID)0,0,&threadId);     for(;;)     {         switch(getch())         {         case 224:             switch(getch())             {             case 72:                 if(flage!=2&&flage>0)                 {                     flage=1;                 }                 break;             case 80:                 if(flage!=1&&flage>0)                 {                     flage=2;                 }                 break;             case 75:                 if(flage!=4&&flage>0)                 {                     flage=3;                 }                 break;             case 77:                 if(flage!=3&&flage>0)                 {                     flage=4;                 }                 break;             }             break;         case 32:             flage=-flage;             break;         case 'w':             if(time_interval<200)             {                 time_interval=time_interval+1;             }             break;         case 'e':             if(time_interval>1)             {                 time_interval=time_interval-1;             }             break;         }         Sleep(100);     }     getchar();     return 0; }   snake.h #include "snake.c"  void put_logo(); void getpos(HANDLE hOut,COORD *pos); void gotopos(HANDLE hOut,COORD pos); DWORD WINAPI  snake();

在哪个系统上运行的？


Question: 返回值为double的方法为什么编译时发生segmentation fault错误？

-(double)fun1  {        double var;     var=66.66;        return var;  }


Question: 结构体和数组在内存中的存放问题

话不多说，直接引用 引用 3 楼 buyong 的回复:[quote=引用 楼主 xhw88398569 的回复:] 比如说: 1、struct  a{     int i;     int j;}; struct a b;//b存放在堆里吗？ 2、char   ch[10];//ch[10]存放在栈里吗？ch又是存放在哪？ 3、char ch[10];       char *str = "hello word";       ch = str;       //是把str中的每一个元素都放到对应的字符数组里吗？ ch[10]实际可用空间是12字节，如果有新的数据进栈会不会覆盖后2个字节，比如char或者int类型的数据  1 b在栈上 2 在栈上 3 str在常量区。ch = str; 能编译过？[/quote]

引用 3 楼 buyong 的回复:[quote=引用 楼主 xhw88398569 的回复:] 比如说: 1、struct  a{     int i;     int j;}; struct a b;//b存放在堆里吗？ 2、char   ch[10];//ch[10]存放在栈里吗？ch又是存放在哪？ 3、char ch[10];       char *str = "hello word";       ch = str;       //是把str中的每一个元素都放到对应的字符数组里吗？ ch[10]实际可用空间是12字节，如果有新的数据进栈会不会覆盖后2个字节，比如char或者int类型的数据  1 b在栈上 2 在栈上 3 str在常量区。ch = str; 能编译过？[/quote]后面的那个会不会覆盖呢？

引用 3 楼 buyong 的回复:[quote=引用 楼主 xhw88398569 的回复:] 比如说: 1、struct  a{     int i;     int j;}; struct a b;//b存放在堆里吗？ 2、char   ch[10];//ch[10]存放在栈里吗？ch又是存放在哪？ 3、char ch[10];       char *str = "hello word";       ch = str;       //是把str中的每一个元素都放到对应的字符数组里吗？ ch[10]实际可用空间是12字节，如果有新的数据进栈会不会覆盖后2个字节，比如char或者int类型的数据  1 b在栈上 2 在栈上 3 str在常量区。ch = str; 能编译过？[/quote]嗯，谢谢，好长时间不写了，没注意

引用 1 楼 user-4 的回复:局部变量存放在栈中，静态变量、全局变量和申请内存new/malloc得到的变量存放在堆中 变量名不存放在任何位置，在程序编译时直接转换成内存地址，内存地址存放在代码中 数组不能整体赋值，对数组使用=号根本编译不过去，复制字符串必须使用函数而不能使用=  最重要的是，多读书，少空想 想象是好的，空想不是嗯，谢谢

引用 楼主 xhw88398569 的回复:比如说: 1、struct  a{     int i;     int j;}; struct a b;//b存放在堆里吗？ 2、char   ch[10];//ch[10]存放在栈里吗？ch又是存放在哪？ 3、char ch[10];       char *str = "hello word";       ch = str;       //是把str中的每一个元素都放到对应的字符数组里吗？ ch[10]实际可用空间是12字节，如果有新的数据进栈会不会覆盖后2个字节，比如char或者int类型的数据  1 b在栈上 2 在栈上 3 str在常量区。ch = str; 能编译过？

你都没说这些东西你是在哪里声明和定义的。是函数中，还是函数外？


Question: 小弟新手，求哪位大哥给我把下图的算法4.9给我注释以下

想加注释，不知往哪加，自己又不愿意敲代码。唉。。。

引用 8 楼 zjq9931 的回复:从这两张图上来看，这本书似乎不是好书。。。 代码风格，代码排版，很让人蛋疼。。。秦锋主编的数据结构  的确不怎么好

引用 9 楼 zxh707wk 的回复:为什么4.9那个函数没有左边的大括号。。。你看的好仔细啊

引用 5 楼 zhao4zhong1 的回复:代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试是程序员必须掌握的技能之一。嗯嗯  是啊  谢谢大哥指点啊

为什么4.9那个函数没有左边的大括号。。。

这个代码是用来演示内存分配用的，要看懂这代码，要先弄懂 malloc 和 free 函数的左右。 malloc是用来分配内存大小的函数。一般是这样用的 （Type * ）malloc(int size)，size表示分配的内存的大小。 书中是用来分配字符串的大小所以用了sizeof(char)来获取char类型的大小在 乘上字符数 就得到了所要分配的内存大小。 malloc 函数返回的是一个 void 指针，C\C++是强类型的语言需要类型匹配，所以这里用了强制类型转换将void * 转换为char * 用到的free这一行中 之前的if 是判断p_ch是非为空，非空则用 free函数去释放  后面的for循环是来数有多少个字符要赋值给p_ch的，所得结果记录在i中。 当i = 0 时说明要付给p_ch的是个空字符，也就不用去分配内存了。返回0 应该是说明有错误，这里应该是不可以传空字符进来的。 最后的循环是将字符一个个的赋值到p_ch中去。

像素好高啊 什么手机啊

引用 2 楼 user-7 的回复:能不能再懒一点不是懒，我是担心自己敲的话敲错了 你们看不懂啊

不是懒，我是担心自己敲的话敲错了 你们看不懂啊

能不能再懒一点

图放错位置了......有个问题，为啥那个S2都没有初始化，在第四行却直接来个pc=s2?


Question: c语言问题，急求！！！

参考代码： http://bbs.csdn.net/topics/390814969

你先设计一下思路。 用自然与言描述一下，要怎么做，然后在慢慢转换成C语言。


Question: 【大一新生，写一个c语言，卡住了，求解呐~~~】进来看看，求学生成绩及排名。

引用 9 楼 u013115035 的回复:[quote=引用 8 楼 u013115035 的回复:] 抱歉，各位，这两天有点忙，就还没回复。 因为我们的题目要求的用数组来实现的，结构就没用。 数组作为函数参数的设计方法！[/quote] 不能用结构体数组吗？

输出每个学生的学习情况？ 楼主是想说输出前5名的学生的属性吧 如果必须用数组作为函数参数，可以是一个数组包含n个学生的同一个属性，然后依靠下标向各个函数中传值

引用 8 楼 u013115035 的回复:抱歉，各位，这两天有点忙，就还没回复。 因为我们的题目要求的用数组来实现的，结构就没用。 数组作为函数参数的设计方法！

引用 4 楼 u013115035 的回复:[quote=引用 2 楼 wu4357815 的回复:] 排序不建议自己写。建议用c++中的stl算法，把存储成绩的数组改成vetor即动态数组，这样不但可以输入，而且可以动态处理多少个同学。排序用stable_sort算法即可。  c++中的stl算法我们还没学，所以还不想用，嘻嘻。 vetor,而是vector这个？？？我貌似没写vetor呀  serch1(num,a,order) {if(a[i][j]>=85&&) {}}// 这里不知道如何获取“总分在前５名的学生的学习情况”并将其输出，求解答！！！谢谢 [/quote] stl大学里本来就不学，而且就你这个问题，用上去不难

用结构体啊，亲 struct student{    int num;//学号    int text1;//课程1成绩    int text2;//课程2成绩    int text3;//课程3成绩    int grade1;//平均分    int grade2;//总分 } 这样的话你只要建立一个结构体数组然后通过对结构体数组里的成绩进行排序在逐项输出就行了呀，大体思路就是这个样子的，还有些细节你在自己更改一下吧

引用 2 楼 wu4357815 的回复:排序不建议自己写。建议用c++中的stl算法，把存储成绩的数组改成vetor即动态数组，这样不但可以输入，而且可以动态处理多少个同学。排序用stable_sort算法即可。  c++中的stl算法我们还没学，所以还不想用，嘻嘻。 vetor,而是vector这个？？？我貌似没写vetor呀  serch1(num,a,order) {if(a[i][j]>=85&&) {}}// 这里不知道如何获取“总分在前５名的学生的学习情况”并将其输出，求解答！！！谢谢

上面写错了，不是vetor,而是vector

main主函数还没写全。在写下面的函数被卡住了了。  float order(sum[]) {for(i=0;i<10;i++) {if(sum[i]<sum[i+1]) {t= sum[i]; sum[i]=sum[i+1];sum[i+1]=t;} order[i]=sum[i+1];//把两者中的大者赋给order数组？？ }}  serch1(num,a,order) {if(a[i][j]>=85&&) {}}//这里不知道如何获取“总分在前５名的学生的学习情况”并将其输出   serch2(num,a) {if(a[i][j]<60) printf("该成绩不及格学生的成绩为：%f",a[i][j]);}     请大神帮忙解答！~~谢谢啦~~~


Question: C语言头文件定义的疑问

引用 2 楼 u012061345 的回复:无所谓，只要宏定义不会重名即可。个人觉得一般使用有下划线的。因为C习惯上，有下划线的名字表示是代码自用的，而非释放给用户的接口。此处，这个define guard的名字显然是代码自用的。请问是不是也不一定写成TEST_H啊，是不是定义成与文件名不同的名字也可以呢？还是说只能是将文件名变成大写的形式。。我不是很懂。

这个随便吧。有的人愿意加下划线，有的不愿意。只要保证宏定义不重复即可。

这玩意我一贯随便写 最近的爱好是把自己喜欢的小说名字也加进去，保证不会跟别人重名

我习惯用有下划线的。 但是我看codeBlocks自动生成的是没有下划线的。

都可以，只要不重名，ABCDEFG都行

两种都可以。

这个宏的名字是可以随便取的，但是为了说明它是头文件，所以最好——H结尾，希望能帮助你！

引用 6 楼 guodongxiaren 的回复:请问是不是也不一定写成TEST_H啊，是不是定义成与文件名不同的名字也可以呢？还是说只能是将文件名变成大写的形式。。我不是很懂。  楼上有人说了，随便命名，只要不重名即可。但一般都是用文件名的变体，因为同一个项目中，文件名重名的可能性比较低。

应该使用前面没有下划线的版本。


Question: 地址为0的指针

因为没有读写0这块内存

嘿嘿，用0作为一个数据结构的基地址，这样其中的成员变量的地址，就是其在数据结构中的偏移地址了。 这样做更容易获取数据结构中成员变量的偏移地址了。 另外参考下博文：http://blog.csdn.net/cjf_iceking/article/details/7570105

结构体的那个0只是用来算偏移量而已，用pointer-偏移量才是结构体的地址。这与你提出的问题不等价的。

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步对应汇编一行！  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式的值【比如printf("%p\n",...)】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=...】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495

当你说“从火星到木星那么远”时，你不需要站在火星上或者木星上 当指针不用于操作内存时，它就只是一个整数而已，不管它的值是0还是-1，都无所谓

因为这个宏中只是在计算指针偏移, 并没有去访问指针指向的内存.

操作系统不会把任何数据保存在地址0及其附近  也不会把地址0~0xfff的页面映射到物理内存 所以任何对地址0的访问都会 立刻导致段错误

因为没有使用（读写）该指针的解引用，即没有读或者写这块内存。

因为没有赋值


Question: C语言怎么实现从文件中读取指定行内容

直接判断'\n'的个数不就行了吗

引用 5 楼 judwenwen2009 的回复:使用fgets函数，fgets是每次读取一行，如果你要读取第i行，可以使用while while(i--) { fgets(buf,MAX_SIZE,fd); } 丢弃了前i-1行，在读取第i行后，退出了循环，那么buf中就保存的是第i行的内容  楼上比我的写的程序要强壮的多，应该每次使用memset来清除buf，防止上一次buf中的内容未清除。 还有如果行内容太多buf会读不到行结尾的情况。 我写的这个是最简单的。。。。什么错误处理都没考虑

仅供参考//问题： // 1.打开一个文本文件。 // 2.查找这个文本文件的第r行的第c1－c2列？ // // 如： // 文件：a // 11111111 // 22222QQQ // 33333333 // // 查找第2行，第6-8列。 #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAXC 16000 char ln[MAXC]; FILE *f; int r,c1,c2,n,L; void getc1c2(char *fn) {     ln[c2]=0;     printf("Text at row(%d),column(%d..%d) of file %s is [%s]\n",r,c1,c2,fn,ln+c1-1); } int main(int argc,char **argv) {     if (argc<5) {     HELP:         printf("Usage:\n    %s filename.ext r c1 c2\nto get text at row(r),column(c1..c2) of filename.ext\n",argv[0]);         return 1;     }     r=atoi(argv[2]);     c1=atoi(argv[3]);     c2=atoi(argv[4]);     if (r<=0 || c1<=0 || c2<c1 || c2>=MAXC) goto HELP;     f=fopen(argv[1],"r");     if (NULL==f) {         printf("Can not open file %s!\n",argv[1]);         return 2;     }     n=0;     while (1) {         if (NULL==fgets(ln,MAXC,f)) break;         L=strlen(ln);         if ('\n'==ln[L-1]) {             memset(ln+L-1,0,MAXC-L+1);             n++;             if (r==n) {getc1c2(argv[1]);break;}         } else {             n++;             if (r==n) {getc1c2(argv[1]);break;}             printf("Warning: line %d too long(>%d characters)! Ignore tails.",n,MAXC);             while (1) {                 if (NULL==fgets(ln,MAXC,f)) goto END;                 L=strlen(ln);                 if ('\n'==ln[L-1]) break;             }         }     }     END:     fclose(f);     return 0; } //C:\test\Debug>frcc a 2 6 8 //Text at row(2),column(6..8) of file a is [QQQ] //

fopen fread fclose 返回字符串如果在函数里new,要在外面delete

使用fgets可以完成这个功能；

楼上的，你头像好酷！

逐字读取，根据\n符来标记行号


Question: 怎样使用extern声明另一个文件中的数组

extern struct Student stu[]; 可以不需要 N

把N和struct Student的声明都放到一个头文件里面，然后A.c和B.c都include这个头文件，然后按1楼的那样extern就行了

在另一个文件里添加一句：extern struct Student stu[N];


Question: 怎么样实现这样的一个函数

可以将要获取的字符串通过出参获取到，而不是通过返回值。返回值可以用来判定是否读取成功 。

要么使用全局数组，要么在函数中分配一段内存。两种做法都有不爽的地方。 你可以参考C语言中的ctime函数，C库函数的做法就是返回全局数组。

假定文件中的行数必定大于等于whichLine #include<stdio.h>  #include<stdlib.h>   char* ReadSpeacialLine(char* filename, int whichLine){ 	FILE *fp; 	char *pl; 	int i; 	if((fp=fopen(filename,"r"))==NULL){ 		printf("error open %s\n",filename); 		exit(0); 	} 	i=0; 	pl=(char*)malloc(1000); 	while(i<whichLine){ 		fgets(pl,1000,fp); 		i++; 	} 	return pl; } int main(){ 	char fn[100],*pl; 	int wl; 	printf("input filename: "); 	gets(fn); 	printf("whichLine: "); 	scanf("%d",& wl); 	pl=ReadSpeacialLine(fn, wl); 	printf("%s\n",pl); 	free((void*)pl); 	return 0; }


Question: 求高手解决

dest = res; //    printf("sign: %s\n",res); //    printf( "\t%s\n", src );     puts(dest);  //这里是ok的       return dest; }  不要返回局部变量的地址

static char res[33]={'\0'};

char res[33]={'\0'}; 改成 static char res[33]={'\0'};


Question: 各位，帮帮忙啊，怎么解决文件打不开就跳出程序的问题

void copy(char x[66],char y[66],char z[25])  { 	int c; 	FILE *fp1,*fp2,*fp3;  	fp1=fopen(x,"rb"); 	fp2=fopen(y,"rb"); 	fp3=fopen(z,"wb");  	if(fp3 == NULL)  		printf("Can't open file3\n");  	if(fp1 == NULL)  	{    		printf("Can't open file1\n"); 		 		if(fp2 == NULL)     		{ 			printf("Can't open file2\n"); 			return;  //直接return 		} 	 		while((c=fgetc(fp2))!=EOF) //这里 fp2 ！= null 		{ 			fputc(c,fp3); 		} 	}	 	else 	{ 		while((c=fgetc(fp1))!=EOF) 		{ 			fputc(c,fp3); 		} 	} }   //	fclose(fp1);   //	fclose(fp2); //	fclose(fp3); //}


Question: 求求大神帮我看看这个函数互相调用的问题，为什么编译说没被define?

看着头痛，最好能说清楚 问题是哪个东西没define，然后排好版。。。。。


Question: 求助：程序排错

int fun3(int num) { 	long sum; 	int i; 	int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 	sum = num * num * 1000 + num; 	 	while(sum) 	{ 		if(a[sum % 10]) 			a[sum % 10] = 0;  		sum = sum / 10; 	}  	for(i = 0; i < 10; i++) 	{ 		if(a[i] != 0) 			return 0; 	} 	 	return 1; }  int main(int argc, char* argv[]) { 	int i;  	for(i = 100; i < 1000; i++) 	{ 		if(fun3(i)) 		{ 			printf("i = %d, i * i = %ld\n", i, i * i); 		} 	} 	return 0; }  不知道我这种解法怎样？？

感谢，问题解决。 用WIN-TC执行源代码，没有输出结果，不知什么原因。

为何不从123遍历到三百多呢  然后判断是不是？

好吧，看错了，是9位数。。。  #include <stdio.h>  int check_num(int m,int n) { 	int temp[10]={0}; 	int i; 	int num; 	for(;m;m=m/10) 	{ 		temp[m%10]++; 	} 	for(;n;n=n/10) 	{ 		temp[n%10]++; 	} 	for(num=i=0;i<10;i++) 	{ 		if(temp[i]==1)num++; 	} 	if(num==9)return 1; 	return 0; }  int main() { 	int i; 	for(i=100;i<=1000;i++) 	{ 		if(check_num(i,i*i)) 		{ 			printf("sqrt(%d)=%d\n",i*i,i); 		} 	} 	return 0; }

仅供参考 /*题目要求： 使用数字1～9填充等式：sqrt(＃＃＃＃＃＃)=＃＃＃ 每个＃内数字互不相同，即遍历数字1～9 试找出所有的解。*/  #include <stdio.h>  int check_num(int m,int n) { 	int temp[10]={0}; 	int i; 	int num; 	for(;m;m=m/10) 	{ 		temp[m%10]++; 	} 	for(;n;n=n/10) 	{ 		temp[n%10]++; 	} 	for(num=i=0;i<10;i++) 	{ 		if(temp[i]==1)num++; 	} 	if(num==6)return 1; 	return 0; }  int main() { 	int i; 	for(i=100;i<=333;i++) 	{ 		if(check_num(i,i*i)) 		{ 			printf("sqrt(%d)=%d\n",i*i,i); 		} 	} 	return 0; }

我在打开贴子之前，就猜测有2的回复。 对CSDN有所了解。

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试是程序员必须掌握的技能之一。


Question: 关于ELF文件分析

夜深了。。。。。

参考objdump源代码？


Question: vs2013 C debug win32已过期

如果重新生成的时候，出现如下错误： “fatal error LNK1123: 转换到 COFF 期间失败:” 建议去看这个http://jingyan.baidu.com/article/fc07f9891c556412ffe519fa.html

如果你的程序有变化，vs就会认为你的程序已经过期，会弹出提示框。所以楼主直接勾选“不再提示”即可。

是可行，但是每个项目都要清理再重新生成，很不方便 引用 8 楼 StrongManTwo 的回复:在解决方案资源管理器”窗口中，右击项目名，点击清理，然后点击“重新生成”，即可解决问题

确实有用 引用 8 楼 StrongManTwo 的回复:在解决方案资源管理器”窗口中，右击项目名，点击清理，然后点击“重新生成”，即可解决问题

我也遇到了这个问题，下面的方法解决了，谢谢你  引用 8 楼 StrongManTwo 的回复:在解决方案资源管理器”窗口中，右击项目名，点击清理，然后点击“重新生成”，即可解决问题

clean + rebuild all

很郁闷啊 重装了vs2013还是不行 然后装了vs2012结果正常了

选了是就是第三张图 不能编译  主要问题是没法include < > include < > 就是报错

楼主贴个代码上来，我帮你试一下！

楼上正解，选是就能编译了

你点下 “是” 不就完了么，你想问什么？ 你不会以为提示你 VC 版本过期了吧？ 这个的意思是说你的代码比你上次编译生成的 exe 更新，直接调试可能符号和代码不对应，重新编译下再调试就 OK 了。

http://www.microsoft.com/visualstudio/chs/downloads#d-2010-express 点开Visual C++ 2010 Express下面的语言选‘简体中文’，再点立即安装


Question: Linux下如何把读出的unicode码转成中文保存到文件里啊

对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A #include <stdio.h> #include <string.h> FILE *f; char buffer[4096]; int r,a; void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%08x -",i+addr);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             printf("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         printf("%s\n",binstr);     } } int main(int argc,char **argv) {     if (argc<2) {         fprintf(stderr,"Usage: %s filename.ext\n",argv[0]);         return 2;     }     f=fopen(argv[1],"rb");     if (NULL==f) {         fprintf(stderr,"Can not open file [%s]!\n",argv[1]);         return 1;     }     a=0;     while (1) {         r=fread(buffer,1,4096,f);         HexDump(buffer,r,a);         a+=r;         if (r<4096) break;     }     fclose(f);     return 0; }

引用 1 楼 zhao4zhong1 的回复://iconv_linux下字符集编码转换轻松实现 (1) iconv_t iconv_open(const char *tocode, const char *fromcode); //此函数说明将要进行哪两种编码的转换,tocode是目标编码,fromcode是原编码,该函数返回一个转换句柄,供以下两个函数使用。 (2) size_t iconv(iconv_t cd,char **inbuf,size_t *inbytesleft,char **outbuf,size_t *outbytesleft); //此函数从inbuf中读取字符,转换后输出到outbuf中,inbytesleft用以记录还未转换的字符数,outbytesleft用以记录输出缓冲的剩余空间。 (3) int iconv_close(iconv_t cd); //此函数用于关闭转换句柄,释放资源。  //例子1: 用C语言实现的转换示例程序  /* f.c : 代码转换示例C程序 */ #include <iconv.h> #define OUTLEN 255 main() { char *in_utf8 = "姝ｅ?ㄥ??瑁?"; char *in_gb2312 = "正在安装"; char out[OUTLEN];  /*unicode码转为gb2312码*/ rc = u2g(in_utf8,strlen(in_utf8),out,OUTLEN); printf("unicode-->gb2312 out=%sn",out); //gb2312码转为unicode码  rc = g2u(in_gb2312,strlen(in_gb2312),out,OUTLEN); printf("gb2312-->unicode out=%sn",out); } /*代码转换:从一种编码转为另一种编码*/ int code_convert(char *from_charset,char *to_charset,char *inbuf,int inlen,char *outbuf,int outlen) { iconv_t cd; int rc; char **pin = &inbuf; char **pout = &outbuf;  cd = iconv_open(to_charset,from_charset); if (cd==0) return -1; memset(outbuf,0,outlen); if (iconv(cd,pin,&inlen,pout,&outlen)==-1) return -1; iconv_close(cd); return 0; } /*UNICODE码转为GB2312码*/ int u2g(char *inbuf,int inlen,char *outbuf,int outlen) { return code_convert("utf-8","gb2312",inbuf,inlen,outbuf,outlen); } /*GB2312码转为UNICODE码*/ int g2u(char *inbuf,size_t inlen,char *outbuf,size_t outlen) { return code_convert("gb2312","utf-8",inbuf,inlen,outbuf,outlen); }  //例子2: 用C++语言实现的转换示例程序  /* f.cpp : 代码转换示例C++程序 */ #include <iconv.h> #include <iostream>  #define OUTLEN 255  using namespace std;  // 代码转换操作类  class CodeConverter {  private: iconv_t cd; public:  // 构造 CodeConverter(const char *from_charset,const char *to_charset) { cd = iconv_open(to_charset,from_charset); }   // 析构 ~CodeConverter() { iconv_close(cd); }   // 转换输出 int convert(char *inbuf,int inlen,char *outbuf,int outlen) { char **pin = &inbuf; char **pout = &outbuf;  memset(outbuf,0,outlen); return iconv(cd,pin,(size_t *)&inlen,pout,(size_t *)&outlen); } };  int main(int argc, char **argv) { char *in_utf8 = "姝ｅ?ㄥ??瑁?"; char *in_gb2312 = "正在安装"; char out[OUTLEN];  // utf-8-->gb2312 CodeConverter cc = CodeConverter("utf-8","gb2312"); cc.convert(in_utf8,strlen(in_utf8),out,OUTLEN); cout << "utf-8-->gb2312 in=" << in_utf8 << ",out=" << out << endl;  // gb2312-->utf-8 CodeConverter cc2 = CodeConverter("gb2312","utf-8"); cc2.convert(in_gb2312,strlen(in_gb2312),out,OUTLEN); cout << "gb2312-->utf-8 in=" << in_gb2312 << ",out=" << out << endl; }    二、利用iconv命令进行编码转换  iconv命令用于转换指定文件的编码,默认输出到标准输出设备,亦可指定输出文件。  用法： iconv [选项...] [文件...]  有如下选项可用:  输入/输出格式规范： -f, --from-code=名称 原始文本编码 -t, --to-code=名称 输出编码  信息： -l, --list 列举所有已知的字符集  输出控制： -c 从输出中忽略无效的字符 -o, --output=FILE 输出文件 -s, --silent 关闭警告 --verbose 打印进度信息  -?, --help 给出该系统求助列表 --usage 给出简要的用法信息 -V, --version 打印程序版本号  例子: iconv -f utf-8 -t gb2312 aaa.txt >bbb.txt 这个命令读取aaa.txt文件，从utf-8编码转换为gb2312编码,其输出定向到bbb.txt文件。  小结: Linux为我们提供了强大的编码转换工具,给我们带来了方便。     我在LINUX下用iconv命令iconv -f UCS-2 -t utf8 unicode1.txt > unicode2.txt去转是OK的，但是在代码里用iconv转出来还是乱码，求指正！ FILE *fpo = fopen("/tmp/unicode1.txt", "rb"); char srcBuf[256] = {0}; fread(srcBuf, sizeof(srcBuf)-1, 1, fpo); iconv_t cd = iconv_open("UTF-8", "UCS-2"); int srcLen = 256; int outLen = 256; char s_outbuf[outLen]; memset(s_outbuf, 0, outLen); const char* srcStart = (const char*)srcBuf; char* tmpOutBuf = s_outbuf; iconv(cd, (const char**)&srcStart, (size_t *)&srcLen, &tmpOutBuf, (size_t *)&outLen); iconv_close(cd); fclose(fpo); fpo = NULL; printf("=========soutbuf : %s===========\n", s_outbuf);


Question: Socket Select 函数疑问

服务器起码要有一个监听套接字，然后每建立一个连接都要用一个套接字 楼主所谓的“一般情况也只有一个”，我实在想不出是什么情况


Question: 二叉树的界面输入问题

大神啊， 我要学多久才能象你们这么牛啊！！！！！！！！！11

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


Question: head课程设计

怎么写？急用


Question: RSA Crypto.lib  RSAPubKeyDeCry公钥解密问题 在线==

数据已经是加密后的。我有合法的公钥的。我再工具上测试过了的。解密数据完全正确的。

你有合法的私钥和公钥？

RE_DATA ox0401 说明是decrypted data is not a valid PKCS#1 data block. 来高手帮忙看看啊。


Question: vc tubro返回值问题

很谢了....

或者将 char *s="ABCde"; 改为 char s[]="ABCde";

#pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！


Question: 求大神看代码

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试是程序员必须掌握的技能之一。

外层循环和内层循环的循环计数器怎么都用同一个变量？


Question: 自己写的strcat编译没有问题，运行报错了

你这个函数调用时，要确定你s所指向的数组有可以修改，并且足够空间再存下。 "hello "是字符常量，一是不可修改，二是也只有6个字符大小空间，怎么可能还能再接上个"world".

楼上回复的有点有问题 http://www.cnblogs.com/lancidie/archive/2011/08/05/2128318.html 这是关于C++内存管理的，先看看吧

char *strp=s; strp是mystrcat()函数里面的变量，是存放在栈中的，当前函数结束后，占用的资源就释放了。所以会出现错误。 char* Strcat(char* s, const char* t) { 	char* ch = s;  	while (*ch != '\0') { 		++ch; 	}  	while ((*ch++ = *t++) != '\0') { 		 	}  	return s; }

越界了？这样做有些危险。注意别越界就行。

函数没问题，调用的地方有问题

常量问题。。。

字符串常量在常量区

内存访问问题，你都没有为目标字符串申请足够大的内存。

引用 7 楼 cfjtaishan 的回复:"hello "因为这个字符串是字符串常量，所以是不可以进行修改的，但是你的自定义函数里对起进行了修改，所以会出现运行出错。+++++++++++

问题解决，做了几年的JAVA把C忘的差不多了，JAVA太多事情帮忙弄好了，刚回归C感觉要考虑的东西很多啊

不能这样直接用字符串做参数吗？

代码就不看了，告诉你，库函数这么使用一样不行

#include <stdio.h>  char *mystrcat(char *s, const char *t) {     char *strp=s;     while(*s!='\0')     {         s++;     }     while(*s++=*t++)     {         ;     }     return strp; }  int main() {     char firststr[64]  = {"hello"};     char secondstr[64] = {" world"};      printf("%s\n", mystrcat(firststr, secondstr));     return 0; }   只给你做了少许修改，没有做错误检测。 再一个，你传进去的是指向常量区的字符串指针，常量区的内存是不允许修改的。所以你得用用数组保存起来。再做后续操作。

mystrcat("hello ", "world!")中的字符串都是常量，你的函数中对"hello "常量越界操作了 应该  #include <stdio.h>  char *mystrcat(char *s, const char *t) { 	char *strp=s; 	while(*s!='\0') 	{ 		s++; 	} 	while(*s++=*t++) 	{ 		; 	} 	return strp; }  int main(void) { 	char source[120] = "hello ";         printf("%s\n", mystrcat(source, "world!"));         return 0; }

引用 2 楼 genffe 的回复:不能这样直接用字符串做参数吗？ 传的常量字符串怎么改变内容。。


Question: 急急急，各位大神，麻烦问一下，在windows c里面怎么实现创建目录，而且目录名是变化的

引用 13 楼 zilaishuichina 的回复:[quote=引用 11 楼 sinat_16612001 的回复:]  这不是 已经说明问题了么   cut里面打印是对的，因为你赋值了'\0'，但是实际上你的cut里面的那个数组a长度是不够的，'\0'被赋值到了a数组的后面的内存中 而在main函数当中，zh，yy，mm是连续的内存，也就是说cut(str,27,31,zh)的时候，zh不是传给a了么，cut里面的a[j]='\0'，实际上就是zh[5]='\0'，而这个zh[5]实际上就是yy[0]，因为yy[0]被填上了'\0'，同理cut(str,33,36,yy)也是一样，‘\0’被填到了mm[0]上，所以你printf("%s\n",a)打印出来的都是对的。  那么为什么你main函数中打印的不对了呢，因为cut(str,27,31,zh)执行完，zh[5]，也就是yy[0]被填上了'\0'，然后你紧接着执行了cut(str,33,36,yy)，这里面将yy[0]填上了str[33]，yy[1]填上了str[34]，yy[2]填上了str[35]，yy[3]填上了str[36] yy[0]里面本来被赋值的'\0'被改成了str[33]，于是zh的'\0'没有了。这时候你再打印，答应出来的就是zh跟yy连在一起的一个字符串  再同理如果你连续执行 cut(str,27,31,zh); cut(str,33,36,yy); cut(str,37,38,mm) 然后再打印，打印出来的就是zh跟yy跟mm连在一起的一个字符串。  所以你应该定义 char zh[6]; char yy[5]; char mm[3]; 这样每个字符串就是有‘\0’的，就不会连在一起了[/quote] 是的，我前面搞错了，呵呵，谢谢

int year = 2014; int month = 6; int day = 17; char command[100]; sprintf(command, "md %4d-%02d-%02d", year, month, day); system(command);

引用 11 楼 sinat_16612001 的回复: 这不是 已经说明问题了么   cut里面打印是对的，因为你赋值了'\0'，但是实际上你的cut里面的那个数组a长度是不够的，'\0'被赋值到了a数组的后面的内存中 而在main函数当中，zh，yy，mm是连续的内存，也就是说cut(str,27,31,zh)的时候，zh不是传给a了么，cut里面的a[j]='\0'，实际上就是zh[5]='\0'，而这个zh[5]实际上就是yy[0]，因为yy[0]被填上了'\0'，同理cut(str,33,36,yy)也是一样，‘\0’被填到了mm[0]上，所以你printf("%s\n",a)打印出来的都是对的。  那么为什么你main函数中打印的不对了呢，因为cut(str,27,31,zh)执行完，zh[5]，也就是yy[0]被填上了'\0'，然后你紧接着执行了cut(str,33,36,yy)，这里面将yy[0]填上了str[33]，yy[1]填上了str[34]，yy[2]填上了str[35]，yy[3]填上了str[36] yy[0]里面本来被赋值的'\0'被改成了str[33]，于是zh的'\0'没有了。这时候你再打印，答应出来的就是zh跟yy连在一起的一个字符串  再同理如果你连续执行 cut(str,27,31,zh); cut(str,33,36,yy); cut(str,37,38,mm) 然后再打印，打印出来的就是zh跟yy跟mm连在一起的一个字符串。  所以你应该定义 char zh[6]; char yy[5]; char mm[3]; 这样每个字符串就是有‘\0’的，就不会连在一起了

引用 8 楼 sinat_16612001 的回复:不对啊，那输出yy,mm的值都是对的，没问题，只有zh不行，而且设成zh[6]也没用，还是空的  那么你  void cut(char *x, int y,int z, char *a)   {     int i,j=0;     for(i=y;i<=z;i++)     {         a[j]=x[i];           j++;     }     a[j]='\0';     printf("%s\n",a); //你看这地方是什么，这地方的zh，yy，mm值分别是什么 }

那个所读取的name.txt是这样的

yy， mm同理，   记得当用char数组存放字符串的时候，需要多分配1个字符存放你看不见的结束符'\0'

引用 4 楼 sinat_16612001 的回复:谢谢各位大神，但是我用的过程中还遇到个问题，  void cut(char *x, int y,int z, char *a)   {     int i,j=0;     for(i=y;i<=z;i++)     {         a[j]=x[i];           j++;     }     a[j]='\0'; } void main() {     FILE *fp;         char str[66];      	char zh[5];     char yy[4];     char mm[2];      fp=fopen("D:\\name.txt","r+");     if(fp==NULL)         printf("Can't open name");       while(fgets(str,66-1,fp))     {		 		cut(str,27,31,zh); 		cut(str,33,36,yy); 		cut(str,37,38,mm);                 printf("%s\n",yy);} } 不知道为什么这样输出的zh值是空的，但如果把cut(str,27,31,zh)放到cut(str,33,36,yy)后面，zh的值就有了，但这时yy的值就变成yyzz在一起的值了[/code] [/quote]  cut(str,27,31,zh);总共复制了5个字符，你的zh总长只有5，也就是说最后一个结束符没地方放了。应该定义为char zh[6];

谢谢各位大神，但是我用的过程中还遇到个问题，  void cut(char *x, int y,int z, char *a)   {     int i,j=0;     for(i=y;i<=z;i++)     {         a[j]=x[i];           j++;     }     a[j]='\0'; } void main() {     FILE *fp;         char str[66];      	char zh[5];     char yy[4];     char mm[2];      fp=fopen("D:\\name.txt","r+");     if(fp==NULL)         printf("Can't open name");       while(fgets(str,66-1,fp))     {		 		cut(str,27,31,zh); 		cut(str,33,36,yy); 		cut(str,37,38,mm);                 printf("%s\n",yy);} } 不知道为什么这样输出的zh值是空的，但如果把cut(str,27,31,zh)放到cut(str,33,36,yy)后面，zh的值就有了，但这时yy的值就变成yyzz在一起的值了[/quote][/code]

void main() {    FILE *fp;        char str[66] = { '\0' };                            char yy[6] = { '\0' };    char mm[6] = { '\0' };     char cmd[120] = { '\0' };         fp=fopen("D:\\name.txt","r+");    if(fp==NULL)       printf("Can't open name");         while(fgets(str,50-1,fp))          /*逐行读取文件name,由于每行的文件格式均为D:\data\yymm\yymm-FTM.txt，从中读取年月的值*/    {           strncpy(yy, cut(str,13,15), 2);        strncpy(mm, cut(str,15,16), 2);        sprintf(cmd, "md D:\\%s\\%s\\test3.txt", yy, mm);        system(cmd); /*创建文件夹，文件夹目录为所读取的年和月*/      }    fclose(fp); }

void cut(char *x, int y,int z, char *a)  /*a改为参数*/ { 	int i,j=0; 	for(i=y;i<=z;i++) 	{ 		a[j]=x[i];   		j++; 	} 	a[j] = '\0';//记得赋值结束符 }  void main() { 	FILE *fp;     	char str[66];                         	char yy[10]; 	char mm[10];  	fp=fopen("D:\\name.txt","r+"); 	if(fp==NULL) 		printf("Can't open name");  	while(fgets(str,50-1,fp)) 	{ 		cut(str,15,18, yy); 		cut(str,19,20, mm);   		char dir[255] = {0};  		sprintf_s(dir, "md D:\\%s\\%s\\test3.txt", yy, mm);//也可以用strcat，具体可以自己百度 		system(dir); 	} 	fclose(fp); }

1） 创建文件夹目录时，不能带入我所读取的年、月的变量； ：可以用sprintf函数解决这个问题 2）每次调用cut函数，由于定义的是static，用完返回值后，它不会释放空间，而一直保存前一个值，使得重新调用的时候就不能准确调出我需要的值。 ：把static删了不就行了吗？


Question: 用C语言创建多叉树问题

谢谢，多得老师提醒。现在已经靠自己解决了

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试是程序员必须掌握的技能之一。

你的指针都分配内存了吗？ T就没有。


Question: 为什么VC6.0跟VS2013运行后的结果不一样（在贴吧里看到的一个问题）

因为  +i                      +i        i+              +i                    +i                +i     i+  i++ii+++++i++i+i+ii+++        i++i    ++    ++            i++i+ii+++++  ++++++i+i++++ii+     i+          +i  i+                  +i    ++    +i    i+              ++    +i          ++           +i+++++++++i++i+i+                  +++++++++i+i+++i            +i    i+          +i           ++    +i  +i    +i      +i        +i      i+                    +i    i+++i++i+++++i +i+++i    ++++i++ii+i++++i++        ++++  +i        ++              i+i++i+i    +i    ++    +i     +i                  ++            ++            ++      i+      +i    i+          +i     ++      +i++i++ii++i+ii+              +++i+++i+i++i++ii++ii+    i+        +++ii++++ii++i++i+     ++      ++          i+              ++                i+        ++        ++      i+      ++     +i      ++i+i+i++i+i++            i+      i++++ii+++i++i++      i++i+i++  ++      ++      ++     ++      i+          i+        +++i+i      i+          +i              +i  +i+i+i+ii+i+++++i+     +i      i+i++i+++i++i+            +i      ++          +i              i+  +i      +i      i+     +i  ++        ++                  i+      +i          i+              +i          +i     +++i  +++i++i++++ii++i+ii+        ++      +i          ++      +i      ++          i+    i+     ++            ++                  +i      +++ii++i+++i+i        ++  +i    +++i+++++ii++i+i+i                   +i                  ++      i+          ++          i+                      ++

printf("%d,%d,%d\n", ++n, n += 2, --n); 这样的语句中，建议最好不要出现自增和自减的运算，因为不同的编译器，计算的顺序是不一样的，有的是从前往后算的，有的是从后往前算的，所以才出现楼主所说的问题

这个问题，高手和低手都会回答不知道，回答知道的就是广大的中间层次的人

写出这样代码的人，如果是在实际项目中使用，肯定是 SB  结果只是教学，那就算了

这个涉及到传参顺序和规则，自加和自减操作，依赖于编译器的实现，只能VC6和vs2013使用的不是同一版本的编译器。  纠结于这些没用什么意义。

不一样好了 一样就麻烦了 不然楼主就会认为这个就是答案了

不一样就对了。 如果一样，又有些人出来“分析”为什么了


Question: 求一个用c/c++编写的简单c语言编译器源代码，急，急，急！！！！

引用 26 楼 zhao4zhong1 的回复:[quote=引用 25 楼 my_live_123 的回复:] gcc, tcc, ucc, lcc任选一个，都是开源的，自己google！ [/quote] 赵老师卖萌~

引用 25 楼 my_live_123 的回复:gcc, tcc, ucc, lcc任选一个，都是开源的，自己google！

gcc, tcc, ucc, lcc任选一个，都是开源的，自己google！

引用 23 楼 zilaishuichina 的回复:多少年前曾说，csdn应该有个 课程设计版块的了  最好还是付费交易的。像淘宝一样

多少年前曾说，csdn应该有个 课程设计版块的了

这时候还写个毛啊，上Ｘ宝找个店花点钱买算了。

引用 19 楼 xcg88 的回复:赵四老师帮帮忙，一个关于文本关键字问题，催的急，感激！ 已私信您了 参考astyle源代码。

老师有点问题

赵四老师帮帮忙，一个关于文本关键字问题，催的急，感激！ 已私信您了

引用 16 楼 yunchao630 的回复:[quote=引用 14 楼 zhao4zhong1 的回复:] Tiny C Compiler即tcc 引用 15 楼 zyjj_99 的回复:赵4老师神一般的存在 我想问一下 赵四老师和刘能老师是什么关系？[/quote] 亲家

参考TinyCC（http://bellard.org/tcc/）  引用 楼主 cc13645204359 的回复:求一个用c/c++编写的简单c语言编译器源代码，急，急，急！！！！  课程设计啊，就要结课了

引用 14 楼 zhao4zhong1 的回复:Tiny C Compiler即tcc 引用 15 楼 zyjj_99 的回复:赵4老师神一般的存在 我想问一下 赵四老师和刘能老师是什么关系？

赵4老师神一般的存在

Tiny C Compiler即tcc

引用 11 楼 user-13 的回复:[quote=引用 9 楼 cc13645204359 的回复:] [quote=引用 7 楼 user-13 的回复:] 都6月17号了，才想起来，估计有点来不及了。楼上说的看gcc，更加来不及。 比较靠谱点的，还是借同学的改改吧。一个年级总有几个学霸的 每个人的选题都不同啊，所以来这里求助了，最近在准备考研所以没弄这个，下星期五就要交成果了，急啊。[/quote]  这么早就开始准备了啊？  还有10多天，如果改改tcc，估计有希望，加油吧[/quote] 谢了，我去下载代码看看。

引用 9 楼 cc13645204359 的回复:[quote=引用 7 楼 user-13 的回复:] 都6月17号了，才想起来，估计有点来不及了。楼上说的看gcc，更加来不及。 比较靠谱点的，还是借同学的改改吧。一个年级总有几个学霸的 每个人的选题都不同啊，所以来这里求助了，最近在准备考研所以没弄这个，下星期五就要交成果了，急啊。[/quote]  这么早就开始准备了啊？  还有10多天，如果改改tcc，估计有希望，加油吧

引用 8 楼 zhao4zhong1 的回复:TinyC TinyC

引用 7 楼 user-13 的回复:都6月17号了，才想起来，估计有点来不及了。楼上说的看gcc，更加来不及。 比较靠谱点的，还是借同学的改改吧。一个年级总有几个学霸的 每个人的选题都不同啊，所以来这里求助了，最近在准备考研所以没弄这个，下星期五就要交成果了，急啊。


Question: 图像处理的程序，关于标签化的。不知道为什么老是一直运行下去。不出结果。求各位大神指教。谢谢啦

for(;;)。。。死循环，而if(cnt==0)break;不一定是等于0，这样就跳不出去了。。 还有就是你的代码好歹多写几个大括号呀

感谢感谢

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


Question: 指针强制转换问题！

记不住优先级和结合方向时，多用用括号吧

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

引用 1 楼 jerry_dqh 的回复:(BiTree)p->lchild 改为((BiTree)p)->lchild  谢谢，原来如此！

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

(BiTree)p->lchild 改为((BiTree)p)->lchild


Question: array[count]=count++时发生了什么？

引用 2 楼 piaobotudou 的回复:你打印出来的是刚好没有被  myarray[count]=count++; 赋值的元素，所以打印的是内存被申请时的原始值 嗯，明白了，刚才怎么想了想不通，绕进去了

引用 1 楼 falcomavin 的回复:myarray[count]=count++; count被赋值后才++，后来你打印的已经不是赋值的那个数组单元了。其实你赋值的单元式0,2,4，。。。 是不是这样，我给myarray[0]赋值为0；然后count++成了1；我打印出来的就是myarray[1]的值，但myarray1还没有被赋值。


Question: 急求，二维数组进行字符串的比较题目，，，急急急！！！！

引用 1 楼 zhao4zhong1 的回复:#define MAXS 1000 //最多字符串数 #define MAXC 256   //每个字符串最多字符数 char s[MAXS][MAXC]; if (0<=strcmp(s[1],s[2])) ...

这几天学生作孽比较多哦。

二维数组字符串比较吧。。。书上的作业吗？

lz想干啥？？？

题目都说不清楚


Question: 区间操作 c语言 求解

楼主 求解答 感恩

仅供参考//实现一个函数：求数轴上多个线段覆盖的区域对应的多个线段; 输入多个线段,求出被这些线段覆盖的所有区域(也用线段表示); 一条线段用两个值表示(x0,x1), 其中x1>x0; //比如(1,3);(2,4);(5,6);结果为(1,4);(5,6); //比如(1,3);(2,4);(5,6);(4,7);结果为(1,7); #include <stdio.h> #define MAXLINES 100 struct LINE {     int x0;//左端     int x1;//右端 } ls[MAXLINES]; int i,j,k,n,x0,x1,c; void add() {     if (0==n) {//加入第一对点         ls[n].x0=x0;         ls[n].x1=x1;         n=1;     } else {         if (x1==ls[0].x0) {//右端＝第一条线段的左端             ls[0].x0=x0;//第一条线段的左端修改为左端             return;         }         if (x1<ls[0].x0) {//右端＜第一条线段的左端             for (i=n-1;i>=0;i--) {//将所有线段往后移                 ls[i+1].x0=ls[i].x0;                 ls[i+1].x1=ls[i].x1;             }             ls[0].x0=x0;//新第一条线段为x0,x1             ls[0].x1=x1;             n++;             return;         }         if (ls[n-1].x1<x0) {//左端＞最后那条线段的右端             ls[n].x0=x0;//新最后那条线段             ls[n].x1=x1;             n++;             return;         }         if (x0<=ls[0].x0 && ls[n-1].x1<=x1) {//左端≤第一条线段的左端且最后那条线段的右端≤右端             ls[0].x0=x0;//只剩这一条线段             ls[0].x1=x1;             n=1;             return;         }         for (i=0;i<n;i++) {//从左到右依次检查每条线段             if (ls[i].x0<=x0 && x0<=ls[i].x1) {//第i条线段的左端≤左端≤第i条线段的右端                 for (j=i;j<n;j++) {//从第i条线段开始从左到右依次检查每条线段                     if (ls[j].x0<=x1 && x1<=ls[j].x1) {//第j条线段的左端≤右端≤第j条线段的右端                         ls[i].x1=ls[j].x1;//第i条线段的右端改为第j条线段的右端                         for (k=1;k<=n-j-1;k++) {//将剩余线段往前移                             ls[i+k].x0=ls[j+k].x0;                             ls[i+k].x1=ls[j+k].x1;                         }                         n-=j-i;                         return;                     }                     if (ls[j].x1<x1 && (j==n-1 || x1<ls[j+1].x0)) {//第j条线段的右端＜右端＜第j+1条线段的左端(如果有)                         ls[i].x1=x1;//第i条线段的右端改为右端                         for (k=1;k<=n-j-1;k++) {//将剩余线段往前移                             ls[i+k].x0=ls[j+k].x0;                             ls[i+k].x1=ls[j+k].x1;                         }                         n-=j-i;                         return;                     }                 }             }             if (ls[i].x1<x0 && (i==n-1 || x0<ls[i+1].x0)) {//第i条线段的右端＜左端＜第i+1条线段的左端(如果有)                 if (i!=n-1 && x1<ls[i+1].x0) {//右端＜第i+1条线段的左端(如果有)                     for (k=n-1;k>=i+1;k--) {//将从第i+1条线段开始的所有线段往后移                         ls[k+1].x0=ls[k].x0;                         ls[k+1].x1=ls[k].x1;                     }                     ls[i+1].x0=x0;//新第i+1条线段为x0,x1                     ls[i+1].x1=x1;                     n++;                     return;                 }                 for (j=i+1;j<n;j++) {//从第i+1条线段开始从左到右依次检查每条线段                     if (ls[j].x0<=x1 && x1<=ls[j].x1) {//第j条线段的左端≤右端≤第j条线段的右端                         ls[i+1].x0=x0;//第i+1条线段的左端改为左端                         ls[i+1].x1=ls[j].x1;//第i+1条线段的右端改为第j条线段的右端                         for (k=1;k<=n-j-1;k++) {//将剩余线段往前移                             ls[i+1+k].x0=ls[j+k].x0;                             ls[i+1+k].x1=ls[j+k].x1;                         }                         n-=j-i-1;                         return;                     }                     if (ls[j].x1<x1 && (j==n-1 || x1<ls[j+1].x0)) {//第j条线段的右端＜右端＜第j+1条线段的左端(如果有)                         ls[i+1].x0=x0;//第i+1条线段的左端改为左端                         ls[i+1].x1=x1;//第i+1条线段的右端改为右端                         for (k=1;k<n-j-1;k++) {//将剩余线段往前移                             ls[i+k].x0=ls[j+k].x0;                             ls[i+k].x1=ls[j+k].x1;                         }                         n-=j-i-1;                         return;                     }                 }             }             if (x0<ls[i].x0) {//左端＜第i条线段的左端                 for (j=i;j<n;j++) {//从第i条线段开始从左到右依次检查每条线段                     if (ls[j].x0<=x1 && x1<=ls[j].x1) {//第j条线段的左端≤右端≤第j条线段的右端                         ls[i].x0=x0;//第i条线段的左端改为左端                         ls[i].x1=ls[j].x1;//第i条线段的右端改为第j条线段的右端                         for (k=1;k<=n-j-1;k++) {//将剩余线段往前移                             ls[i+k].x0=ls[j+k].x0;                             ls[i+k].x1=ls[j+k].x1;                         }                         n-=j-i;                         return;                     }                     if (ls[j].x1<x1 && (j==n-1 || x1<ls[j+1].x0)) {//第j条线段的右端＜右端＜第j+1条线段的左端(如果有)                         ls[i].x0=x0;//第i条线段的左端改为左端                         ls[i].x1=x1;//第i条线段的右端改为右端                         for (k=1;k<=n-j-1;k++) {//将剩余线段往前移                             ls[i+k].x0=ls[j+k].x0;                             ls[i+k].x1=ls[j+k].x1;                         }                         n-=j-i;                         return;                     }                 }             }         }     } } void show() {     for (i=0;i<n;i++) {         printf("(%d,%d);",ls[i].x0,ls[i].x1);     }     printf("\n"); } void main() {     n=0;     c=0;     while (1) {         printf("Input x0,x1(x0<x1;0,0 to exit):");         fflush(stdout);         rewind(stdin);         if (2==scanf("%d,%d",&x0,&x1)) {             if (0==x0&&0==x1) break;             if (x1>x0) {                 c++;                 if (c>=MAXLINES) {                     printf("Up to %d!\n",MAXLINES);                     break;                 }                 add();                 show();             }         }     } }

看起来像是OJ上的题目，可能是某门课的作业吧。可以用区间树之类的BST解决。

基本上就是OJ或者ACM之类的。 没兴趣就放弃吧。

20分我想没人给你写的，除非有人想否定我，楼主要这个程序做什么啊


Question: 程序运行崩溃，但随意添加一行代码就好不崩溃，谁能帮忙分析下。

问题找到了， 掉用静态库中的库函数发生了memcpy越界。 汗！！！！

引用 8 楼 yangyunzhao 的回复:内存越界(不一定是数组越界)，或者访问已经释放的区域……，所造成的后果，一般称为未定义。 也就是说如果你代码写的有问题，你无法预知可能的结果。说不定你自己测试的时候，运气好没有问题。 到工业环境中就出问题。  千万不要抱侥幸心理，还是尽量做点代码检查吧。试试pclint  有做pclint的。

引用 7 楼 buyong 的回复:clean + rebuild all clean + rebuild all  N 遍了。

引用 5 楼 zhao4zhong1 的回复:[quote=引用 4 楼 zhao4zhong1 的回复:] 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处。  为什么现在教C/C++语言的老师都不告诉学生这句话或者都自己也不会照这句话调试程序捏！  害我在CSDN复制粘贴这句话骗了多少C/C++莘莘学子的分啊！  [/quote] 想看Release版汇编指令对应C/C++源代码第几行，请在生成Release版exe的时候设置生成.pdb文件。

根据经验，如此莫名其妙的问题，一般是内存溢出造成的。

俺们掐指一算，楼主该啊 不上代码。。。

LZ这是盲人摸象。 其实很简单，要么上代码，要么上debugger。 原因也很简单，LZ能折腾出来的东西，多半就是内存越界什么的。

加了代码，就有可能改变了栈和代码段的内存布局，肯定程序是有问题的。或者rebuild一下看看

看堆栈不就行了~~

clean + rebuild all

前面我也遇到过类似问题， Debug下运行结果没错，一旦Release ， 不是崩就是跑出来的结果不正确， 郁闷的是加了两句cout语句，居然就正确了  那个函数就是传进去一个三维数组，而且也没有越界访问  后来把三维数组替换成别的数据结构也达到了自己的目的 但是那个问题一直萦绕在脑海！！！

引用 4 楼 zhao4zhong1 的回复:崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处。  为什么现在教C/C++语言的老师都不告诉学生这句话或者都自己也不会照这句话调试程序捏！  害我在CSDN复制粘贴这句话骗了多少C/C++莘莘学子的分啊！

引用 1 楼 adlay 的回复:同意内存访问越界的说法  有相关的查找调试经验或方法不？ 给介绍下吧！

show me the code

同意内存访问越界的说法


Question: void main ( )和 main ( )

引用 30 楼 zhao4zhong1 的回复:[quote=引用 29 楼 yangwenjun2017 的回复:] [quote=引用 5 楼 zhao4zhong1 的回复:] 行不行由自己当前手头上的这个编译器说了算，不由各种标准和不在自己手头上的其它编译器说了算！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！ 那我是要听你的还是不要听你的呢[/quote] 参考《仙剑奇侠传》中书中仙解决沉思鬼先迈左脚还是先迈右脚问题的办法！[/quote] 我是要听你这一句还是不要听呢

引用 29 楼 yangwenjun2017 的回复:[quote=引用 5 楼 zhao4zhong1 的回复:] 行不行由自己当前手头上的这个编译器说了算，不由各种标准和不在自己手头上的其它编译器说了算！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！ 那我是要听你的还是不要听你的呢[/quote] 参考《仙剑奇侠传》中书中仙解决沉思鬼先迈左脚还是先迈右脚问题的办法！

引用 16 楼 Liucsdn7 的回复:[quote=引用 10 楼 u013697891 的回复:] 楼主是大学生吗，为什么学习c啊  我是高中生，对C比较有兴趣，所以就买了一些书籍，以及琢磨。打算用高一高二的空余时间掌握C。[/quote]  有钱途

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

我也不大理解，但从没去深究过。。。得多看看书了。。。

引用 20 楼 ForestDB 的回复:早期的C，如果函数没有返回类型，那么就是int，所以main()和int main()就是一个意思。  至于main()和main(void)有没有区别，忘了。 大意是说main(void)表示没有参数，而main()可以有无数参数；而C++统一起来，都是表示没有参数。 记得不准了，LZ可以挖掘下。嗯嗯

引用 25 楼 luotuo44 的回复:没必要纠结这个问题 嗯嗯

没必要纠结这个问题

引用 23 楼 zhongniangyou 的回复:[quote=引用 16 楼 Liucsdn7 的回复:] [quote=引用 10 楼 u013697891 的回复:] 楼主是大学生吗，为什么学习c啊  我是高中生，对C比较有兴趣，所以就买了一些书籍，以及琢磨。打算用高一高二的空余时间掌握C。[/quote]  有钱途[/quote]  哇擦，高中就玩编程。

因为你看的《C程序设计语言》虽然经典，但是毕竟老了。不是按C99标准来的

书的问题，坚持标准吧

best wishes toyou

引用 17 楼 Liucsdn7 的回复:[quote=引用 14 楼 user-11 的回复:]  现在明白了，标准只有两个，具体的要看你手头的编译器。[/quote] 如果你考虑可移植性的话， 不能考虑某编译器特有的。

引用 14 楼 user-11 的回复: 现在明白了，标准只有两个，具体的要看你手头的编译器。

引用 10 楼 u013697891 的回复:楼主是大学生吗，为什么学习c啊  我是高中生，对C比较有兴趣，所以就买了一些书籍，以及琢磨。打算用高一高二的空余时间掌握C。

引用 9 楼 cfjtaishan 的回复:windows下和linux下是有不同的。之前在windows下编程，都基本上用void main(void)，目前在linux下编程一律使用了int main(void)形式（当然如果需要系统参数时，将main函数的参数补上）。  嗯！

引用 5 楼 zhao4zhong1 的回复:行不行由自己当前手头上的这个编译器说了算，不由各种标准和不在自己手头上的其它编译器说了算！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！ 受教了！非常感谢

受教了！非常感谢


Question: 求助

include\float.h ... #define DBL_DIG         15                      /* # of decimal digits of precision */ #define DBL_EPSILON     2.2204460492503131e-016 /* smallest such that 1.0+DBL_EPSILON != 1.0 */ #define DBL_MANT_DIG    53                      /* # of bits in mantissa */ #define DBL_MAX         1.7976931348623158e+308 /* max value */ #define DBL_MAX_10_EXP  308                     /* max decimal exponent */ #define DBL_MAX_EXP     1024                    /* max binary exponent */ #define DBL_MIN         2.2250738585072014e-308 /* min positive value */ #define DBL_MIN_10_EXP  (-307)                  /* min decimal exponent */ #define DBL_MIN_EXP     (-1021)                 /* min binary exponent */ #define _DBL_RADIX      2                       /* exponent radix */ #define _DBL_ROUNDS     1                       /* addition rounding: near */  #define FLT_DIG         6                       /* # of decimal digits of precision */ #define FLT_EPSILON     1.192092896e-07F        /* smallest such that 1.0+FLT_EPSILON != 1.0 */ #define FLT_GUARD       0 #define FLT_MANT_DIG    24                      /* # of bits in mantissa */ #define FLT_MAX         3.402823466e+38F        /* max value */ #define FLT_MAX_10_EXP  38                      /* max decimal exponent */ #define FLT_MAX_EXP     128                     /* max binary exponent */ #define FLT_MIN         1.175494351e-38F        /* min positive value */ #define FLT_MIN_10_EXP  (-37)                   /* min decimal exponent */ #define FLT_MIN_EXP     (-125)                  /* min binary exponent */ #define FLT_NORMALIZE   0 #define FLT_RADIX       2                       /* exponent radix */ #define FLT_ROUNDS      1                       /* addition rounding: near */  ...

越界了，double的范围为-2^1024 ~ +2^1024   即15~16位

c 中float的精度只有5到6 位 其他都是随机的 用double

LZ运行程序时的输入，就是合理的实例 随着6的个数的增多，能够表示的准确的6的个数，就是在15~16个左右，这就是现象； 而已经有人回答了，这是浮点数的精度问题，且是15~16左右的精度，这就是结论； 如果还要知道准确的原理，那么请查阅IEEE 754规范。

是不是数据i表示范围越界呢？？？

引用 5 楼 tiandragon00 的回复:我是想得到一个合理的实例来解释 仅供参考#include <stdio.h> #include <stdlib.h> #include <string.h> float f; double d; void showf() {     char bs[65];     char b[65];     unsigned char *p;     char e[12];     char *t;     int ex;      printf("\nf=%.6f\n",f);     p=(unsigned char *)&f;     printf("hex=%02X %02X %02X %02X\n",p[3],p[2],p[1],p[0]);     ltoa(*(long *)&f,b,2);     sprintf(bs,"%032s",b);     printf("bin=%s\n",bs);     printf("bin=%.1s %.8s   %s\n",bs,bs+1,bs+9);     strncpy(e,bs+1,8);e[8]=0;     ex=strtol(e,&t,2);     printf("    %c %-4d-127 1.%s\n",(bs[0]=='0')?'+':'-',ex,bs+9);     ex-=127;     printf("    %c %-8d 1.%s\n",(bs[0]=='0')?'+':'-',ex,bs+9); } void showd() {     char bs[65];     char b[65];     unsigned char *p;     char e[12];     char *t;     int ex;      printf("\nd=%.15lf\n",d);     p=(unsigned char *)&d;     printf("hex=%02X %02X %02X %02X %02X %02X %02X %02X\n",p[7],p[6],p[5],p[4],p[3],p[2],p[1],p[0]);     _i64toa(*(__int64 *)&d,b,2);     sprintf(bs,"%064s",b);     printf("bin=%s\n",bs);     printf("bin=%.1s %.11s   %s\n",bs,bs+1,bs+12);     strncpy(e,bs+1,11);e[11]=0;     ex=strtol(e,&t,2);     printf("    %c %-6d-1023 1.%s\n",(bs[0]=='0')?'+':'-',ex,bs+12);     ex-=1023;     printf("    %c %-11d 1.%s\n",(bs[0]=='0')?'+':'-',ex,bs+12); } int main() {      for (f=0.0f;f<=2.2f;f+=0.2f) showf();     printf("------------\n");     f=2.0f;showf();     printf("-----------------------------------\n");     for (d=0.0 ;d<=2.2 ;d+=0.2 ) showd();     printf("------------\n");     d=2.0 ;showd();      return 0; } // //f=0.000000 //hex=00 00 00 00 //bin=00000000000000000000000000000000 //bin=0 00000000   00000000000000000000000 //  + 0   -127 1.00000000000000000000000 //  + -127     1.00000000000000000000000 // //f=0.200000 //hex=3E 4C CC CD //bin=00111110010011001100110011001101 //bin=0 01111100   10011001100110011001101 //  + 124 -127 1.10011001100110011001101 //  + -3       1.10011001100110011001101 // //f=0.400000 //hex=3E CC CC CD //bin=00111110110011001100110011001101 //bin=0 01111101   10011001100110011001101 //  + 125 -127 1.10011001100110011001101 //  + -2       1.10011001100110011001101 // //f=0.600000 //hex=3F 19 99 9A //bin=00111111000110011001100110011010 //bin=0 01111110   00110011001100110011010 //  + 126 -127 1.00110011001100110011010 //  + -1       1.00110011001100110011010 // //f=0.800000 //hex=3F 4C CC CD //bin=00111111010011001100110011001101 //bin=0 01111110   10011001100110011001101 //  + 126 -127 1.10011001100110011001101 //  + -1       1.10011001100110011001101 // //f=1.000000 //hex=3F 80 00 00 //bin=00111111100000000000000000000000 //bin=0 01111111   00000000000000000000000 //  + 127 -127 1.00000000000000000000000 //  + 0        1.00000000000000000000000 // //f=1.200000 //hex=3F 99 99 9A //bin=00111111100110011001100110011010 //bin=0 01111111   00110011001100110011010 //  + 127 -127 1.00110011001100110011010 //  + 0        1.00110011001100110011010 // //f=1.400000 //hex=3F B3 33 34 //bin=00111111101100110011001100110100 //bin=0 01111111   01100110011001100110100 //  + 127 -127 1.01100110011001100110100 //  + 0        1.01100110011001100110100 // //f=1.600000 //hex=3F CC CC CE //bin=00111111110011001100110011001110 //bin=0 01111111   10011001100110011001110 //  + 127 -127 1.10011001100110011001110 //  + 0        1.10011001100110011001110 // //f=1.800000 //hex=3F E6 66 68 //bin=00111111111001100110011001101000 //bin=0 01111111   11001100110011001101000 //  + 127 -127 1.11001100110011001101000 //  + 0        1.11001100110011001101000 // //f=2.000000 //hex=40 00 00 01 //bin=01000000000000000000000000000001 //bin=0 10000000   00000000000000000000001 //  + 128 -127 1.00000000000000000000001 //  + 1        1.00000000000000000000001 //------------ // //f=2.000000 //hex=40 00 00 00 //bin=01000000000000000000000000000000 //bin=0 10000000   00000000000000000000000 //  + 128 -127 1.00000000000000000000000 //  + 1        1.00000000000000000000000 //----------------------------------- // //d=0.000000000000000 //hex=00 00 00 00 00 00 00 00 //bin=0000000000000000000000000000000000000000000000000000000000000000 //bin=0 00000000000   0000000000000000000000000000000000000000000000000000 //  + 0     -1023 1.0000000000000000000000000000000000000000000000000000 //  + -1023       1.0000000000000000000000000000000000000000000000000000 // //d=0.200000000000000 //hex=3F C9 99 99 99 99 99 9A //bin=0011111111001001100110011001100110011001100110011001100110011010 //bin=0 01111111100   1001100110011001100110011001100110011001100110011010 //  + 1020  -1023 1.1001100110011001100110011001100110011001100110011010 //  + -3          1.1001100110011001100110011001100110011001100110011010 // //d=0.400000000000000 //hex=3F D9 99 99 99 99 99 9A //bin=0011111111011001100110011001100110011001100110011001100110011010 //bin=0 01111111101   1001100110011001100110011001100110011001100110011010 //  + 1021  -1023 1.1001100110011001100110011001100110011001100110011010 //  + -2          1.1001100110011001100110011001100110011001100110011010 // //d=0.600000000000000 //hex=3F E3 33 33 33 33 33 34 //bin=0011111111100011001100110011001100110011001100110011001100110100 //bin=0 01111111110   0011001100110011001100110011001100110011001100110100 //  + 1022  -1023 1.0011001100110011001100110011001100110011001100110100 //  + -1          1.0011001100110011001100110011001100110011001100110100 // //d=0.800000000000000 //hex=3F E9 99 99 99 99 99 9A //bin=0011111111101001100110011001100110011001100110011001100110011010 //bin=0 01111111110   1001100110011001100110011001100110011001100110011010 //  + 1022  -1023 1.1001100110011001100110011001100110011001100110011010 //  + -1          1.1001100110011001100110011001100110011001100110011010 // //d=1.000000000000000 //hex=3F F0 00 00 00 00 00 00 //bin=0011111111110000000000000000000000000000000000000000000000000000 //bin=0 01111111111   0000000000000000000000000000000000000000000000000000 //  + 1023  -1023 1.0000000000000000000000000000000000000000000000000000 //  + 0           1.0000000000000000000000000000000000000000000000000000 // //d=1.200000000000000 //hex=3F F3 33 33 33 33 33 33 //bin=0011111111110011001100110011001100110011001100110011001100110011 //bin=0 01111111111   0011001100110011001100110011001100110011001100110011 //  + 1023  -1023 1.0011001100110011001100110011001100110011001100110011 //  + 0           1.0011001100110011001100110011001100110011001100110011 // //d=1.400000000000000 //hex=3F F6 66 66 66 66 66 66 //bin=0011111111110110011001100110011001100110011001100110011001100110 //bin=0 01111111111   0110011001100110011001100110011001100110011001100110 //  + 1023  -1023 1.0110011001100110011001100110011001100110011001100110 //  + 0           1.0110011001100110011001100110011001100110011001100110 // //d=1.600000000000000 //hex=3F F9 99 99 99 99 99 99 //bin=0011111111111001100110011001100110011001100110011001100110011001 //bin=0 01111111111   1001100110011001100110011001100110011001100110011001 //  + 1023  -1023 1.1001100110011001100110011001100110011001100110011001 //  + 0           1.1001100110011001100110011001100110011001100110011001 // //d=1.800000000000000 //hex=3F FC CC CC CC CC CC CC //bin=0011111111111100110011001100110011001100110011001100110011001100 //bin=0 01111111111   1100110011001100110011001100110011001100110011001100 //  + 1023  -1023 1.1100110011001100110011001100110011001100110011001100 //  + 0           1.1100110011001100110011001100110011001100110011001100 // //d=2.000000000000000 //hex=3F FF FF FF FF FF FF FF //bin=0011111111111111111111111111111111111111111111111111111111111111 //bin=0 01111111111   1111111111111111111111111111111111111111111111111111 //  + 1023  -1023 1.1111111111111111111111111111111111111111111111111111 //  + 0           1.1111111111111111111111111111111111111111111111111111 // //d=2.200000000000000 //hex=40 01 99 99 99 99 99 99 //bin=0100000000000001100110011001100110011001100110011001100110011001 //bin=0 10000000000   0001100110011001100110011001100110011001100110011001 //  + 1024  -1023 1.0001100110011001100110011001100110011001100110011001 //  + 1           1.0001100110011001100110011001100110011001100110011001 //------------ // //d=2.000000000000000 //hex=40 00 00 00 00 00 00 00 //bin=0100000000000000000000000000000000000000000000000000000000000000 //bin=0 10000000000   0000000000000000000000000000000000000000000000000000 //  + 1024  -1023 1.0000000000000000000000000000000000000000000000000000 //  + 1           1.0000000000000000000000000000000000000000000000000000 //

能否详细一点

我是想得到一个合理的实例来解释

引用 2 楼 adlay 的回复:浮点数能表示的精确有效位数是有限的 +1

浮点数能表示的精确有效位数是有限的


Question: c语言简单问题求助

说原因，最好有个例子，选什么我知道的

应该是选d吧

我认为选 d


Question: 文本编辑器问题（新手）---windows程序设计（第六章）TYPER程序

引用 4 楼 zhao4zhong1 的回复:问题1：在WM_CHAR:中  这3个事件中 的 case '\n':                    // line feed if (++yCaret == cyBuffer)     //★line feed的意思就是将光标位置往下挪一行，对应++yCaret,但如果已经挪到最下面一行的话yCaret == cyBuffer,就挪到最上面一行     yCaret = 0 ;                                              // if 语句  有什么作用 break ;  case '\r':                    // carriage return xCaret = 0 ;                  // 为什么还是对这 xCaret   yCaret    赋值0？★carriage return的意思就是将光标挪到最左边  if (++yCaret == cyBuffer)     //★这里是让'\r'完成和'\r\n'一样的功能     yCaret = 0 ; break ;  case '\x1B':                  // escape for (y = 0 ; y < cyBuffer ; y++)     for (x = 0 ; x < cxBuffer ; x++)         BUFFER (x, y) = ' ' ; //这个FOR语句    为什么要这样写★escape的功能是将光标挪到最左上角，并将以前输入的字符全部擦除  xCaret = 0 ; yCaret = 0;                     //为什么  要对这2个变量设置为0？  InvalidateRect (hwnd, NULL, FALSE) ; break ;     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 问题2：  case WM_KEYDOWN: case WM_CHAR:  为什么都要用SetCaretPos();  //★因为这两种消息都可能会改变当前光标所在位置。 获益良多

引用 2 楼 zhao4zhong1 的回复:都是将编辑光标所在位置挪到最左边。 能详细点吗

都是将编辑光标所在位置挪到最左边。

问题1：在WM_CHAR:中    这3个事件中 的  case '\n':                    // line feed                     if (++yCaret == cyBuffer)                          yCaret = 0 ;     // if 语句  有什么作用                     break ;                                      case '\r':                    // carriage return                          xCaret = 0 ;                          [color=#0000FF]// 为什么还是对这 xCaret   yCaret    赋值0？                                                if (++yCaret == cyBuffer)                          yCaret = 0 ;[/color]                     break ;                                      case '\x1B':                  // escape                     for (y = 0 ; y < cyBuffer ; y++)                          for (x = 0 ; x < cxBuffer ; x++)                               BUFFER (x, y) = ' ' ;                                       [color=#0000FF] //这个FOR语句    为什么要这样写                                                xCaret = 0 ;                     yCaret = 0;                     //为什么  要对这2个变量设置为0？                                                InvalidateRect (hwnd, NULL, FALSE) ;                     break ;[/color]     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 问题2： case WM_KEYDOWN: case WM_CHAR:  为什么都要用SetCaretPos();


Question: 期末作业 跪求好心大神解答 要求在Visual++6.0实现

引用 13 楼 zhou09039051698 的回复:[quote=引用 5 楼 zhao4zhong1 的回复:] 我不是好心大神，我是专门来害楼主考试不及格且学不到编程真本事的闲的蛋疼的混分族。 //如果一个数（可能包含前导0）乘以2，如142857*2=285714，依然由原来的数字组成的话，这样的数(142857)就叫Magic Number。 //输入 //一个不大于1e10000整数。 //输出 //判断这个数是不是Magic Number，是的话输出“Magic Number”，否则输出“Not Magic Number”。 //输入样例 //142857 //或者 //857142 //输出样例 //Magic Number //或者 //Not Magic Number #include <stdio.h> #include <string.h> #define MAXLEN 10001 char a1[MAXLEN]; char a2[MAXLEN]; char a3[MAXLEN]; static int v1[MAXLEN]; static int v2[MAXLEN]; static int v3[MAXLEN]; int i,j,n,L,z; int main(void) {     fgets(a1,MAXLEN,stdin);     if ('\n'==a1[strlen(a1)-1]) a1[strlen(a1)-1]=0;     strcpy(a2,a1);      L=strlen(a1);     for (i=0;i<L;i++) v1[i]=a1[L-1-i]-'0';      L=strlen(a2);     for (i=0;i<L;i++) v2[i]=a2[L-1-i]-'0';      for (i=0;i<MAXLEN;i++) v3[i]=v1[i]+v2[i];      for (i=0;i<MAXLEN;i++) {         if (v3[i]>=10) {             v3[i+1]+=v3[i]/10;             v3[i]=v3[i]%10;         }     }      j=0;     z=0;     for (i=MAXLEN-1;i>=0;i--) {         if (z==0) {             if (v3[i]!=0) {                 sprintf(a3+j,"%d",v3[i]);j++;                 z=1;             }         } else {             sprintf(a3+j,"%d",v3[i]);j++;         }     }     if (z==0) sprintf(a3,"0");      L=strlen(a3);     for (i=0;i<L;i++) if (NULL==strchr(a1,a3[i])) break;     if (i<L) {         printf("Not Magic Number\n");     } else {         printf("Magic Number\n");     }     return 0; }  //给你n个整数，用这n个数拼成一个超长的整数，要令这个新的整数最小 //例如： 11 110 123 拼出的最小数为：11011123 //例如： 123 11 11 拼出的最小数为：1111123 // //输入 //第一行为n(1<=n<=1000)，接下来是n个正整数，使用空格或者换行分开， //每个数字的长度不会超过1000，不存在前导0； //当n为0时结束程序 // //输出 //对于每组输入，输出拼成的新的整数的结果。 // //输入样例 //3 //987 123 190 //0 //输出样例 //123190987 #include <stdio.h> #include <string.h> int n; char d[1000][1001]; char t[1001]; int i,j; int main() {     while (1) {         scanf("%d",&n);         if (0==n) break;         for (i=0;i<n;i++) scanf("%1000s",d[i]);         for (i=0;i<n-1;i++) {             for (j=i+1;j<n;j++) {                 if (strcmp(d[i],d[j])>0) {                     strcpy(t,d[i]);                     strcpy(d[i],d[j]);                     strcpy(d[j],t);                 }             }         }         for (i=0;i<n;i++) printf("%s",d[i]);         printf("\n");     }     return 0; }  这个数据试一试，连给的例子都过不去的程序。。。。。 11 110 123[/quote] 改一下第32行，让"110"比"11"小。

引用 8 楼 zhao4zhong1 的回复:行不行不会自己编译链接运行一下吗？ 是骡子是马拉出来溜溜。 不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  你的口头禅好长啊，看到了好几年，我已经快能背下来了

随便一个帐号，上来第一个帖子就是伸手，how much？

第一题大数乘法，第二题j就是合并以下再strcmp比一下。 代码如下多找点数据测一测看谁的对  #include<iostream> #include<Cstdio> #include<Cstring> using namespace std;   char A2[5000], A1[5000], Sum1[5000], Sum[5000]; int hash1[10], hash2[10]; void Mul(char* A, char* B, char* result) { 	 	int i = 0, j = 0, sum, takeOver = 0, length; 	 	for(j = 0; j < 5000; j++) 		result[j] = '0'; 	 	 	while(A[i] != '\0') 	{ 		j = 0; 		while (B[j] != '\0') 		{ 			sum = (A[i] - '0') * (B[j] - '0')  			+ (result[i + j] - '0') + takeOver; 			 			result[i + j] = (sum%10) + '0'; 			takeOver = sum/10; 			j++; 		} 		if(takeOver == 0) 			length = i + j; 		else 		{ 			length = i + j + 1; 			result[i + j] += takeOver; 			takeOver = 0; 		} 		         i++; 	} 	 	result[length] = '\0'; }  void Reverse(char* n) { 	char temp; 	int i = 0, j = 0; 	while (n[j] != '\0') 	    j++; 	j--; 	while(i < j) 	{ 		temp = n[i]; 		n[i] = n[j]; 		n[j] = temp; 		 		i++;j--; 	} }   int main() { 	int i; 	bool flag = true; 	cin >> A1; 	Reverse(A1); 	A2[0] = '2'; A2[1] = '\0'; 	Mul(A1, A2, Sum); 	 	for(i = 0; i < 10; i++) 	{ 		hash1[i] = 0; hash2[i] = 0; 	} 	i = 0; 	while(A1[i] != '\0') 	{ 		hash1[A1[i] - '0']++; 		i++; 	} 	i = 0; 	while(Sum[i] != '\0') 	{ 	    hash2[Sum[i] - '0']++; 		i++; 	} 	 	for(i = 0; i < 10; i++) 	{ 		if(hash1[i] != hash2[i]) 		{ 			flag = false; 			break; 		} 	} 	if(flag) 		cout << "Magic Number" << endl; 	else 		cout << "Not Magic Number"<< endl; 	return 0; }    #include<iostream> #include<cstdio>  #include<cstring>   using namespace std;   char array[1001][1001]; char temp[1001];   char temp1[2001], temp2[2001];         bool compare(char* a1, char* a2) {     char *p1 = a1, *p2 = a2, *p3 = temp1;     while(*p1 != '\0')     {         *p3 = *p1;         p1++; p3++;     }           while(*p2 != '\0')     {         *p3 = *p2;         p2++; p3++;     }     *p3 = '\0';            p1 = a1, p2 = a2, p3 = temp2;     while(*p2 != '\0')     {         *p3 = *p2;         p2++; p3++;     }           while(*p1 != '\0')     {         *p3 = *p1;         p1++; p3++;     }     *p3 = '\0';            if(strcmp(temp1, temp2) > 0)         return true;     return false; }         void ShellSort(int length) {           int d = length/2;       int i, j;     char *p1, *p2;     while(d>=1)         {         for(i=d;i<length;i++)             {                 p1 = temp, p2 = array[i];             while(*p2 != '\0')             {                 *p1 = *p2;                 p1++; p2++;             }             *p1 = '\0';                           j=i-d;             while(j>=0 && compare(array[j], temp) > 0)               {                     p1 = array[j+d], p2 = array[j];                 while(*p2 != '\0')                 {                     *p1 = *p2;                     p1++; p2++;                 }                 *p1 = '\0';                 j=j-d;                 }                 p1 = array[j+d], p2 = temp;             while(*p2 != '\0')             {                 *p1 = *p2;                 p1++; p2++;             }             *p1 = '\0';         }                   d= d/2;        } }     int main() {     int size, i;     while(1)     {         cin >> size;         if(size == 0)             break;         for(i = 0; i < size; i++)            cin >> array[i];         ShellSort(size);         for(i = 0; i < size; i++)             cout << array[i];         cout << endl;     }    return 0; }

引用 5 楼 zhao4zhong1 的回复:我不是好心大神，我是专门来害楼主考试不及格且学不到编程真本事的闲的蛋疼的混分族。 //如果一个数（可能包含前导0）乘以2，如142857*2=285714，依然由原来的数字组成的话，这样的数(142857)就叫Magic Number。 //输入 //一个不大于1e10000整数。 //输出 //判断这个数是不是Magic Number，是的话输出“Magic Number”，否则输出“Not Magic Number”。 //输入样例 //142857 //或者 //857142 //输出样例 //Magic Number //或者 //Not Magic Number #include <stdio.h> #include <string.h> #define MAXLEN 10001 char a1[MAXLEN]; char a2[MAXLEN]; char a3[MAXLEN]; static int v1[MAXLEN]; static int v2[MAXLEN]; static int v3[MAXLEN]; int i,j,n,L,z; int main(void) {     fgets(a1,MAXLEN,stdin);     if ('\n'==a1[strlen(a1)-1]) a1[strlen(a1)-1]=0;     strcpy(a2,a1);      L=strlen(a1);     for (i=0;i<L;i++) v1[i]=a1[L-1-i]-'0';      L=strlen(a2);     for (i=0;i<L;i++) v2[i]=a2[L-1-i]-'0';      for (i=0;i<MAXLEN;i++) v3[i]=v1[i]+v2[i];      for (i=0;i<MAXLEN;i++) {         if (v3[i]>=10) {             v3[i+1]+=v3[i]/10;             v3[i]=v3[i]%10;         }     }      j=0;     z=0;     for (i=MAXLEN-1;i>=0;i--) {         if (z==0) {             if (v3[i]!=0) {                 sprintf(a3+j,"%d",v3[i]);j++;                 z=1;             }         } else {             sprintf(a3+j,"%d",v3[i]);j++;         }     }     if (z==0) sprintf(a3,"0");      L=strlen(a3);     for (i=0;i<L;i++) if (NULL==strchr(a1,a3[i])) break;     if (i<L) {         printf("Not Magic Number\n");     } else {         printf("Magic Number\n");     }     return 0; }  //给你n个整数，用这n个数拼成一个超长的整数，要令这个新的整数最小 //例如： 11 110 123 拼出的最小数为：11011123 //例如： 123 11 11 拼出的最小数为：1111123 // //输入 //第一行为n(1<=n<=1000)，接下来是n个正整数，使用空格或者换行分开， //每个数字的长度不会超过1000，不存在前导0； //当n为0时结束程序 // //输出 //对于每组输入，输出拼成的新的整数的结果。 // //输入样例 //3 //987 123 190 //0 //输出样例 //123190987 #include <stdio.h> #include <string.h> int n; char d[1000][1001]; char t[1001]; int i,j; int main() {     while (1) {         scanf("%d",&n);         if (0==n) break;         for (i=0;i<n;i++) scanf("%1000s",d[i]);         for (i=0;i<n-1;i++) {             for (j=i+1;j<n;j++) {                 if (strcmp(d[i],d[j])>0) {                     strcpy(t,d[i]);                     strcpy(d[i],d[j]);                     strcpy(d[j],t);                 }             }         }         for (i=0;i<n;i++) printf("%s",d[i]);         printf("\n");     }     return 0; }  这个数据试一试，连给的例子都过不去的程序。。。。。 11 110 123

第一道题可以转化为比较两个数字字符串，即将原数和乘积之后的数都转换成字符串，然后再使用字符串的相关函数解析。

OMG - - 好吧。谢谢了

第一题的要求就是只输入一次。中学语文阅读理解成绩不咋地吧。

第一题 运行后只能输出一次.   是不是用下while ( scanf） ？

第一题这样也行么？  #include <stdio.h> #include <string.h> #define MAX 10001 typedef struct { int date[MAX]; int len; }BigInt; int magic(BigInt a,int m); int main() { char str[MAX]; BigInt a; int i,len; while ( scanf("%s",str) != EOF ) { len = strlen(str); for ( i = 0; i < len; i++ ) { a.date[len-i-1] = str[i] - '0'; } a.len = len; if ( magic(a,2) ) { printf("Magic Number\n"); } else { printf("Not Magic Number\n"); } } return 0; } int magic(BigInt a,int m) { int i,temp; int carry = 0; int s[10],e[10]; for( i = 0; i < 10; i++ ) { s[i] = e[i] = 0; } for ( i = 0; i < a.len; i++ ) { s[a.date[i]] ++; } for ( i = 0; i < a.len; i ++ ) { temp = a.date[i] * m + carry; e[temp%10] ++; carry = temp / 10; } if ( carry ) { e[carry] ++; } for ( i = 0; i < 10; i++ ) { if ( s[i] != e[i] ) { return 0; } } return 1; }

C++ 6.0 实现不了啊

做什么做，楼主你室友在等你玩游戏呢...

好多都不会。求完全帮助

作业还是自己做吧 给你个思路，可能不是最好的，应该是比较好完成的 1   定义一个arr[10]   下标可以对应你的每位数数字的个数 2   用vector<string>   进行排序，在输出就OK了

期末作业 跪求好心大神解答 要求在Visual++6.0实现....好心大神 看一看帮一把  好伤心啊


Question: 拓扑排序的作用

自己百度。

刚百度了一下，类似于施工流程图


Question: Win32(非MFC)下创建的非模式窗口，如何销毁

引用 3 楼 user-3 的回复:SendMessage WM_CLOSE    如果你是非模态对话框那就可以这么做，如果登陆界面做成模态对话框,在响应确定或取消的时候 EndDialog。

引用 2 楼 hlx_beat 的回复:WM_DESTROY：PostQuitMessage(...);  非常感谢，那想问问，关闭窗口时，不调用PostQuitMessage能否作为隐藏窗口的一种方法呢？ 就比如说我有一个登录窗口，输入帐号密码后，如果把这个窗口销毁，登录后显示的主界面就出 不来了，所以能否用这种方法实现这类效果？

还要用PostQuitMessage才能退出。

SendMessage WM_CLOSE


Question: scanf连续输入字符串的问题

// crt_scanf_s.c // This program uses the scanf_s and wscanf_s functions // to read formatted input.    #include <stdio.h>  int main( void ) {    int      i,             result;    float    fp;    char     c,             s[81];    wchar_t  wc,             ws[81];     result = scanf_s( "%d %f %c %C %s %S", &i, &fp, &c, 1,                      &wc, 1, s, 80, ws, 80 );    printf( "The number of fields input is %d\n", result );    printf( "The contents are: %d %f %c %C %s %S\n", i, fp, c,            wc, s, ws);    result = wscanf_s( L"%d %f %hc %lc %S %ls", &i, &fp, &c, 2,                       &wc, 1, s, 80, ws, 80 );    wprintf( L"The number of fields input is %d\n", result );    wprintf( L"The contents are: %d %f %C %c %hs %s\n", i, fp,             c, wc, s, ws); }

char str[10] = "ccccc"; printf("%s\n", str); scanf_s("%s", str,10-1); printf("%s\n", str); system("pause"); return 0;

引用 5 楼 lin5161678 的回复:引用 4 楼 sozenvN 的回复:我用的scanf是在VS2012下的scanf_s,难道是因为这个函数的原因？你什么代码出问题 就贴什么代码 别随便改 浪费别人时间 不好意思啊，我是担心编译器不一样，不知道是scanf_s的问题

引用 3 楼 zxhuser-3 的回复: 哪有问题了？ 我用的scanf是在VS2012下的scanf_s,难道是因为这个函数的原因？

哪有问题了？

引用 1 楼 lin5161678 的回复:你说清楚你是怎么操作的 程序输出 ccccc 之后 你干了些什么 而程序是怎么反应的? 输入"sad" 回车 就是想修改str里面的值

引用 4 楼 sozenvN 的回复:[quote=引用 3 楼 zxhuser-3 的回复:]  哪有问题了？ 我用的scanf是在VS2012下的scanf_s,难道是因为这个函数的原因？[/quote] 对你不知说啥好。。。


Question: 程序0x77f92373指令引用的内存“0x00000010”内存,该内存不能为written

谢谢各位大牛！！！

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

CRITICAL_SECTION g_cs; 全局定义

调过 InitializeCriticalSection 没？

最好贴   g_cs   的定义、初始化代码


Question: 字符串查找并返回问题，谢谢

lz没看见 if？？？？

您好，问您一个问题，这里有两个return,第一个如果执行了，第二个还会返回吗？ 引用 2 楼 zhao4zhong1 的回复:C:\Program Files\Microsoft Visual Studio\VC98\CRT\SRC\STRCHR.C /*** *strchr.c - search a string for a given character * *       Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved. * *Purpose: *       defines strchr() - search a string for a character * *******************************************************************************/  #include <cruntime.h> #include <string.h>  /*** *char *strchr(string, c) - search a string for a character * *Purpose: *       Searches a string for a given character, which may be the *       null character '\0'. * *Entry: *       char *string - string to search in *       char c - character to search for * *Exit: *       returns pointer to the first occurence of c in string *       returns NULL if c does not occur in string * *Exceptions: * *******************************************************************************/  char * __cdecl strchr (         const char * string,         int ch         ) {         while (*string && *string != (char)ch)                 string++;          if (*string == (char)ch)                 return((char *)string);         return(NULL); }

*ret++;注释掉了，忘记打了，谢谢

C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\intel\strchr.asm 		page	,132 		title	strchr - search	string for given character ;*** ;strchr.asm	- search a string for a	given character ; ;		Copyright (c) Microsoft	Corporation. All rights	reserved. ; ;Purpose: ;		defines	strchr() - search a	string for a character ; ;*******************************************************************************  		.xlist 		include	cruntime.inc 		.list  page ;*** ;char *strchr(string, chr) - search	a string for a character ; ;Purpose: ;		Searches a string for a	given character, which may be the ;		null character '\0'. ; ;		Algorithm: ;		char * ;		strchr (string,	chr) ;		char *string, chr; ;		{ ;		  while	(*string &&	*string	!= chr) ;			  string++; ;		  if (*string == chr) ;			  return(string); ;		  return((char *)0); ;		} ; ;Entry: ;		char *string - string to search	in ;		char chr	 - character to	search for ; ;Exit: ;		returns	pointer	to the first occurence of c	in string ;		returns	NULL if	chr	does not occur in string ; ;Uses: ; ;Exceptions: ; ;*******************************************************************************  		CODESEG  found_bx: 		lea		eax,[edx - 1] 		pop		ebx					; restore ebx 		ret							; _cdecl return  		align	16 		public	strchr,	__from_strstr_to_strchr strchr	proc \ 		string:ptr byte, \ 		chr:byte  		OPTION PROLOGUE:NONE, EPILOGUE:NONE  		.FPO	( 0, 2,	0, 0, 0, 0 )  		xor		eax,eax 		mov		al,[esp	+ 8]		; al = chr (search char)  __from_strstr_to_strchr	label proc  		push	ebx					; PRESERVE EBX 		mov		ebx,eax				; ebx =	0/0/0/chr 		shl		eax,8				; eax =	0/0/chr/0 		mov		edx,[esp + 8]		; edx =	buffer 		test	edx,3				; test if string is	aligned	on 32 bits 		jz		short main_loop_start  str_misaligned:						; simple byte loop until string	is aligned 		mov		cl,[edx] 		add		edx,1 		cmp		cl,bl 		je		short found_bx 		test	cl,cl 		jz		short retnull_bx 		test	edx,3				; now aligned ? 		jne		short str_misaligned  main_loop_start:					; set all 4	bytes of ebx to	[chr] 		or		ebx,eax				; ebx =	0/0/chr/chr 		push	edi					; PRESERVE EDI 		mov		eax,ebx				; eax =	0/0/chr/chr 		shl		ebx,10h				; ebx =	chr/chr/0/0 		push	esi					; PRESERVE ESI 		or		ebx,eax				; ebx =	all	4 bytes	= [chr]  ; in the main loop (below),	we are looking for chr or for EOS (end of string)  main_loop: 		mov		ecx,[edx]			; read	dword (4 bytes) 		mov		edi,7efefeffh		; work with	edi	& ecx for looking for chr  		mov		eax,ecx				; eax =	dword 		mov		esi,edi				; work with	esi	& eax for looking for EOS  		xor		ecx,ebx				; eax =	dword xor chr/chr/chr/chr 		add		esi,eax  		add		edi,ecx 		xor		ecx,-1  		xor		eax,-1 		xor		ecx,edi  		xor		eax,esi 		add		edx,4  		and		ecx,81010100h		; test for chr 		jnz		short chr_is_found	; chr probably has been	found  		; chr was not found, check for EOS  		and		eax,81010100h		; is any flag set ?? 		jz		short main_loop		; EOS was not found, go	get	another	dword  		and		eax,01010100h		; is it	in high	byte? 		jnz		short retnull		; no, definitely found EOS,	return failure  		and		esi,80000000h		; check	was	high byte 0	or 80h 		jnz		short main_loop		; it just was 80h in high byte,	go get 									; another dword retnull: 		pop		esi 		pop		edi retnull_bx: 		pop		ebx 		xor		eax,eax 		ret							; _cdecl return  chr_is_found: 		mov		eax,[edx - 4]		; let's look one more time on this dword 		cmp		al,bl				; is chr in	byte 0? 		je		short byte_0 		test	al,al				; test if low byte is 0 		je		retnull 		cmp		ah,bl				; is it	byte 1 		je		short byte_1 		test	ah,ah				; found	EOS	? 		je		retnull 		shr		eax,10h				; is it	byte 2 		cmp		al,bl 		je		short byte_2 		test	al,al				; if in	al some	bits were set, bl!=bh 		je		retnull 		cmp		ah,bl 		je		short byte_3 		test	ah,ah 		jz		retnull 		jmp		short main_loop		; neither chr nor EOS found, go	get 									; another dword byte_3: 		pop		esi 		pop		edi 		lea		eax,[edx - 1] 		pop		ebx					; restore ebx 		ret							; _cdecl return  byte_2: 		lea		eax,[edx - 2] 		pop		esi 		pop		edi 		pop		ebx 		ret							; _cdecl return  byte_1: 		lea		eax,[edx - 3] 		pop		esi 		pop		edi 		pop		ebx 		ret							; _cdecl return  byte_0: 		lea		eax,[edx - 4] 		pop		esi					; restore esi 		pop		edi					; restore edi 		pop		ebx					; restore ebx 		ret							; _cdecl return  strchr	endp 		end

引用 3 楼 tudou12345679 的回复:您好，问您一个问题，这里有两个return,第一个如果执行了，第二个还会返回吗？ [quote=引用 2 楼 zhao4zhong1 的回复:] C:\Program Files\Microsoft Visual Studio\VC98\CRT\SRC\STRCHR.C /*** *strchr.c - search a string for a given character * *       Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved. * *Purpose: *       defines strchr() - search a string for a character * *******************************************************************************/  #include <cruntime.h> #include <string.h>  /*** *char *strchr(string, c) - search a string for a character * *Purpose: *       Searches a string for a given character, which may be the *       null character '\0'. * *Entry: *       char *string - string to search in *       char c - character to search for * *Exit: *       returns pointer to the first occurence of c in string *       returns NULL if c does not occur in string * *Exceptions: * *******************************************************************************/  char * __cdecl strchr (         const char * string,         int ch         ) {         while (*string && *string != (char)ch)                 string++;          if (*string == (char)ch)                 return((char *)string);         return(NULL); } [/quote]  当然不会


Question: apache接受到数据如何转发给c写的服务器

应该都是buf数据，转发就好可以吧！ 对方解析就好

WebSevice

顶一个。没人知道？？？？？？


Question: 成绩打印及绩点计算操作excel

楼主的问题解决了嘛，同求啊~

本人是菜鸟， 过来逛逛

引用 1 楼 zxhuser-4 的回复:lz你是不是发错版块了？？？ 同上，另外问一下，楼主想干什么

lz你是不是发错版块了？？？


Question: c语言 自增运算 自右向左结合性如何理解，源码如下，求高人分析

世上本无事，庸人自扰之。

引用 1 楼 buyong 的回复: 看置顶贴。++这种运算符给生活带来不少乐趣 引用 2 楼 u012421456 的回复:总之不要这么用了，看置顶帖——http://bbs.csdn.net/topics/370153775  谢谢，提供的置顶帖我看了， 通篇看下来就看到这一句：实际应该说的是：这种东西根本不该写，讨论其效果没有意义。  不过人家编译器能给出相应的报错提示，证明有其依据可言，别人能断定这是error ，而不是某些人所说的 没有意义。  不过第三问我已经参与相关书籍知道了， 那就是：increment/decrement操作符-前置返回reference,后置返回const obj  而自增自减运算只对变量  其它两问 不知道还有没有人可以解答一下的？

谢谢，提供的置顶帖我看了， 通篇看下来就看到这一句：实际应该说的是：这种东西根本不该写，讨论其效果没有意义。  不过人家编译器能给出相应的报错提示，证明尤其依据可言，就人家能断定这是error ，而不是某些人所说的 没有意义。  不过第三问我已经参与相关书籍知道了， 那就是：increment/decrement操作符-前置返回reference,后置返回const obj  而自增自减运算只对变量  其它两问 不知道还有没有人可以解答一下的？

看置顶贴。++这种运算符给生活带来不少乐趣

引用 1 楼 buyong 的回复: 看置顶贴。++这种运算符给生活带来不少乐趣 引用 2 楼 u012421456 的回复:总之不要这么用了，看置顶帖——http://bbs.csdn.net/topics/370153775 引用 5 楼 zhao4zhong1 的回复:http://bbs.csdn.net/topics/370153775 引用 6 楼 lin5161678 的回复:1.自增运算与加减混合的时候怎么结合？ 如 y = ++i +i+++i 到底是y = (++i)+i+(++i)  还是 y = (++i)+(i++)+i？怎么来？  你可以将其称之为 贪婪法则  最大限度的读取合法的标记 对于 i+++i 这样的表达式  +后面是+ 可以组成 ++ 那么就按照++理解  ++后面有一个+ 但是没有一个运算符是 +++ 所以就拆开  (++i)+(i++)+i  2.自右向左结合到底怎么运算？ 为什么 y = (++i)+(i++)+i中先计算 ++i 而不是 （i++) ，从汇编上看就是从++i计算到（i++）的过程，这不是自左向右了？ 自右向左到底是啥？ 这个如果按照你所谓的 你有看置顶帖 那么你就根本不会有这个疑问 另外 结合性也好 优先级也好 和怎么运算是毫无关系的 结合性和优先级只是用于确认 运算符和哪些子表达式结合 仅此而已  3.为什么语句：y = ++i+i+++++i;要报错：error C2105: '++' needs l-value， 为什么 +++++i可以正常运算？ i++++ 这个表达式解析为 ((i++)++) 第二个++的操作数是 i++  这里的问题是 ++的操作数要求是左值  而 i++ 这个表达式不是左值 所以就Error 而对于 ++++i 这个解析为(++(++i)) ++i 这个表达式在C++中是返回一个左值引用 所以可以继续 ++ 而对于C语言 ++i 结果不是左值 所以 ++++i 在C语言里面是Error 另外在说一点  ++自增运算符只能操作于变量，不能用于常量和表达式， 这个说法是扯淡  ++运算符[不考虑重载] 是只能用于表达式 [可修改左值表达式] 变量其实也是一个简单表达式! 引用 7 楼 zhao4zhong1 的回复:世上本无事，庸人自扰之。   谢谢各位贡献出来的答案， 本贴可以正式结贴了  我也想分享一下，自己的想法：  解决问题的速度和准确度，取决于TA构建的知识网络有多大，有多完善；一个点的盲区，可能是连接或激活一个新大陆的枢纽，就如"垃圾"只是放错了位置的宝贝一样。  就像这个问题的提出， 或许我从来没有写出 這样++++-----的代码，或许以后也不会写，通过综合回帖内容，发现了还有一些其它不一样的看法，盲区以及已经存在的误区  为了构筑更加强大的网络体系，当一回庸人又何妨？ ^_^


Question: 关于bland c的问题

Borland C++ 3.1，Borland C++ 4.5 到处都是

borland的C开发编译器

是一个很老的IDE吧，是指borland c

Borland C++ 3.1 ?