Inside The C++ Object Model

// programmer defined default constructor
Bar::Bar() { str = 0; }

// 上面的代码会被转换为下面的代码
// Augmented default constructor
// Pseudo C++ Code
Bar::Bar()
{
   foo.Foo::Foo(); // augmented compiler code
   str = 0;        // explicit user code
}

class X { public: int i; };
class A : public virtual X   { public: int j; };
class B : public virtual X   { public: double d; };
class C : public A, public B { public: int k; };
// cannot resolve location of pa->X::i at compile-time
void foo( const A* pa ) { pa->i = 1024; }
main() {
   foo( new A );
   foo( new C );
   // ...
}

// 上面 foo 的代码会被转换为下面的代码
// possible compiler transformation
void foo( const A* pa ) { pa->__vbcX->i = 1024; }

// 下面的声明展现了基于位的 copy 语义
class Word {
public:
   Word( const char* );
   ~Word() { delete [] str; }
   // ...
private:
  int   cnt;
  char *str; 
};

// 下面的声明没有展现了基于位的 copy 语义
// declaration does not exhibits bitwise copy semantics
class Word {
public:
   Word( const String& );
   ~Word();
   // ...
private:
   int    cnt;
   String str;
};
// where String declares an explicit copy constructor:
class String {
public:
   String( const char * );
   String( const String& );
   ~String();
   // ...
};

// In this case, the compiler needs to synthesize a copy constructor in order to invoke the
// copy constructor of the member class String object:
// A synthesized copy constructor
// Pseudo C++ Code
inline Word::Word( const Word& wd )
{
   str.String::String( wd.str );
   cnt = wd.cnt;
}

void foo_bar() {
   X x1( x0 );
   X x2 = x0;
   X x3 = x( x0 );
   // ...
}

//上面的代码会被转换为下面的代码
// Possible program transformation
// Pseudo C++ Code
void foo_bar() {
   X x1; //定义被重写，初始化操作被剥离
   X x2; //同上
   X x3; //同上
   // compiler inserted invocations
   // of copy constructor for X
   x1.X::X( x0 );
   x2.X::X( x0 );
   x3.X::X( x0 );
   // ... 
}

X xx;
// ...
foo( xx );

// 上面的代码会被转换为下面的代码
// Pseudo C++ code
// compiler generated temporary
X __temp0;
// compiler invocation of copy constructor
__temp0.X::X ( xx );
// rewrite function call to take temporary
foo( __temp0 );

并且 foo 会被修改为
void foo( X& x0 );

X bar() {
   X xx;
   // process xx ...
   return xx;
}

// 上面的代码会被转换为下面的代码
// function transformation to reflect application of copy constructor
// Pseudo C++ Code
void
bar( X& __result )
{
   X xx;
   // compiler generated invocation
   // of default constructor
   xx.X::X();
   // ... process xx
   // compiler generated invocation
   // of copy constructor
   __result.X::X( xx );
   return; 
}

//并且所有调用 bar 的函数需要进行修改：
// 情况 1
X xx = bar();
// is transformed into the following two statements. // note: no default constructor applied
X xx;
bar( xx );

// 情况 2
bar().memfunc();
// compiler generated temporary
X __temp0;
( bar( __temp0 ), __temp0 ).memfunc();

// 情况 3
void ( *pf )( X& );
pf = bar;

origin._y = 0.0;
// 那么地址&origin._y 将等于 &origin+(&Point3d::y-1);
// Tips：
// 指向数据成员的指针，其值总是被加上 1，这样可以使编译系统区分“一个指向数据成员的指针，用以指出类的第一个成员”和“一个指向数据成员的指针，没有指出任何成员两种情况”。

  // 32位机器上，Concrete类对象大小为8Byte
  // val(4Byte) + c1(1Byte) + c2(1Byte) + c3(1Byte) + 字填充字节(1Byte) = 8Byte
  class Concrete
  {
  public:
      // ...
  private:
      int val;
      char c1;
      char c2;
      char c3;
  };

  // 将上面的Concret类分解为下面三个类
  // Concrete1 类对象大小为 8Byte  val(4Byte) + c1(1Byte) + 字填充字节(1Byte)
  class Concrete1
  {
  public:
      // ...
  protected:
      int val;
      char c1;
  };

  class Concrete2 : public Concrete1
  {
  public:
      // ...
  protected:
      char c2;
  };

  class Concrete3 : public Concrete2
  {
  public:
      // ...
  protected:
      char c3;
  };

