strlen（）计算字符数组的字符数，以"\0"为结束判断，不计算为'\0'的数组元素。

    而sizeof计算数据（包括数组、变量、类型、结构体等）所占内存空间，用字节数表示。

    2.指针与静态数组(代表数组的变量)的sizeof操作

    指针均可看为变量类型的一种。所有指针变量的sizeof 操作结果均为4.

    注意：int *p； sizeof（p）=4；

    但sizeof（*p）相当于sizeof（int）；

    对于静态数组，sizeof可直接计算数组大小；

    例：int a[10]；char b[]="hello"；

    sizeof（a）等于4*10=40；

    sizeof（b）等于6；

    注意：数组名做型参时，数组名称只能当作指针使用！！

    void  fun（char p[]）

    {sizeof（p）等于4}

    经典问题：

    double* （*a）[3][6]；

    cout<<sizeof（a）<<endl； // 4 a为指针

    cout<<sizeof（*a）<<endl； // 72 *a为一个有3*6个指针元素的数组

    cout<<sizeof（**a）<<endl； // 24 **a为数组一维的6个指针

    cout<<sizeof（***a）<<endl； // 4 ***a为一维的第一个指针

    cout<<sizeof（****a）<<endl； // 8 ****a为一个double变量

    问题解析：a是一个很奇怪的定义，他表示一个指向维度为[3][6]元素为double * 数组的指针。既然是指针，所以sizeof（a）就是4.

         既然a是执行double*[3][6]类型的指针，*a就表示一个double*[3][6]的多维数组类型，因此sizeof（*a）=3*6*sizeof(double*)=72.同样的，double*[3][6]实际上可以看成一个指针,指向所代表数组的起始元素,由前可知,*a指向一个类型为double* [6]的数据,那么**a就表示一个double*[6]类型的数组，所以sizeof（**a）=6*sizeof  （double*）=24.***a就表示其中的一个元素，也就是double*了，所以sizeof（***a）=4.至于****a，就是一个double了，所以sizeof（****a）=sizeof（double）=8.

    3.格式的写法

    sizeof操作符，对变量或对象可以不加括号，但若是类型，须加括号。

    4.使用sizeof时string的注意事项

    string s="hello"；

    sizeof（s）等于string类的大小，sizeof（s.c_str（））得到的是与字符串长度。

    5.union 与struct的空间计算

    总体上遵循两个原则：

    （1）整体空间是 占用空间最大的成员（的类型）所占字节数的整倍数

    （2）数据对齐原则——内存按结构成员的先后顺序排列，当排到该成员变量时，其距离结构体起始的偏移量必须是该成员类型大小的整倍数，如果不够则补齐，以此向后类推……
             也就是说各成员变量存放的起始地址相对于结构体的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。
      (3)构成的新类型的对齐方式是空间最大的成员的对齐方式

      (4)注意：因为数组按照单个变量一个一个的摆放，所以就不是看成整体。他的对齐方式是她的元素对齐方式
      (5)如果成员中有自定义的类、结构体，也要注意数组问题。

    类型对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量） 
    Char 
    偏移量必须为sizeof(char)即1的倍数 
    int 
    偏移量必须为sizeof(int)即4的倍数 
    float 
    偏移量必须为sizeof(float)即4的倍数 
    double 
    偏移量必须为sizeof(double)即8的倍数 
    Short 
    偏移量必须为sizeof(short)即2的倍数 
    各成员变量在存放的时候根据在结构中出现的顺序依次申请空间，同时按照上面的对齐方式调整位置，空缺的字节会自动填充。同时为了确保结构的大小为结构的字节边界基数（即该结构中占用最大空间的类型所占用的字节数）的倍数，所以在为最后一个成员变量申请空间后，还会根据需要自动填充空缺的字节。

    因为对齐问题使结构体的sizeof变得比较复杂，看下面的例子：（默认对齐方式下）

