Question: 正余弦函数图像的动态扫描

仅供参考#include <stdio.h> #include <math.h> #ifndef M_PI #define M_PI       3.14159265358979323846 #endif #define W 80 #define H 20 char s[W][H]; double x,y; int i,j,i1; void main() {     for (j=0;j<H;j++)         for (i=0;i<W;i++)             s[i][j]=' ';     i1=0;     for (x=0.0;x<=359.0;x+=1.0) {         i=(int)(x*W/360.0);         if (i<0) i=0;         if (i>W-1) i=W-1;         y=sin(x*M_PI/180.0);         j=(int)(H/2-(H/2-1)*y);         if (j<0) j=0;         if (j>H-1) j=H-1;         if (i1!=i) {             s[i][j]='*';             i1=i;         }     }     printf("sin\n");     for (j=0;j<H;j++) {         for (i=0;i<W;i++) {             printf("%c",s[i][j]);         }         printf("\n");     }     for (j=0;j<H;j++)         for (i=0;i<W;i++)             s[i][j]=' ';     i1=0;     for (x=0.0;x<=359.0;x+=1.0) {         i=(int)(x*W/360.0);         if (i<0) i=0;         if (i>W-1) i=W-1;         y=cos(x*M_PI/180.0);         j=(int)(H/2-(H/2-1)*y);         if (j<0) j=0;         if (j>H-1) j=H-1;         if (i1!=i) {             s[i][j]='*';             i1=i;         }     }     printf("cos\n");     for (j=0;j<H;j++) {         for (i=0;i<W;i++) {             printf("%c",s[i][j]);         }         printf("\n");     } } //sin // //              ************* //            **             ** //          **                 ** //        **                     ** //      **                         ** //     *                             * //   **                               ** //  *                                   * // *                                     ** //                                         *                                     * //                                          *                                   * //                                           **                               ** //                                             *                             * //                                              **                         ** //                                                **                     ** //                                                  **                 ** //                                                    **             ** //                                                      ****** ****** //                                                            * //cos // // ******                                                                   ****** //       **                                                               ** //         **                                                           ** //           **                                                       ** //             **                                                   ** //               *                                                 * //                **                                             ** //                  *                                           * //                   *                                         * //                    **                                     ** //                      *                                   * //                       **                               ** //                         *                             * //                          **                         ** //                            **                     ** //                              **                 ** //                                **             ** //                                  ****** ****** //                                        *

应该有相关的库函数，自己搜搜


Question: 用Eclipse写C语言的困惑

引用 9 楼 zhao4zhong1 的回复: 引用 11 楼 u011779875 的回复: 非常感谢大家，菜鸟刚开始学习，有点不知所措

引用 8 楼 yinan9 的回复:[quote=引用 7 楼 u011779875 的回复:] 你用这个Eclipse+MinGW 你是学java的吧哥  写c语言用gcc  还是换codeblocks吧 这个是免费的 好的 谢谢！ 随便问下，gcc是啥[/quote] GCC（GNU Compiler Collection，GNU编译器集合）是一套由GNU工程开发的支持多种编程语言的编译器。

引用 2 楼 u011779875 的回复:printf("the number you entered is: %d",a);  这句话你加\n了吗  c语言的printf是行缓冲的 C的printf不一定是怎样缓冲的。缓冲模式和console相关。我估计可能是因为eclipse的控制台是行缓冲的。

引用 6 楼 yinan9 的回复:[quote=引用 4 楼 zhao4zhong1 的回复:] 换VS20XX 这个貌似收费吧，我用公司的机器做一些实验的，担心会涉及license问题[/quote] 这个绝对免费： http://www.microsoft.com/visualstudio/chs/downloads#d-2010-express 点开Visual C++ 2010 Express下面的语言选‘简体中文’，再点立即安装

引用 7 楼 u011779875 的回复:你用这个Eclipse+MinGW 你是学java的吧哥  写c语言用gcc  还是换codeblocks吧 这个是免费的 好的 谢谢！ 随便问下，gcc是啥

引用 4 楼 zhao4zhong1 的回复:换VS20XX 这个貌似收费吧，我用公司的机器做一些实验的，担心会涉及license问题

引用 3 楼 u011779875 的回复:结尾加句话 printf("\n");试试看 谢谢回复！ 但是加了也没起作用啊，你可能没明白我的问题。 我的问题是，程序运行没有先打印第一句话，而是要我输入数字 等我输入之后，两个printf一起执行了

结尾加句话 printf("\n");试试看

自己顶一下，求解释


Question: memcpy问题

memcpy 什么时候跟大小端有关系啦？不同大小端的处理器上不是还要重新编译，根本生成而二进制就不一样。你没用这个函数不说明你调用的库函数就不用这函数

告诉楼主一个NB的方法。  连接器说找不到memcpy，你在.c文件里实现一个就行了。

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

引用 8 楼 AnYidan 的回复:先根据提示修改别的错误，如果仅此一条，用#if(0) ... #endif 逐步确定错误范围 实在不行只有这样了，呵呵

引用 1 楼 u011779875 的回复:自己实现的memcpy1和memcpy2  是否调用了<stdlib.h>中的相关库函数 有的函数的实现是借助memcpy实现的  你注掉你写的memcpy1函数 看是否出现undefined refence to memcpy 如果不出现 说明你的实现借用了相关库函数 加上头文件即可 这个周我在调调，最近忙的没有顾得上这个事，谢谢大家啊

编译器错误提示最直接的信息来源，“某某文件”，这是你自己忽视最直接的线索。

引用 6 楼 max_min_ 的回复:[quote=引用 5 楼 N_sev7 的回复:] [quote=引用 4 楼 max_min_ 的回复:] 单步吧！可能是其他地方调用了！或者是其他库函数引起调用的！ 怎么单步编译？求版主详解[/quote]  是哦！他编译还没过！我的！单步不了， 只有根据提示修改语法问题，或者先写简单的deme测试下， 不要是乌龙！[/quote] 额，差点吓死我和小伙伴，以为自己连编译阶段的单步都没用过...

引用 5 楼 N_sev7 的回复:[quote=引用 4 楼 max_min_ 的回复:] 单步吧！可能是其他地方调用了！或者是其他库函数引起调用的！ 怎么单步编译？求版主详解[/quote]  是哦！他编译还没过！我的！单步不了， 只有根据提示修改语法问题，或者先写简单的deme测试下， 不要是乌龙！

引用 4 楼 max_min_ 的回复:单步吧！可能是其他地方调用了！或者是其他库函数引起调用的！ 怎么单步编译？求版主详解

单步吧！可能是其他地方调用了！或者是其他库函数引起调用的！

编译选项加/EP /P，重新编译，查看宏展开后对应的.i文件。gcc加-E

引用 楼主 gongzhaoye 的回复:我用的cds编译环境，程序中我并没有用memcpy函数，而是自己编写的替代函数memcpy1和memcpy2，主要是为了防止大小端问题。但是编译后老是报出某某文件“undefined refence to memcpy”，我检查很多次压根没有memcpy函数，把头文件、memcpy1和2函数名改了也不行，这是为什么呢  看看obj文件，哪里使用了memcpy


Question: C语言中，如何检查调用一个函数之后，有无内存泄露。

引用 26 楼 icesky1stm 的回复:[quote=引用 19 楼 max_min_ 的回复:] 让程序持续运行，查看内存使用情况吧！ 这个服务程序是给一个界面系统做服务端用的，所以新增加业务的时候，免不了要调用其他人自己写的程序。所以持续运行只能检查现有程序，不能让对以后新增加的程序做限制。  我目前折中的做法是，每次子进程调用了一定（可配置的）次数之后，舍弃掉。  哎，看来是没啥好办法了。[/quote] 《Unix编程艺术》

引用 16 楼 zhao4zhong1 的回复:检查是否资源泄漏的办法之一： 在任务管理器 进程 查看 选择列 里面选择：内存使用、虚拟内存大小、句柄数、线程数、USER对象、GDI对象 让你的程序(进程)不退出,循环执行主流程很多遍，越多越好，比如1000000次甚至无限循环，记录以上各数值，再隔至少一小时，越长越好，比如一个月，再记录以上各数值。如果以上两组数值的差较大或随时间流逝不断增加，则铁定有对应资源的资源泄漏！  PURIFY /BOUND CHECKER/ vc开DEBUG宏/xcode 的PROFILE 的LEAKS

搜一下API钩子吧。 大概就是 用跳转指令，替换函数内部的前几条指令 这样就会先执行，你自己定义的函数  这几乎要用到汇编了，不过可以不用汇编，直接嵌入二进制代码。 大概就是这种　Jmp DOWROD PTR XXX　指令　xxx 是函数地址  这种指令写成数据，如果有权限改写代码块，先保存，原来的内容，用数据Jmp DOWROD PTR XXX 替换 函数前几条指令， 大概是6字节吧。Jmp指令代码是 0xFF 0x25 0xXXXXXXXX   0xXXXXXXXX 就是你字节的函数地址。

学习了，厉害厉害

引用 24 楼 lm_whales 的回复:[quote=引用 23 楼 Starmean 的回复:] 如果要完全自己实现的话，我有一个想法 自己写一个头文件，代替掉原来的内存分配头文件 等于是重写里面的malloc和free函数等函数 申请内存时，先调用真正的malloc函数，获得了内存指针后，将此指针做个记录 释放内存时，根据内存指针地址，把相应的记录给删除 最后，如果记录为0表示没有泄漏  调试完成后，就可以把原来的真正文件还原重新链接编译 ++  还有一种方式，就是API钩子的实现方式。  程序启动时替换 malloc 开头的几个指令，跳入你自己的malloc实现 然后，恢复 malloc 开头的几个指令 ，调用 malloc 结束，完毕后再次替换。  确保用户使用的是你自己的内存分配函数。 其他内存管理函数，也可以这么做。  这样，你就可以随便检查了。[/quote]  自己封装一下目前实现不了，以为要改好多现有的业务程序了。  API钩子的方式，可否详细说一下。 怎么调到自己的malloc里去，要用嵌入汇编么。

引用 19 楼 max_min_ 的回复:让程序持续运行，查看内存使用情况吧！ 这个服务程序是给一个界面系统做服务端用的，所以新增加业务的时候，免不了要调用其他人自己写的程序。所以持续运行只能检查现有程序，不能让对以后新增加的程序做限制。  我目前折中的做法是，每次子进程调用了一定（可配置的）次数之后，舍弃掉。  哎，看来是没啥好办法了。

引用 20 楼 jiandingzhe 的回复:valgrind  虽然valgrind不能解决这个问题，但是我也我用了一下啊，但是当连接ORACLE数据库的时候，提示我没有连接权限。 valgrind --tool=memcheck --leak-check=yes CounterServerPP CTS CTS-MIDI 55666这样执行，不是用的当前用户的权限， 有什么办法把权限放大么。

引用 23 楼 Starmean 的回复:如果要完全自己实现的话，我有一个想法 自己写一个头文件，代替掉原来的内存分配头文件 等于是重写里面的malloc和free函数等函数 申请内存时，先调用真正的malloc函数，获得了内存指针后，将此指针做个记录 释放内存时，根据内存指针地址，把相应的记录给删除 最后，如果记录为0表示没有泄漏  调试完成后，就可以把原来的真正文件还原重新链接编译 ++  还有一种方式，就是API钩子的实现方式。  程序启动时替换 malloc 开头的几个指令，跳入你自己的malloc实现 然后，恢复 malloc 开头的几个指令 ，调用 malloc 结束，完毕后再次替换。  确保用户使用的是你自己的内存分配函数。 其他内存管理函数，也可以这么做。  这样，你就可以随便检查了。

引用 18 楼 baipv008 的回复:用内存池，要求对方只从你的内存池里分配内存。  嗯，赞同，而且在C++中，可以通过重载operator new和operator delete来实现，自定义内存管理

弄过一个资源管理器，将申请的内存，句柄，socket等全部进行注册，释放的时候就去注册。这样就随时查看注册的资源是否忘了释放。前提是提供申请资源的接口.

valgrind

让程序持续运行，查看内存使用情况吧！

用内存池，要求对方只从你的内存池里分配内存。

引用 15 楼 icesky1stm 的回复:[quote=引用 8 楼 xihu1364 的回复:] [quote=引用 楼主 icesky1stm 的回复:] 如题。 如何才能检测出内存泄露。   char * m1=NULL; char * m2=NULL; m1 = malloc(1); free(m1);  Main_Flow(); /*主服务进程，内部有动态调用业务级函数库(dlopen) */  m2 = malloc(1); free(m2);  if( m1 != m2)     printf("主进程有内存泄露？？？？\n");   开个玩笑，请教下大家有啥好办法。 楼主思维还是挺好的，赞一个！但是不可行...[/quote] 才发现，是个假版主。。。[/quote] 我又不是版主，只版主的大哥，你懂的

引用 8 楼 xihu1364 的回复:[quote=引用 楼主 icesky1stm 的回复:] 如题。 如何才能检测出内存泄露。   char * m1=NULL; char * m2=NULL; m1 = malloc(1); free(m1);  Main_Flow(); /*主服务进程，内部有动态调用业务级函数库(dlopen) */  m2 = malloc(1); free(m2);  if( m1 != m2)     printf("主进程有内存泄露？？？？\n");   开个玩笑，请教下大家有啥好办法。 楼主思维还是挺好的，赞一个！但是不可行...[/quote] 才发现，是个假版主。。。

引用 13 楼 user-11 的回复:这样是不行的，nt里面有freelist，这种招式，查不出内存泄露的。  推荐你看一下，java堆喷射里面的实现技巧，呵呵呵  用JAVA就会写个HELLO WORLD。。。。。。

引用 8 楼 xihu1364 的回复:[quote=引用 楼主 icesky1stm 的回复:] 如题。 如何才能检测出内存泄露。   char * m1=NULL; char * m2=NULL; m1 = malloc(1); free(m1);  Main_Flow(); /*主服务进程，内部有动态调用业务级函数库(dlopen) */  m2 = malloc(1); free(m2);  if( m1 != m2)     printf("主进程有内存泄露？？？？\n");   开个玩笑，请教下大家有啥好办法。 楼主思维还是挺好的，赞一个！但是不可行...[/quote]  版主大哥有混分的嫌疑。。。


Question: 求大神指导下！关于链表的！

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

林锐 高质量 C++& C 编程指南

La是一个指针的意思是，La作为一个变量，他的值是一个地址， 最初的地址是NULL，你现在要更改La的值，那么必须要把La的地址传递进去，无论La本身是什么变量。

想要在在子函数中赋值，就必须要传址。 传值的结果就是调用initlist_Link(La)之后，La的值还是NULL。 你可以在initlist_Link  下面一行打印一下La。

void initlist_Link(Linklist &L)///设置成引用或者 void initlist_Link(Linklist *L)///设置成指向指针的指针


Question: 指针内存分配！！求高手现身。

哥我信你，结贴！

//1 没有别人的语法错误！稍微修改                                                                                struct blocked_ip *bip; bip = (struct blocked_ip *)malloc(sizeof(struct blocked_ip)); memset(bip, 0 ,sizeof(struct blocked_ip)); bzero(bip->ip, 16); bip->next = NULL;  //2 calloc和malloc不同点就是会对分配的内存初始化而已！ //你先分配了内存没有释放，然后对它取值，然后在分配内存直接是错误的做法！不合语法 //如果是要双指针的话，可以如下操作 struct blocked_ip **bip=(struct blocked_ip **)calloc(1,sizeof(struct blocked_ip *)); *bip = (struct blocked_ip *)malloc(sizeof(struct blocked_ip)); //这里只是分配一个结构体内存空间而已 memset(bip, 0 ,sizeof(struct blocked_ip)); bzero(bip->ip, 16); bip->next = NULL;  //3 ip已经是数组，当你给bip分配内存空件的时候，就已经给它分配了的！ //所以不需要再额外分配内存空间 //如果是 char *p ,则需要再额外分配