class Point2d 
{
public:
    Point2d( float x = 0.0, float y = 0.0 ) : _x( x ), _y( y ) {};
    // access functions for x & y same as above
    // invariant across type: not made virtual
    // add placeholders for z — do nothing ...
    virtual float z(){ return 0.0 };
    virtual void z( float ) {}
    // turn type explicit operations virtual
    virtual void operator+=( const Point2d& rhs ) { _x += rhs.x(); _y += rhs.y(); }
    // ... more members
protected:
    float _x, _y;
};

class Point3d : public Point2d 
{
public:
    Point3d( float x = 0.0, float y = 0.0, float z = 0.0 ) : Point2d( x, y ), _z( z ) {};
    float z() { return _z; }
    void z( float newZ ) { _z = newZ; }
    void operator+=( const Point2d& rhs ) 
    {
        Point2d::operator+=( rhs ); _z += rhs.z();
    }
    // ... more members
protected:
    float _z;
};

// Point2d   Vertex
//    |         |
// Point3d      |
//    |_________|
//         |
//     Vertex3d
//
class Point2d{}
class Point3d: public Point2d{}
class Vertex{}
class Vertex3d : public Point3d, public Vertex {}

Vertex3d v3d;
Vertex  *pv;
Point2d *pp;
Point3d *p3d;

pv = &v3d;
// 上面的代码会被转换为下面的代码 Pseudo C++ Code
pv = (Vertex*)(((char*)&v3d) + sizeof( Point3d ));

pv = p3d;
// 上面的代码会被转换为下面的代码 Pseudo C++ Code
pv = p3d ? (Vertex*)((char*)p3d) + sizeof( Point3d ) : 0;

//      Point2d
//     ____|_____
//    |         |
// Point3d   Vertex
//    |_________|
//         |
//     Vertex3d
//
class Point2d{}
class Vertex : public virtual Point2d  {}
class Point3d : public virtual Point2d {} 
class Vertex3d : public Vertex, public Point3d {}

void Point3d::operator+=(const Point3d &rhs)
{
    // 下面代码被编译器改为 __vbcPoint2d->_x += rhs.__vbcPoint2d->x;
    _x += rhs._x;
    // 下面代码被编译器改为 __vbcPoint2d->_y += rhs.__vbcPoint2d->y;
    _y += rhs._y;
    // 下面代码编译器不做修改
    _z += rhs._z;
}

// Point2d* p2d = pv3d ? pv3d->__vbcPoint2d : 0;
Point2d* p2d = pv3d;

// 原始成员函数
Point3d Point3d::magnitude()
{
   return sqrt(_x * _x + _y * _y + _z * _z);
}
// step 1
Point3d Point3d::magnitude( Point3d *const this )
Point3d Point3d::magnitude( const Point3d *const this )
// step 2
{
  return sqrt(this->_x * this->_x + this->_y * this->_y + this->_z * this->_z );
}
// step 3
extern magnitude__7Point3dFv( register Point3d *const this );

// 代码中的转化
obj.magnitude();   // 变为 magnitude__7Point3dFv( &obj );
ptr->magnitude();  // 变为 magnitude__7Point3dFv( ptr );

ptr->normalize();
// 上面的代码会被转换为下面的代码
(*ptr->vptr[1])( ptr );

ptr->z();  // 我们不知道ptr所指的对象的真正类型，但是，我们知道，经由ptr可以访问到该对象的virtual table