struct s1 { char a; double b; int c; char d; }; struct s2 { char a; char b; int c; double d; }; cout<<sizeof(s1)<<endl; // 24 cout<<sizeof(s2)<<endl; // 16

    同样是两个char类型，一个int类型，一个double类型，但是因为对齐问题，导致他们的大小不同。计算结构体大小可以采用元素摆放法，我举例子说明一下：首先，CPU判断结构体的边界基数，根据上一节的结论，s1和s2的边界基数都取最大的元素类型，也就是double类型的sizeof(double)=8.然后开始摆放每个元素。

    对于s1，因为0是任何类型大小的倍数，所以都从0开始,先放一个sizeof(char)=1的a变量,此时下一个空闲的地址是1，但是下一个元素d是double类型，sizeof(double)=8 ，需要补足7个字节才能使距离结构开始偏移量变为8(满足对齐方式），因此自动填充7个字节，d存放在偏移量为8 的地址上，它占用8个字节。 此时下一个空闲地址变成了16，下一个元素c的大小是4，16可以满足，所以c放在了16，此时下一个空闲地址变成了20，下一个元素d大小是1，所以距离结构任何偏移量都满足，结构体在地址21处结束。由于s1的大小需要是边界基数8的倍数，所以21-23的空间被空白填上，s1的大小变成了24.

    对于s2，首先把a放到0处，此时下一个空闲地址是1，下一个元素的大小也是1，所以b摆放在1，下一个空闲地址变成了2；下一个元素c的大小是4，要取离最近的大于2并且是4倍数的位置来摆放c，就是4了,放下c后下一个空闲地址变成了8，下一个元素d的大小是8，所以d摆放在偏移量为8的地方，所有元素摆放完毕，结构体在16处结束，占用总空间为16，正好是8的倍数。

    这里有个陷阱，对于结构体中的结构体成员，不要认为它的对齐方式就是他的大小，看下面的例子：

struct s1 { char a[8]; }; struct s2 { double d; }; struct s3 { s1 s; char a; }; struct s4 { s2 s; char a; }; cout<<sizeof(s1)<<endl; // 8 cout<<sizeof(s2)<<endl; // 8 cout<<sizeof(s3)<<endl; // 9 cout<<sizeof(s4)<<endl; // 16;

        s1和s2大小虽然都是8，但最终导致了在s3和s4中才有占用空间大小的差异。这是因为他们的边界基数不一样所致.
        s3中占用空间最大的成员是s1,虽然他的大小为1,但他的对齐方式是1的倍数,这是因为s1是由一个数组构成,数组是他唯一在自然也是他最大的成员,所以数组的对齐方式就是s1的对齐方式,如前所述,数组的对齐方式是元素的对齐方式,所以综上所述,s1的对齐方式居然是数组元素的对齐方式.
        s4的边界基数由其占用最大的s2来决定的,s2的对齐方式自然是他唯一成员double所决定.所以s4的边界基数为8,大小就该是16.
       所以，在自己定义结构体的时候，如果空间紧张的话，最好考虑对齐因素来排列结构体里的元素,最好不要让double干扰你的位域.
       总结下,计算结构的大小,要考虑到这几个指标:一个结构的边界基数,二是成员的对齐方式,以及成员的大小:
占用空间最大的成员的对齐方式自然是结构的边界基数;
如果成员也是结构的话,那么对齐方式不是其大小,而是他的最大的成员的对齐方式,
如果成员是数组的话,那么对齐方式是元素的对齐方式.

    在结构体和类中，可以使用位域来规定某个成员所能占用的空间，所以使用位域能在一定程度上节省结构体占用的空间。不过考虑下面的代码：

struct s1 { 　int i: 8; 　int j: 4; 　double b; 　int a:3; }; struct s2 { 　int i; 　int j; 　double b; 　int a; }; struct s3 { 　int i; 　int j; 　int a; 　double b; }; struct s4 { 　int i: 8; 　int j: 4; 　int a:3; 　double b; }; cout<<sizeof(s1)<<endl; // 24 cout<<sizeof(s2)<<endl; // 24 cout<<sizeof(s3)<<endl; // 24 cout<<sizeof(s4)<<endl; // 16

    可以看到，有double存在会干涉到位域（sizeof的算法参考上一节），所以使用位域的的时候，最好把float类型和double类型放在程序的开始或者最后。

    相关常数：

    sizeof int：4

    sizeof short：2

    sizeof long：4

    sizeof float：4

    sizeof double：8

    sizeof char：1

    sizeof p：4

    sizeof WORD：2

    sizeof DWORD：4

方法一：在配置文件/etc/ld.so.conf中指定动态库搜索路径。

可以通过编辑配置文件/etc/ld.so.conf来指定动态库的搜索路径，该文件中每行为一个动态库搜索路径。每次编辑完该文件后，都必须运行命令ldconfig使修改后的配置生效。我们通过例1来说明该方法。

例1：

我们通过以下命令用源程序pos_conf.c（见程序1）来创建动态库 libpos.so

 (1)     # gcc -c pos_conf.c
          # gcc -shared -fPCI -o libpos.so pos_conf.o
         
           程序1: pos_conf.c程序1: pos_conf.c
           #include <stdio.h>
           void pos()
           {
                  printf("/root/test/conf/lib\n");
           }
          

 (2)    接着通过以下命令编译main.c（见程序2）生成目标程序pos。

         # gcc -o pos main.c -L. -lpos
           
         程序2: main.c 
         void pos();
          int main()
          {
               pos();
               return 0;
          }
         

(3)  然后把库文件移动到目录/root/test/conf/lib中。

           # mkdir -p /root/test/conf/lib
           # mv libpos.so /root/test/conf/lib
           

 (4)  最后编辑配置文件/etc/ld.so.conf，在该文件中追加一行"/root/test/conf/lib"。

     运行程序pos试试。

           # ./pos
           ./pos: error while loading shared libraries: libpos.so: cannot open shared object file: No such file or directory
           
        出错了，系统未找到动态库libpos.so。找找原因，原来在编辑完配置文件/etc/ld.so.conf后，没有运行命令ldconfig，所以刚才的修改还未生效。我们运行ldconfig后再试试。

           # ldconfig
           # ./pos
             /root/test/conf/lib 
           

        程序pos运行成功，并且打印出正确结果。

 方法二：通过环境变量LD_LIBRARY_PATH指定动态库搜索路径。

      通过设定环境变量LD_LIBRARY_PATH也可以指定动态库搜索路径。当通过该环境变量指定多个动态库搜索路径时，路径之间用冒号"："分隔。下面通过例2来说明本方法。

例2： 我们通过以下命令用源程序pos_env.c（见程序3）来创建动态库libpos.so。

           # gcc -c pos_env.c
           # gcc -shared -fPCI -o libpos.so pos_env.o
           
           程序3: pos_env.c 
           #include <stdio.h>
          void pos()
          {
                printf("/root/test/env/lib\n");
          }
          测试用的可执行文件pos可以使用例1中的得到的目标程序pos，不需要再次编译,链接。因为pos_conf.c中的函数pos和pos_env.c中的函数pos 函数原型一致，且动态库名相同，只是运行时搜索路径发生了变化.
          这就好比修改动态库pos后重新创建该库一样。这也是使用动态库的优点之一。

         然后把动态库libpos.so移动到目录/root/test/conf/lib中。

           # mkdir -p /root/test/env/lib
           # mv libpos.so /root/test/env/lib
           

          我们可以使用export来设置该环境变量，在设置该环境变量后所有的命令中，该环境变量都有效。

          例如： # export LD_LIBRARY_PATH=/root/test/env/lib
          

           但本文为了举例方便，使用另一种设置环境变量的方法，既在命令前加环境变量设置，该环境变量只对该命令有效，当该命令执行完成后，该环境变量就无效了。如下述命令：

            # LD_LIBRARY_PATH=/root/test/env/lib 
            #./pos
              /root/test/env/lib
           程序pos运行成功，并且打印的结果是"/root/test/env/lib"，正是程序pos_env.c中的函数pos的运行结果。因此程序pos搜索到的动态库是/root/test/env/lib/libpos.so。

 方法三：在编译目标代码时指定该程序的动态库搜索路径。

           还可以在编译目标代码时指定程序的动态库搜索路径。这是通过gcc 的参数"-Wl,-rpath,"指定（如例3所示）。当指定多个动态库搜索路径时，路径之间用冒号"："分隔。

例3： 我们通过以下命令用源程序pos.c（见程序4）来创建动态库libpos.so。

           # gcc -c pos.c
           # gcc -shared -fPCI -o libpos.so pos.o
            
          程序4: pos.c 
          #include <stdio.h>
          void pos()
          {
                printf("./\n");
          }
        

      因为我们需要在编译目标代码时指定可执行文件的动态库搜索路径，所以需要用gcc命令重新编译源程序main.c(见程序2)来生成可执行文件pos。

     # gcc -o pos main.c -L. -lpos -Wl,-rpath,./
      注意了哈,-L -l 指定的链接路径,-Wl,-rpath,./是运行时被导入库的搜索路径,对于使用动态链接来说,搜索路径作用远大于链接路径.一般来说,链接用来指定只有函数声明的头文件,用来检查语法错误,搜索则是指定了运行时要使用的实现.

     再运行程序pos试试。

     # ./pos
        ./

    程序pos运行成功，输出的结果正是pos.c中的函数pos的运行结果。说明程序pos搜索到的动态库是./libpos.so。

    以上介绍了三种指定动态库搜索路径的方法，加上默认的动态库搜索路径/lib和/usr/lib，共五种动态库的搜索路径，那么它们搜索的先后顺序是什么呢？

     在介绍上述三种方法时，分别创建了动态库./libpos.so、 /root/test/env/lib/libpos.so和/root/test/conf/lib/libpos.so。我们再用源程序 pos_lib.c（见程序5）来创建动态库/lib/libpos.so，用源程序pos_usrlib.c（见程序6）来创建动态库 /usr/lib/libpos.so。

           
          程序5: pos_lib.c
          #include <stdio.h>
           void pos()
           {
                   printf("/lib\n");
           }
          
          程序6: pos_usrlib.c
          #include <stdio.h>
          void pos()
          {
                 printf("/usr/lib\n");
          }
          

        这样我们得到五个动态库libpos.so，这些动态库的名字相同，且都包含相同函数原型的公用函数pos。但存储的位置不同和公用函数pos 打印的结果不同。每个动态库中的公用函数pos都输出该动态库所存放的位置。这样我们可以通过执行例3中的可执行文件pos得到的结果不同获知其搜索到了 哪个动态库，从而获得第1个动态库搜索顺序，然后删除该动态库，再执行程序pos，获得第2个动态库搜索路径，再删除第2个被搜索到的动态库，如此往复， 将可得到Linux搜索动态库的先后顺序。程序pos执行的输出结果和搜索到的动态库的对应关系如表1所示：

程序pos输出结果
使用的动态库
对应的动态库搜索路径指定方式

./
./libpos.so
编译目标代码时指定的动态库搜索路径

/root/test/env/lib
/root/test/env/lib/libpos.so
环境变量LD_LIBRARY_PATH指定的动态库搜索路径

/root/test/conf/lib
/root/test/conf/lib/libpos.so
配置文件/etc/ld.so.conf中指定的动态库搜索路径

/lib
/lib/libpos.so
默认的动态库搜索路径/lib

/usr/lib
/usr/lib/libpos.so
默认的动态库搜索路径/usr/lib

表1: 程序pos输出结果和动态库的对应关系

       创建各个动态库，并放置在相应的目录中。测试环境就准备好了。执行程序pos，并在该命令行中设置环境变量LD_LIBRARY_PATH。

          # LD_LIBRARY_PATH=/root/test/env/lib 
          # gcc -o pos main.c -L. -lpos -Wl,-rpath,./
          #./pos
           ./
           
         根据程序pos的输出结果可知，最先搜索的是编译目标代码时指定的动态库搜索路径。

          然后我们把动态库./libpos.so删除了，再运行上述命令试试。

          # rm libpos.so
          rm: remove regular file `libpos.so'? y
          # LD_LIBRARY_PATH=/root/test/env/lib 
          # gcc -o pos main.c -L. -lpos -Wl,-rpath,./
           #./pos
          /root/test/env/lib
          

         根据程序pos的输出结果可知，第2个动态库搜索的路径是环境变量LD_LIBRARY_PATH指定的。

          我们再把/root/test/env/lib/libpos.so删除，运行上述命令。

          # rm /root/test/env/lib/libpos.so
          rm: remove regular file `/root/test/env/lib/libpos.so'? y
          # LD_LIBRARY_PATH=/root/test/env/lib 
         # gcc -o pos main.c -L. -lpos -Wl,-rpath,./
          #./pos
          /root/test/conf/lib
          

         根据程序pos的输出结果可知,第3个动态库的搜索路径是配置文件/etc/ld.so.conf指定的路径。

          删除动态库/root/test/conf/lib/libpos.so后再运行上述命令。

           # rm /root/test/conf/lib/libpos.so
          rm: remove regular file `/root/test/conf/lib/libpos.so'? y
          # LD_LIBRARY_PATH=/root/test/env/lib
          # gcc -o pos main.c -L. -lpos -Wl,-rpath,./
          #./pos
          /lib
         

         根据程序pos的输出结果可知,第4个动态库的搜索路径是默认搜索路径/lib。

         我们再删除动态库/lib/libpos.so，运行上述命令。

          # rm /lib/libpos.so
          rm: remove regular file `/lib/libpos.so'? y
          # LD_LIBRARY_PATH=/root/test/env/lib 
         # gcc -o pos main.c -L. -lpos -Wl,-rpath,./
         #./pos
          /usr/lib

        最后的动态库搜索路径是默认搜索路径/usr/lib。

综合以上结果可知，动态库的搜索路径搜索的先后顺序是：

1.编译目标代码时指定的动态库搜索路径；

2.环境变量LD_LIBRARY_PATH指定的动态库搜索路径；

3.配置文件/etc/ld.so.conf中指定的动态库搜索路径；

4.默认的动态库搜索路径/lib;

5.默认的动态库搜索路径/usr/lib。

在上述1、2、3指定动态库搜索路径时，都可指定多个动态库搜索路径，其搜索的先后顺序是按指定路径的先后顺序搜索的。

　　冤魂 Z 之所以杀不死，是因为它已经死了，否则怎么叫 Zombie（僵尸）呢？冤魂不散，自然是生前有结未解之故。在UNIX/Linux中，每个进程都有一个父进程，进程号叫PID（Process ID），相应地，父进程号就叫PPID（Parent PID）。当进程死亡时，它会自动关闭已打开的文件，舍弃已占用的内存、交换空间等等系统资源，然后向其父进程返回一个退出状态值，报告死讯。如果程序有 bug，就会在这最后一步出问题。儿子说我死了，老子却没听见，没有及时收棺入殓，儿子便成了僵尸。在UNIX/Linux中消灭僵尸的手段比较残忍，执行 ps axjf 找出僵尸进程的父进程号（PPID，第一列），先杀其父，然后再由进程天子 init（其PID为1，PPID为0）来一起收拾父子僵尸，超度亡魂，往生极乐。注意，子进程变成僵尸只是碍眼而已，并不碍事，如果僵尸的父进程当前有要务在身，则千万不可贸然杀之。

#include <sys/types.h> /* 提供类型pid_t的定义 */

            #include <sys/wait.h>

            pid_t wait(int *status)

            

		pid = wait(NULL);

            

下面就让我们用一个例子来实战应用一下wait调用：

             /* wait1.c */

             #include <sys/types.h>

             #include <sys/wait.h>

             #include <unistd.h>

             #include <stdlib.h>

              main()

              {

                  pid_t pc,pr;

                  pc=fork();

                  if(pc<0)   /* 如果出错 */

                     printf("error ocurred!\n");

                  else if(pc==0){  /* 如果是子进程 */ 

                   printf("This is child process with pid of %d\n",getpid());

                   sleep(10); /* 睡眠10秒钟 */

                  }

                  else{   /* 如果是父进程 */

                   pr=wait(NULL); /* 在这里等待 */

                   printf("I catched a child process with pid of %d\n"),pr);

                  }  

                  exit(0);

              }

