Thinking in C++读书笔记--13.4继承与组合

#include "stdafx.h"
#include <iostream>
using namespace std;
//13.4组合与继承的联合
class A {
 int i;
public:
 A( int I ) { i = I; }
 ~A() {}
 void f() const {}
};

class B {
 int i;
public:
 B( int I ) { i = I; }
 ~B() {}
 void f() const {}
};

class C : public B {
 A a;
public:
 C( int I ) : B( I ), a( I ) {}//调用了基类的构造函数和成员对象的构造函数
 ~C() {}//调用~A与~B
 void f() const {//重定义了所继承的B::f(),并且还调用基类的版本。（只能在继承期间重定义函数）
  a.f();//通过成员对象，只能操作这个对象的公共接口，而不能重定义它
  B::f();//
 }
};

//13.4.1构造函数和析构函数的次序

#define CLASS(ID) class ID {/
public:/
 ID( int ) { cout <<#ID <<" constructor" <<endl; } /
 ~ID( ) { cout <<#ID <<" destructor" <<endl; }/
};
CLASS( base1 );
CLASS( member1 );
CLASS( member2 );
CLASS( member3 );
CLASS( member4 );

class derived1 : public base1 {
 member1 m1;
 member2 m2;
public:
 derived1( int ) : m2( 1 ), m1( 2), base1( 3 ) {
  cout <<"derived constructor" <<endl;
 }
 ~derived1( ) {
  cout <<"derived destructor" <<endl;
 }
};

class derived2 : public derived1 {
 member3 m3;
 member4 m4;
public:
 derived2( ) : m3( 1 ), m4( 2 ), derived1( 3 ) {
  cout <<"derived2 constructor" <<endl;
 }
 ~derived2( ) {
  cout <<"derived2 destructor" <<endl;
 }
};
int _tmain(int argc, _TCHAR* argv[])
{
 C c( 47 );
 derived2 d2;
 return 0;
}

 程序的输出如下图所示：

可见，构造在类层次的最根处开始，在每一层，首先调用基类的构造函数，然后调用成员对象构造函数。调用析构函数则严格按照构造函数的相反顺序进行。