// 虽然，不知道哪个z()函数的实体会被调用，但是我们知道每个z()函数地址都被放在slot4，因此，上面的代码被编译器转化为：
(ptr->vptr[4])(ptr);

Base2 *ptr = new Derived;
// invokes Derived::~Derived
// ptr must be adjusted backward by sizeof( Base1 )
delete ptr;

Derived *pder = new Derived;
// invokes Base2::mumble()
// pder must be adjusted forward by sizeof( Base1 )
pder->mumble();

Base2 *pb1 = new Derived;
// invokes Derived* Derived::clone()
// return must be adjusted to address Base2 subobject
Base2 *pb2 = pb1->clone();

float (Point::*pmf)() = &Point::z;
Point *ptr = new Point3d;

ptr->*pmf();
// 在cfront2.0非正式版中，上面的代码被编译器改为
// ( ((int)pmf) & ~127 ) ?
// (*pmf)(ptr) :                       // 非虚函数， *pmf 为该函数内存中真实地址，直接调用
// *(ptr->vptr[(int)pmf])(ptr)         // 虚函数，*pmf为虚函数在虚表中的索引，从虚表取得函数真实地址，再调用
// 上面的代码假设继承体系中最多只有128个虚函数，引入多重继承后，上面方法被弃用

// fully general structure to support
// pointer to member functions under MI
struct __mptr {
   int delta;               // this 指针的 offset 值
   int index;               // 虚表索引
   union {
      ptrtofunc  faddr;     // 非虚成员函数地址
      int        v_offset;  // 虚基类（或多重继承中第二或后继的）基类的 vptr 位置。
   };
};

ptr->*pmf();
// 上面代码被编译器改为
// (pmf.index<0) ?
// (*pmf.faddr)(ptr) :           // 非虚函数
// (*ptr->vptr[pmf.index](ptr)   // 虚函数

inline int
bar()
{
   int minval;
   int val1 = 1024;
   int val2 = 2048;
/*(1)*/minval = min( val1, val2 );
/*(2)*/minval = min( 1024, 2048 );
/*(3)*/minval = min( foo(), bar()+1 );
   return minval;
}

//(1) simple argument substitution
minval = val1 < val2 ? val1 : val2;

//(2)     constant folding following substitution
minval = 1024;

//(3)     side-effects and introduction of temporary
int t1;
int t2;
minval =
   ( t1 = foo() ), ( t2 = bar() + 1 ),
   t1 < t2 ? t1 : t2;

// generated temporary static object guard
static struct Matrix *__0__F3 = 0 ;
// the C analog to a reference is a pointer
// identity()'s name is mangled based on signature
struct Matrix*
identity__Fv ()
{
   static struct Matrix __1mat_identity ;

   // if the guard is set, do nothing, else
   // (a) invoke the constructor: __ct__6MatrixFv
   // (b) set the guard to address the object
   __0__F3
   ? 0
   : (__ct__1MatrixFv ( & __1mat_identity ),
     (__0__F3 = (&__1mat_identity)));
   ...
}

void*
vec_new(
   void *array,      // address of start of array
   size_t elem_size, // size of each class object
   int elem_count,   // number of elements in array
   void (*constructor)( void* ),
   void (*destructor)( void*, char )
}

void*
vec_delete(
   void *array,      // address of start of array
   size_t elem_size, // size of each class object
   int elem_count,   // number of elements in array
   void (*destructor)( void*, char )
}

class complex {
   complex(double=0.0, double=0.0);
   ... 
};

// 编译器会合成下面的构造函数
complex::complex()
{
   complex( 0.0, 0.0 );
}

int *pi = new int(5);
//上面的代码会被转换为下面的代码
int *pi;
if ( pi = __new( sizeof( int )))
    *pi = 5;

delete pi;
//上面的代码会被转换为下面的代码
if ( pi != 0 )
   __delete( pi );

// 1 new 对象
Point3d *origin = new Point3d;