编译并运行:

$ cc wait1.c -o wait1

            $ ./wait1

            This is child process with pid of 1508

            I catched a child process with pid of 1508

            

参数status：

如果参数status的值不是NULL，wait就会把子进程退出时的状态取出并存入其中，这是一个整数值（int），指出了子进程是正常退出还是被非正常结束的（一个进程也可以被其他进程用信号结束，我们将在以后的文章中介绍），以及正常结束时的返回值，或被哪一个信号结束的等信息。由于这些信息被存放在一个整数的不同二进制位中，所以用常规的方法读取会非常麻烦，人们就设计了一套专门的宏（macro）来完成这项工作，下面我们来学习一下其中最常用的两个：

1，WIFEXITED(status) 这个宏用来指出子进程是否为正常退出的，如果是，它会返回一个非零值。

（请注意，虽然名字一样，这里的参数status并不同于wait唯一的参数--指向整数的指针status，而是那个指针所指向的整数，切记不要搞混了。）

2， WEXITSTATUS(status) 当WIFEXITED返回非零值时，我们可以用这个宏来提取子进程的返回值，如果子进程调用exit(5)退出，WEXITSTATUS(status) 就会返回5；如果子进程调用exit(7)，WEXITSTATUS(status)就会返回7。请注意，如果进程不是正常退出的，也就是说， WIFEXITED返回0，这个值就毫无意义。

