递归的规律

  1 #include                                                                                  
  2
  3 using namespace std;
  4
  5 class A
  6 {
  7     public:
  8         A()
  9         {
 10             cout << "A::A()"<< endl;
 11         }
 12
 13 };
 14
 15 class B:public A
 16 {
 17     public:
 18         B():j(0)
 19     {
 20         cout<<"B::B()"< 21     }
 22     private:
 23         int j;
 24 };
 25
 26 class c1
 27 {
 28     public:
 29         c1(int i):a(i)
 30     {
 31         cout <<"c1::c1()"< 32     }
 33     private:
 34         int a;
 35 };
 36
 37 class c2
 38 {
 39     public:
 40         c2(double val):d(val)
 41     {
 42         cout <<"c2::c2()"< 43     }
 44     private:
 45         double d;
 46 };
 47
 48 class c3
 49 {
 50     public:
 51         c3(int v = 0):j(v)
 52     {
 53         cout << "c3:c3()"< 54     }
 55     private:
  56         int j;
 57 };
 58
 59 class D:public B
 60 {
 61     public:
 62         D(double v2,int v1):cc2(v2),cc1(v1)
 63     {
 64         cout<<"D::D()";
 65     }
 66     private:
 67      c1 cc1;
 68      c2 cc2;
 69      c3 cc3;
 70 };
 71
 72 int main(void)
 73 {
 74     D d(1.0,3);
 75     return 0;
 76 }


执行结果：
A::A()
B::B()
c1::c1()
c2::c2()
c3:c3()
D::D()
我想这个程序  你应该觉得稀松平常

以此来说明一下递归的规律：

（1） 递归从父类对象开始，D的构造函数首先通过“初始化”操作构造其直接父类B 的构造函数
（2）构造类A的对象后，B的 初始化 操作执行初始化类表的j(0)对j进行初始化。
（3）构造类B的对象后，类D 的  初始化  操作接着初始化其成员变量对象，这里是cc1,cc2,cc3.
 (4) 随着cc1,cc2,cc3这三个成员变量构造完毕，类D的构造函数的  初始化 操作部分结束，程序开始进入其构造函数的第二部分。
（5） 在c++中，创建销毁对象是影响性能的一个非常突出的操作。
（6）  您看到，如果在实现构造函数时，没有注意到执行构造函数体前的初始化操作已经将所有父类对象和成员变量对象构造完毕。