5.1 “无继承” 情况下的对象构造
1. 普通类型(和C相同)
2. 抽相数据类型
3. 为继承作准备

5.2 继承体系下对象的构造
1.  通用继承构造规则
     (1) 在成员初始化列表中的data members初始化操作会被放进constructor的函数本身，并以members的声明顺序为顺序。
     (2) 如果有一个member没有出现在初始化列表中，但它有一个default constructor，那么default constructor会被调用。
     (3) 如果class object 有virtual table pointer(s)， 它(们)必须被设定初始值，指向适当的virtual table(s)。
     (4) 在那之前，所有的上一层的base class constructors必须被调用, 以base class的声明顺序为顺序
     (5) 在那之前，所有的virtual base class constructors必须被调用，从左到右，从最深到最浅。

2. 虚拟继承(virtual Inheritance)
如对于下面的类: 

 1 class Point3d : public virtual Point
 2  { 
 3  public: 
 4     Point3d( float x = 0.0, float y = 0.0, float z = 0.0 ) 
 5         : Point( x, y ), _z( z ) {} 
 6     Point3d( const Point3d& rhs ) 
 7         : Point( rhs ), _z( rhs._z ) {} 
 8     ~Point3d(); 
 9     Point3d& operator=( const Point3d& ); 
10 
11     virtual float z(){ return _z; } 
12     //  
13  protected: 
14     float _z; 
15  }; 

 
 可能的转换是这样的:

 //
 对于如下的继承层次:
 class Vertex   : virtual public Point { ... };
 class Vertex3d : public Point3d, public Vertex { ... };
 class PVertex  : public Vertex3d { ... };

 类Point3d的构造可能是:

 //
 对于Vertex3d的构造可能是如下:

3. vptr初始化语意学(The Semantics of the vptr Initialization)
     (1) 构造函数执行算法
          I.    在derived class constructor 中, 所有的"virtual base classes" 及 "上一层base class"的constructors会被调用.
   II.  上述完成之后, 对象的vptr(s)会被初始化, 指向相关的virtual talbe(s).
   III. 如果有成员初始化列表的话, 将在constructor体内扩展开来. 这必须在vptr被设定之后才能进行,以免有一个virtual member function被调用
   IV. 最后, 执行程序所提供的代码.
    
     (2) 示例:
     For example, given the following user-defined PVertex constructor:

  可能一个扩展如下:

5.3 对象的复制(Object Copy Sematics)
1. Copy constructor operator 在以下几种情况下不会表现出: bitwisecopy
     (1) class 内带有一个member object, 而其类有一个copy constructor operator时。
     (2)  当一个 class 的base 有一个copy assignment operator时。
     (3)  当类声明了任何一个virtual functions时。
     (4)  当class继承自一个virtual base class时
 2. 合成示例

5.4 对象的功能

5.5 析构语意学(Semantics of Destruction)
1. 析构函数生成原则：
 如果类没有定义destructor, 那么只有在class内带的member object(或是class自己的base class)拥有destructor的情况下，编译器才会自动的合成一个来。否则，destructor会被视为不需要，也就不需要被合成(当然更不需要被调用)

2. 析构调用过程
     (1) destructor的函数本身首先被执行。
     (2) 如果class拥有member class objects, 而后者拥有destructors, 那么它会以其声明顺序的相反顺序被调用.
     (3) 如果object内带一个vptr， 则现在被重新设定，指向适当的base class的virtual table.
     (4) 如果任何直接的(上一层)novirtual base classes 拥有destructor，那么它会以其声明顺序相反的顺序调用
     (5) 如果有任何的virtual base classes 拥有destructor， 而当前讨论的这个class是最末端的class， 那么它们会以其原来的构造顺序相反的顺序被调用.