下面通过例子来实战一下我们刚刚学到的内容：

            /* wait2.c */

            #include <sys/types.h>

            #include <sys/wait.h>

            #include <unistd.h>

            main()

            {

             int status;

             pid_t pc,pr;

             pc=fork();

              if(pc<0) /* 如果出错 */

                 printf("error ocurred!\n");

             else if(pc==0){ /* 子进程 */

              printf("This is child process with pid of %d.\n",getpid());

              exit(3); /* 子进程返回3 */

             }

             else{  /* 父进程 */

              pr=wait(&status);

                if(WIFEXITED(status)){ /* 如果WIFEXITED返回非零值 */

              printf("the child process %d exit normally.\n",pr);

              printf("the return code is %d.\n",WEXITSTATUS(status));

              }else   /* 如果WIFEXITED返回零 */

              printf("the child process %d exit abnormally.\n",pr);

              }

            }
            

$ cc wait2.c -o wait2

            $ ./wait2

            This is child process with pid of 1538.

            the child process 1538 exit normally.

            the return code is 3.          

当然，处理进程退出状态的宏并不止这两个，但它们当中的绝大部分在平时的编程中很少用到，就也不在这里浪费篇幅介绍了，有兴趣的读者可以自己参阅Linux man pages去了解它们的用法。