写法1：少了指针的强制(struct blocked_ip *)转换 写法2：重复分配会造成内存泄露 写法3：ip是数组，已经分配空间，不需要再动态分配  引用 楼主 u011742078 的回复:针对： struct blocked_ip { 	char ip[16]; 	struct blocked_ip* next; };  以下三种方法，分别错误在什么地方： 写法1： struct blocked_ip *bip; bip = malloc(sizeof(struct blocked_ip)); bzero(bip->ip, 16); bip->next = NULL;  写法2： struct blocked_ip *bip=(struct blocked_ip *)calloc(1,sizeof(struct blocked_ip *)); *bip = malloc(sizeof(struct blocked_ip)); bzero(bip->ip, 16); bip->next = NULL;  写法3： struct blocked_ip* bip = (struct blocked_ip*) malloc(sizeof(struct blocked_ip*)); bip->ip = (char *) calloc(1,16); bip->next = NULL;


Question: 这错在哪啊？

void指针虽然能容纳全部类型，但是用的时候必须做类型转换。而且你那句只是赋值没有调用。代码的话参考15楼的就好了。不过15楼19行错了，是((PFUN)(buf[j]))(); 建议你了解下函数指针。

把15楼代码改一行： (PFUN)(buf[j]); 改为： ((PFUN)(buf[j]))();

引用 15 楼 nightkids_008 的回复:即使你代码没错也不会有打印的，你的buf[i]=hello，只是赋值，并没有调用。 #include <stdio.h>    void hello(void)//定义一个无返回值无形参类型的函数hello {     fprintf(stderr,"Hello!\n");//输出函数 }  typedef void (* PFUN)(void)  void func(void) {     void   *buf[10];  //定义一个无类型指针数组     static    int    i;  //定义静态局部变量i            for(i = 0; i < 10; i++) {         buf[i] = hello;     }     for(int j = 0; j < 10; ++j)     {         (PFUN)(buf[j]);     } }    int main(void) {     //int buf[1000];//定义一个长度为1000的整型数组            func();//函数调用            return 0; }这能运行？你确定？

看lz的代码，是想定义一个函数指针数组吗？ 若是函数指针数组，则修改那个数组定义就可以了，代码如下：  #include <stdio.h>  void hello(void)//定义一个无返回值无形参类型的函数hello { 	fprintf(stderr,"Hello!\n");//输出函数 }  void func(void) { //	char	*buf[10];  //定义一个无类型指针数组 	void	(*buf[10])(void); 	static	int    i;  //定义静态局部变量i 	 	for(i = 0; i < 30; i++) { 		buf[i] = hello; 	}	 }  int main(void) { 	int buf[1000];//定义一个长度为1000的整型数组 	 	func();//函数调用 	 	return 0; }

怎么帮忙改下，是的其最后不崩溃，在Ubuntu下运行是输出了一段hello!后 出现段错误，核心已经存储。

#include <stdio.h>   void hello(void)//定义一个无返回值无形参类型的函数hello {     fprintf(stderr,"Hello!\n");//输出函数 }   void func(void) {     void   *buf[10];  //定义一个无类型指针数组     static    int    i;  //定义静态局部变量i           for(i = 0; i < 100; i++) {<-------越界/＊这怎么越界来着?*/         buf[i] = hello;     }     }   int main(void) {     int buf[1000];//定义一个长度为1000的整型数组           func();//函数调用           return 0; } 源程序是这样的，你们自己运行下，可以运行但是最终这程序会崩溃，主要错在数组越界。

引用 1 楼 lunat 的回复:char    *buf[10];  //定义一个无类型指针数组  这叫无类型指针数组？ void * buf[30];打错了，我的错，本来是void * buf[30]这样的

完全不明白这程序啥意思 main中的int buf[1000];摆设？ static    int    i;需要static？就当需要吧.... char    *buf[10];buf[i]=hello; ? 不是void *也不是函数指针，能buf[i]=hello？  完全意义不明

for(i = 0; i < 30; i++) {         buf[i] = hello;     } 注释什么的，就自己修改把。  #include <stdio.h>   void hello(void)//定义一个无返回值无形参类型的函数hello {     fprintf(stderr,"Hello!\n");//输出函数 }   void func(void) {     char    *buf[10];  //定义一个无类型指针数组     static    int    i;  //定义静态局部变量i           for(i = 0; i < 10; i++) {         buf[i] = "hello";     }     }   int main(void) {     int buf[1000];//定义一个长度为1000的整型数组           func();//函数调用           return 0; }

char    *buf[10];——这个为什么认为是无类型？应该像2楼说的void * 而且数组明显会溢出。。

各种错，连注释都错

楼上太厉害了，居然看懂了楼主的意图！

地址的数组指针，指针没有分配内存空间吧！ 而且写的函数指针也不是这样吧！

引用 2 楼 junlinfushi 的回复:buf[i] = hello;这个肯定是错的首先，你的hello如果是函数的话，那就应该加上括号。可是，你的hello()函数是void型的，所以，你的buf[i] = hello();也是错的

你这程序有错吗，只是变量赋值而已！

buf[i] = hello;这个肯定是错的


Question: 初学数据结构，陷入伪代码的泥淖

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

问题3中的，L.elem[i]，这个elem是struct的结构体中的成员。比如下面这个例子：struct Node{     int name;     int no;     int[] elem; }; struct Node L;这样L就有了elem成员，要取出该成员时可以这样，L.elem[0]，其他的成员就是L.name什么的

至于问题三: 你看的是严蔚敏的那版数据结构吧

引用 22 楼 u012686437 的回复:左边newbase不就是一个指针名吗，右面表示的不就是elemtype类型的指针吗。我前面已经定义了newbase是elemtype类型的..所以左边直接用newbase不行吗 你如果定义过了，=左边直接用newbase就可以了，如果没定义过，一般用的是malloc。realloc是重新分配内存空间的时候用的。

问题二: 取地址符的问题,首先我们说说取地址符的作用,&这个符号,可以做取地址符也可以做引用. 取地址符是指针和&结合使用,引用是变量和&结合使用,注意引用申明必须初始化,作用就是给一个变量另一个名字. 好,接下来结合你的问题.在函数的声明中,形参使用&是对调用函数时的实参的引用,优点在于直接访问实参,无需拷贝一个副本,如果函数改变了实参的值,那么结果会对实参有影响,若不用&,即对实参先拷贝一个副本,再使用这个副本,函数对实参无影响.  其实,用&和不用看函数是否需要对实参进行实质性的改变.

引用 20 楼 oOo532200 的回复:问题一: 当然可以不要*,首先我们分析一下这句代码,ElementType是个类型,声明了*newBase(翻译为基址,很明显是指向申请空间的首地址),后面分为两部分,(ElementType *)和realloc(...),我们先说后面的,后面是申请内存空间,看看realloc原型是extern void *realloc(void *mem_address, unsigned int newsize);函数意义是:指针名=（数据类型*）realloc（要改变内存大小的指针名，新的大小）,如果你不要* ,你得先知道realloc分配空间的首地址,再用ElementType类型的指针指向这段新分配的空间首地址.之所以用指针,是因为指针的地址是系统分配的,我们可以很方便的通过指针指向我们所希望的对象,不用考虑newBase的地址当然要是想知道这段地址也是可以通过指针获取到的.为什么需要*,是因为realloc函数定义就是这么写的,我们只是调用.左边newbase不就是一个指针名吗，右面表示的不就是elemtype类型的指针吗。我前面已经定义了newbase是elemtype类型的..所以左边直接用newbase不行吗

引用 19 楼 Adol1111 的回复:[quote=引用 17 楼 u012686437 的回复:] 好吧，看来阁下所认为的C基础要比我们这些菜鸟高多了，我不知道啥叫引用，知识水平有限！！ 说了半天，为什么感觉你还是不能虚心接受一下呢？如果你要争论我也没办法，需要的知识都跟你说过了。如果你想了解下引用的话，我也给你举个例子吧，希望你能理解下。 int a=0; int* p; p=&a;//这里是一个取地址，把a的地址取出来赋给p,是C语言的基础 int& b=a;//这里是一个引用，一个引用相当于给另一个变量取别名，注意看&的位置就知道了 [/quote]好吧。挺好理解的。就是被代码弄得挺恼火的。

引用 17 楼 u012686437 的回复:好吧，看来阁下所认为的C基础要比我们这些菜鸟高多了，我不知道啥叫引用，知识水平有限！！ 说了半天，为什么感觉你还是不能虚心接受一下呢？如果你要争论我也没办法，需要的知识都跟你说过了。如果你想了解下引用的话，我也给你举个例子吧，希望你能理解下。 int a=0; int* p; p=&a;//这里是一个取地址，把a的地址取出来赋给p,是C语言的基础 int& b=a;//这里是一个引用，一个引用相当于给另一个变量取别名，注意看&的位置就知道了

伪代码是有很多，但用伪代码是因为跟语法无关，不必因为语言不同而造成理解问题，实现的话需要你自己去翻译。但你贴出的代码都是C语言的。我给你举一段伪代码的例子： QUICKSORT(A，p，r) 1　if p<r 2　then q ←PARTITION(A，p，r) 3　QUICKSORT(A，p，q-1) 4　QUICKSORT(A，q+1，r)  PARTITION(A，p，r) 1　x←A[r] 2　i←p-1 3　for j←p to r-1 4　do if A[j]≤x 5　then i←i+1 6　exchange A[i]←→A[j] 7　exchange A[i+1]←→A[r] 8　return i+1 这是快速排序的伪代码，他只是表述了整个方法的流程，没有涉及任何语言的语法。

引用 16 楼 Adol1111 的回复:[quote=引用 12 楼 u012686437 的回复:] 既然你这么说。那我肯定地告诉你，这就是严蔚敏那本说是用C写的数据结构。。但是里面出现了大量的伪代码和C++中的引用。这是有人才告诉我的。你说我说用C看不懂有没有道理！！！！ 我说的是C语言基础书籍，如果没有这些就不要算一本真正的C语言书。 还有不要以为用了&就是引用，严蔚敏那本书，没有一个引用，只是取地址而已，不要混淆概念了。如果有人告诉你是C++的引用，那你就应该好好找那个人问清楚，为什么是引用。 严蔚敏那本书用了很多你说的内容是事实，但这些不代表跟C基础无关。这些都是C里最常用的东西，你应该先了解下这些C语言的基础吧。[/quote]好吧，看来阁下所认为的C基础要比我们这些菜鸟高多了，我不知道啥叫引用，知识水平有限！！

引用 12 楼 u012686437 的回复:既然你这么说。那我肯定地告诉你，这就是严蔚敏那本说是用C写的数据结构。。但是里面出现了大量的伪代码和C++中的引用。这是有人才告诉我的。你说我说用C看不懂有没有道理！！！！ 我说的是C语言基础书籍，如果没有这些就不要算一本真正的C语言书。 还有不要以为用了&就是引用，严蔚敏那本书，没有一个引用，只是取地址而已，不要混淆概念了。如果有人告诉你是C++的引用，那你就应该好好找那个人问清楚，为什么是引用。 严蔚敏那本书用了很多你说的内容是事实，但这些不代表跟C基础无关。这些都是C里最常用的东西，你应该先了解下这些C语言的基础吧。

引用 5 楼 baipv008 的回复:[quote=引用 2 楼 u012686437 的回复:] 拜托，我在c中根本就没有见过这种写法！！  你在c中没写过？ 1 char *p=malloc(100);//前面不加char？ 2 void foo(int a, int b);//a前面一定要有&？ 3 struct {char elem[10]} L;    L.elem[0]=1;  //有问题？[/quote]1如果前面已经定义了p的类型，在这里还需要加上char吗？2看数据结构就会出现加地址的。不知道你看过严蔚敏那本没有。3我是想问线性表是包括数组吗，如果包括，这样写没错。但为什么说数组是属于线性表呢，他不就是个线性表吗。

引用 7 楼 AnYidan 的回复:[quote=引用 3 楼 u012686437 的回复:] [quote=引用 1 楼 max_min_ 的回复:] 这个和数据结构没有关系！ 是c语言基础没有过关吧！都是基础知识！找本书补补基础！...我在c中根本就没见过这种语法！！！！[/quote]  LZ 读的c 和我们看的不同[/quote]C中的确没有引用这个概念！！！

伪代码比具体代码更抽象，更稳定。

引用 9 楼 Adol1111 的回复:[quote=引用 3 楼 u012686437 的回复:] [quote=引用 1 楼 max_min_ 的回复:] 这个和数据结构没有关系！ 是c语言基础没有过关吧！都是基础知识！找本书补补基础！...我在c中根本就没见过这种语法！！！！[/quote]没见过不代表没有吧，你都说是初学了，就应该听听人家的意见。既然提示你是C的语法了，应该回去补下C吧，这都是C的语法基础了。 如果你坚持没看过，那我也没办法。如果是你看的那本书，从头到尾没出现过，那你先确定是不是讲C的，如果是的话，建议你丢了，重新换一本。[/quote]既然你这么说。那我肯定地告诉你，这就是严蔚敏那本说是用C写的数据结构。。但是里面出现了大量的伪代码和C++中的引用。这是有人才告诉我的。你说我说用C看不懂有没有道理！！！！

引用 4 楼 wsx199397 的回复:ElemType指得是elememt type也就是元素类型，这个应该换成你需要的类型，比如int float...... 或者用typedef。  void LocateElem_Sq(SqList L, ElemTy pe e)；这个应该是函数声明，在L加上&不就成C++引用了吗。但是看到其他基本操作比如删除插入初始化什么的都加了地址。。严蔚敏那本书说是用c写的，但是鱼龙混杂不知道可能用了C++。。看不懂

引用 3 楼 u012686437 的回复:[quote=引用 1 楼 max_min_ 的回复:] 这个和数据结构没有关系！ 是c语言基础没有过关吧！都是基础知识！找本书补补基础！...我在c中根本就没见过这种语法！！！！[/quote]没见过不代表没有吧，你都说是初学了，就应该听听人家的意见。既然提示你是C的语法了，应该回去补下C吧，这都是C的语法基础了。 如果你坚持没看过，那我也没办法。如果是你看的那本书，从头到尾没出现过，那你先确定是不是讲C的，如果是的话，建议你丢了，重新换一本。

我记得大学的这本教程里头，里边的sample，前提都是有使用一个通用的定义吧

引用 1 楼 max_min_ 的回复:这个和数据结构没有关系！ 是c语言基础没有过关吧！都是基础知识！找本书补补基础！...我在c中根本就没见过这种语法！！！！


Question: strlen和sizeof的区别

strlen是一个C函数，sizeof是一个操作符.

strlen是一个C函数，用来计算一个字符串的长度，不包含‘\0’； sizeof是一个操作符，返回一个目标所占得字节。而且目标必须是已知大小的！  性质完全不一样~~~~！

sizeof是关键字，就像int，long一样的，支持c语言的平台都可以用这个关键字， strlen是测量字符串长度的函数，使用时包含string.h，作为补充

很明显一个是给字符串的， 另一个不是， 是计算各个类型的字节数

strlen用于计算一个字符串中的字符个数,计算方法是从起始字符开始直到遇到结束符'\0'结束。sizeof操作符用于返回目标所占字节数

gggggggggggggggggggggg

sizeof 是操作符，用于计算类型或对象所占用的空间，以 byte 为单位，在编译期完成  strlen 是函数，计算字符串的长度，遇到 '\0'结束，返回值以 byte 为单位，不含'\0'；在运行期完成

http://www.cplusplus.com/reference/cstring/strlen/ http://en.cppreference.com/w/cpp/language/sizeof  sizeof是操作符，必须作用于大小已知的对象或类型，返回编译期常量； strlen是C标准库中<string.h>(<cstring>)的字符串操作函数，在运行期返回一个C字符串的长度，即从指定位置开始到值为\0之前的所有字节数；