4.1 Member 函数的各种调用方式
1. Nonstatic Member Function(非静态成员函数)
    要做如下的转换:
    (1) 改写函数的原形, 安插一个参数到member function中, 用于提供一个存取管道, 使class object 得以调用该函数, 这个额外的指针称之为: this指针.
    如:  
 Point3d::magnitude()  会转换为:  Point3d::magnitude(Point3d *const  this)

    (2)  对函数内每一个针对nostatic data member的存取操作改经由this指针来存取.
     如:
           return sqrt(
  this->_x  *  this->_x  + this->y * this->_y  + this->_z * this->_z;
    (3)  将对member function 重写一个外部函数, 对函数名称进行"mangling"处理, 使它生成一个独一无二的名称
   
2. Virtual Member Function(虚拟成员函数)
     例如:
  ptr->normalize();
  它将被转化为如下的调用:
 ( * ptr->vptr[ 1 ])( ptr );
 这里有几点说明：　
 i.  vptr是由编译器生成的指针，指向virtual table
 ii.  1 这里是virtual table slot 的索引值，它关联到nomalize这个函数
 iii.  第二个ptr表示this指针

3. Static Member Function(静态成员函数)
     如果Point3d::normalize()是一个static member function的话，这两个调用会转化为一般的操作：
     obj.normalize();
     ptr->normalize();
     转化为：　
     // obj.normalize();
     normalize__7Point3dSFv();
     // ptr->normalize();
     normalize__7Point3dSfv();

4.2 Virtual Member Functions(虚拟成员函数)
1. 单一继承下的Virtual Functions
     一个多态的class object 身上增加两个members:
 I.   一个字符串或数字,  表示class的类型
 II.  一个指针，指向某个表格，表格中带有程序的virtual function的执行时期地址
    对于一个active virtual function包括下面三个内容：　
        I.   这个class 所定义的函数实体, 它会改写一个可能存在的base class virtual function 函数实体.
 II.  继承自基类的实体，　这是在derived class 决定不改写virtual function 时才会出现的情况
 III. 一个pure_virtual_called()函数实体，它既可以扮演pur virtual function的空间保卫者角色,　也可以当做执行期异常函数.

2. 多重继承下的Virtual Functions
    这种继承涉及到要调整this指针，并且要求不止一个vtbl和vptr，同时要好几个这种虚表和指针

3. 虚拟继承下的Virtual Functions

4.3 函数的效能

4.4 指向Member Functions的指针(Pointer-to-Member Functions)
1. 指向一般成员函数的指针(Nostatic member and novirtual member function)
    取一个nostatic member function的地址,  如果该函数是novirtual, 则得到的结果是它在内存中真正的地址, 然而这个地址也不是完全的, 它也需要绑定到某个class object的地址上, 才能够调用该函数. 所有的nostatic member functions都要对象的地址(用this指出).
    例如:
     double (Point::*pmf)(); // 定义一个成员函数指针
      pfm = &Point::y;   // 初始化这个指针为
     (ptr->*pfm)() ;   // 调用为,  编译器转化为: (pfm)(ptr)

2. 支持"指向Virtual Member Functions"的指针
    对于virtual function, 其地址在编译时期是未知的, 所能知道的仅是virtual function在相关的vitual table 中的索引值. 也就是说对于一个virtual member function取其地址, 所能获得的只是一个索引值.
    所以如果:
    pmf = &Point::z(); // 获得的是索引值,  调用时:
    (ptr.->pmf)()   // 会转化为: (* ptr->vptr[(int)pfm] (ptr)

3. 在多重继承下,指向Member Functions的指针
     比较复杂,  定义了一个结构支持这们的操作

4. 指向 Member Functions 指针的效率

4.4 Inline Functions
1. inline functions的生成条件

2. 对形式参数的处理(Formal Arguments)
例如:

 
用下面的方式进行处理:
   (1)  直接的参数替换
 //(1)     simple argument substitution
 minval = val1 < val2 ? val1 : val2;

   (2) 如果实际参数是一个常量表达式(const expression),  我们就可以在替换前完成对它的求值操作.
 //(2)  constant folding following substitution
 minval = 1024;
  
   (3) 带有副作用的实际参数, 引入临时性的对象
 //(3)     side-effects and introduction of temporary
 int t1;
 int t2;

 minval =  ( t1 = foo() ), ( t2 = bar() + 1 ),  t1 < t2 ? t1 : t2;

3. 对inline函数带有局部变量的处理(Local Variables)
    如:
 inline int min( int i, int j )
 {
  int minval = i < j ? i : j;
  return minval;
 }
    对于如下的调用:
    {
    int local_var;
    int minval;

    // ...
    minval = min( val1, val2 );
     }

    转换可能的结果是:

示例代码：
class X {};
class Y : public virtual X {};
class Z : public virtual X {};
class A : public Y, public Z {};

一个类对象的大小受三个因素的影响
i.   语言本身所造成的额外负担(overhead),  当语言要支持virtual base class 时，就会导致一些额外的负担.
ii.  编译器对特殊情况所提供的优化处理,  如virtual base class class X subobject 的1bytes大小会出现在子类Y, Z的身上.
      如: sizeof(Y) = sizeof(Z) = 4(8) // 这里的4(8)和编译器相关
     
      有时候有的编译器会用empty virtual base class 技术来优化, VC就是采用这一技术的, 这样virtual base class 就不用占用大小了.

iii.  Alignment 的限制, Y和Z的大小本来大小都是4, 加上virtual base subobject的1bytes的大小共5个字节, 但实际上去是8bytes，这里就是受到字节对齐的影响.

C++对象模型对数据的存放结构是:
i.   把nonstatic data members直接的放在class object之中, 对继承(不管是virtual 或 nonvirtual base class )而来的nonstatic data members也是这一样的.
ii.  没有强制定义其间的排列顺序
iii. 对static data members, 则被放置在一个global data segment中, 不会影响单个类的大小, 并且只保存一份实体. (template有所不同)

3.1 Data Member的绑定(The Binding of Data Member)
    示例代码:

 1 // A third party foo.h header file 
 2  // pulled in from somewhere 
 3  extern float x; 
 4 
 5  // the programmer's Point3d.h file 
 6  class Point3d 
 7  { 
 8  public: 
 9     Point3d( float, float, float ); 
10 
11     // question:  which x is returned and set? 
12     float X() const { return x; } 
13 
14     void X( float new_x ) const { x = new_x; } 
15 
16     //  
17 
18  private: 
19     float x, y, z; 
20  }; 
21 
22 

 在早期的编译器中会出错, 不过在 C++2.0后就不会了, 在C++2.0后, 采用的是"rewriting rule" == "member scope rsolution rule" 规则来处理它.
 以前的编译器中, float X() const { return x; }, 它不知道要返回哪一个x, 这里它会返回全局的 extern float x, 所以是不正确的. 后来的编译器是会在整个class的声明都出现了后才会分析member functions, 所以它不会现错.

 对于下面的例子还是会出错, 因为对于member functions signatures的分析不会到类完成以后, 而是第一次出现的时候就会分析的. 如下面的:

  所以最好始终的把"nested type declare" 放在类的起始处. (这在STL中好像最明显, 都是先声明的)

3.2 Data Member的布局 (Data Member Layout)

示例代码: 

 1 class Point3d { 
 2  public: 
 3 
 4     //  
 5 
 6  private: 
 7     float x; 
 8     static List<Point3d*> *freeList; 
 9     float y; 
10     static const int chunkSize = 250; 
11     float z; 
12  }; 
13 

      Data Member的布局按如下的规则:
      i.   Nonstatic data member 在class object中的排列顺序和被声明的顺序是一样的, 任何中间介入的static data member都不会被放进对象的布局中.
      ii.  要求在同一access section中"较晚出现的members在class object中有较高的地址"这一条件就可以.
      iii. 编译器可能会合成一些内部使用的data members, 以支持整个对象模型, 如vptr指针.  对于它的具体位置, C++ Standard 没有规定, 由编译器产商自己决定. 不过传统上一般是放在所有声明的members的最后, 也有把vptr放在所有class object的最前端的.

3.3 Data Member的存取
示例:
      Point3d origin, *pt = &origin;
      origin.x    = 0.0;
      pt->x = 0.0

1. Static Data Members的存取
    每一个static data member只有一个实体，存在于程序的data segment中。每次程序取用这个static data member的时候，就会被转化为对该实体的唯一的extern实体的直接参考操作.  用指针存取一个数和用对象去存取一个数是一样的。
    
2. Nostatic Data Members的存取
    Nostatic data member 直接存放在每一个class object之中，除非经由明确的或暗喻的class object，否则没有办法直接的存取它们。
    例如:
    Point3d  Point3d::translate( const Point3d &pt )
    {
    x += pt.x;
    y += pt.y;
    z += pt.z;
    }
    实际经过转换后为：
    Point3d  Point3d::translate( Point3d *const this, const Point3d &pt )
    {
     this->x += pt.x;
    this->y += pt.y;
    this->z += pt.z;
    }
    对nostatic data member的访问是这样的: 
 origin._y = 0.0; 
    实际转换操作是:
        &origin + (&Point3d::_y - 1 );
      
       注意:  这里的-1操作。指向data member的指针，其offset值总是被加上1， 这样可以使编译系统区分出:
 i.  一个用以指出class的第一个member的data member的指针.
 ii. 一个没有指出任何member的data member的指针.
  
    如果是virtual 继承的话，就可以不一样了，可能要多加层的访问层; 也可能要到运行时才能决定，由编译器所决定.

3.4 “继承”与Data Member
 示例数据:

    C++的继承模型:
 在C++的继承模型中， 一个derived class object 所表现出来的东西，是其自己的member加上其base class(es) member的总和。对于数据成员出现的顺序在C++ Standard 中没有规定。从下面几个方面来讨论数据继承:
 i.   单一继承且不含有virtual functions
 ii.   单一继承并含有virtual functions
 iii.  多重继承
 iV. 虚拟继承

1. 只要继承不要多态(Inheritance Without Polymoophism)
    继承一般不会增加空间或存取时间。但继承有时会有这样两种情况出现:
    i.   经验不足的人有时可能会重复的设计一些相同的函数.
    ii.  把一个类分解为多层，有可能会为了表现class的体系抽象化，使所需要的空间膨胀。
        因为C++语言要保证: 出现在derived class 中的base class subobject 有其完整原样性。

2. 加上多态(Adding Polymorphism)
    如：

 1  class Point2d 
 2  { 
 3  public: 
 4     Point2d( float x = 0.0, float y = 0.0 ) 
 5        : _x( x ), _y( y ) {}; 
 6 
 7     // access functions for x & y same as above 
 8     // invariant across type: not made virtual 
 9   
10     // add placeholders for z ?do nothing  
11     virtual float z(){ return 0.0 }; 
12     virtual void z( float ) {} 
13 
14     // turn type explicit operations virtual 
15     virtual void operator+=( const Point2d& rhs )
16     { 
17         _x += rhs.x(); _y += rhs.y();
18      } 
19   
20     //  more members 
21 
22  protected: 
23   float _x, _y; 
24  }; 
25 
26 

 //
 要支持多态，Point2d数据成员要做如下的工作:
 i.   导入一个和Point2d有关的virtual table(vtbl), 存放它声明的每一个virtual function的地址
 ii.   在每个class object中导入一个vptr, 提供执行期的链接，使每个object都能找到相应的virtual table.
 iii.  加强construtor, 使它能够为vptr设定初值，让它指向class所对应的virtual table.
 iV.  加强destructor, 使它能够抹消"指向class的相关"virtual table" 的vptr.

 Figure 3.3. Data Layout: Single Inheritance with Virtual Inheritance
 

3. 多重继承(Multiple Inheritance)
 
 
4. 虚拟继承(Virtual Inheritance)
    Class 中如果含一个或多个virtual base class subobjects, 它将被分为两个部分: 一个不变的局部和一个共享的局部.
    i.   不变的局部中的数据，不管后继如何衍化，总有固定的offset， 所这一部分的数据可以直接的被存取。
    ii.  共享的局部，所表现的就是virtual base class subobject, 这一部分的数据会因为每次派生的操作而有变化, 所以它们只能间接的存取。

3.5 对象成员的效率(Object Member Efficiency)

3.6 指向数据成员的指针(Point to Data Members)

class  Foo  {  public : Foo(), Foo( int ) . } ;
class  Bar  {  public : Foo foo;  char   * str; } ; 
  
void  foo_bar()
{
       Bar bar;  //  Bar::foo在这里被初始化(调用Foo的缺省构造行数: Foo:Foo())
      
       //
      if  (str)  { }   . 
   }

    
    对于有多个成员对象的类，则按成员对象在类的声明中的顺序调用它们的构造函数。
      
    2. 带有 Default Constructor 的 Base Class(带有缺省构造函数的基类对象)       指的是一个没有任何constructorsrs的类派生自一个带有“default constructor”的基类。 如果类存在多个构造函数的话，那么编译器也会扩充现有的每一个构造函数，将调用基类的default constructor的代码加入到其中。
       
    3. 带有一个 Virtual Function 的 Class
    这样的virtual Function可以使继承来的或直接定义的。 编译器在编译期间会做如下工作
    a. 生成一个virtual Function talbe(vtbl), 用来存放class 的virtual function的地址
    b. 在每一个class object中，添加一个额外的pointer member(vptr)，它指向class vtbl的地址
   
    4. 带有一个 Virtual Base Class 的 Class
    这种情况是在导出类的安插一个virtual base classes的指针，用来在运行时存取virtual base class 的成员。例如：

 1     class X { public: int i; }; 
 2     class A : public virtual X   { public: int j; }; 
 3     class B : public virtual X   { public: double d; }; 
 4     class C : public A, public B { public: int k; }; 
 5 
 6     // cannot resolve location of pa->X::i at compile-time 
 7     void foo( const A* pa ) { pa->i = 1024; } 
 8     // 在编译期可能生成如下形式:
 9     // void foo(const A* pa) { pa->_vbcX->i = 1024; } // _vbcX: virtual base class X
10     
11     main() 
12     { 
13         foo( new A ); 
14         foo( new C ); 
15     
16         //  
17     }
18 
19 

    
    注意:　在合成的default constructor中，只有base class subobjects和member class objects会被初始化，其它所有的nostatic data member都不会执行初始化的操作．要我们自己手动的去执行初始化的操作．

    其实把握一个原则：要不要合成一个构造函数，依据编译器的需要与否，合成出来的constructor也只是完成那些编译器所需求。
   
    两个错误的观点：
 i. 任何时候，如果没有定义default constructor，就会被合成一个出来。(而是根据编译器的需要决定是否生成一个deault constructor)
 ii. 编译器生成出来的default constructor会明确的初始化每类中的每一个data member.

2.2 Copy Constructor的构建操作
    有三种情况下会有一个Copy Constructor的操作：
 i.   对一个object做明确的初始化操作  // class X{ ....};   X x;    X xx = x;
 ii.  当某个object作为参数传递给某个函数  // void foo(X x) { .... }
 iii. 函数传回一个class object对象  // void foo(){ X xx; return xx;}

    1. Default Memberwise Initialization(缺省的按成员初始化)
    如果一个类没有explicit copy constructor时, class object在执行copy constructor时，内部以default member initialization的手法来完成，就是把每一个内建或者派生而来的data member的值从某个object 拷贝一份到另一个object身上，对member class object是以递归的方式调用memberwise initialization的。
   
    这种初始化是通过在必要时生成一个copy constructor或通过 bitwise copy 来完成的。 如果要通过bitwise来完成这这样的操作，那么必须表现出bitwise copy semantise. 
   
    C++ Standard中也把copy constructor分成trial 和notrivial两种类型，只有notrivial的实体才会被合成于程序中。决定一个copy constructor是否为trivial在于类是否表现出所谓的"Bitwise copy sematics".
   
    2. Bitwise Copy Semantics
    在 bitwise copy sematics 下，不会构造出一个default copy constructor. 例如：
 

 1    class Word
 2     {
 3     public: 
 4         Word(const char*);
 5         ~Word(){ delete []str; }
 6         //
 7     private:
 8         int cnt;
 9         char *str;
10     }  
11     以上的是一个表现出Bitwise copy sematics的类，而以下是一个没有表现出bitwise copy sematics的类
12     class Word
13     {
14     public: 
15         Word(const char*);
16         ~Word(){ delete []str; }
17         //
18     private:
19         int cnt;
20         String str;
21     }
22     
23     class String 
24     {
25     public: 
26         String(const char*);
27         String(const string&); // String的显示copy constructor
28         ~String();
29         //.
30     }
31     这种情况下会合成一个copy constructor以调用class String object的copy constructor.
32     inline Word::Word(const Word& wd)
33     {
34         str.String::String(wd.str);
35         cnt = wd.cnt;
36     }    
37 

       
    3. 不表现出Bitwise Copy Sematics的特性的情况
    以下的几种情况class不表现出 Bitwise Sematics:
        a. 当class 内含有一个member object, 而后者的class 声明有一个copy constructor时(合成或声明的都可以)，就不表现出Bitwise Sematics
        b. 当class 继承自一个base class, 而后者存在有一个copy constructor(合成或声明的都可以), 就不表现出Bitwise Sematics.
        c. 当类声明了一个或多个virtual function时
        d. 当class派生自一个继承创串链，其中有一个或多个virtual base classes时, 类就不表现出Bitwise Sematics
    这四种情况和default constructor生成的是否一个trivial是一样的, 也是满足编译器的需求。
      
    4. 重新设定Virtual Table 的指针
    对于以上：当类声明了一个或多个virtual function的情况，程序会为类对象做如下两个扩张操作：
        (1) 增加一个vtbl的指针，内含virtual function的指针地址。
        (2) 在类对象内安插一个vptr指针，指向virtual function table.
    对于把一个base class object 以其derived class object的值初始化操作的时候，会发生切割(sliced)操作。这时也要保证vtbl的正确和vtpr的正确性。
   
    5. 处理Virtual Base Class Subobject
    如果一个class object是以另外一个object作为初始值的话，而后者又有一个virtual base class suboject的话，那么也会使bitwise copy sematics失效。例如：

 1     class Raccoon : public virtual ZooAnimal{
 2     public:
 3   Raccoon(){  ; }
 4   Raccoon(int val) { ; }
 5   private:
 6   // 
 7     };
 8 
 9     class RedPanda : public Raccoon{
10     public:
11   RedPanda() { .; }
12   RedPanda(int val) { .; }
13   private:
14   // 
15     };
16     执行如下操作时会要求合成一个copy constructor:
17     RedPanda little_red;
18     Raccoon little_critter = little_re;  // 这里编译器必须明确的把little_critter的virtual base class pointer/offset初始化。
19 
20     // 如果只是这样的操作用bitwise copy 就可以了
21     Raccoon rocky;
22     Raccoon little_critter = rocky;   // 用简单的bitwise copy 就可以搞定了
23 
24 

2.3 程序转化语义学(Program Transformation Semantics)
 指的是程序在执行的是候要做的类型和操作的转换。 下面例子反映了三种转换操作：

 1  #include "X.h"
 2 
 3  X foo( X x0)
 4  {
 5   X xx;
 6 
 7   // ., 对xx和x0进行操作
 8 
 9   return XX;
10  }
11 

 1. 明确的初始化操作(Explicit Initialization)
 例如：

1 X x0
2   void  foo_bar()
3   {
4   X x1(x0);
5   X x2  =  x0;
6   X x3  =  X(x0);
7  }
8

 
 对程序做两个阶段的转化：
 i. 重写每一个定义，其中的初始化操作都会被剥除
 ii. 类的Copy constructor操作会被安插进去
 转化后可能成为这样的(伪码)：
 这也就是说前面三种的初始化操作都会转换成Explicit Initialization.

 2. 参数的初始化(Argument Initialization)
 例如下面：

 1  void foo(X x0){ ; }
 2  void call()
 3  {
 4   X xx;
 5 
 6   // . xxx 初始化及其操作
 7 
 8   foo(xx);
 9  }
10  转换后的操作为：
11  void call()
12  {
13   X xx;
14 
15   X __temp0;
16   __temp0.X::X(xx);
17   foo(__temp0);                // foo 函数应变成：void foo(X& x0);
18   __temp0.X::~X();  
19  }
20 
21 

 这就是为什么当传值到孙数的时候，不会把函数内对传入值的操作结果不会被修改，因为它在函数内本来修改的就不是外部传人的那个变量。

 3. 返回值的初始化(Return Value Initialization)
 例如：
 X bar()
 {
  X xx;
  // ....
  return xx;
 } 
 
 转化为如下伪码:
 void bar(X& __result)
 {
  X xx;
  xx.X::X();   // 编译器生成的一个缺省的构造函数调用

  // 处理 ....

  __result.X::X(xx);    // 编译器生成的copy constructor调用操作
  return;
 }
 
 如下的操作转化为：
 void foo()
 {
  X xx = bar();
 }

 被转化为：
 void foo()
 {
  X xx;
  bar(xx);   // 注意这里不用执行 default constructor
 }
 
 针对这种转换，可以从使用层面上进行优化和在编译器层面上做优化操作。在编译器层面上的操作就是采用NRV(Named Return Value)技术。
 如：
 x bar()
 {
  X xx;
  // ....
  return xx;
 }
 优化为：
 void bar(X& __result)
 {
  __result.X::X();

  //....  直接的处理 __result

  //
  return ;
 } 

2.4 成员初始化队伍(Member Initialization List)
 这里有两点要注意：
 1. 以下的四种情况下必须使用 member intialization list
  I.   当初始化一个reference member时
  II.  当初始化一个const member时
  III. 当初始化一个base class 的constructor，而它拥有一组参数时
  IV.  当调用一个member class的constructor, 而它拥有一组参数时

  其它情况下可以用在构造函数内初始化也可以
 
 2. 关于初始化的次序问题：
  编译器的初始化的顺序是按member声明次序来依次的初始化的。它会安插一些代码到构造函数内，并放在任何其它用户初始化的代码之前.

     2. C++语言数据和方法
     C++中是通过ADT(Abstract Data Type, ADT)来实现的。 C++可以在不同层次上进行抽象，造成的复杂度可能也不一样。
     书中从简单到复杂四个层次的抽象: 简单类、继承、一个参数的Template、两个参数的模板。

二.C++加上封装后的布局成本(Layout Costs for Adding Encapsulation)

    1. C++中的对象的布局
    a. data member:  直接的包涵在每一个class object(注意: 类对象，不是类)之中，这和C struct的情况是一样的
    b. member function: 它不出现在class object 之中.
       non-inline member: 它会产生一个行数的实体. 如果是非static的funciton, 每个function会加上一个this指针作为function的第一个参数.
       inline member: 会在每一个使用者身上产生一个函数的实体。这一般是为了提高效率。
   
    2. C++布局和存取上的额外开销
    a. virtual function 机制: 用以支持一个有效的"执行期绑定(runtime binding)" 
    b. virtual base class


三. C++对象模型(The C++ Object Model)

    1. 简单对象模型(A Simple Object Model)
    这种模型中，每个object是一系列的slots, 每个slot指向一个member. 每个member按其申明的次序各占用一个slot. 这里的member包括data member 和 function member. 每个member是通过slot的索引来访问的。
    具体的模型参看: 
   

    2. 表格驱动模型(A Table-driven Object Model)
    这种模型中把class object的members分组放在一个data member table 和一个function member table中，class object内含两个指向table的指针. member function table 是一系列的slots, 每个slot指向一个function member. data member table 则是直接的包涵有data本身。
    具体的模型参看: 
   

    3. C++对象模型(The C++ Object Model)
    C++的对象模型如下:
    a. nostatic data members 被直接的配置在每一个class object之内。
    b. static data member 、static 和 nonstatic function members全部被放在所有的class object 之外。
    c. virtual functions 则是以下列步骤支持的：
        i. 每一个class 产生一堆指向virtual functions的指针，放在表格之中，我们称这个表格为：virtual table(vtbl).
 ii. 每个得class object 被添加了一个指针，指向相关的virtual table，我们把class object的这个指针称之为vptr(virtual pointer)；这个vptr的设定和重置是由类的constructor、destructor 和 copy assignment 运算符自动完成的；每个类的type_info object也是经由virtual table指出的，通常是放在表格的第一个slot处。
    具体的模型参看: 
     

    d. 加上继承(Adding Inheritance)
    在 A Simple Object Model 中，每一个基类可以被derived class object的一个slot指出，该slot内含base class subobject的地址。
    在虚拟继承的情况下，base class 不管在继承链中被派生多少次，永远只有一个实体(subobject). 书中以iostream继承体系说明。

    C++中的base class subobject的data members直接放置于derived class object中。那么它的function members是怎么处理的呢？(我没有理解这块)
    对于virtual base class, C++ 2.0 是在class object中添加一个关联 virtual base class object的指针。

    e. 对象模型对程序的影响
    我觉得书上的这段代码非常好的体现了不同模型对程序的影响
    预定义 class X 如下：
   

class  X
{
public :
     virtual   ~ X() {  }
    X &  X( const  X &  rhs) {  }

     virtual   void  foo() {  }
}

//  定义一个方法
X foobar()
{
    X xx;
    X  * px  =   new  X();
     //  
    xx.foo();
    px -> foo();

     //
    delete px;
     return  xx;
}

//  这个函数可能的转化为：
void  foobar(X &  _result)
{
    _result.X::X();
 
     //
    px  =   new (  sizeof (X) );
     if (px  !=   0 )
        px -> X::X();

     //  这里是不使用virtual 机制的foo调用
     //  注意这里的调用方法，不是用vtbl, 
     //  这样如果有从class X 继承的类初始化或赋值给X基类时，
     //  调用foo的方法是X的方法, 是编译时确定的
    foo( & _result);

     //  是用virtual 机制的foo调用, 它是运行时确定的
 ( * px -> vtbl[ 2 ])(px);

      //  delete px 
      if (px  !=   0 )
  {
         ( * px -> vtbl[ 1 ])(px);   //  destructor
         _delete(px);
     }

      //  
      return  ;

四. 关键词所带来的差异(A Keyword Distinction)
    讨论了class 和 struct 的差异和选择

五. 对象的差异( A Object Distinction)

    1. C++程序设计模型支持三种programming paradigms.
    a. 程序模型(procedural model) 就是像 C 一样进行编程
    b. 抽象数据类型模型(abstract data type model, ADT) 用对象进行编程
    c. 面向对象模型(object-oriented model)
    模型中有一些彼此相关的类型，通过一个抽象的base class被封装起来(也就是：接口)。类型之间的操作是通过接口进行的。

    纯粹的以一种paradigm写程序是好的.(哈哈，好像这不太可能，我还做不到)

   二. 面向对象模型(object-oriented model)
    a . C++中多态支持性的支持是通过: pointer 和 reference来实现的.
    多态通过下面三种方法来支持:
        i. 经由一组隐含的转化操作:   shape *ps = new circle();
        ii. 经由virtual function 机制  ps->rotate();
        iii. 经由 dynamic_cast和typeid来支持:
             if(circle *pc = dynamic_cast<circle*>(ps)) ...
   多态内存需求
       i. 其 nonstatic data members 的总和大小
       ii. 任何字节对齐的额外填充(padding)
       iii. 支持virtual 而产生的额外负担
    
    b. 指针的类型
    "指向不同类型的各指针"的差异，不在于其指针的表示法不同，也不在于其内容的不同， 而是其寻址出来的object的类型不同。也就是说"指针类型"会教导编译器如何解释某个特定地址中的内存内容及其大小.

    c.  加上多态之后(Adding Polymorphism)
    以如下为例:    

 1 class  Bear :  public  ZooAnimal
 2 { 
 3 public : 
 4     Bear(); 
 5      ~ Bear(); 
 6
 7      //   
 8      void  rotate(); 
 9      virtual   void  dance(); 
10
11      //   
12 protected : 
13      enum  Dances  {  } ; 
14
15     Dances dances_known; 
16      int  cell_block; 
17 } ; 
18
19 /**/ ///
20 Bear b(  " Yogi "  ); 
21 Bear  * pb  =   & b; 
22 Bear  & rb  =   * pb; 
23

    具体的内存布局如 
    
   

    //
    现有   

以上每个都指向Bear object的第一个byte，其间的差别是，pb所涵盖的地址包含整个的Bear object, 而pz所涵盖的地址只包含Bear object中的 ZooAnimal subobject部分。你只能用pz来处理Bear中的virtual functions, 而不能直接的处理Bear中的其他任何members.
    注意pz的类型将在编译时确定以下两点:
     i. pz固定的可用接口
     ii. pz的接口的access level；因为子类的access level可能是不同于基类的，编译时会检测是否可以转换。

    e. 对象赋值问题
 

 Bear b; 
 ZooAnimal za  =  b; 

  //  ZooAnimal::rotate() invoked 
 za.rotate(); 

    这里有两个问题
    i. za为什么调用的是ZoomAnimal::rotate的实体而不是 Bear的实体?
   答：za并不是一个Bear, 它只是一个ZoomAnimal, 多态的这种特性不能用在直接存取的objects上。所以  za.rotate()调用只能是 ZooAnimal::rotate()

    ii. 如果初始化函数将一个object的内容完全拷贝到另一个object中去，为什么za的vpt不是指向Bear的virtual table呢？
    答：编译器在初始化或赋值操作时，如果某个object含有一个或多个vptrs, 那么这些vptrs的内容不会被原对象初始化或改变.
 例如上例的 ZooAnimal za = b, 这里的vptr并不会被 b 的vptr所替代.