进程同步：

有时候，父进程要求子进程的运算结果进行下一步的运算，或者子进程的功能是为父进程提供了下一步执行的先决条件（如：子进程建立文件，而父进程写入数据），此时父进程就必须在某一个位置停下来，等待子进程运行结束，而如果父进程不等待而直接执行下去的话，可以想见，会出现极大的混乱。这种情况称为进程之间的同步，更准确地说，这是进程同步的一种特例。进程同步就是要协调好2个以上的进程，使之以安排好地次序依次执行。解决进程同步问题有更通用的方法，我们将在以后介绍，但对于我们假设的这种情况，则完全可以用wait系统调用简单的予以解决。请看下面这段程序：

            #include <sys/types.h>

            #include <sys/wait.h>

            main()

            {

              pid_t pc, pr;

              int status;

              

              pc=fork();

              

              if(pc<0)

                 printf("Error occured on forking.\n");

              else if(pc==0){

                /* 子进程的工作 */

                exit(0);

              }else{

               /* 父进程的工作 */

               pr=wait(&status);

               /* 利用子进程的结果 */

              }

            }

            

            

#include <sys/types.h> /* 提供类型pid_t的定义 */

            #include <sys/wait.h>

            pid_t waitpid(pid_t pid,int *status,int options)

            

pid