sizeof 是一个物理层面的操作符， 通常在编译期间确定，得到的是一个对象/类型在栈上的投影大小。 strlen 是一个逻辑层面的函数， 运行时求值，得到的是一个 char[] 中第一个 '\0' 之前所有字符的数量。


Question: main函数参数问题

引用 8 楼 zhao4zhong1 的回复:http://bbs.csdn.net/topics/390469280 赞！非常感谢！

你这里的情况是  char* p = NULL; char** argv = &p; 这时候 你argv 得到的是指向 p的指针 &p 需要你做 *argv 才能得到 NULL

引用 2 楼 shanwu1985 的回复:可以执行啊…  ./smltest　xxxx(档名)　  就行了～ 执行是没有问题的，疑问是为啥不会core，引用了空地址，为啥不core呢？

引用 1 楼 user-6 的回复:都是空了 为什么还要取值呢？地址都是为空的！ 地址是空的话，取*应该会core，非法地址引用吧，但是实际情况是没core。

完全看不懂啊，你这是C语言吗？

至于会不会报段错误，都要看编译器了，说不定编译器实现的时候有预留什么的。

nil 表示无值的意思，程序没有问题。不过这不是C/C++的标准的关键字，Objective-C, Ruby之类的有这个关键字，估计编译器实现的时候借鉴了下吧。

可以执行啊…  ./smltest　xxxx(档名)　  就行了～

都是空了 为什么还要取值呢？地址都是为空的！


Question: 你们好

大概这样既可： char a[100]; fread(a, sizeof(char), 100, fp);  引用 楼主 C372285925 的回复:大家好，我想请问文件中的字符如何一次性全部导入到新定义的数组里？谢谢

fread

if（！feof（fp）） { fcanf(fp,"%c",&a[i]); }  大概就这样。。。你看看行不

这个需要先解析出来的，然后赋值呗

你知道你的文件内容有多大，这样就可以一次性导入了。


Question: 小数减大数和0比较，居然是大于0

引用 楼主 wangjun403 的回复:  y3和y2都是long型的  这是怎么回事呢，我实在不知道为什么 其他地方的问题。

问题可能在其它代码段。  引用 4 楼 wangjun403 的回复:[quote=引用 3 楼 turingo 的回复:] 这比较诡异了，查查其它地方是否有访问越界或者是堆栈溢出的情况。  [quote=引用 2 楼 wangjun403 的回复:] [quote=引用 1 楼 turingo 的回复:] y3-y2不是明明等于-14772么？  [quote=引用 楼主 wangjun403 的回复:]   y3和y2都是long型的  这是怎么回事呢，我实在不知道为什么[/quote] 是的啊，但却进入了if的条件[/quote][/quote]  本人菜鸟一个，几个普通的局部变量应该会是越界的问题 堆栈溢出，我不知道怎么去查  蛋疼[/quote]

引用 3 楼 turingo 的回复:这比较诡异了，查查其它地方是否有访问越界或者是堆栈溢出的情况。  [quote=引用 2 楼 wangjun403 的回复:] [quote=引用 1 楼 turingo 的回复:] y3-y2不是明明等于-14772么？  [quote=引用 楼主 wangjun403 的回复:]   y3和y2都是long型的  这是怎么回事呢，我实在不知道为什么[/quote] 是的啊，但却进入了if的条件[/quote][/quote]  本人菜鸟一个，几个普通的局部变量应该会是越界的问题 堆栈溢出，我不知道怎么去查  蛋疼

这比较诡异了，查查其它地方是否有访问越界或者是堆栈溢出的情况。  引用 2 楼 wangjun403 的回复:[quote=引用 1 楼 turingo 的回复:] y3-y2不是明明等于-14772么？  [quote=引用 楼主 wangjun403 的回复:]   y3和y2都是long型的  这是怎么回事呢，我实在不知道为什么[/quote] 是的啊，但却进入了if的条件[/quote]

引用 1 楼 turingo 的回复:y3-y2不是明明等于-14772么？  [quote=引用 楼主 wangjun403 的回复:]   y3和y2都是long型的  这是怎么回事呢，我实在不知道为什么[/quote] 是的啊，但却进入了if的条件

y3-y2不是明明等于-14772么？  引用 楼主 wangjun403 的回复:  y3和y2都是long型的  这是怎么回事呢，我实在不知道为什么

看所有的代码，起码是这几个变量所在的函数定义。 除了堆栈溢出的可能之外，怀疑是类型隐式提升（无符号long类型）。

很诡异的当然要重构，确保源文件跟执行文件匹配...

引用 10 楼 wangjun403 的回复:[quote=引用 7 楼 zhao4zhong1 的回复:] 重建所有  难道赵老师遇到问题就重构？[/quote] 帖主的问题十有八九是源代码和可执行目标代码不对应造成的。 解决这种问题不重建所有还有其它更好的办法？ 愿听高手指教。

引用 7 楼 zhao4zhong1 的回复:重建所有  难道赵老师遇到问题就重构？

引用 8 楼 user-6 的回复:赵老师又来坑爹了。  LZ使用的IDE默认long型是有符号还是无符号的？建议把全部代码贴出来  IDE是eclipse long默认肯定是有符号的  代码是不可能全部贴出来的，也没有人会看那么长的东西

重建所有


Question: 分治法与递归区别

非常感谢大神们的解答。

引用 2 楼 caozhy 的回复:分治法也可以不用递归实现，比如自己用一个堆栈去模拟。  总之前者是思路，后者是做法。 我们做家务，也可以用分治法，我们管理一个组织，也可以用分治法，但是这就和编程完全无关了。

分治法是指一种算法（分而治之，逐步细化地处理） 递归是指一种实现（函数中调用自身）  好比穷举法和循环的关系。


Question: linux c 写文件问题

哦，找到问题了。吧文件名当作数据传递过去了，写错了 哈哈后！

乱码并不代表一定是错的，也可能是编码方式的问题，直接看二进制数据最准确。  引用 5 楼 aaadddzxc 的回复:我看 write 的返回值的确是我传进去的大小，但是我打开写好的文件一堆乱码

我没看到有地方出错

我看 write 的返回值的确是我传进去的大小，但是我打开写好的文件一堆乱码

在哪里出错，打印一下errno  这样写肯定数据不对，前面一部分会被文件名./123.txt替换掉的。

先单步调试。  引用 2 楼 aaadddzxc 的回复:我直接这样调用写数据都不行  const char *lpszCookie = "的挖挖的那我的那我你的哦啊温暖的哦啊温暖的哦啊温暖的哦安稳的哦那我的哦你啊";      clouddisk_WriteFile("./123.txt",lpszCookie,strlen(lpszCookie));

1、单步调试看看数据是到哪里不对了； 2、一般更常用fopen/fclose/fread/fwrite等函数。  引用 楼主 aaadddzxc 的回复:从缓冲区接受的数据，要保存到文件怎么弄的。。下面代码哪儿有问题，咋写出来不对呢    int clouddisk_WriteFile(const char *lpszFileName,const char *lpszSource,int nLen) {     int hFile = 0;      if (-1 == (hFile = open(lpszFileName,O_RDWR | O_CREAT,S_IRUSR | S_IWUSR | S_IXUSR)))     {         return 0;     }      size_t nWriteCount = 0;     size_t nCount = nLen;     size_t nSize = write(hFile,lpszFileName,nLen);     nWriteCount = nSize;     while (nWriteCount < nCount)     {         nSize = write(hFile,lpszSource + nWriteCount,nLen - nWriteCount);         nWriteCount += nSize;     }      close(hFile);     return 1; }

推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。  对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A


Question: 什么意思，求解

我靠这个40分呐，我给你说个结果吧，输出整数4，然后换行

引用 1 楼 user-7 的回复:n << 2 ：表示n向左移动2位  这是c语言的基础，移位运算！ 给你一个链接，好好看看，补充下基础知识！http://blog.csdn.net/heiniaoyuyouling/article/details/4696586 ++ 左移两位，然后打印移位后的值。

引用 4 楼 Luisfan 的回复:[quote=引用 1 楼 user-7 的回复:]  n << 2 ：表示n向左移动2位  这是c语言的基础，移位运算！ 给你一个链接，好好看看，补充下基础知识！http://blog.csdn.net/heiniaoyuyouling/article/details/4696586  正解                [/quote]+1

引用 1 楼 user-7 的回复:n << 2 ：表示n向左移动2位  这是c语言的基础，移位运算！ 给你一个链接，好好看看，补充下基础知识！http://blog.csdn.net/heiniaoyuyouling/article/details/4696586  正解

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

这是C语言中的位运算， <<是左移运算符， 原来是00000001 左移两位 运算后00000100


Question: 大家好，请问一下看书的顺序。

感谢的大家的建议，我突然就想通了。 个人觉得最好的方法是，大致的过一下某些具体重要的书，粗略的看过。 之后结合实际项目和代码，那些书就当作是参考资料，哪里不会看哪里。 谢谢大家！可否推荐一些关键词，让我搜索一些开源项目来研究呢？

引用 7 楼 Adol1111 的回复:W.Rchard Stevens的书本本都是经典啊。看书的顺序的话还是和1楼说的差不多。TCP/IP主要讲报文、协议什么的比较枯燥，最好能自己组个小型的局域网络进行测试下，更能加深理解。（至于环境的话，现在应该很难找到了吧，多多少少会有些小差异，不过FreeBSD和linux还是很不错的代替品） 确实，stevens先生的书每本都是巨作！

引用 6 楼 zmlovelx 的回复:嵌入式不一定要懂硬件 会看datasheet会与硬件工程师沟通就差不多了。 虽然是这么说，但感觉还是要懂一点的。主要也是由于嵌入式学习的东西太多太广。我又急于写一些小项目。。

嵌入式不一定要懂硬件 会看datasheet会与硬件工程师沟通就差不多了。

引用 2 楼 nice_cxf 的回复:《UNIX环境高级编程》    《TCP/IP协议详解》必读，UNIX网络编程可以放到后边，有时间再读 谢谢！主要是想尽快利用知识做一个小项目。

引用 1 楼 JiMoKuangXiangQu 的回复:建议顺序： 《UNIX环境高级编程》 《UNIX网络编程》结合 《TCP/IP协议详解》读：看前一本的同时翻翻后一本。 之后是边实践，遇到不熟悉的，边回过头翻阅相应篇章，不要指望看一遍就全部理解了。  个人建议，仅供参考。 谢谢！！

看书，先看目录，之后翻到想看的页。

引用 13 楼 zhao4zhong1 的回复:个人意见：网络编程首先要学会使用抓包软件比如wireshark.  不知道有多少前人掉在TCP Socket send(人多)send(病少)send(财富) recv(人多病)recv(少财富) 陷阱里面啊！ http://topic.csdn.net/u/20120210/09/51109ed0-07b9-41f2-b487-a51597f2ca01.html  这个建议很中肯！！

引用 11 楼 zhao4zhong1 的回复:《Linux C编程一站式学习》  赵老师，您不能这样啊。

《Linux C编程一站式学习》


Question: 请教多个for语句的执行顺序是怎样的？

外-》里-》外

分号结束是简单循环模块，要是有大括号，就说明循环模块不止一句话。其实都一样的，知道循环的模块，执行完就是i++

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

初始化，执行中间判断条件满足则执行下面的语句，执行完语句，再执行后面的循环递进！ 再判断中间的条件，满足继续，不满足退出 每个for循环最好都用一对大括号包括起来！

不用非有括号啊

执行完下面3条for再i++， 最里面的先执行完， 再执行完上一级，直到最上级加一

#include <stdio.h>  int main(void) { 	int i, j, k; 	char letter; 	 	printf("Please input a capital:"); 	scanf("%c",&letter); 	 	k = letter - 'A' + 1; 	 	for (i = 0; i < k; i++) 	{ 		for (j = 0; j < k - i; j++) 		{ 			printf(" "); 		} 		 		for (j = 0; j <= i; j++) 		{ 			printf("%c", 'A' + j); 		} 		 		for (j = i - 1; j >= 0; j--) 		{ 			printf("%c",'A' + j); 		} 		 		printf("\n"); 	} 	 	return 0; }

何不单步运行一下


Question: 菜鸟问题

C++用vector，插入不定个数元素，然后sum累加，除以vector.size()？ 或者自己用变量统计元素个数？ 方法应该很多吧

引用 6 楼 zhao4zhong1 的回复:第1个数的平均值＝第1个数 第n个数的平均值＝((n-1)*前n-1个数的平均值+第n个数)/n，n=2...  ++

这个是老师留的作业吧。。。你还是自己动动脑筋吧。。。

引用 2 楼 jk19941122 的回复:模版动态数组求和 补充一下，模版动态数组求和之后除以数组的实际长度就是所求的平均值

模版动态数组求和

记录每次输入的个数就好了！搞个sum 加所有输入的值的和！


同一级别的init，看makefile 加载顺序，obj -y += xxx.o在前面的就先启动

我也碰到这样一个问题。 比如我在加载alsps时，驱动同时兼容了几颗alsps ic的，我想让某特定的一颗最后加载，以便于在其他alsps加载失败(未贴片)时，再来加载此特定的一颗。我有尝试将此特定alsps的module_init改用late_initcall，但不满足平台设定(具体原因不用理会)。如果各alsps都用module_init来加载，如何来控制加载的顺序？ 有没有真懂这一块的？求真神~~

引用 4 楼 xingtian19880101 的回复:那个优先级我知道，主要是想知道同级别的到底是依据什么，不知道是我看错了还是怎么，两个驱动加载顺序改变了但是设备结点的创建还是没变了 这我还还真没听说有啥依据,或者说无所谓从哪里说起.  同类型的设备,比如都是标准的通用输入设备:键盘,鼠标,ts,写字板,从内核的角度来说他们的工作都是独立开来的,驱动也应该是不相互干扰或者说具有互斥或依赖部分。所以他们加载驱动的先后不会有什么影响，既然没影响干嘛要分先后。 至于你说的设备节点号 没变动，这还真只能去看对应部分的源码慢慢找。

引用 2 楼 user-3123 的回复:[quote=引用 1 楼 xingtian19880101 的回复:] 各位大神，知道的说下啊，一直没搞太清楚。。。。  该按一定顺序的就要按一定顺序，没有为什么。 或者init中注册的函数本身有优先级参数，那么内核会按优先级去管理。  至于你说的键盘和TS的问题这2个颠倒过来也不会有影响，想换个顺序自己在源码找呗。[/quote]  引用 2 楼 user-3123 的回复:[quote=引用 1 楼 xingtian19880101 的回复:] 各位大神，知道的说下啊，一直没搞太清楚。。。。  该按一定顺序的就要按一定顺序，没有为什么。 或者init中注册的函数本身有优先级参数，那么内核会按优先级去管理。  至于你说的键盘和TS的问题这2个颠倒过来也不会有影响，想换个顺序自己在源码找呗。[/quote]      ......

引用 1 楼 xingtian19880101 的回复:各位大神，知道的说下啊，一直没搞太清楚。。。。  该按一定顺序的就要按一定顺序，没有为什么。 或者init中注册的函数本身有优先级参数，那么内核会按优先级去管理。  至于你说的键盘和TS的问题这2个颠倒过来也不会有影响，想换个顺序自己在源码找呗。

各位大神，知道的说下啊，一直没搞太清楚。。。。


感久 zxs123451 就是 工具 -> 选项 ->环境->字体和颜色->突出显示的引用 如果是英文版就是 highlighted reference 我找了好久

工具 -> 选项 ->环境->字体和颜色->突出显示的引用 设置项背景颜色

工具 -> 选项 ->环境->字体和颜色->突出显示的引用

