C++-杂记

0. 静态，动态转换

statci_cast 一般用于同一类型的转化，可以不是指针和引用： 如：pKernel = static_cast<DynamicKernel*>(xGroup->mpCompiledFormula);，这里 xGroup->mpCompiledFormula就是DynamicKernel类型。  const formula::DoubleVectorRefToken* pDVR =

        static_cast< const formula::DoubleVectorRefToken* >(

                ft->GetFormulaToken()); 也是、、、

 

dynamic_cast 用于继承关系的转化，如：dynamic_cast<Reduction*>(pCodeGen.get())，这个是判断这个操作符号是不是真正的Reduction类型的（因为运行的时候操作符有可能不是Reduction类型的），如果不是这返回NULL，运行时候判断，但是如果用static_cast的话，永远返回True.得不到判断。

 

 

1.（C++）explicit 关键字修饰的单参数构造函数，意识是不能隐身转换调用，比如 类A 有个构造函数 explicit A(int a);  A obja = a;就会失败，

 

2. （C++)const和引用成员变量 只能用初始化列表初始化。

 

3. (C++)

• const在函数前与函数后的区别

• 一   const基础   
      
    如果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]的情况相同，都是指针所指向的内容为常量，这种情况下不允许对内容进行更改操 作，如不能*a   =   3   ；[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；[4]为指针本身和指向的内容均为常 量。   
    另外const   的一些强大的功能在于它在函数声明中的应用。在一个函数声明中，const   可以修饰函数的返回值，或某个参数；对于成员函数，还可以修饰是整个函数。有如下几种情况，以下会逐渐的说明用法：a&   operator=(const   a&   a);   
    void   fun0(const   a*   a   );   
    void   fun1(   )   const;   //   fun1(   )   为类成员函数   
    const   a   fun2(   );   
      
    二   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();   
    引用：   
      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;   
      
    三   作为参数和返回值的const修饰符   
      
    其实，不论是参数还是返回值，道理都是一样的，参数传入时候和函数返回的时候，初始化const变量   
    1   修饰参数的const，如   void   fun0(const   a*   a   );   void   fun1(const   a&   a);   
    调用函数的时候，用相应的变量初始化const常量，则在函数体中，按照const所修饰的部分进行常量化，如形参为const   a*   a，则不能对传递进来的指针的内容进行改变，保护了原指针所指向的内容；如形参为const   a&   a，则不能对传递进来的引用对象进行改变，保护了原对象的属性。   
    [注意]：参数const通常用于参数为指针或引用的情况;   
    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修饰返回值为对象本身的情况多用于二目操作符重载函数并产生新对象的时候。   
    [总结]   一般情况下，函数的返回值为某个对象时，如果将其声明为const时，多用于操作符的重载。通常，不建议用const修饰函数的返回值类型为某个对象或对 某个对象引用的情况。   
    原因如下：   
    如果返回值为某个对象为const或某个对象的引用为const   ，则返回值具有const属性，则返回实例只能访问类a中的公有数据成员和const成员函数，并且不允许对其进行赋值操作，这在一般情况下很少用 到。   
      
    [思考3]：   这样定义赋值操作符重载函数可以吗？   
    const   a&   operator=(const   a&   a);   
      
    四   类成员函数中const的使用   
      
    一般放在函数体后，形如：void   fun()   const;   
    如果一个成员函数的不会修改数据成员，那么最好将其声明为const，因为const成员函数中不允许对数据成员进行修改，如果修改，编译器将报错，这大 大提高了程序的健壮性。   
    五   使用const的一些建议   
      
    1   要大胆的使用const，这将给你带来无尽的益处，但前提是你必须搞清楚原委；   
    2   要避免最一般的赋值操作错误，如将const变量赋值，具体可见思考题；   
    3   在参数中使用const应该使用引用或指针，而不是一般的对象实例，原因同上；   
    4   const在成员函数中的三种用法要很好的使用；   
    5   不要轻易的将函数的返回值类型定为const;   
    6   除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;  

  4.Overload(重载)：在C++程序中，可以将语义、功能相似的几个函数用同一个名字表示，但参数或返回值不同（包括类型、顺序不同），即函数重载。

  （1）相同的范围（在同一个类中）；
  （2）函数名字相同；
  （3）参数不同；
  （4）virtual 关键字可有可无。

  Override(覆盖)：是指派生类函数覆盖基类函数，特征是：
  （1）不同的范围（分别位于派生类与基类）；
  （2）函数名字相同；
  （3）参数相同；
  （4）基类函数必须有virtual 关键字。

  Overwrite(重写)：是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
  （1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual
  关键字，基类的函数将被隐藏（注意别与重载混淆）。
  （2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual
  关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

  特别注意

  如果基类有某个函数的多个重载（overload）版本，而你在子类中重写(overwrite)了其中的一个，或是子类添加新的函数版本，则所有基类的重载版本都被遮蔽。所以，正常情况下，在子类中应重写基类中的所有重载版本。

  具体地讲，继承类中的重载和重写都包含了重写的涵义，即只要函数名一样，基类的函数版本就会被遮蔽，所以，在派生类中要保持基类的重载版本，就应该重写所有基类的重载版本。重载只在当当前类中有效，继承会失去重载的特性。也就是说，把基类的重载函数放在继承类里，就必须重写。

   

   

   

  整型溢出有点老生常谈了，bla, bla, bla… 但似乎没有引起多少人的重视。整型溢出会有可能导致缓冲区溢出，缓冲区溢出会导致各种黑客攻击，比如最近OpenSSL的heartbleed事件，就是一个buffer overread的事件。在这里写下这篇文章，希望大家都了解一下整型溢出，编译器的行为，以及如何防范，以写出更安全的代码。

  什么是整型溢出

  C语言的整型问题相信大家并不陌生了。对于整型溢出，分为无符号整型溢出和有符号整型溢出。

  对于unsigned整型溢出，C的规范是有定义的——“溢出后的数会以2^(8*sizeof(type))作模运算”，也就是说，如果一个unsigned char（1字符，8bits）溢出了，会把溢出的值与256求模。例如：

  unsigned char x = 0xff;
  printf("%d\n", ++x);

  上面的代码会输出：0 （因为0xff + 1是256，与2^8求模后就是0）

  对于signed整型的溢出，C的规范定义是“undefined behavior”，也就是说，编译器爱怎么实现就怎么实现。对于大多数编译器来说，算得啥就是啥。比如：

  signed char x =0x7f; //注：0xff就是-1了，因为最高位是1也就是负数了
  printf("%d\n", ++x);

  上面的代码会输出：-128，因为0x7f + 0×01得到0×80，也就是二进制的1000 0000，符号位为1，负数，后面为全0，就是负的最小数，即-128。

   

  另外，千万别以为signed整型溢出就是负数，这个是不定的。比如：

  signed char x = 0x7f;
  signed char y = 0x05;
  signed char r = x * y;
  printf("%d\n", r);

  上面的代码会输出：123

  相信对于这些大家不会陌生了。

  整型溢出的危害

  下面说一下，整型溢出的危害。

  示例一：整形溢出导致死循环

   ... ...
  ... ...
  short len = 0;
  ... ...
  while(len< MAX_LEN) {
      len += readFromInput(fd, buf);
      buf += len;
  }

  上面这段代码可能是很多程序员都喜欢写的代码（我在很多代码里看到过多次），其中的MAX_LEN 可能会是个比较大的整型，比如32767，我们知道short是16bits，取值范围是-32768 到 32767 之间。但是，上面的while循环代码有可能会造成整型溢出，而len又是个有符号的整型，所以可能会成负数，导致不断地死循环。

  示例二：整形转型时的溢出

  int copy_something(char *buf, int len)
  {
      #define MAX_LEN 256
      char mybuf[MAX_LEN];
       ... ...
       ... ...
  
       if(len > MAX_LEN){ // <---- [1]
           return -1;
       }
  
       return memcpy(mybuf, buf, len);
  }

  上面这个例子中，还是[1]处的if语句，看上去没有会问题，但是len是个signed int，而memcpy则需一个size_t的len，也就是一个unsigned 类型。于是，len会被提升为unsigned，此时，如果我们给len传一个负数，会通过了if的检查，但在memcpy里会被提升为一个正数，于是我们的mybuf就是overflow了。这个会导致mybuf缓冲区后面的数据被重写。

  示例三：分配内存

  关于整数溢出导致堆溢出的很典型的例子是，OpenSSH Challenge-Response SKEY/BSD_AUTH 远程缓冲区溢出漏洞。下面这段有问题的代码摘自OpenSSH的代码中的auth2-chall.c中的input_userauth_info_response() 函数:

  nresp = packet_get_int();
  if (nresp > 0) {
      response = xmalloc(nresp*sizeof(char*));
      for (i = 0; i < nresp; i++)
          response[i] = packet_get_string(NULL);
  }

  上面这个代码中，nresp是size_t类型（size_t一般就是unsigned int/long int），这个示例是一个解数据包的示例，一般来说，数据包中都会有一个len，然后后面是data。如果我们精心准备一个len，比如：1073741825（在32位系统上，指针占4个字节，unsigned int的最大值是0xffffffff，我们只要提供0xffffffff/4 的值——0×40000000，这里我们设置了0×4000000 + 1）， nresp就会读到这个值，然后nresp*sizeof(char*)就成了 1073741825 * 4，于是溢出，结果成为了 0×100000004，然后求模，得到4。于是，malloc(4)，于是后面的for循环1073741825 次，就可以干环事了（经过0×40000001的循环,用户的数据早已覆盖了xmalloc原先分配的4字节的空间以及后面的数据，包括程序代码，函数指针，于是就可以改写程序逻辑。关于更多的东西，你可以看一下这篇文章《Survey of Protections from Buffer-Overflow Attacks》）。

  示例四：缓冲区溢出导致安全问题

  int func(char *buf1, unsigned int len1,
           char *buf2, unsigned int len2 )
  {
     char mybuf[256]; 
  
     if((len1 + len2) > 256){    //<--- [1]
         return -1;
     } 
  
     memcpy(mybuf, buf1, len1);
     memcpy(mybuf + len1, buf2, len2); 
  
     do_some_stuff(mybuf); 
  
     return 0;
  }

  上面这个例子本来是想把buf1和buf2的内容copy到mybuf里，其中怕len1 + len2超过256 还做了判断，但是，如果len1+len2溢出了，根据unsigned的特性，其会与2^32求模，所以，基本上来说，上面代码中的[1]处有可能为假的。（注：通常来说，在这种情况下，如果你开启-O代码优化选项，那个if语句块就全部被和谐掉了——被编译器给删除了）比如，你可以测试一下 len1=0×104， len2 = 0xfffffffc 的情况。

  这样的例子有很多很多，这些整型溢出的问题如果在关键的地方，尤其是在搭配有用户输入的地方，如果被黑客利用了，就会导致很严重的安全问题。

  关于编译器的行为

  在谈一下如何正确的检查整型溢出之前，我们还要来学习一下编译器的一些东西。请别怪我罗嗦。

  编译器优化

  如何检查整型溢出或是整型变量是否合法有时候是一件很麻烦的事情，就像上面的第四个例子一样，编译的优化参数-O/-O2/-O3基本上会假设你的程序不会有整形溢出。会把你的代码中检查溢出的代码给优化掉。

  关于编译器的优化，在这里再举个例子，假设我们有下面的代码（又是一个相当相当常见的代码）：

  int len;
  char* data;
  
  if (data + len < data){
      printf("invalid len\n");
      exit(-1);
  }
  

  上面这段代码中，len 和 data 配套使用，我们害怕len的值是非法的，或是len溢出了，于是我们写下了if语句来检查。这段代码在-O的参数下正常。但是在-O2的编译选项下，整个if语句块被优化掉了。

  你可以写个小程序，在gcc下编译（我的版本是4.4.7，记得加上-O2和-g参数），然后用gdb调试时，用disass /m命信输出汇编，你会看到下面的结果（你可以看到整个if语句块没有任何的汇编代码——直接被编译器和谐掉了）：

  7           int len = 10;
  8           char* data = (char *)malloc(len);
     0x00000000004004d4 <+4>:     mov    $0xa,%edi
     0x00000000004004d9 <+9>:     callq  0x4003b8 <malloc@plt>
  
  9
  10          if (data + len < data){
  11              printf("invalid len\n");
  12              exit(-1);
  13          }
  14
  15      }
     0x00000000004004de <+14>:    add    $0x8,%rsp
     0x00000000004004e2 <+18>:    retq
  

  对此，你需要把上面 char* 转型成 uintptr_t 或是 size_t，说白了也就是把char*转成unsigned的数据结构，if语句块就无法被优化了。如下所示：

  if ((uintptr_t)data + len < (uintptr_t)data){
      ... ...
  }

  关于这个事，你可以看一下C99的规范说明《 ISO/IEC 9899:1999 C specification 》第 §6.5.6 页，第8点，我截个图如下：（这段话的意思是定义了指针+/-一个整型的行为，如果越界了，则行为是undefined）

  注意上面标红线的地方，说如果指针指在数组范围内没事，如果越界了就是undefined，也就是说这事交给编译器实现了，编译器想咋干咋干，那怕你想把其优化掉也可以。在这里要重点说一下，C语言中的一个大恶魔—— Undefined! 这里都是“野兽出没”的地方，你一定要小心小心再小心。

  花絮：编译器的彩蛋

  上面说了所谓的undefined行为就全权交给编译器实现，gcc在1.17版本下对于undefined的行为还玩了个彩蛋（参看Wikipedia）。

  下面gcc 1.17版本下的遭遇undefined行为时，gcc在unix发行版下玩的彩蛋的源代码。我们可以看到，它会去尝试去执行一些游戏NetHack， Rogue 或是Emacs的 Towers of Hanoi，如果找不到，就输出一条NB的报错。

  execl("/usr/games/hack", "#pragma", 0); // try to run the game NetHack
  execl("/usr/games/rogue", "#pragma", 0); // try to run the game Rogue
  // try to run the Tower's of Hanoi simulation in Emacs.
  execl("/usr/new/emacs", "-f","hanoi","9","-kill",0);
  execl("/usr/local/emacs","-f","hanoi","9","-kill",0); // same as above
  fatal("You are in a maze of twisty compiler features, all different");

  正确检测整型溢出

  在看过编译器的这些行为后，你应该会明白——“在整型溢出之前，一定要做检查，不然，就太晚了”。

  我们来看一段代码：

   void foo(int m, int n)
  {
      size_t s = m + n;
      .......
  }

  上面这段代码有两个风险：1）有符号转无符号，2）整型溢出。这两个情况在前面的那些示例中你都应该看到了。所以，你千万不要把任何检查的代码写在 s = m + n 这条语名后面，不然就太晚了。undefined行为就会出现了——用句纯正的英文表达就是——“Dragon is here”——你什么也控制不住了。（注意：有些初学者也许会以为size_t是无符号的，而根据优先级 m 和 n 会被提升到unsigned int。其实不是这样的，m 和 n 还是signed int，m + n 的结果也是signed int，然后再把这个结果转成unsigned int 赋值给s）

  比如，下面的代码是错的：

   void foo(int m, int n)
  {
      size_t s = m + n;
      if ( m>0 && n>0 && (SIZE_MAX - m < n) ){
          //error handling...
      }
  }

  上面的代码中，大家要注意 (SIZE_MAX – m < n) 这个判断，为什么不用m + n > SIZE_MAX呢？因为，如果 m + n 溢出后，就被截断了，所以表达式恒真，也就检测不出来了。另外，这个表达式中，m和n分别会被提升为unsigned。

  但是上面的代码是错的，因为：

  1）检查的太晚了，if之前编译器的undefined行为就已经出来了（你不知道什么会发生）。

  2）就像前面说的一样，(SIZE_MAX – m < n) 可能会被编译器优化掉。

  3）另外，SIZE_MAX是size_t的最大值，size_t在64位系统下是64位的，严谨点应该用INT_MAX或是UINT_MAX

   所以，正确的代码应该是下面这样：

   void foo(int m, int n)
  {
      size_t s = 0;
      if ( m>0 && n>0 && ( UINT_MAX - m < n ) ){
          //error handling...
          return;
      }
      s = (size_t)m + (size_t)n;
  }

  在《苹果安全编码规范》（PDF）中，第28页的代码中：

  如果n和m都是signed int，那么这段代码是错的。正确的应该像上面的那个例子一样，至少要在n*m时要把 n 和 m 给 cast 成 size_t。因为，n*m可能已经溢出了，已经undefined了，undefined的代码转成size_t已经没什么意义了。（如果m和n是unsigned int，也会溢出），上面的代码仅在m和n是size_t的时候才有效。

  不管怎么说，《苹果安全编码规范》绝对值得你去读一读。

  上溢出和下溢出的检查

  前面的代码只判断了正数的上溢出overflow，没有判断负数的下溢出underflow。让们来看看怎么判断：

  对于加法，还好。

  #include <limits.h>
  
  void f(signed int si_a, signed int si_b) {
      signed int sum;
      if (((si_b > 0) && (si_a > (INT_MAX - si_b))) ||
          ((si_b < 0) && (si_a < (INT_MIN - si_b)))) {
          /* Handle error */
          return;
      }
      sum = si_a + si_b;
  }

  对于乘法，就会很复杂（下面的代码太夸张了）：

  void func(signed int si_a, signed int si_b)
  {
    signed int result;
    if (si_a > 0) {  /* si_a is positive */
      if (si_b > 0) {  /* si_a and si_b are positive */
        if (si_a > (INT_MAX / si_b)) {
          /* Handle error */
        }
      } else { /* si_a positive, si_b nonpositive */
        if (si_b < (INT_MIN / si_a)) {
          /* Handle error */
        }
      } /* si_a positive, si_b nonpositive */
    } else { /* si_a is nonpositive */
      if (si_b > 0) { /* si_a is nonpositive, si_b is positive */
        if (si_a < (INT_MIN / si_b)) {
          /* Handle error */
        }
      } else { /* si_a and si_b are nonpositive */
        if ( (si_a != 0) && (si_b < (INT_MAX / si_a))) {
          /* Handle error */
        }
      } /* End if si_a and si_b are nonpositive */
    } /* End if si_a is nonpositive */
  
    result = si_a * si_b;
  }

  更多的防止在操作中整型溢出的安全代码可以参看《INT32-C. Ensure that operations on signed integers do not result in overflow》

  其它

  对于C++来说，你应该使用STL中的numeric_limits::max() 来检查溢出。

  另外，微软的SafeInt类是一个可以帮你远理上面这些很tricky的类，下载地址：http://safeint.codeplex.com/

  对于Java 来说，一种是用JDK 1.7中Math库下的safe打头的函数，如safeAdd()和safeMultiply()，另一种用更大尺寸的数据类型，最大可以到BigInteger。

  可见，写一个安全的代码并不容易，尤其对于C/C++来说。对于黑客来说，他们只需要搜一下开源软件中代码有memcpy/strcpy之类的地方，然后看一看其周边的代码，是否可以通过用户的输入来影响，如果有的话，你就惨了。

  参考：

  • Basic Integer Overflow
  • OWASP：Integer overflow
  • C compilers may silently discard some wraparound checks
  • Apple Secure Coding Guide
  • Wikipedia: Undefined Behavior

  • INT32-C. Ensure that operations on signed integers do not result in overflow

  最后， 不好意思，这篇文章可能罗嗦了一些，大家见谅。

  （全文完）

   

   

   

  单看这文章的标题，你可能会觉得好像没什么意思。你先别下这个结论，相信这篇文章会对你理解C语言有帮助。这篇文章产生的背景是在微博上，看到@Laruence同学出了一个关于C语言的题，微博链接。微博截图如下。我觉得好多人对这段代码的理解还不够深入，所以写下了这篇文章。

  为了方便你把代码copy过去编译和调试，我把代码列在下面：

  #include <stdio.h>
  struct str{
      int len;
      char s[0];
  };
  
  struct foo {
      struct str *a;
  };
  
  int main(int argc, char** argv) {
      struct foo f={0};
      if (f.a->s) {
          printf( f.a->s);
      }
      return 0;
  }
  

  你编译一下上面的代码，在VC++和GCC下都会在14行的printf处crash掉你的程序。@Laruence 说这个是个经典的坑，我觉得这怎么会是经典的坑呢？上面这代码，你一定会问，为什么if语句判断的不是f.a？而是f.a里面的数组？写这样代码的人脑子里在想什么？还是用这样的代码来玩票？不管怎么样，看过原微博的回复，我个人觉得大家主要还是对C语言理解不深，如果这算坑的话，那么全都是坑。

   

  接下来，你调试一下，或是你把14行的printf语句改成：

  printf("%x\n", f.a->s);

  你会看到程序不crash了。程序输出：4。 这下你知道了，访问0×4的内存地址，不crash才怪。于是，你一定会有如下的问题：

  1）为什么不是 13行if语句出错？f.a被初始化为空了嘛，用空指针访问成员变量为什么不crash？

  2）为什么会访问到了0×4的地址？靠，4是怎么出来的？

  3）代码中的第4行，char s[0] 是个什么东西？零长度的数组？为什么要这样玩？

  让我们从基础开始一点一点地来解释C语言中这些诡异的问题。

  结构体中的成员

  首先，我们需要知道——所谓变量，其实是内存地址的一个抽像名字罢了。在静态编译的程序中，所有的变量名都会在编译时被转成内存地址。机器是不知道我们取的名字的，只知道地址。

  所以有了——栈内存区，堆内存区，静态内存区，常量内存区，我们代码中的所有变量都会被编译器预先放到这些内存区中。

  有了上面这个基础，我们来看一下结构体中的成员的地址是什么？我们先简单化一下代码：

  struct test{
      int i;
      char *p;
  };

  上面代码中，test结构中i和p指针，在C的编译器中保存的是相对地址——也就是说，他们的地址是相对于struct test的实例的。如果我们有这样的代码：

  struct test t;

  我们用gdb跟进去，对于实例t，我们可以看到：

  # t实例中的p就是一个野指针
  (gdb) p t
  $1 = {i = 0, c = 0 '\000', d = 0 '\000', p = 0x4003e0 "1\355I\211\..."}
  
  # 输出t的地址
  (gdb) p &t
  $2 = (struct test *) 0x7fffffffe5f0
  
  #输出(t.i)的地址
  (gdb) p &(t.i)
  $3 = (char **) 0x7fffffffe5f0
  
  #输出(t.p)的地址
  (gdb) p &(t.p)
  $4 = (char **) 0x7fffffffe5f4

  我们可以看到，t.i的地址和t的地址是一样的，t.p的址址相对于t的地址多了个4。说白了，t.i 其实就是(&t + 0×0), t.p 的其实就是 (&t + 0×4)。0×0和0×4这个偏移地址就是成员i和p在编译时就被编译器给hard code了的地址。于是，你就知道，不管结构体的实例是什么——访问其成员其实就是加成员的偏移量。

  下面我们来做个实验：

  struct test{
      int i;
      short c;
      char *p;
  };
  
  int main(){
      struct test *pt=NULL;
      return 0;
  }

  编译后，我们用gdb调试一下，当初始化pt后，我们看看如下的调试：（我们可以看到就算是pt为NULL，访问其中的成员时，其实就是在访问相对于pt的内址）

  (gdb) p pt
  $1 = (struct test *) 0x0
  (gdb) p pt->i
  Cannot access memory at address 0x0
  (gdb) p pt->c
  Cannot access memory at address 0x4
  (gdb) p pt->p
  Cannot access memory at address 0x8

  注意：上面的pt->p的偏移之所以是0×8而不是0×6，是因为内存对齐了（我在64位系统上）。关于内存对齐，可参看《深入理解C语言》一文。

  好了，现在你知道为什么原题中会访问到了0×4的地址了吧，因为是相对地址。

  相对地址有很好多处，其可以玩出一些有意思的编程技巧，比如把C搞出面向对象式的感觉来，你可以参看我正好11年前的文章《用C写面向对像的程序》（用指针类型强转的危险玩法——相对于C++来说，C++编译器帮你管了继承和虚函数表，语义也清楚了很多）

  指针和数组的差别

  有了上面的基础后，你把源代码中的struct str结构体中的char s[0];改成char *s;试试看，你会发现，在13行if条件的时候，程序因为Cannot access memory就直接挂掉了。为什么声明成char s[0]，程序会在14行挂掉，而声明成char *s，程序会在13行挂掉呢？那么char *s 和 char s[0]有什么差别呢？

  在说明这个事之前，有必要看一下汇编代码，用GDB查看后发现：

  • 对于char s[0]来说，汇编代码用了lea指令，lea   0×04(%rax),   %rdx
  • 对于char*s来说，汇编代码用了mov指令，mov 0×04(%rax),   %rdx

  lea全称load effective address，是把地址放进去，而mov则是把地址里的内容放进去。所以，就crash了。

  从这里，我们可以看到，访问成员数组名其实得到的是数组的相对地址，而访问成员指针其实是相对地址里的内容（这和访问其它非指针或数组的变量是一样的）

  换句话说，对于数组 char s[10]来说，数组名 s 和 &s 都是一样的（不信你可以自己写个程序试试）。在我们这个例子中，也就是说，都表示了偏移后的地址。这样，如果我们访问 指针的地址（或是成员变量的地址），那么也就不会让程序挂掉了。

  正如下面的代码，可以运行一点也不会crash掉（你汇编一下你会看到用的都是lea指令）：

  struct test{
      int i;
      short c;
      char *p;
      char s[10];
  };
  
  int main(){
      struct test *pt=NULL;
      printf("&s = %x\n", pt->s); //等价于 printf("%x\n", &(pt->s) );
      printf("&i = %x\n", &pt->i); //因为操作符优先级，我没有写成&(pt->i)
      printf("&c = %x\n", &pt->c);
      printf("&p = %x\n", &pt->p);
      return 0;
  }

  看到这里，你觉得这能算坑吗？不要出什么事都去怪语言，大家要想想是不是问题出在自己身上。

  关于零长度的数组

  首先，我们要知道，0长度的数组在ISO C和C++的规格说明书中是不允许的。这也就是为什么在VC++2012下编译你会得到一个警告：“arning C4200: 使用了非标准扩展 : 结构/联合中的零大小数组”。

  那么为什么gcc可以通过而连一个警告都没有？那是因为gcc 为了预先支持C99的这种玩法，所以，让“零长度数组”这种玩法合法了。关于GCC对于这个事的文档在这里：“Arrays of Length Zero”，文档中给了一个例子（我改了一下，改成可以运行的了）：

  #include <stdlib.h>
  #include <string.h>
  
  struct line {
     int length;
     char contents[0]; // C99的玩法是：char contents[]; 没有指定数组长度
  };
  
  int main(){
      int this_length=10;
      struct line *thisline = (struct line *)
                       malloc (sizeof (struct line) + this_length);
      thisline->length = this_length;
      memset(thisline->contents, 'a', this_length);
      return 0;
  }

  上面这段代码的意思是：我想分配一个不定长的数组，于是我有一个结构体，其中有两个成员，一个是length，代表数组的长度，一个是contents，代码数组的内容。后面代码里的 this_length（长度是10）代表是我想分配的数据的长度。（这看上去是不是像一个C++的类？）这种玩法英文叫：Flexible Array，中文翻译叫：柔性数组。

  我们来用gdb看一下：

  (gdb) p thisline
  $1 = (struct line *) 0x601010
  
  (gdb) p *thisline
  $2 = {length = 10, contents = 0x601010 "\n"}
  
  (gdb) p thisline->contents
  $3 = 0x601014 "aaaaaaaaaa"

  我们可以看到：在输出*thisline时，我们发现其中的成员变量contents的地址居然和thisline是一样的（偏移量为0×0??!!）。但是当我们输出thisline->contents的时候，你又发现contents的地址是被offset了0×4了的，内容也变成了10个‘a’。（我觉得这是一个GDB的bug，VC++的调试器就能很好的显示）

  我们继续，如果你sizeof(char[0])或是 sizeof(int[0]) 之类的零长度数组，你会发现sizeof返回了0，这就是说，零长度的数组是存在于结构体内的，但是不占结构体的size。你可以简单的理解为一个没有内容的占位标识，直到我们给结构体分配了内存，这个占位标识才变成了一个有长度的数组。

  看到这里，你会说，为什么要这样搞啊，把contents声明成一个指针，然后为它再分配一下内存不行么？就像下面一样。

  struct line {
     int length;
     char *contents;
  };
  
  int main(){
      int this_length=10;
      struct line *thisline = (struct line *)malloc (sizeof (struct line));
      thisline->contents = (char*) malloc( sizeof(char) * this_length );
      thisline->length = this_length;
      memset(thisline->contents, 'a', this_length);
      return 0;
  }

  这不一样清楚吗？而且也没什么怪异难懂的东西。是的，这也是普遍的编程方式，代码是很清晰，也让人很容易理解。即然这样，那为什么要搞一个零长度的数组？有毛意义？！

  这个事情出来的原因是——我们想给一个结构体内的数据分配一个连续的内存！这样做的意义有两个好处：

  第一个意义是，方便内存释放。如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。（读到这里，你一定会觉得C++的封闭中的析构函数会让这事容易和干净很多）

  第二个原因是，这样有利于访问速度。连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）

  我们来看看是怎么个连续的，用gdb的x命令来查看：(我们知道，用struct line {}中的那个char contents[]不占用结构体的内存，所以，struct line就只有一个int成员，4个字节，而我们还要为contents[]分配10个字节长度，所以，一共是14个字节)

  (gdb) x /14b thisline
  0x601010:       10      0       0       0       97      97      97      97
  0x601018:       97      97      97      97      97      97

  从上面的内存布局我们可以看到，前4个字节是 int length，后10个字节就是char contents[]。

  如果用指针的话，会变成这个样子：

  (gdb) x /16b thisline
  0x601010:       1       0       0       0       0       0       0       0
  0x601018:       32      16      96      0       0       0       0       0
  (gdb) x /10b this->contents
  0x601020:       97      97      97      97      97      97      97      97
  0x601028:       97      97

  上面一共输出了四行内存，其中，

  • 第一行前四个字节是 int length，第一行的后四个字节是对齐。
  • 第二行是char* contents，64位系统指针8个长度，他的值是0×20 0×10 0×60 也就是0×601020。
  • 第三行和第四行是char* contents指向的内容。

  从这里，我们看到，其中的差别——数组的原地就是内容，而指针的那里保存的是内容的地址。

  后记

  好了，我的文章到这里就结束了。但是，请允许我再唠叨两句。

  1）看过这篇文章，你觉得C复杂吗？我觉得并不简单。某些地方的复杂程度不亚于C++。

  2）那些学不好C++的人一定是连C都学不好的人。连C都没学好，你们根本没有资格鄙视C++。

  3）当你们在说有坑的时候，你得问一下自己，是真有坑还是自己的学习能力上出了问题。

  如果你觉得你的C语言还不错，欢迎你看看《C语言的谜题》还有《谁说C语言很简单？》还有《语言的歧义》以及《深入理解C语言》一文。

  （全文完）

   

   

   

  《高质量C++编程》的作者林锐博士推荐后一种做法，认为后者是一种良好的编程风格。后来查了查《C++ Primer》（第三版，Stanley B Lippman Josee Lajoie 著，潘爱民 张丽译），里面给出的理论依据是：由于内联函数必须在调用它的每个文本文件中被定义，所以没有在类体中定义的内联成员函数必须被放在类定义出现的头文件中。

   

  =======================什么是友元类=======================

        当一个类B成为了另外一个类A的“朋友”时，那么类A的私有和保护的数据成员就可以被类B访问。我们就把类B叫做类A的友元。

  =======================友元类能做什么=======================

        友元类可以通过自己的方法来访问把它当做朋友的那个类的所有成员。但是我们应该注意的是，我们把类B设置成了类A的友元类，但是这并不会是类A成为类B的友元。说白了就是：甲愿意把甲的秘密告诉乙，但是乙不见得愿意把乙自己的秘密告诉甲。

  =======================友元类的声明方法和其用法=======================

        声明友元类的方法其实很简单，只要我们在类A的成员列表中写下如下语句：

  friend  class  B;

  　　这样一来，类B就被声明成了类A的友元。注意，类B虽然是类A的友元，但是两者之间不存在继承关系。这也就是说，友元类和原来那个类之间并没有什么继承关系，也不存在包含或者是被包含的关系，友元类和我上一篇博文《谈谈：C++类的“包含”机制》中的包含是完全不一样的！

  =======================友元类的一个具体例子=======================

        在这里，我们引用一个我从网上收集到的例子来说明友元类的作用：假设我们要设计一个模拟电视机和遥控器的程序。大家都之道，遥控机类和电视机类是不相包含的，而且，遥控器可以操作电视机，但是电视机无法操作遥控器，这就比较符合友元的特性了。即我们把遥控器类说明成电视机类的友元。下面是这个例子的具体代码：

转载于:https://www.cnblogs.com/haochen2016/p/5529766.html