从参数的名字pid和类型pid_t中就可以看出，这里需要的是一个进程ID。但当pid取不同的值时，在这里有不同的意义。

1. pid>0时，只等待进程ID等于pid的子进程，不管其它已经有多少子进程运行结束退出了，只要指定的子进程还没有结束，waitpid就会一直等下去。
2. pid=-1时，等待任何一个子进程退出，没有任何限制，此时waitpid和wait的作用一模一样。
3. pid=0时，等待同一个进程组中的任何子进程，如果子进程已经加入了别的进程组，waitpid不会对它做任何理睬。
4. pid<-1时，等待一个指定进程组中的任何子进程，这个进程组的ID等于pid的绝对值。

options

options提供了一些额外的选项来控制waitpid，目前在Linux中只支持WNOHANG和WUNTRACED两个选项，这是两个常数，可以用"|"运算符把它们连接起来使用，比如：

ret=waitpid(-1,NULL,WNOHANG | WUNTRACED);

            

ret=waitpid(-1,NULL,0);

            

而WUNTRACED参数，由于涉及到一些跟踪调试方面的知识，加之极少用到，这里就不多费笔墨了，有兴趣的读者可以自行查阅相关材料。

    wait不就是经过包装的waitpid吗？没错，察看<内核源码目录>/include/unistd.h文件349-352行就会发现以下程序段：

static inline pid_t wait(int * wait_stat)

            {

            return waitpid(-1,wait_stat,0);

            }            

1.9.2 返回值和错误

waitpid的返回值比wait稍微复杂一些，一共有3种情况：

1. 当正常返回的时候，waitpid返回收集到的子进程的进程ID；
2. 如果设置了选项WNOHANG，而调用中waitpid发现没有已退出的子进程可收集，则返回0；
3. 如果调用中出错，则返回-1，这时errno会被设置成相应的值以指示错误所在；

当pid所指示的子进程不存在，或此进程存在，但不是调用进程的子进程，waitpid就会出错返回，这时errno被设置为ECHILD；

            #include <sys/types.h>

            #include <sys/wait.h>

            #include <unistd.h>

            main()

            {

                pid_t pc, pr;

                

                pc=fork();

                if(pc<0)  /* 如果fork出错 */

                printf("Error occured on forking.\n");

                else if(pc==0)

                {  /* 如果是子进程 */

                sleep(4); /* 睡眠4秒 */

                exit(0);

                }

                /* 如果是父进程 */

                do

                {

                pr=waitpid(pc, NULL, WNOHANG); /* 使用了WNOHANG参数，waitpid不会在这里等待 */

                 if(pr==0)

                 {   /* 如果没有收集到子进程 */

                  printf("No child exited\n");

                  sleep(1);

                 }

                }while(pr==0);    /* 没有收集到子进程，就回去继续尝试 */

                if(pr==pc)

                 printf("successfully release child %d\n", pr);

                else

                 printf("some error occured\n");

            }

编译并运行：

$ cc waitpid.c -o waitpid

            $ ./waitpid

            No child exited

            No child exited

            No child exited

            No child exited

            successfully release child 1526

            

父进程经过4次失败的尝试之后，终于收集到了退出的子进程。

因为这只是一个例子程序，不便写得太复杂，所以我们就让父进程和子进程分别睡眠了4秒钟和1秒钟，代表它们分别作了4秒钟和1秒钟的工作。父子进程都有工作要做，父进程利用工作的简短间歇察看子进程的是否退出，如退出就收集它.这样的话,既不影响父进程的工作,也可以消除僵尸进程.

最后 不管是 wait 还是waitpid函数都有个参数来反映子进程的结束状态,底下有几个宏可判别结束情况,参数当然是指针指向的那个：
WIFEXITED（status）如果子进程正常结束则为非0 值。
WEXITSTATUS（status）取得子进程exit（）返回的结束代码，一
般会先用WIFEXITED 来判断是否正常结束才能使用此宏。
WIFSIGNALED（status）如果子进程是因为信号而结束则此宏值为
真
WTERMSIG（status） 取得子进程因信号而中止的信号代码，一般
会先用WIFSIGNALED 来判断后才使用此宏。
WIFSTOPPED（status） 如果子进程处于暂停执行情况则此宏值为
真。一般只有使用WUNTRACED 时才会有此情况。
WSTOPSIG（status） 取得引发子进程暂停的信号代码，一般会先
用WIFSTOPPED 来判断后才使用此宏。
返回值
如果执行成功则返回子进程识别码（PID），如果有错误发生则返回
-1。失败原因存于errno 中。

 

2.       const 修饰类的数据成员。如：
class A

{

    const int size;