很多人一开始想用工具解决问题，但后来终其一生都在研究如何改进工具，到死也没解决当初的问题。  推荐阅读《你的灯还亮着吗？》

5楼说的对。

google下吧！还没用过这么新的

我知道在字体和颜色哪里改，但是不知道该哪一项，有这么多啊：

你去这个网站挑一个颜色配置来 http://studiostyl.es/

工具 -> 选项 ->环境->字体和颜色

没用过，一般在tool->option-》文本编辑->c/c++中修改

vs2013没用过，一般在 options 中，看看 help


Question: 『IMP』求教！！！！about fork child&parent pipe

引用 楼主 wunan0423 的回复:Please write a program, in C language, with 5 child process writing data into the same file.  After each child process complete its job , it will notify the parent process through IPC.  Finally ,when the parent process receive all child messages, it will print the file data in console.   写了很久还是不会，最后把程序改的一团乱麻！今天就要交了，求各位大神指教！！！！   #include<unistd.h> #include<stdio.h> #include<sys/types.h>   int main() { 	int fd[2]; 	pipe(fd); 	 	 pid_t child[5]; 	//so that we can have five childprocess that produces fork  	child[0] = fork(); 	//set self as the variable that fork send back  	FILE *fp; 	FILE *fpp; 	  	if(child[0] !=0) 	child[1]=fork();  	if(child[0] !=0 && child[1] !=0) 	child[2]=fork();  	if(child[0] !=0 && child[1] !=0 && child[2] !=0) 	child[3]=fork();  	if(child[0] !=0 && child[1] !=0 && child[2] !=0 && child[3] !=0) 	child[4]=fork();  	if(child[0] !=0 && child[1] !=0 && child[2] !=0 && child[3] !=0 && child[4] !=0) 	 	{ 	fpp=fopen("homework2-h34028028.txt","r+"); 	 	fprintf(fpp,"%s");  	fclose(fpp); 	//Parentprocess needs to print the content that child process has writen into the txt file 		 	} 	 	  	else{ 	//ChildProcess will start this txt file and write something into this file 	fp=fopen("homework2-h34028028.txt","a"); 	fprintf(fp,"Operating System Homework is really difficult\n"); 	fclose(fp); 	} 	     } 引用 2 楼 user-1 的回复:[quote=引用 1 楼 wunan0423 的回复:] 不好意思想问一下大家，就是pipe的话是不是只能子程序写父程序读，我有看到一个关于子父程序转换角色的帖子 http://blog.csdn.net/yake25/article/details/7447086 但是根据这个调了很久之后逻辑愈发不对！！！ 各位大神求教！小妹在此拜谢大家！！  不是的！一个读一个写！这里不太合适用管道！用socket或者消息队列吧！ [/quote]thanks!

但是当时讲解这个程序的时候是说要用pipe写 子进程五个child process自己往txt里面写东西，然后再父进程在console中打印txt中的东西。。 鼓捣了半天都没有鼓捣出来到论坛上求救ing～求问说pipe在多个子进程的时候应该怎么用啊

引用 1 楼 wunan0423 的回复:不好意思想问一下大家，就是pipe的话是不是只能子程序写父程序读，我有看到一个关于子父程序转换角色的帖子 http://blog.csdn.net/yake25/article/details/7447086 但是根据这个调了很久之后逻辑愈发不对！！！ 各位大神求教！小妹在此拜谢大家！！  不是的！一个读一个写！这里不太合适用管道！用socket或者消息队列吧！


Question: 这是为什么？这样答案还对？

新手同学习了

i < a.Length-4？为什么要减4？外层只循环了一次当然是2 3 7 5 8了。。。

引用 4 楼 xiaoyongaihua 的回复:我正在给以前的帖子结贴 ，太二笔了 对不起各位了 结帖率低也就算了，楼主竟然跑到C\C++专区问C#的代码。。

我正在给以前的帖子结贴 ，太二笔了 对不起各位了

2 3 7 5 8

怎么结贴啊  我已经知道错了  我看错了

这结贴率


楼上的用过习语言吗？ 哪个版本？  习语言绘图最方便了，顺序执行。 没听说过有效率问题。

赵老师的这个是控制台，看 习语言的真图形模式，2行 绘图程序：  #包含 “习语言系统.接口” 整数类型 主函数（）{ 图形开始(宽：480,高：320)； 图形画圆(水平中心点：200，垂直中心点：200，半径：50);  图形结束（‘等待’）； 返回 0;}      引用 7 楼 zhao4zhong1 的回复:那就来个更短的：#pragma comment(lib,"user32") #pragma comment(lib,"gdi32") #include <stdlib.h> #include <windows.h> extern "C" HWND WINAPI GetConsoleWindow(); int main() {     system("color F0&cls");     HWND hwnd=GetConsoleWindow();     HDC  hdc =GetDC(hwnd);     MoveToEx(hdc,0,0,NULL);     LineTo(hdc,300,300);     ReleaseDC(hwnd,hdc);     return 0; }

习语言 绘图程序，最短 可以 只要2行。 赵老师 敢比试吗？ 引用 5 楼 zhao4zhong1 的回复:号称最短Windows绘图程序：#include <windows.h> LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {     PAINTSTRUCT ps;     HDC hdc;     HFONT hfont,ohfont;     RECT r;     COLORREF oc;      switch(message) {     case WM_CLOSE://按Alt+F4退出         PostQuitMessage(0);         break;     case WM_PAINT:         BeginPaint(hWnd, &ps);         hdc = ps.hdc; // the device context to draw in         GetClientRect(hWnd, &r); // Obtain the window's client rectangle         hfont = CreateFont(240, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "华文楷体");         ohfont=SelectObject(hdc,hfont);         oc=SetTextColor(hdc,0x00C080FF);         SetBkMode(hdc, TRANSPARENT);         TextOut(hdc,r.left+r.right/2-720, r.top+r.bottom/2-120,"最短画图程序",12);         SelectObject(hdc,ohfont);         SetTextColor(hdc,oc);         DeleteObject(hfont);         EndPaint(hWnd, &ps);         break;     default:         return DefWindowProc(hWnd, message, wParam, lParam);     }     return 0; } int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {     MSG msg             = {0};     WNDCLASS wc         = {0};     HBRUSH hbrh;     hbrh=CreateSolidBrush(0x00000000);     wc.lpfnWndProc      = WndProc;     wc.hInstance        = hInstance;     wc.hbrBackground    = hbrh;     wc.lpszClassName    = "minwindowsapp";     wc.hCursor          = LoadCursor(NULL,IDC_ARROW);     if( FAILED(RegisterClass(&wc)) ) return 1;      if(FAILED(CreateWindow(wc.lpszClassName,                         "Minimal Windows Application",                         WS_POPUP|WS_VISIBLE,                         0,                         0,                         GetSystemMetrics(SM_CXSCREEN),                         GetSystemMetrics(SM_CYSCREEN),                         0,                         0,                         hInstance,                         NULL)))         return 2;      while( GetMessage( &msg, NULL, 0, 0 ) > 0 ) {         DispatchMessage( &msg );     }     DeleteObject(hbrh);     return 0; }  Line and Curve Functions The following functions are used with lines and curves.        AngleArc   Arc   ArcTo   GetArcDirection   LineDDA   LineDDAProc   LineTo   MoveToEx   PolyBezier   PolyBezierTo   PolyDraw   Polyline   PolylineTo   PolyPolyline   SetArcDirection        Filled Shape Functions The following functions are used with filled shapes.        Chord   Ellipse   FillRect   FrameRect   InvertRect   Pie   Polygon   PolyPolygon   Rectangle   RoundRect

引用 2 楼 xiyuyan 的回复:用习语言就好了，不用那么麻烦，直接绘图，而且还是中文的。 效率不行的！很多不行的地方！ 楼主看看文档吧，可以是调用的方法不对哦

用习语言就好了，不用那么麻烦，直接绘图，而且还是中文的。

easyx自带一个帮助文档，里面的函数库很全了，可以参考里面有的。initgraph()函数用法不同，你应该看到了。


Question: 谁有gif解码算法?

绘制下一帧前： 无移出方法 保持原样 还原背景 还原上一帧 四选一

引用 2 楼 max_min_ 的回复:mark下！没有区分帧类型么？每一次都是一个完整的I帧？ 引用 3 楼 LargeSkyMensk 的回复:那是因为，gif在显示的时候，每一帧都是叠加在前面帧上的。  你可以下载这个，我自己使用wic写的。源代码，希望有用 http://download.csdn.net/detail/largeskymensk/5995581   第一帧是帧,第二帧开始只有那个小人的区域,我是直接叠上去的,但有些位置还是不对.

GIF文件格式约定中应该有详细说明。

引用 5 楼 zhao4zhong1 的回复:绘制下一帧前： 无移出方法 保持原样 还原背景 还原上一帧 四选一  原来是这样,在 图象标识符(Image Descriptor) 里面并没有说明,这个是在哪里定义的?

引用 6 楼 LargeSkyMensk 的回复:[quote=引用 3 楼 LargeSkyMensk 的回复:] 那是因为，gif在显示的时候，每一帧都是叠加在前面帧上的。  你可以下载这个，我自己使用wic写的。源代码，希望有用 http://download.csdn.net/detail/largeskymensk/5995581  一个GIF文件，由背景与若干个帧图片组成。 GIF文件，有总的长宽，而每一帧可能有不同的位置，与长宽。 在绘制的时候，首先绘制背景，然后逐帧叠加（注意位置与长宽）。  其实我提供的下载连接里面，是我使用WIC写的，是一个Win32小程序，功能就是提取GIF中的每帧图片。 而且其中包含一个功能：在提取每一帧的时候，是否采用叠加的方法。 WIC是微软系统提供的一个组件。用于处理图片的。[/quote]  我要的是c源码,不是在windows上面用的.

引用 3 楼 LargeSkyMensk 的回复:那是因为，gif在显示的时候，每一帧都是叠加在前面帧上的。  你可以下载这个，我自己使用wic写的。源代码，希望有用 http://download.csdn.net/detail/largeskymensk/5995581  一个GIF文件，由背景与若干个帧图片组成。 GIF文件，有总的长宽，而每一帧可能有不同的位置，与长宽。 在绘制的时候，首先绘制背景，然后逐帧叠加（注意位置与长宽）。  其实我提供的下载连接里面，是我使用WIC写的，是一个Win32小程序，功能就是提取GIF中的每帧图片。 而且其中包含一个功能：在提取每一帧的时候，是否采用叠加的方法。 WIC是微软系统提供的一个组件。用于处理图片的。

mark下！没有区分帧类型么？每一次都是一个完整的I帧？

试试http://sourceforge.net/projects/giflib/  引用 楼主 hyz_cs 的回复:找了一个算法( http://download.csdn.net/detail/dugujin263/1426312 ) 挺简洁的,但是用的时候发现有个问题,像这种第二帧以上是局部更新的gif图片,第二帧以上不正常.  gif图片    解码后的第1帧:   解码后的第2帧:   解码后的第3帧:    gif文件格式中,局部更新的帧,是把区域直接叠加到前一帧上面吗?


Question: C语言关于socket编程的问题，菜鸟求助

你这是Linux下的代码，windows下只要 #include "winsock2.h" 然后引入 ws2_32.lib，用WSAStartup函数初始化一下就行了

引用 27 楼 Luisfan 的回复:你这个是linux上的吧,求改成windows的

你这个是linux上的吧,

我绑定的端口改为9999 附上运行结果:

代码比较粗糙，将就着看吧~~ 呃~~不好意思，这个是基于TCP的 #include <string> #include <stdio.h> #include <stdlib.h> #include <iostream> #include <WinSock2.h> using namespace std;  #pragma comment(lib,"Ws2_32.lib")  #define PORT 9999 /*使用的port */  int main(int argc, char* argv[]) { 	WORD wVersionRequested = MAKEWORD(2,2);  	WSADATA ws = {0x00}; 	WSAStartup(wVersionRequested,&ws); 	SOCKET nSock = socket(AF_INET,SOCK_STREAM,0); //TCP 	if (nSock<0) 	{ 		perror(argv[0]); 		system("pause"); 		WSACleanup(); 		return -1; 	} 	printf("socket success!\n");  	struct sockaddr_in addr = {0x00}; 	size_t nLen = sizeof(addr); 	addr.sin_family = AF_INET; 	addr.sin_addr.s_addr = htonl(INADDR_ANY); 	addr.sin_port = htons(PORT);  	if(SOCKET_ERROR == bind(nSock,(LPSOCKADDR)&addr,nLen)) //绑定 	{ 		printf("Bind Error!ErrorNo[%d]\n",WSAGetLastError()); 		closesocket(nSock); 		system("pause"); 		WSACleanup(); 		return -1; 	}  	printf("Bind Success!\n");  	if(SOCKET_ERROR == listen(nSock,1)) //监听 	{ 		printf("Listen Error!ErrorNo[%d]\n",WSAGetLastError()); 		closesocket(nSock); 		system("pause"); 		WSACleanup(); 		return -1; 	} 	printf("Listen Soccess!\n"); 	 	while(true) 	{ 		SOCKADDR_IN inSaddr = {0x00}; 		int ninSaddr = sizeof(inSaddr); 		SOCKET sAccept = accept(nSock,(sockaddr*)&inSaddr,&ninSaddr); //接收 		if (sAccept<0) 		{ 			printf("accept Error!ErrorNo[%d]\n",WSAGetLastError()); 			closesocket(nSock); 			system("pause"); 			WSACleanup(); 			return -1; 		}  		printf("Accept success!\n");  		char szBuffer[256] = {0x00}; 		int nRecv = recv(sAccept,szBuffer,sizeof(szBuffer),0);//读取 		if (nRecv > 0) 		{ 			printf("接收消息[%s]\n",szBuffer); 		} 		else if (0 == nRecv) 		{ 			printf("未接收到消息!\n"); 		} 		else 		{ 			printf("读取失败!\n"); 			closesocket(nSock); 			system("pause"); 			WSACleanup(); 			return -1; 		}   	}  	closesocket(nSock); 	system("pause"); 	WSACleanup();  	return 0; }

这个是linux下的网络编程的源码吧，基于UDP协议的服务器端的源码

大婶。。。

建议静下心来学习，最基本的东西都到论坛上来问，可见人心浮躁！

求各位大婶把这个改成windows版的，谢谢了

头文件包含有误，无法链接过去

引用 18 楼 ak47_wz 的回复:。。。首先有一两个小错误。    bezro(buffer, sizeof(buffer));         len = recvfrom(socket, buffer, sizeof(buffer), 0, &addr &addr_len);   这里的bezro打错了，应该是bzero（置0）才是。 另外，第二句少了个分号。   这是linux上面网络编程的源码。这是一个基于UDP协议的服务端程序。能帮我改成windows版的吗？

引用 16 楼 AnYidan 的回复:Windows网络编程  带源码好吧，其实希望你直接解决就哈

Windows网络编程  带源码

引用 13 楼 max_min_ 的回复:[quote=引用 8 楼 A38017032 的回复:] [quote=引用 7 楼 ganpengjin1 的回复:] #include <WinSock2.h> #pragma comment(lib, "ws2_32.lib")难道这个代码还有问题吗？还是错误，可以详细点吗？谢谢了[/quote] 代码没有错误！可能是别人在linux下的源码！windows不兼容，需要修改部分错误！ 先注释掉掉types.h，然后根据报错提示，查找相关申明的windows下对应的头文件！[/quote]好像代码有很多问题的，有的地方少了括号之类的都有

引用 8 楼 A38017032 的回复:[quote=引用 7 楼 ganpengjin1 的回复:] #include <WinSock2.h> #pragma comment(lib, "ws2_32.lib")难道这个代码还有问题吗？还是错误，可以详细点吗？谢谢了[/quote] 代码没有错误！可能是别人在linux下的源码！windows不兼容，需要修改部分错误！ 先注释掉掉types.h，然后根据报错提示，查找相关申明的windows下对应的头文件！