//上面的代码会被转换为下面的代码
//Pseudo C++ code
Point3d *origin;
if ( origin = __new( sizeof( Point3d )))
     origin = Point3d::Point3d( origin );

//如果支持异常处理 则会转换为
if ( origin = __new( sizeof( Point3d ))) {
   try {
        origin = Point3d::Point3d( origin );
   }
   catch( ... ) {
     // invoke delete lib function to
     // free memory allocated by new ...
     __delete( origin );
     // propagate original exception upward
     throw; 
   }
}

// 2 delete 对象
delete origin;

//上面的代码会被转换为下面的代码
if ( origin != 0 ) {
     // Pseudo C++ code
     Point3d::~Point3d( origin );
     __delete( origin );
}
//如果支持异常处理 则会转换为
if ( origin != 0) {
     try {
      Point3d::~Point3d( origin );
   }
   catch( ... )
   {
      __delete( origin );
      throw; 
   }
}

//下面这样的写法虽然正确，但是每一次 new 的调用必须返回一个独一无二的指针，所以如果申请 0 字节的内存，new 操作会将 size 变为 1.
new T[ 0 ];

// new 的实现，没有考虑异常处理
extern void*
operator new( size_t size )
{
   if ( size == 0 )
        size = 1;
   void *last_alloc;
   while ( !( last_alloc = malloc( size )))
   {
      if ( _new_handler )
         ( *_new_handler )();
      else return 0;
   }
   return last_alloc;
}

extern void
operator delete( void *ptr )
{
   if ( ptr )
      free( (char*) ptr );
}

// array_key is the address of the new array
// mustn't either be 0 or already entered
// elem_count is the count; it may be 0
typedef void *PV;
extern int __insert_new_array(PV array_key, int elem_count);
// fetches (and removes) the array_key from table
// either returns the elem_count, or -1
extern int __remove_old_array(PV array_key);

PV __vec_new(PV ptr_array, int elem_count,
            int size, PV construct )
{
  // if ptr_array is 0, allocate array from heap
  // if set, programmer wrote either
  //    T array[ count ];
  // or
  //    new ( ptr_array ) T[ 10 ]
  int alloc = 0; // did we allocate here within vec_new?
  int array_sz = elem_count * size;
  if ( alloc = ptr_array == 0)
        // global operator new ...
        ptr_array = PV( new char[ array_sz ] );
  // under Exception Handling,
  // would throw exception bad_alloc
  if ( ptr_array == 0/
  return 0;
  // place (array, count) into the cache
  int status = __insert_new_array( ptr_array, elem_count );
  if (status == -1) {
    // under Exception Handling, would throw exception
    // would throw exception bad_alloc
    if ( alloc )
        delete ptr_array;
    return 0;
  }
  if (construct) {
    register char* elem = (char*) ptr_array;
    register char* lim = elem + array_sz;
    // PF is a typedef for a pointer to function
    register PF fp = PF(construct);
    while (elem < lim) {
        // invoke constructor through fp
        // on `this' element addressed by elem
        (*fp)( (void*)elem );
        // then advance to the next element
        elem += size;
    }
  }
  return PV(ptr_array);
}

  Point* ptr = new Point3d[10];
  // 该代码只会抵用 Point 的析构函数。
  delete [] ptr;

  class L6_Point3d_01: public L6_Point_01
  {
  public:
      L6_Point3d_01()
      {
          cout << "L6_Point3d_01()" << endl;
      }
      ~L6_Point3d_01()
      {
          cout << "~L6_Point3d_01()" << endl;
      }
  };
  void l6_test01()
  {
      L6_Point_01* ptr = new L6_Point3d_01[3];
      delete [] ptr;
  }
  // 代码的输出：
  // L6_Point_01()
  // L6_Point3d_01()
  // L6_Point_01()
  // L6_Point3d_01()
  // L6_Point_01()
  // L6_Point3d_01()
  // ~L6_Point_01()
  // ~L6_Point_01()
  // ~L6_Point_01()