    …

}

const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类声明中初始化const数据成员，因为类的对象未被创建时，编译器不知道const 数据成员的值是什么。如

class A

{

 const int size = 100;    //错误

 int array[size];         //错误，未知的size

}

const数据成员的初始化只能在类的构造函数的初始化表中进行。要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现。如

class A

{…

 enum {size1=100, size2 = 200 };

int array1[size1];

int array2[size2];

}

枚举常量不会占用对象的存储空间，他们在编译时被全部求值。但是枚举常量的隐含数据类型是整数，其最大值有限，且不能表示浮点数。

3.       const修饰指针的情况，见下式：

int b = 500;
const int* a = &b          [1]
int const *a = &b           [2]
int* const a = &b           [3]
const int* const a = &b     [4] 

    我们可以参考《Effective c++》Item21上的做法，如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。因此，[1]和[2]的情况相同，都是指针所指向的内容为常量（const放在变量声明符的位置无关），这种情况下不允许对内容进行更改操作，如不能*a = 3 ；[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；[4]为指针本身和指向的内容均为常量。

4.     const的初始化

先看一下const变量初始化的情况
1) 非指针const常量初始化的情况：A b;
const A a = b;

2) 指针const常量初始化的情况：

A* d = new A();
const A* c = d;
或者：const A* c = new A();
3）引用const常量初始化的情况：
A f;
const A& e = f;      // 这样作e只能访问声明为const的函数，而不能访问一           

般的成员函数；

    [思考1]：以下的这种赋值方法正确吗？
    const A* c=new A();
    A* e = c;
    [思考2]：以下的这种赋值方法正确吗？
    A* const c = new A();
    A* b = c;

5.     另外const 的一些强大的功能在于它在函数声明中的应用。在一个函数声明中，const 可以修饰函数的返回值，或某个参数；对于成员函数，还可以修饰是整个函数。有如下几种情况，以下会逐渐的说明用法：
A& operator=(const A& a);
void fun0(const A* a );
void fun1( ) const; // fun1( ) 为类成员函数
const A fun2( );
1）修饰参数的const，如 void fun0(const A* a ); void fun1(const A& a);
调用函数的时候，用相应的变量初始化const常量，则在函数体中，按照const所修饰的部分进行常量化，如形参为const A* a，则不能对传递进来的指针的内容进行改变，保护了原指针所指向的内容；如形参为const A& a，则不能对传递进来的引用对象进行改变，保护了原对象的属性。
[注意]：参数const通常用于参数为指针或引用的情况，且只能修饰输入参数;若输入参数采用“值传递”方式，由于函数将自动产生临时变量用于复制该参数，该参数本就不需要保护，所以没有必要用const修饰。
[总结]对于非内部数据类型的输入参数，因该将“值传递”的方式改为“const引用传递”，目的是为了提高效率。例如，将void Func(A a)改为void Func(const A &a)
      对于内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x)不应该改为void Func(const int &x)
2） 修饰返回值的const，如const A fun2( ); const A* fun3( );
这样声明了返回值后，const按照"修饰原则"进行修饰，起到相应的保护作用。
const Rational operator*(const Rational& lhs, const Rational& rhs)
{
return Rational(lhs.numerator() * rhs.numerator(),
                      lhs.denominator() * rhs.denominator());
}

返回值用const修饰可以防止允许这样的操作发生:Rational a,b;
Radional c;
(a*b) = c;

一般用const修饰返回值为对象本身（非引用和指针）的情况多用于二目操作符重载函数并产生新对象的时候。
[总结]
1.     一般情况下，函数的返回值为某个对象时，如果将其声明为const时，多用于操作符的重载。通常，不建议用const修饰函数的返回值类型为某个对象或对某个对象引用的情况。原因如下：如果返回值为某个对象为const（const A test = A 实例）或某个对象的引用为const（const A& test = A实例），则返回值具有const属性，则返回实例只能被访问到类A中的公有（保护）数据成员和const成员函数，并且不允许对其进行赋值操作，这在一般情况下很少用到。
2.       如果给采用“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。如：

const char * GetString(void);

如下语句将出现编译错误：

char *str=GetString();

正确的用法是：
const char *str=GetString();

6.     类成员函数中const的使用
一般放在函数体后，形如：void fun() const;
任何不会修改数据成员的函数都因该声明为const类型。如果在编写const成员函数时，不慎修改了数据成员，或者调用了其他非const成员函数，编译器将报错，这大大提高了程序的健壮性。如：

class Stack

{

 public:

      void Push(int elem);

      int Pop(void);

      int GetCount(void) const;   //const 成员函数

 private:

      int m_num;

      int m_data[100];

};

int Stack::GetCount(void) const

{

 ++m_num;              //编译错误，企图修改数据成员m_num

 Pop();                    //编译错误，企图调用非const函数

 Return m_num;

}