引用 11 楼 ganpengjin1 的回复:http://wdtxslqnn.blog.163.com/blog/static/44246485201232882939450/  你自己参考吧！  哎...哎，好吧，还是谢谢了

引用 9 楼 ganpengjin1 的回复:你这是哪里抄来的程序，很多定义都没有，比如： addr_len.. 哎....http://see.xidian.edu.cn/cpp/html/372.html在这个网站看的，求助了


Question: 菜鸟求助？C 写入信息到文件的

根据你的想法猜测，你的 for 循环应该这样写  for (i = 0; i < n; i++) {     printf("input %d:", i + 1);     scanf("%d %s", &infor.num, infor.name);     fprintf(fp, "%d %s\n", infor.num, infor.name); }

引用 8 楼 linbounconstraint 的回复:[quote=引用 7 楼 lipoor1234 的回复:] [quote=引用 5 楼 linbounconstraint 的回复:] [quote=引用 1 楼 user-6 的回复:] [quote=引用 楼主 linbounconstraint 的回复:] 先输入要写入多少人，然后输入学号，名字，保存信息到.txt 里面。 #include <stdio.h> struct stu { 	int num; 	char name[]; }; int main() { 	FILE * fp; 	struct stu infor; 	int n, i; 	fp = fopen("student.txt", "w+"); 	if(fp == NULL) 	{ 		printf("error open file\n"); 		return 1; 	} 	printf("input all student number \n"); 	scanf("%d", &n); 	for(i = 0; i < n; i++) 	{ 		printf("input the num and name\nlike:03 jim\nthe NO%d:\n", i+1); 		scanf("%d %s", &(infor).num, (infor).name); 		fwrite(&infor, sizeof(infor), 1, fp); 		 	} 	fclose(fp); 	printf("资料已保存！\n"); 	 	return 0; }  [cxl@chenxiaolei ~]$ gcc -Wall  main.c -o main  [cxl@chenxiaolei ~]$ ./main input all student number  2 input the num and name like:03 jim the NO1: 03 sam 段错误 (core dumped) [cxl@chenxiaolei ~]$  好歹给name一个存储空间，^_^. #include <stdio.h>  #define NAME_LEN 100  struct stu { 	int num; 	char name[NAME_LEN]; };  int main() { 	FILE * fp; 	struct stu infor; 	int n, i;  	fp = fopen("student.txt", "w+"); 	if (fp == NULL) 	{ 		printf("error open file\n"); 		return 1; 	} 	printf("input all student number \n"); 	scanf("%d", &n); 	for(i = 0; i < n; i++) 	{ 		printf("input the num and name\nlike:03 jim\nthe NO%d:\n", i+1); 		scanf("%d %s", &infor.num, infor.name); 		fwrite(&infor, sizeof(infor), 1, fp); 	} 	fclose(fp); 	printf("资料已保存！\n"); 	 	return 0; }[/quote]  会有乱码.     jim 烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫   lin 烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫  ??[/quote] 用之前给name数组初始化一下 用0填 ,这样按字符串输出的时候 可以正确找到结束,不初始化 编译器会自己帮你填值 vc是0xcc 0xcccc就是中文的烫[/quote]  这样吗？ int main() {     FILE * fp;     char ch;     struct stu infor;     int n, i;     char name[NAME_LEN] = {0};  这样貌似也不行的，还有烫字[/quote]   #include <stdio.h>   #define NAME_LEN 100   struct stu {     int num;     char name[NAME_LEN]; };   int main() {     FILE * fp;     struct stu infor;     int n, i;       fp = fopen("student.txt", "w+");     if (fp == NULL)     {         printf("error open file\n");         return 1;     }     printf("input all student number \n");     scanf("%d", &n);     for(i = 0; i < n; i++)     {         printf("input the num and name\nlike:03 jim\nthe NO%d:\n", i+1); 		memset(infor.name,0,NAME_LEN);         scanf("%d %s", &infor.num, infor.name);         fwrite(&infor, sizeof(infor), 1, fp);     }     fclose(fp);     printf("资料已保存！\n");           return 0; }  这样就不会有烫了 但是你的程序应该还有问题

引用 7 楼 lipoor1234 的回复:[quote=引用 5 楼 linbounconstraint 的回复:] [quote=引用 1 楼 user-6 的回复:] [quote=引用 楼主 linbounconstraint 的回复:] 先输入要写入多少人，然后输入学号，名字，保存信息到.txt 里面。 #include <stdio.h> struct stu { 	int num; 	char name[]; }; int main() { 	FILE * fp; 	struct stu infor; 	int n, i; 	fp = fopen("student.txt", "w+"); 	if(fp == NULL) 	{ 		printf("error open file\n"); 		return 1; 	} 	printf("input all student number \n"); 	scanf("%d", &n); 	for(i = 0; i < n; i++) 	{ 		printf("input the num and name\nlike:03 jim\nthe NO%d:\n", i+1); 		scanf("%d %s", &(infor).num, (infor).name); 		fwrite(&infor, sizeof(infor), 1, fp); 		 	} 	fclose(fp); 	printf("资料已保存！\n"); 	 	return 0; }  [cxl@chenxiaolei ~]$ gcc -Wall  main.c -o main  [cxl@chenxiaolei ~]$ ./main input all student number  2 input the num and name like:03 jim the NO1: 03 sam 段错误 (core dumped) [cxl@chenxiaolei ~]$  好歹给name一个存储空间，^_^. #include <stdio.h>  #define NAME_LEN 100  struct stu { 	int num; 	char name[NAME_LEN]; };  int main() { 	FILE * fp; 	struct stu infor; 	int n, i;  	fp = fopen("student.txt", "w+"); 	if (fp == NULL) 	{ 		printf("error open file\n"); 		return 1; 	} 	printf("input all student number \n"); 	scanf("%d", &n); 	for(i = 0; i < n; i++) 	{ 		printf("input the num and name\nlike:03 jim\nthe NO%d:\n", i+1); 		scanf("%d %s", &infor.num, infor.name); 		fwrite(&infor, sizeof(infor), 1, fp); 	} 	fclose(fp); 	printf("资料已保存！\n"); 	 	return 0; }[/quote]  会有乱码.     jim 烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫   lin 烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫  ??[/quote] 用之前给name数组初始化一下 用0填 ,这样按字符串输出的时候 可以正确找到结束,不初始化 编译器会自己帮你填值 vc是0xcc 0xcccc就是中文的烫[/quote]  这样吗？ int main() {     FILE * fp;     char ch;     struct stu infor;     int n, i;     char name[NAME_LEN] = {0};  这样貌似也不行的，还有烫字

引用 5 楼 linbounconstraint 的回复:[quote=引用 1 楼 user-6 的回复:] [quote=引用 楼主 linbounconstraint 的回复:] 先输入要写入多少人，然后输入学号，名字，保存信息到.txt 里面。 #include <stdio.h> struct stu { 	int num; 	char name[]; }; int main() { 	FILE * fp; 	struct stu infor; 	int n, i; 	fp = fopen("student.txt", "w+"); 	if(fp == NULL) 	{ 		printf("error open file\n"); 		return 1; 	} 	printf("input all student number \n"); 	scanf("%d", &n); 	for(i = 0; i < n; i++) 	{ 		printf("input the num and name\nlike:03 jim\nthe NO%d:\n", i+1); 		scanf("%d %s", &(infor).num, (infor).name); 		fwrite(&infor, sizeof(infor), 1, fp); 		 	} 	fclose(fp); 	printf("资料已保存！\n"); 	 	return 0; }  [cxl@chenxiaolei ~]$ gcc -Wall  main.c -o main  [cxl@chenxiaolei ~]$ ./main input all student number  2 input the num and name like:03 jim the NO1: 03 sam 段错误 (core dumped) [cxl@chenxiaolei ~]$  好歹给name一个存储空间，^_^. #include <stdio.h>  #define NAME_LEN 100  struct stu { 	int num; 	char name[NAME_LEN]; };  int main() { 	FILE * fp; 	struct stu infor; 	int n, i;  	fp = fopen("student.txt", "w+"); 	if (fp == NULL) 	{ 		printf("error open file\n"); 		return 1; 	} 	printf("input all student number \n"); 	scanf("%d", &n); 	for(i = 0; i < n; i++) 	{ 		printf("input the num and name\nlike:03 jim\nthe NO%d:\n", i+1); 		scanf("%d %s", &infor.num, infor.name); 		fwrite(&infor, sizeof(infor), 1, fp); 	} 	fclose(fp); 	printf("资料已保存！\n"); 	 	return 0; }[/quote]  会有乱码.     jim 烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫   lin 烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫  ??[/quote] 用之前给name数组初始化一下 用0填 ,这样按字符串输出的时候 可以正确找到结束,不初始化 编译器会自己帮你填值 vc是0xcc 0xcccc就是中文的烫

引用 2 楼 max_min_ 的回复:1 name给个大小空间，你没有给大小！ 2 吃掉第一次输入的时候多余的回车符！  是第一次scanf，多少个人的空格吗？比如：2空格  这个空格吗？ 如何吃掉，getchar（）吗？这个不是得到字符的，解释下，版主，谢谢。对了，txt文件是乱码如 ：   jim 烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫   lin 烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫  怎么回事？

引用 1 楼 user-6 的回复:[quote=引用 楼主 linbounconstraint 的回复:] 先输入要写入多少人，然后输入学号，名字，保存信息到.txt 里面。 #include <stdio.h> struct stu { 	int num; 	char name[]; }; int main() { 	FILE * fp; 	struct stu infor; 	int n, i; 	fp = fopen("student.txt", "w+"); 	if(fp == NULL) 	{ 		printf("error open file\n"); 		return 1; 	} 	printf("input all student number \n"); 	scanf("%d", &n); 	for(i = 0; i < n; i++) 	{ 		printf("input the num and name\nlike:03 jim\nthe NO%d:\n", i+1); 		scanf("%d %s", &(infor).num, (infor).name); 		fwrite(&infor, sizeof(infor), 1, fp); 		 	} 	fclose(fp); 	printf("资料已保存！\n"); 	 	return 0; }  [cxl@chenxiaolei ~]$ gcc -Wall  main.c -o main  [cxl@chenxiaolei ~]$ ./main input all student number  2 input the num and name like:03 jim the NO1: 03 sam 段错误 (core dumped) [cxl@chenxiaolei ~]$  好歹给name一个存储空间，^_^. #include <stdio.h>  #define NAME_LEN 100  struct stu { 	int num; 	char name[NAME_LEN]; };  int main() { 	FILE * fp; 	struct stu infor; 	int n, i;  	fp = fopen("student.txt", "w+"); 	if (fp == NULL) 	{ 		printf("error open file\n"); 		return 1; 	} 	printf("input all student number \n"); 	scanf("%d", &n); 	for(i = 0; i < n; i++) 	{ 		printf("input the num and name\nlike:03 jim\nthe NO%d:\n", i+1); 		scanf("%d %s", &infor.num, infor.name); 		fwrite(&infor, sizeof(infor), 1, fp); 	} 	fclose(fp); 	printf("资料已保存！\n"); 	 	return 0; }[/quote]  会有乱码.     jim 烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫   lin 烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫  ??

如果name不想用定长数组的话，就每次自己分配空间，清除空间 不过从你的程序看，这样做好像也没什么意义

进程意外退出会在当前目录下产生‘core’文件或形如‘core.数字’的文件比如‘core.1234’ 使用命令 gdb 运行程序名 core或core.数字 进入gdb然后使用bt命令 可以查看进程意外退出前函数调用的堆栈，内容为从上到下列出对应从里层到外层的函数调用历史。 如果进程意外退出不产生core文件，参考“ulimit -c core文件最大块大小”命令

引用 楼主 linbounconstraint 的回复:先输入要写入多少人，然后输入学号，名字，保存信息到.txt 里面。 #include <stdio.h> struct stu { 	int num; 	char name[]; }; int main() { 	FILE * fp; 	struct stu infor; 	int n, i; 	fp = fopen("student.txt", "w+"); 	if(fp == NULL) 	{ 		printf("error open file\n"); 		return 1; 	} 	printf("input all student number \n"); 	scanf("%d", &n); 	for(i = 0; i < n; i++) 	{ 		printf("input the num and name\nlike:03 jim\nthe NO%d:\n", i+1); 		scanf("%d %s", &(infor).num, (infor).name); 		fwrite(&infor, sizeof(infor), 1, fp); 		 	} 	fclose(fp); 	printf("资料已保存！\n"); 	 	return 0; }  [cxl@chenxiaolei ~]$ gcc -Wall  main.c -o main  [cxl@chenxiaolei ~]$ ./main input all student number  2 input the num and name like:03 jim the NO1: 03 sam 段错误 (core dumped) [cxl@chenxiaolei ~]$  好歹给name一个存储空间，^_^. #include <stdio.h>  #define NAME_LEN 100  struct stu { 	int num; 	char name[NAME_LEN]; };  int main() { 	FILE * fp; 	struct stu infor; 	int n, i;  	fp = fopen("student.txt", "w+"); 	if (fp == NULL) 	{ 		printf("error open file\n"); 		return 1; 	} 	printf("input all student number \n"); 	scanf("%d", &n); 	for(i = 0; i < n; i++) 	{ 		printf("input the num and name\nlike:03 jim\nthe NO%d:\n", i+1); 		scanf("%d %s", &infor.num, infor.name); 		fwrite(&infor, sizeof(infor), 1, fp); 	} 	fclose(fp); 	printf("资料已保存！\n"); 	 	return 0; }


Question: 用C语言实现，通过com端口的名字，获得com端口序号，（如com1,com2……）

引用 9 楼 zhao4zhong1 的回复:其实最应该得分的是7楼。 C:\>devcon /? Device Console Help: devcon [-r] [-m:\\<machine>] <command> [<arg>...] -r if specified will reboot machine after command is complete, if needed. <machine> is name of target machine. <command> is command to perform (see below). <arg>... is one or more arguments if required by command. For help on a specific command, type: devcon help <command> classfilter          Allows modification of class filters. classes              List all device setup classes. disable              Disable devices that match the specific hardware or instance ID. driverfiles          List driver files installed for devices. drivernodes          Lists all the driver nodes of devices. enable               Enable devices that match the specific hardware or instance ID. find                 Find devices that match the specific hardware or instance ID. findall              Find devices including those that are not present. help                 Display this information. hwids                Lists hardware ID's of devices. install              Manually install a device. listclass            List all devices for a setup class. reboot               Reboot local machine. remove               Remove devices that match the specific hardware or instance ID. rescan               Scan for new hardware. resources            Lists hardware resources of devices. restart              Restart devices that match the specific hardware or instance ID. sethwid              Modify Hardware ID's of listed root-enumerated devices. stack                Lists expected driver stack of devices. status               List running status of devices. update               Manually update a device. updateni             Manually update a device (non interactive).

其实最应该得分的是7楼。

看到3楼回复的时候，笑喷了 是我笑点低么 Nice Code!

搜“devcon”

引用 4 楼 huangai123 的回复:大神，先谢谢你的代码。但是您还是误会了我的意思 目前已知条件只有Inter(R)Active Managerment Technology而不是 Inter(R)Active Managerment Technology（com3），要通过注册表或者其他方式才能或得到，不是简单的字符串处理，如果是简单的字符串处理，我也就没必要发帖了 第一点 问问题不准确 也不专业 我想没人会回答你这个问题的  第二点 只是个大问题按你所说 你认为区区40分这个问题就能用三言俩语解决 第三 上下文环境没有交代清楚 就算是图灵来了也是徒劳的

