多个类中包含子对象时(构造函数,析构函数,初始化列表顺序)

/*

      此程序定义了 A,B,Sample 三个类.

      主函数main()定义一个类的对象s.因为Sample类中包含了类A和类B的子对象a与b,所以构造函数的调用顺序是先调用子对象的构造函数.

      ( 按照它们在类定义时出现的顺序,而不是按照构造列表中出现的顺序. ) 所以先调用a的构造函数,在调用b的构造函数.

      于是打印出:

      A Constructor

      B Constructor

     紧接着打印出,Sample类的构造函数.

     Sample Constructor

     调用了Sample类的构造函数后,程序接着往下走,走完了,于是再调用析构函数.所以打印出.

     Sample Destructor

     (这里可能我有些不懂,为什么先输出了(前面后调用的类B构造函数),先打印出B的析构函数)

     (我想可能是不是因为 内存中存储在 "栈" 中的 " 先进后出","后进先出" 的原则呢).

     如果是按这个原理的话:

     最先初始化调用存储的A,和最后初始化存储调用的B.

     后进先出,于是 先打印出 B 的析构函数.

     B Destructor

     然后调用A的析构函数,

     A Destructor

     最后程序结束.

    (  程序大致走向: 

               首先构造Sample 对象s  --------- 因为类中包含子类对象(先调用子对象构造函数) (按照类定义子类对象的顺序)      -----------(先调用 A构造   然后B构造)

               -------------- 回到Sample对象s 的构造  ---------------- Sample s对象构造完后,因为程序走完,析构,,-----------------  可能是存贮在 "栈" (先进后出,后进先出原则)

              ------------ 所以a是最先构造---------b后构造-----------s构造-----------s析构---------b析构--------a析构. (程序运行结束).

  )

    请注意:程序中内存运行的走向原则,完全个人理解,因为是初学有很多不懂,只是把自己的"认为"写出来,如果有不对的地方,还望请多多指正!!

 

      完整打印结果:

     A Constructor

     B Constructor

     Sample Constructor

     Sample Destructor

     B Destructor

     A Destructor

*/ 

 

 

#include <iostream.h>

class A
{
public:
/* A()
 {
  cout<<"A default"<<endl;
 }*/
 A(int i)
 {
  cout<<"A Constructor"<<endl;
 }
 ~A()
 {
  cout<<"A Destructor"<<endl;
 }
};

class B
{
public:
/* B()
 {
  cout<<"B default"<<endl;
 }*/
 B(int i)
 {
  cout<<"B Constructor"<<endl;
 }
 ~B()
 {
  cout<<"B Destructor"<<endl;
 }
};

class Sample
{
public:
 Sample():b(11),a(11)       //这里是初始化列表
 {
  cout<<"Sample Constructor"<<endl;
 }
 ~Sample()
 {
  cout<<"Sample Destructore"<<endl;
 }
private:        //这里是定义的子类对象
 A a;
 B b;
};

void main()
{
 Sample s;
}