7.       使用const的一些建议

1 要大胆的使用const，这将给你带来无尽的益处，但前提是你必须搞清楚原委；
2 要避免最一般的赋值操作错误，如将const变量赋值，具体可见思考题；
3 在参数中使用const应该使用引用或指针，而不是一般的对象实例，原因同上；
4 const在成员函数中的三种用法（参数、返回值、函数）要很好的使用；
5 不要轻易的将函数的返回值类型定为const;
6除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;

[思考题答案]
1 这种方法不正确，因为声明指针的目的是为了对其指向的内容进行改变，而声明的指针e指向的是一个常量，所以不正确；
2 这种方法正确，因为声明指针所指向的内容可变；

1.       静态函数会被自动分配在一个一直使用的存储区，直到退出应用程序实例，避免了调用函数时压栈出栈，速度快很多。
2.       关键字“static”，译成中文就是“静态的”，所以内部函数又称静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件。 使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名，因为同名也没有关系。

c语言中static的语义
1.static变量:
  1).局部
     a.静态局部变量在函数内定义,生存期为整个源程序，但作用域与自动变量相同，只能在定义该变量的函数内使用。退出该函数后， 尽管该变量还继续存在，但不能使用它。
     b.对基本类型的静态局部变量若在说明时未赋以初值，则系统自动赋予0值。而对自动变量不赋初值，则其值是不定的。
  2).全局
    全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。但是他们的作用域，非静态全局 变量的作用域是整个源程序（多个源文件可以共同使用）； 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。
2.static函数（也叫内部函数）
   只能被本文件中的函数调用，而不能被同一程序其它文件中的函数调用。区别于一般的非静态函数（外部函数）
    static在c里面可以用来修饰变量，也可以用来修饰函数。
         先看用来修饰变量的时候。变量在c里面可分为存在全局数据区、栈和堆里。其实我们平时所说的堆栈是栈而不包含对，不要弄混。
        int a ;
        main()
        {
             int b ;
             int c* = (int *)malloc(sizeof(int));
        }
        a是全局变量，b是栈变量，c是堆变量。
        static对全局变量的修饰，可以认为是限制了只能是本文件引用此变量。有的程序是由好多.c文件构成。彼此可以互相引用变量，但加入static修饰之后，只能被本文件中函数引用此变量。
        static对栈变量的修饰，可以认为栈变量的生命周期延长到程序执行结束时。一般来说，栈变量的生命周期由OS管理，在退栈的过程中，栈变量的生命也就结束了。但加入static修饰之后，变量已经不在存储在栈中，而是和全局变量一起存储。同时，离开定义它的函数后不能使用，但如再次调用定义它的函数时，它又可继续使用， 而且保存了前次被调用后留下的值。
       static对函数的修饰与对全局变量的修饰相似，只能被本文件中的函数调用，而不能被同一程序其它文件中的函数调用。 
      static 声明的变量在C语言中有两方面的特征：
　　1)、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。 
　　2)、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。

　　问题：Static的理解

　　关于static变量，请选择下面所有说法正确的内容：

　　A、若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度；

　　B、若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度；

　　C、设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题；

　　D、静态全局变量过大，可那会导致堆栈溢出。

　　答案与分析：

　　对于A，B：根据本篇概述部分的说明b)，我们知道，A,B都是正确的。

　　对于C：根据本篇概述部分的说明a)，我们知道，C是正确的（所谓的函数重入问题，下面会详细阐述）。

　　对于D：静态变量放在程序的全局数据区，而不是在堆栈中分配，所以不可能导致堆栈溢出，D是错误的。

　　因此，答案是A、B、C。

　　前面有个问题是何为不可重入函数,下面有个这样的问题

　　曾经设计过如下一个函数，在代码检视的时候被提醒有bug，因为这个函数是不可重入的，为什么？

unsigned int sum_int( unsigned int base )
{
　unsigned int index;
　static unsigned int sum = 0; // 注意，是static类型的。
　for (index = 1; index <= base; index++)
　{
　　sum += index;
　}
　return sum;
}

　　答案与分析：

　　所谓的函数是可重入的（也可以说是可预测的），即：只要输入数据相同就应产生相同的输出。
　　这个函数之所以是不可预测的，就是因为函数中使用了static变量，因为static变量的特征，这样的函数被称为：带“内部存储器”功能的的函数。因此如果我们需要一个可重入的函数，那么，我们一定要避免函数中使用static变量，这种函数中的static变量，使用原则是，能不用尽量不用。
　　将上面的函数修改为可重入的函数很简单，只要将声明sum变量中的static关键字去掉，变量sum即变为一个auto 类型的变量，函数即变为一个可重入的函数。
　　当然，有些时候，在函数中是必须要使用static变量的，比如当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，创建的就会保存在栈里面,函数调用一结束,就马上回收,则返回指针就是野指针了。