#include <stdio.h> #include <string.h> char s[]="Inter(R)Active Managerment Technology（com3）"; char COMn[6]; int main() {  if (1==sscanf(s,"Inter(R)Active Managerment Technology（%5[comCOM0123456789]",COMn)) {   printf("[%s]\n",COMn);  } else {   printf("Format Error:[%s]\n",s);  }  return 0; } //[com3] //

你理解错我的问题了 举例说明： 设备管理器里面显示：Inter(R)Active Managerment Technology（com3） 就是通过    Inter(R)Active Managerment Technology 来获取com3;

#include <stdio.h> #include <string.h> char comn[]="com16"; char COMn[6]; int comport; int main() {  strncpy(COMn,comn,5);COMn[5]=0;  strupr(COMn);  if (1==sscanf(COMn,"COM%d",&comport)) {   printf("%s is COM port %d\n",comn,comport);  } else {   printf("Format Error:[%s]\n",comn);  }  return 0; }


请检查每个函数的返回值。


Question: FD_SET之后, select不到的问题

哎，沦落到自己顶一下的地步了。

感谢两位的回答，我代码删多了，引起了大家的误会的，我关心的fd其实是动态的。 就是每次select的fd数量，都是不一定的。 每次发给子进程信息后，都会等待子进程返回，不同的子进程，管道描述符也不一样，因此FD_SET的fd也是不一样的， 现在我将代码完善一下，发给出来。  这是发生问题的代码，就是说只能select到最后一个mypid[i].fd，前几个进程的返回都没有触发select:      FD_ZERO(&rset);       FD_SET(listenfd, &rset);       for(;;)      {           nselect = select(fdmax+1, &rset, NULL, NULL, NULL);         if( FD_ISSET(listenfd, &rset) ) {       /*收到客户端连接请求*/               connfd = accept(listenfd, (SA *)&clientaddr, (socklen_t *)&len);               //此处省略循环找mypid中的第一个status为空闲的，因此两次请求 i 是不同的值。fd也是不同的。              FD_SET(mypid[i].fd, &rset);             /*加入描述集，等待子进程*/               fdmax = max(fdmax ,mypid[i].fd);               //此处省略把连接套接字传送给子进程             close(connfd);                                        if(--nselect  ==0)                   continue;           }           else          {               for(i = 0; i < nchild; i++ )              {                 if(FD_ISSET(mypid[i].fd , &rset))                  {                     read(mypid[i].fd, &c, 1);                       FD_CLR(mypid[i].fd, &rset);                       mypid[i].status = IDLE;                     nselect--;                 }                 if(nselect  == 0)                       break;               }         }     }   }  这是修改之后的,问题解决了，但是不知道为什么，其实就加了一个oset作为临时变量,ISSET和SET不是同一个了。      FD_ZERO(&oset);       FD_ZERO(&rset);       FD_SET(listenfd, &rset);       for(;;)      {           rset = oset;         nselect = select(fdmax+1, &rset, NULL, NULL, NULL);         if( FD_ISSET(listenfd, &rset) ) {       /*收到客户端连接请求*/               connfd = accept(listenfd, (SA *)&clientaddr, (socklen_t *)&len);               //此处省略循环找mypid中的第一个status为空闲的，因此多次请求 i 是不同的值。fd也是不同的。              FD_SET(mypid[i].fd, &oset);             /*加入描述集，等待子进程*/               fdmax = max(fdmax ,mypid[i].fd);               //此处省略把连接套接字传送给子进程             close(connfd);                                        if(--nselect  ==0)                   continue;           }           else          {               for(i = 0; i < nchild; i++ )              {                 if(FD_ISSET(mypid[i].fd , &rset))                  {                     read(mypid[i].fd, &c, 1);                       FD_CLR(mypid[i].fd, &oset);                       mypid[i].status = IDLE;                     nselect--;                 }                 if(nselect  == 0)                       break;               }         }     }   }

引用 7 楼 icesky1stm 的回复:噢，我理解了。 是select 调用之后，就会重置readfds 。 比如， 我FD_SET 了，3,4,5,6  四个文件描述符，然后调用select ,当select返回描述符4可读的时候， 3 ,5,6这三个描述符也被FD_CLR了。 如果要继续select 3,5,6 就必须再调用select之前重新FD_SET。  是的，还要注意的是select的最后一个参数timeout int select(int nfds, fd_set *restrict readfds,        fd_set *restrict writefds, fd_set *restrict errorfds,        struct timeval *restrict timeout);  Upon successful completion, the select() function may modify the object pointed to by the timeout argument  所以要用这个参数的话，在循环里每次都得重新赋值

噢，我理解了。 是select 调用之后，就会重置readfds 。 比如， 我FD_SET 了，3,4,5,6  四个文件描述符，然后调用select ,当select返回描述符4可读的时候， 3 ,5,6这三个描述符也被FD_CLR了。 如果要继续select 3,5,6 就必须再调用select之前重新FD_SET。  引用 6 楼 mymtom 的回复:int select(int nfds, fd_set *restrict readfds,        fd_set *restrict writefds, fd_set *restrict errorfds,        struct timeval *restrict timeout);  注意几个fds都是(fd_set *)类型，没有const哦，会被修改该的。  If the readfds argument is not a null pointer, it points to an object of type fd_set that on input specifies the file descriptors to be checked for being ready to read, and on output indicates which file descriptors are ready to read.  说的明白一点就是说： 调用select时，你用 readfds 告诉系统哪些描述字需要监测， select返回时，系统用 readfds 告诉你哪些描述字已经可读！ 我理解的对吧。  另外感谢 引用 3 楼 ak47_wz 的回复:1.第一个你存在的问题是因为，select中fd_set值-结果参数，并且你所关心的那一位是相同的。多个请求到达的时候，由于值-结果的缘故，只有最后一个请求保存下来了。其他覆盖掉了。所以通常我们在再次调用select函数的时候，都得再次把所有关心的字集置1. 2.第二个问题，我不太懂你的意思。FD_CLR 只是关闭那个位，并不代表那个位的空间就不存在了。另外，这也许是设计上的问题。我不太懂这个。 个人见解。 我没有很好的理解你的意思。

select(nfds, readfds, writefds, exceptfds, timeout); nfds 是三个 fd_set 中最大句柄 +1 你的代码三个 fd_set 只有一个句柄 使用 nselect = select(listenfd+1, &rset, NULL, NULL, NULL); 应该就可以了


Question: Linux32位下如何给64位无符号整型变量赋值遇到的一个奇怪的问题

万一   。。。 里面修改了ret的值呢？

自己看内存吧， 调试器(gdb)的print有时候不可靠

是不是get_int 的声明在另一个程序文件里，而在调用的程序文件里又没有声明。


Question: 在Linux C编程下实现的练习！求大神。。。

用个简单的数据结构 栈 就能解决包括括号、优先级在内的问题了。

想起以前我们这样输入不定个数的任意数算24，加减乘除都好说，但是考虑括号就复杂了

引用 6 楼 JiMoKuangXiangQu 的回复:简单、粗糙、局限性大，但达到了基本要求，供参考。  #include <stdio.h> #include <string.h>   #define OP_N		4 #define EXPR_LEN	(5 + 1)  int eval(const char *expr) { 	int op1, op2, op3, result = 0;  	op1 = expr[0] - '0'; 	op2 = expr[2] - '0'; 	op3 = expr[4] - '0'; 	if (expr[1] == '*' || expr[1] == '/' || expr[3] == '+' || expr[3] == '-') { 		switch (expr[1]) { 		case '+': result = (op1 + op2); break; 		case '-': result = (op1 - op2); break; 		case '*': result = (op1 * op2); break; 		case '/': result = (op1 / op2); break; 		} 		switch (expr[3]) { 		case '+': result = (result + op2); break; 		case '-': result = (result - op2); break; 		case '*': result = (result * op2); break; 		case '/': result = (result / op3); break; 		} 	} else { 		switch (expr[3]) { 		case '+': result = (op2 + op3); break; 		case '-': result = (op2 - op3); break; 		case '*': result = (op2 * op3); break; 		case '/': result = (op2 / op3); break; 		} 		switch (expr[1]) { 		case '+': result = (op1 + result); break; 		case '-': result = (op1 - result); break; 		case '*': result = (op1 * result); break; 		case '/': result = (op1 / result); break; 		} 	}  	return result; }  int main() { 	const char *template = "1%c1%c1"; 	const char ops[] = {'+', '-', '*', '/'}; 	const char exprs[OP_N*OP_N][EXPR_LEN];  	int i, j;  	for (i = 0; i < OP_N; i++) 	{ 		for (j = 0; j < OP_N; j++) 		{ 			sprintf(exprs[i*OP_N + j], template, ops[i], ops[j]); 		} 	}  	for (i = 0; i < OP_N; i++) 	{ 		for (j = 0; j < OP_N; j++) 		{ 			//printf("%s=%d\n", exprs[i*OP_N + j], eval(exprs[i*OP_N + j])); 			if (eval(exprs[i*OP_N + j]) == 1) 			{ 				printf(exprs[i*OP_N + j]); 				printf("\n"); 			} 		} 	}  	getch(); 	return 0; } #include <stdio.h> #include <string.h>   #define OP_N		4 #define EXPR_LEN	(5 + 1)  int eval(const char *expr) { 	int op1, op2, op3, result = 0;  	op1 = expr[0] - '0'; 	op2 = expr[2] - '0'; 	op3 = expr[4] - '0'; 	if (expr[1] == '*' || expr[1] == '/' || expr[3] == '+' || expr[3] == '-') { 		switch (expr[1]) { 		case '+': result = (op1 + op2); break; 		case '-': result = (op1 - op2); break; 		case '*': result = (op1 * op2); break; 		case '/': result = (op1 / op2); break; 		} 		switch (expr[3]) { 		case '+': result = (result + op2); break; 		case '-': result = (result - op2); break; 		case '*': result = (result * op2); break; 		case '/': result = (result / op3); break; 		} 	} else { 		switch (expr[3]) { 		case '+': result = (op2 + op3); break; 		case '-': result = (op2 - op3); break; 		case '*': result = (op2 * op3); break; 		case '/': result = (op2 / op3); break; 		} 		switch (expr[1]) { 		case '+': result = (op1 + result); break; 		case '-': result = (op1 - result); break; 		case '*': result = (op1 * result); break; 		case '/': result = (op1 / result); break; 		} 	}  	return result; }  int main() { 	const char *template = "1%c1%c1"; 	const char ops[] = {'+', '-', '*', '/'}; 	const char exprs[OP_N*OP_N][EXPR_LEN];  	int i, j;  	for (i = 0; i < OP_N; i++) 	{ 		for (j = 0; j < OP_N; j++) 		{ 			sprintf(exprs[i*OP_N + j], template, ops[i], ops[j]); 		} 	}  	for (i = 0; i < OP_N; i++) 	{ 		for (j = 0; j < OP_N; j++) 		{ 			//printf("%s=%d\n", exprs[i*OP_N + j], eval(exprs[i*OP_N + j])); 			if (eval(exprs[i*OP_N + j]) == 0) 			{ 				printf(exprs[i*OP_N + j]); 				printf("\n"); 			} 		} 	}  	getch(); 	return 0; } 晕，应该是判断等于0，呵呵。

我的程序考虑了优先级问题

我的程序没考虑优先级问题

仅供参考/*--------------------------------------- 函数型计算器(VC++6.0,Win32 Console)程序由 yu_hua 于2007-07-27设计完成 功能： 目前提供了10多个常用数学函数:     ⑴正弦sin     ⑵余弦cos     ⑶正切tan     ⑷开平方sqrt     ⑸反正弦arcsin     ⑹反余弦arccos     ⑺反正切arctan     ⑻常用对数lg     ⑼自然对数ln     ⑽ｅ指数exp     ⑾乘幂函数∧ 用法： 如果要求2的32次幂，可以打入2^32<回车> 如果要求30度角的正切可键入tan(Pi/6)<回车> 注意不能打入：tan(30)<Enter> 如果要求1.23弧度的正弦，有几种方法都有效： sin(1.23)<Enter> sin 1.23 <Enter> sin1.23  <Enter> 如果验证正余弦的平方和公式,可打入sin(1.23)^2+cos(1.23)^2 <Enter>或sin1.23^2+cos1.23^2 <Enter> 此外两函数表达式连在一起,自动理解为相乘如：sin1.23cos0.77+cos1.23sin0.77就等价于sin(1.23)*cos(0.77)+cos(1.23)*sin(0.77) 当然你还可以依据三角变换，再用sin(1.23+0.77)也即sin2验证一下。 本计算器充分考虑了运算符的优先级因此诸如：2+3*4^2 实际上相当于：2+(3*(4*4)) 另外函数名前面如果是数字,那么自动认为二者相乘. 同理，如果某数的右侧是左括号，则自动认为该数与括弧项之间隐含一乘号。 如：3sin1.2^2+5cos2.1^2 相当于3*sin2(1.2)+5*cos2(2.1) 又如：4(3-2(sqrt5-1)+ln2)+lg5 相当于4*(3-2*(√5 -1)+loge(2))+log10(5) 此外，本计算器提供了圆周率 Pi键入字母时不区分大小写,以方便使用。 ----------------------------------------*/ #include <iostream> #include <iomanip> #include <cstdlib> #include <cstring> #include <cctype> #include <cmath> #include <stdio.h> #include <string.h> #include <windows.h> using namespace std; const char Tab=0x9; const int  DIGIT=1; const int MAXLEN=16384; char s[MAXLEN],*endss; int pcs=15; double fun(double x,char op[],int *iop) {     while (op[*iop-1]<32) //本行使得函数嵌套调用时不必加括号,如 arc sin(sin(1.234)) 只需键入arc sin sin 1.234<Enter>         switch (op[*iop-1]) {         case  7: x=sin(x);  (*iop)--;break;         case  8: x=cos(x);  (*iop)--;break;         case  9: x=tan(x);  (*iop)--;break;         case 10: x=sqrt(x); (*iop)--;break;         case 11: x=asin(x); (*iop)--;break;         case 12: x=acos(x); (*iop)--;break;         case 13: x=atan(x); (*iop)--;break;         case 14: x=log10(x);(*iop)--;break;         case 15: x=log(x);  (*iop)--;break;         case 16: x=exp(x);  (*iop)--;break;         }     return x; } double calc(char *expr,char **addr) {     static int deep; //递归深度     static char *fname[]={ "sin","cos","tan","sqrt","arcsin","arccos","arctan","lg","ln","exp",NULL};     double ST[10]={0.0}; //数字栈     char op[10]={'+'}; //运算符栈     char c,*rexp,*pp,*pf;     int ist=1,iop=1,last,i;     if (!deep) {         pp=pf=expr;         do {             c = *pp++;             if (c!=' '&& c!=Tab)                 *pf++ = c;         } while (c!='\0');     }     pp=expr;     if ((c=*pp)=='-'||c=='+') {         op[0] = c;         pp++;     }     last = !DIGIT;     while ((c=*pp)!='\0') {         if (c=='(') {//左圆括弧             deep++;             ST[ist++]=calc(++pp,addr);             deep--;             ST[ist-1]=fun(ST[ist-1],op,&iop);             pp = *addr;             last = DIGIT;             if (*pp == '('||isalpha(*pp) && strnicmp(pp,"Pi",2)) {//目的是：当右圆括弧的右恻为左圆括弧或函数名字时，默认其为乘法                 op[iop++]='*';                 last = !DIGIT;                 c = op[--iop];                 goto operate ;             }         }         else if (c==')') {//右圆括弧             pp++;             break;         } else if (isalpha(c)) {             if (!strnicmp(pp,"Pi",2)) {                 if (last==DIGIT) {                     cout<< "π左侧遇）" <<endl;exit(1);                 }                 ST[ist++]=3.14159265358979323846264338328;                 ST[ist-1]=fun(ST[ist-1],op,&iop);                 pp += 2;                 last = DIGIT;                 if (!strnicmp(pp,"Pi",2)) {                     cout<< "两个π相连" <<endl;exit(2);                 }                 if (*pp=='(') {                     cout<< "π右侧遇（" <<endl;exit(3);                 }             } else {                 for (i=0; (pf=fname[i])!=NULL; i++)                     if (!strnicmp(pp,pf,strlen(pf))) break;                 if (pf!=NULL) {                     op[iop++] = 07+i;                     pp += strlen(pf);                 } else {                     cout<< "陌生函数名" <<endl;exit(4);                 }             }         } else if (c=='+'||c=='-'||c=='*'||c=='/'||c=='^') {             char cc;             if (last != DIGIT) {                 cout<< "运算符粘连" <<endl;exit(5);             }             pp++;             if (c=='+'||c=='-') {                 do {                     cc = op[--iop];                     --ist;                     switch (cc) {                     case '+':  ST[ist-1] += ST[ist];break;                     case '-':  ST[ist-1] -= ST[ist];break;                     case '*':  ST[ist-1] *= ST[ist];break;                     case '/':  ST[ist-1] /= ST[ist];break;                     case '^':  ST[ist-1] = pow(ST[ist-1],ST[ist]);break;                     }                 } while (iop);                 op[iop++] = c;             } else if (c=='*'||c=='/') { operate:        cc = op[iop-1];                 if (cc=='+'||cc=='-') {                     op[iop++] = c;                 } else {                     --ist;                     op[iop-1] = c;                     switch (cc) {                     case '*':  ST[ist-1] *= ST[ist];break;                     case '/':  ST[ist-1] /= ST[ist];break;                     case '^':  ST[ist-1] = pow(ST[ist-1],ST[ist]);break;                     }                 }             } else {                 cc = op[iop-1];                 if (cc=='^') {                     cout<< "乘幂符连用" <<endl;exit(6);                 }                 op[iop++] = c;             }             last = !DIGIT;         } else {             if (last == DIGIT) {                 cout<< "两数字粘连" <<endl;exit(7);             }             ST[ist++]=strtod(pp,&rexp);             ST[ist-1]=fun(ST[ist-1],op,&iop);             if (pp == rexp) {                 cout<< "非法字符" <<endl;exit(8);             }             pp = rexp;             last = DIGIT;             if (*pp == '('||isalpha(*pp)) {                 op[iop++]='*';                 last = !DIGIT;                 c = op[--iop];                 goto operate ;             }         }     }     *addr=pp;     if (iop>=ist) {         cout<< "表达式有误" <<endl;exit(9);     }     while (iop) {         --ist;         switch (op[--iop]) {         case '+':  ST[ist-1] += ST[ist];break;         case '-':  ST[ist-1] -= ST[ist];break;         case '*':  ST[ist-1] *= ST[ist];break;         case '/':  ST[ist-1] /= ST[ist];break;         case '^':  ST[ist-1] = pow(ST[ist-1],ST[ist]);break;         }     }     return ST[0]; } int main(int argc,char **argv) {     //1 2 3 4 5 6 7 8 9 ＝110 中间可以挿＋ － 或者不挿 如果1 2 不挿的话 就是12     char op[4]=" +-";     int g1;     int g2;     int g3;     int g4;     int g5;     int g6;     int g7;     int g8;      for (g1=0;g1<3;g1++)     for (g2=0;g2<3;g2++)     for (g3=0;g3<3;g3++)     for (g4=0;g4<3;g4++)     for (g5=0;g5<3;g5++)     for (g6=0;g6<3;g6++)     for (g7=0;g7<3;g7++)     for (g8=0;g8<3;g8++) {         strcpy(s,"1 2 3 4 5 6 7 8 9");         s[ 1]=op[g1];         s[ 3]=op[g2];         s[ 5]=op[g3];         s[ 7]=op[g4];         s[ 9]=op[g5];         s[11]=op[g6];         s[13]=op[g7];         s[15]=op[g8];         if (110.0==calc(s,&endss)) printf("%s=110\n",s);     }     /*     if (argc<=1) {         if (GetConsoleOutputCP()!=936) system("chcp 936>NUL");//中文代码页         cout << "计算函数表达式的值。"<<endl<<"支持(),+,-,*,/,^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp"<<endl;         while (1) {             cout << "请输入表达式：";             gets(s);             if (s[0]==0) break;//             cout << s <<"=";             cout << setprecision(15) << calc(s,&endss) << endl;         }     } else {         strncpy(s,argv[1],MAXLEN-1);s[MAXLEN-1]=0;         if (argc>=3) {             pcs=atoi(argv[2]);             if (pcs<0||15<pcs) pcs=15;             printf("%.*lf\n",pcs,calc(s,&endss));         } else {             printf("%.15lg\n",calc(s,&endss));         }     }     */     return 0; } //123+4+5+67-89=110 //123+4-5-6-7-8+9=110 //123-4+5-6-7+8-9=110 //123-4-5+6+7-8-9=110 //12+34+56+7-8+9=110 //12+3+45+67-8-9=110 //12-3+4-5+6+7+89=110 //1+234-56-78+9=110 //1+2+34+5+67-8+9=110 //1-2+3+45-6+78-9=110

#include <stdio.h> #include <string.h>   #define MAX_SIZE 1024    int main() { //输入1()1()1=0 //解析出来 char input[MAX_SIZE]; char op[5]="+-*/"; gets(input); int a,b,c,answer; sscanf(input,"%d()%d()%d=%d",&a,&b,&c,&answer); printf("%d\n",answer);  int i,j; for(i = 0; i < 4;i++){        int temp ;             switch(op[i]){                 case '+': temp=a+b; break;                 case '-': temp=a-b; break;                 case '*': temp=a*b; break;                 case '/': temp=a/b; break;                     default :break;             }  for(j = 0 ; j < 4;j++)  {          int temp1;         switch(op[j]){                 case '+': temp1=temp+c; break;                 case '-': temp1=temp-c; break;                 case '*': temp1=temp*c; break;                 case '/': temp1=temp/c; break;                     default :break;             }         if(temp1 == answer)                 printf("%c %c\n",op[i],op[j]);   } }   return 0; } 仅供参考 希望采纳

枚举


Question: 程序中一个函数的输出结果有误！！！~~

“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出

就是楼上所说的：leaf居然不把LeafCount返回，连个2都不返回，就返回1和0，那肯定只能打印出1和0

int leaf 的递归设计有问题！首先是没有把值做统计，其次是在里面printf始终不会是最终结果的


Question: 两道面试题

少一个括号，否则在32位机器上是16，64位机器上32；

学习了，大家都是高手啊，第一题我都不会。

1.  783 #define container_of(ptr, type, member) ({                      \ 784         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \ 785         (type *)( (char *)__mptr - offsetof(type,member) );}) 786   linux核心的类似用法。 int指针占用4B，加上4，就是偏移4*4=16B,取其整数

引用 3 楼 gigglesun 的回复:[quote=引用 2 楼 user-5 的回复:] 第一个是偏移4个int的地址吧，16 第二个用not exist可以解决吧，select * from t1 where not exist(select * from t2,t3 where t2.key=t3.key and t1.key=t2.key)  第一题我是这样理解的，(（int*)0+4)表示将0转换为地址，在这个基础上偏移4个int的地址，然后在偏移后地址上取一个int值，因而值是未知的，看上去应该是这样呀？[/quote] 不是 4个int类型的字节大小么？依赖于系统，但也算是已知的吧！

引用 2 楼 user-5 的回复:第一个是偏移4个int的地址吧，16 第二个用not exist可以解决吧，select * from t1 where not exist(select * from t2,t3 where t2.key=t3.key and t1.key=t2.key)  第一题我是这样理解的，(（int*)0+4)表示将0转换为地址，在这个基础上偏移4个int的地址，然后在偏移后地址上取一个int值，因而值是未知的，看上去应该是这样呀？


Question: C语言小问题

引用 楼主 u011488256 的回复:*t=(TreeNode*)malloc(sizeof(TreeNode)*6); 	// 下面这个问题还没有搞清楚 	for (int i=0;i<6;i++) 	{ 		t[i]->m_Number=i+1; 	}  这段程序自己调试 其中t 定义的是**t 但是在循环里面每次到t【2】的时候程序就死了 不知道怎么回事 球赐教 谢谢  如果t的定义是**t的话，那t就是数组arr的地址了，即*t = t[0] = arr，假设这个数组arr的长度是len，则有t[1] = arr+len，t[2] = arr+2*len，所以你的数组下标越界了哈 如果lz想要实现的是，用malloc出来的一个指针数组，用这些指针来控制实体对象，可以这样：  T** arrayOfPointers = (T**)malloc(sizeof(T*) * N);//先申请N个指针的空间 int i; for(i = 0; i < N; ++i){     arrayOfPointers[i] = (T*)malloc(sizeof(T));//给每一个指针malloc一个控制的对象 } //然后就可以通过这些指针来控制malloc出来的对象了，就像你写的那样 for(i = 0; i < N; ++i){     arrayOfPointers[i]->m_Number = i+1; }  //do something else  //最后，释放malloc申请的内存的时候也要注意，先释放为每个指针malloc的对象，再释放malloc出来的指针 for(i = 0; i < N; ++i){     free(arrayOfPointers[i]);//释放每一个指针指向的，malloc出来的对象 } free(arrayOfPointer);//释放malloc出来的N个指针

你要么改成这样试试看t=(TreeNode**)malloc(sizeof(TreeNode*)); *t=(TreeNode*)malloc(sizeof(TreeNode)*6); for (int i=0;i<6;i++) {     (*t)[i].m_Number=i+1; }总之每一级指针都要初始化，不论是t还是*t,至于(*t)[i]表示的是一个对象了，所以要用.而不是->。你自己画一幅图，好好理解下吧。

其实电脑开机后物理内存的每个字节都是可读写的，区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。

引用 16 楼 u011488256 的回复:[quote=引用 14 楼 u010165006 的回复:] [quote=引用 10 楼 u011488256 的回复:]   [quote=引用 7 楼 u010165006 的回复:] [quote=引用 5 楼 u011488256 的回复:] 我  [quote=引用 4 楼 u010165006 的回复:] 是不是这样； TreeNode *t; t=(TreeNode*)malloc(sizeof(TreeNode)*6); 或者； TreeNode *t=(TreeNode*)malloc(sizeof(TreeNode)*6);   我用的是  TreeNode **t           *t=(TreeNode*)malloc(sizeof(TreeNode)*6); for (int i=0;i<6;i++) { t[i]->m_Number=i+1; }[/quote] 你给*t=赋值之前，先给t=赋值了吗？t首先应该是指向一个指针数组（数组的每个元素都是指针），然后给每个元素分别赋值，指向一个分配的结构体，单给*t=赋值只是相当于只对t[0]赋值。[/quote]  t 怎么变成指向一个数组的指针啊。我这里定义的就是一个普通的指向指针的指针[/quote] 2楼的： TreeNode** t=(TreeNode**)malloc(sizeof(TreeNode*)*6); 不就是吗？相当于t指向一个指针数组，*6是6个元素,sizeof(TreeNode*)是每个元素的大小，每个元素的类型是TreeNode*，t的类型是TreeNode**。每个元素还要指向一个分配的TreeNode。每个元素t[i]因为是指针，所以用t[i]->访问成员变量。[/quote]   你们说的我都理解了 但是我还有疑惑是： 一开始我发的代码为什么到t【2】，他才开始报错？ t【1】以后我调试 他都是正常按照我的思维运行的      后来我吧代码改了一下 for (int i=0;i<6;i++，（*t）++) { （*t）->m_Number=i+1; }  这样运行还是错的，是不是应该理解为我这个（*t）++应该是t所指向的指针数组的第一个元素的地址值在自己+1， 应该是这样的吧 我去··[/quote] 你只要记住数组与指针的关系（这里t相当于数组，不过数组名不可以++，但可以+i，t可以++）：*t就是t[0],*(t+1)就是t[1],*(t+i)就是t[i]，t作为首地址一般要保留着，假设TreeNode** p=t;在for里面每次p++以后,*p==*(t+1)==t[1],再p++后，*p==*(t+2)==t[2]，一直到*p==*(t+5)==t[5]，当然for里面用t++也可以。

引用 10 楼 u011488256 的回复:  t 怎么变成指向一个数组的指针啊。我这里定义的就是一个普通的指向指针的指针 为什么就不能好好看看，我在2楼写的内容呢？你分配6个，就是模拟一个数组的形式嘛，理解的模型不一样罢了。数组本身就是类似指针的形式，指向数组的指针，就是指向指针的指针。就好比正方形是矩形的一个特例而已，不必死缠这些细节。

对头，t[2]根本没有数据，你应该这样解引用(*t)[2],这样就是你的意图了

引用 14 楼 u010165006 的回复:[quote=引用 10 楼 u011488256 的回复:]   [quote=引用 7 楼 u010165006 的回复:] [quote=引用 5 楼 u011488256 的回复:] 我  [quote=引用 4 楼 u010165006 的回复:] 是不是这样； TreeNode *t; t=(TreeNode*)malloc(sizeof(TreeNode)*6); 或者； TreeNode *t=(TreeNode*)malloc(sizeof(TreeNode)*6);   我用的是  TreeNode **t           *t=(TreeNode*)malloc(sizeof(TreeNode)*6); for (int i=0;i<6;i++) { t[i]->m_Number=i+1; }[/quote] 你给*t=赋值之前，先给t=赋值了吗？t首先应该是指向一个指针数组（数组的每个元素都是指针），然后给每个元素分别赋值，指向一个分配的结构体，单给*t=赋值只是相当于只对t[0]赋值。[/quote]  t 怎么变成指向一个数组的指针啊。我这里定义的就是一个普通的指向指针的指针[/quote] 2楼的： TreeNode** t=(TreeNode**)malloc(sizeof(TreeNode*)*6); 不就是吗？相当于t指向一个指针数组，*6是6个元素,sizeof(TreeNode*)是每个元素的大小，每个元素的类型是TreeNode*，t的类型是TreeNode**。每个元素还要指向一个分配的TreeNode。每个元素t[i]因为是指针，所以用t[i]->访问成员变量。[/quote]   你们说的我都理解了 但是我还有疑惑是： 一开始我发的代码为什么到t【2】，他才开始报错？ t【1】以后我调试 他都是正常按照我的思维运行的      后来我吧代码改了一下 for (int i=0;i<6;i++，（*t）++) { （*t）->m_Number=i+1; }  这样运行还是错的，是不是应该理解为我这个（*t）++应该是t所指向的指针数组的第一个元素的地址值在自己+1， 应该是这样的吧 我去··

引用 12 楼 Adol1111 的回复:即便是你这样想，抛开t的一级指针赋值不谈。用数组做模型的话（方便理解点） *t=(TreeNode*)malloc(sizeof(TreeNode)*6); *t才指向了一个容量为6数组，那么(*t)[i]才是指向具体的单独一个节点吧。  你好 如上所说  *t才指向了一个容量为6的Treenode类型的数组，那按照你的意思t【2】应该根本没有指向对吧？因为t【2】应该是t所指向数组指针的第3个元素，但是t还没有指向任何东西。    我一直认为定义了**t后， *t指向一个东西，那么t自然就是指向*t的

引用 10 楼 u011488256 的回复:  [quote=引用 7 楼 u010165006 的回复:] [quote=引用 5 楼 u011488256 的回复:] 我  [quote=引用 4 楼 u010165006 的回复:] 是不是这样； TreeNode *t; t=(TreeNode*)malloc(sizeof(TreeNode)*6); 或者； TreeNode *t=(TreeNode*)malloc(sizeof(TreeNode)*6);   我用的是  TreeNode **t           *t=(TreeNode*)malloc(sizeof(TreeNode)*6); for (int i=0;i<6;i++) { t[i]->m_Number=i+1; }[/quote] 你给*t=赋值之前，先给t=赋值了吗？t首先应该是指向一个指针数组（数组的每个元素都是指针），然后给每个元素分别赋值，指向一个分配的结构体，单给*t=赋值只是相当于只对t[0]赋值。[/quote]  t 怎么变成指向一个数组的指针啊。我这里定义的就是一个普通的指向指针的指针[/quote] 2楼的： TreeNode** t=(TreeNode**)malloc(sizeof(TreeNode*)*6); 不就是吗？相当于t指向一个指针数组，*6是6个元素,sizeof(TreeNode*)是每个元素的大小，每个元素的类型是TreeNode*，t的类型是TreeNode**。每个元素还要指向一个分配的TreeNode。每个元素t[i]因为是指针，所以用t[i]->访问成员变量。

TreeNode* x; //t要正确初始化 TreeNode**t = &x; *t =(TreeNode*)malloc(sizeof(TreeNode)*6); // 下面这个问题还没有搞清楚 for (int i=0;i<6;i++) {   (*t)[i].m_Number=i+1; }

计算机组成原理→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语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “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

引用 15 楼 u011488256 的回复:[quote=引用 12 楼 Adol1111 的回复:] 即便是你这样想，抛开t的一级指针赋值不谈。用数组做模型的话（方便理解点） *t=(TreeNode*)malloc(sizeof(TreeNode)*6); *t才指向了一个容量为6数组，那么(*t)[i]才是指向具体的单独一个节点吧。  你好 如上所说  *t才指向了一个容量为6的Treenode类型的数组，那按照你的意思t【2】应该根本没有指向对吧？因为t【2】应该是t所指向数组指针的第3个元素，但是t还没有指向任何东西。    我一直认为定义了**t后， *t指向一个东西，那么t自然就是指向*t的[/quote] ...这是不可能的，任何指针都是一级级下来的，你没有指名他的指向，谁知道你是如何分配的？系统不会擅自帮你做决定。我写了3种，其中2种是二维指针，都是一级级分配的，你好好看看吧。你用指针的时候，最好能画个图，分清楚到底是谁指向谁。指向的是一个元素，还是一个数组什么的。总之，先确定一级的指针，然后再确定二级的，一步步来，不要跳步。

t的申明贴出来看看！ t=2 挂了，可能越界访问了

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

引用 7 楼 u010165006 的回复:[quote=引用 5 楼 u011488256 的回复:] 我  [quote=引用 4 楼 u010165006 的回复:] 是不是这样； TreeNode *t; t=(TreeNode*)malloc(sizeof(TreeNode)*6); 或者； TreeNode *t=(TreeNode*)malloc(sizeof(TreeNode)*6);   我用的是  TreeNode **t           *t=(TreeNode*)malloc(sizeof(TreeNode)*6); for (int i=0;i<6;i++) { t[i]->m_Number=i+1; }[/quote] 你给*t=赋值之前，先给t=赋值了吗？t首先应该是指向一个指针数组（数组的每个元素都是指针），然后给每个元素分别赋值，指向一个分配的结构体，单给*t=赋值只是相当于只对t[0]赋值。[/quote]  t 怎么变成指向一个数组的指针啊。我这里定义的就是一个普通的指向指针的指针

非法读写内存

你的指针定义有问题，改成这两种：//版本1 TreeNode* t=(TreeNode*)malloc(sizeof(TreeNode)*6); for (int i=0;i<6;i++) {     t[i].m_Number=i+1; }  //版本2 TreeNode** t=(TreeNode**)malloc(sizeof(TreeNode*)*6); for (int i=0;i<6;i++) {     t[i]=(TreeNode*)malloc(sizeof(TreeNode));     t[i]->m_Number=i+1; }如果是二维指针，需要初始化2次，第一次是声明指针数组的形式，第二次才是指向一个指向TreeNode元素的指针


Question: 关于float或者double的精度问题

计算机组成原理→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对应的汇编并单步执行观察相应内存和寄存器变化。）  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！

引用 13 楼 dale999 的回复:[quote=引用 11 楼 mymtom 的回复:] [quote=引用 9 楼 dale999 的回复:]  学习了，之前没接触过这方面的东西。不过你这段代码在我那儿运行，貌似没法设置精度方向呢？运行成功，fesetround函数执行也成功，但是结果不对，不知道怎么回事 我是在Linux下运行的！[/quote] 我在WINDOWS 和 LINUX下运行都不对……[/quote] 啥叫对？

引用 11 楼 mymtom 的回复:[quote=引用 9 楼 dale999 的回复:]  学习了，之前没接触过这方面的东西。不过你这段代码在我那儿运行，貌似没法设置精度方向呢？运行成功，fesetround函数执行也成功，但是结果不对，不知道怎么回事 我是在Linux下运行的！[/quote] 我在WINDOWS 和 LINUX下运行都不对……

我觉得这个跟 编译器的优化有关   http://msdn.microsoft.com/en-us/library/aa289157%28VS.71%29.aspx  int b1=a*3 给优化成了 b1 = 1.0 \ 3 * 3  VS下面的优化选项：

引用 9 楼 dale999 的回复:学习了，之前没接触过这方面的东西。不过你这段代码在我那儿运行，貌似没法设置精度方向呢？运行成功，fesetround函数执行也成功，但是结果不对，不知道怎么回事 我是在Linux下运行的！

feclearexcept, fegetexceptflag, feraiseexcept, fesetexceptflag, fetestexcept, fegetenv, fegetround, feholdexcept, fesetround, fesetenv, feupdateenv - C99 floating point rounding and exception handling

引用 8 楼 mymtom 的回复:这个与系统的默认浮点环境设置有关系，但是可以根据需要设置。   /*-  * Copyright (C), 1988-2013 mymtom  *  * vi:set ts=4 sw=4:  */ #ifndef lint static const char rcsid[] = "$Id$"; #endif /* not lint */  /**  * @file    rnd.c  * @brief     */  #pragma STDC FENV_ACCESS ON #include <fenv.h>  #include <stdio.h>  static void func1(void); static void func2(void); static void func3(void); static void func4(void);  int main(int argc, char *argv[]) {      func1();     func2();     func3();     func4();      return 0; }  static void func1(void) {     fesetround(FE_DOWNWARD);     double a=1.0/3;     printf("%f\n",a);     int b1=a*3,b2=0.333333*3;     printf("%d,%d\n",b1,b2); } static void func2(void) {     fesetround(FE_TONEAREST);     double a=1.0/3;     printf("%f\n",a);     int b1=a*3,b2=0.333333*3;     printf("%d,%d\n",b1,b2); } static void func3(void) {     fesetround(FE_TOWARDZERO);     double a=1.0/3;     printf("%f\n",a);     int b1=a*3,b2=0.333333*3;     printf("%d,%d\n",b1,b2); } static void func4(void) {     fesetround(FE_UPWARD);     double a=1.0/3;     printf("%f\n",a);     int b1=a*3,b2=0.333333*3;     printf("%d,%d\n",b1,b2); }  /* 输出 0.333333 0,0 0.333333 1,0 0.333333 0,0 0.333333 1,0  */   学习了，之前没接触过这方面的东西。不过你这段代码在我那儿运行，貌似没法设置精度方向呢？运行成功，fesetround函数执行也成功，但是结果不对，不知道怎么回事

引用 4 楼 zhao4zhong1 的回复:用10进制小数不能精确表示某些三进制小数0.1(3)=0.33333333333……(10) 同理，用二进制小数也不能精确表示某些10进制小数。 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 */ ...  嗯，不能精确表示可以从float类型的存储方式可以看出来嘛~但是像Windows的处理方式，a的值实际已经是小于1/3了，然后乘3赋给b，值返回仍然是1，不编译器是怎么处理的……

引用 1 楼 user-5 的回复:这个怎么感觉是gcc的bug？ 修改成这样：    double a=1.0/3;  	double a2=a*3;     printf("%lf,%lf\n",a,a2);    int b1=a2,b2=0.333333*3;     printf("%d,%d\n",b1,b2); gcc和vs结果相同，都是1，0  其实我就没搞清楚，乘回去等1的情况，编译器怎么知道之前是1/3……

两者的结果都是正确的。

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


Question: 关于float或者double的精度问题

Windows结果，显然更好。 这是误差处理方式不同，造成的。

用10进制小数不能精确表示某些三进制小数0.1(3)=0.33333333333……(10) 同理，用二进制小数也不能精确表示某些10进制小数。 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 */ ...


Question: c语言数据结构二叉树中序遍历的非递归算法


Question: C语言问题

C语言应该比英语简单吧

C不难，是编程的基础，楼上已经说的很详细了，主要是楼主的信心和兴趣，建议楼主从小的程序编起，坚持下来，就会找到成就感。这样学起来就不会太累。

受教

继续坚持！！当你学习阶段最痛苦的时候，也就是你真正学到东西的时候，以后回过头想想你会想回到那个时候的，加油

先找个c基础了解，在看人家代码，不多自己多写提高才有实质性

多看，多学，多写，多练一定会好的，嘻嘻。。

多敲敲吧~这样对学习有帮助

多看书，多写代码，就能学好了

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步对应汇编一行！

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

围棋与象棋。  围棋是我所知规则最为简单的棋，但是同时也是我所知，最难的棋。  象棋是一种相对围棋规则比较多的棋，但是从很多方面而言，象棋在难度上不如围棋。灵活性上更不用说。  你是喜欢象棋还是喜欢围棋？

多敲敲吧~这样对学习有帮助

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

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

那应该放弃编程，转其它领域比较明智。  引用 楼主 u012436723 的回复:C语言程序好复杂，感觉越学越没有头绪，越学越难，编的程序有时都不懂什么意思，我想知道怎样才能真正学好、学懂C语言？

静下心 先把理论知识过关了，多敲书上例程！

循循渐进学。

看不懂,可以别管,继续看后面的,然后再回头看之前的内容,不懂就多看几次,很多东西还是要自己理解才是真. 现在看的书,准备看第三次了,没办法.

多写代码，多调试，水平才能提高。慢慢来，一步一个脚印。


Question: mingw gcc 编译出错

OK，清楚了，应先#include <windows.h>

这个是mingw自带的在iprtrmib.h定义的，

已经提示错误了，为什么不按提示检查一下，再说你贴的内容也太精简了吧！


Question: 字节序的问题

引用 5 楼 xiaohuh421 的回复:写出来就是给人看的了, 而内存中是不一样的.  对于0x04FF. 如果是小端, 你在内存中查看数据会看到.  0xXXXXXX:  FF 04  如果是大端, 你会看到:  0xXXXXXXX: 04 FF 支持！ 离开了字节，就没有所谓大小端问题。

00x04ff的大端是04 FF， 小端是FF 40

引用 4 楼 wangdahu888 的回复:[quote=引用 2 楼 booirror 的回复:] 麻烦各位把2进制存储形式写出来。谢谢 小端 低地址-------------------------->高地址          1111 1111 0000 0010  注意了,大小端是针对多字节存储而言的,是存储地址的高低位与逻辑高低位的对应关系. 对于单字节来说,不存在什么大小端[/quote]++

大端是：高对低，低对高。即内存的高地址存放（数据）低字节，内存的低字节存放（数据）的高字节。 小端是：高对高，低对低。

引用 2 楼 booirror 的回复:麻烦各位把2进制存储形式写出来。谢谢 小端 低地址-------------------------->高地址          1111 1111 0000 0010  注意了,大小端是针对多字节存储而言的,是存储地址的高低位与逻辑高低位的对应关系. 对于单字节来说,不存在什么大小端

引用 2 楼 booirror 的回复:麻烦各位把2进制存储形式写出来。谢谢  详解介绍，图解 例程分析！看看 http://blog.csdn.net/ce123_zhouwei/article/details/6971544

麻烦各位把2进制存储形式写出来。谢谢

大端是高地址存0xff，低地址存0x04 小端是低地址存0xff，高地址存0x04  引用 楼主 booirror 的回复:我老是犯晕，请问大家，0x04ff的大端，小端究竟是怎么存储的。说清楚内存的高低地址


Question: 位操作问题

引用 1 楼 user-10 的回复:num = num | (1<<3)OK

引用 10 楼 qq523176585 的回复:[quote=引用 9 楼 derekrose 的回复:] 孤陋寡闻了，还有第0位？ 那不是数组独有的吗   先把基础打牢吧[/quote]  有一个位串 左数第一位 其实是第二位？

孤陋寡闻了，还有第0位？ 那不是数组独有的吗

是你的表达不专业，C语言一般说到第几位，是从0开始的，而不是从1开始。  引用 6 楼 booirror 的回复:[quote=引用 5 楼 user-10 的回复:] [quote=引用 3 楼 booirror 的回复:] [quote=引用 2 楼 sdhexu 的回复:] num |= 0x00000004; 也就是num |= 0x4，对吗[/quote] 也可以！ 但是 用 移位作比较常见 (1<<3), 0x4也只是运算的结果而已[/quote] 非常抱歉，你回答错误了，1<<3 = 0x8[/quote]

确定是二进制位？

引用 9 楼 derekrose 的回复:孤陋寡闻了，还有第0位？ 那不是数组独有的吗   先把基础打牢吧

用逻辑与操作  应该可以吧

那如果是第3位为1其他位全为0呢？

最后问题就归结在“位是从0开始索引还是从1开始索引”的问题了。这种问题没有任何意义，知道到底是哪一位就行了。

引用 4 楼 turingo 的回复:用 n |= (1 << 3) 这样的写法最好，可以明确的看出是第3位。   引用 楼主 booirror 的回复:将一个数的第三位设置成1，其他位不变，用位操作如何完成？ Ok

引用 6 楼 booirror 的回复:[quote=引用 5 楼 user-10 的回复:] [quote=引用 3 楼 booirror 的回复:] [quote=引用 2 楼 sdhexu 的回复:] num |= 0x00000004; 也就是num |= 0x4，对吗[/quote] 也可以！ 但是 用 移位作比较常见 (1<<3), 0x4也只是运算的结果而已[/quote] 非常抱歉，你回答错误了，1<<3 = 0x8[/quote] sorry，第三位 应该是 1<<2

引用 5 楼 user-10 的回复:[quote=引用 3 楼 booirror 的回复:] [quote=引用 2 楼 sdhexu 的回复:] num |= 0x00000004; 也就是num |= 0x4，对吗[/quote] 也可以！ 但是 用 移位作比较常见 (1<<3), 0x4也只是运算的结果而已[/quote] 非常抱歉，你回答错误了，1<<3 = 0x8

引用 3 楼 booirror 的回复:[quote=引用 2 楼 sdhexu 的回复:] num |= 0x00000004; 也就是num |= 0x4，对吗[/quote] 也可以！ 但是 用 移位作比较常见 (1<<3), 0x4也只是运算的结果而已

引用 2 楼 sdhexu 的回复:num |= 0x00000004; 也就是num |= 0x4，对吗

num |= 0x00000004;

num = num | (1<<3)


Question: png iDAT解码

楼主是否已经弄明白？请赐教！我也在这里卡住了

我也卡到这地方了，png-24的IDAT用zlib库中uncompress解压后，查看内存块始终不对！楼主你现在搞定了没，分享下经验呗！

jxchuan ,这是一种方法，只是我做的是程序解码，我要的不单单是解码结果

用现成的芯片厂商提供的比较好吧。

zlib开源的阿，你可以看看源码了解算法...

自己写解压缩算法，就可以得到各种位数RGB值数据了，并且可以进行各种处理。现在在网上都找不到对pNGIDAT块详细的说明，只知道其中可以选用LZ77和huffman算法，但是具体怎么压缩的，简直没方法理解了，望哪位高人指点一二（有这方面的资料也行）呀？像BMP，GIF，JPEG，我都解出来了，唯独这个PNG简直让我无从下手。

应该是可用zlib函数直接解压，自己写解压算法嘛这个我就不懂了...