先上代码~~~

 #include<iostream.h>
        class A{
        private:
          int a;
        public:
          A(){ a=0;cout<<"A′s defanlt constructor called.\n"; }
          A(int i){ a=i;cout<<"A′s constructor called.\n"; }
          void print(){ cout<<a<<"，"; }
          ~A(){ cout<<"A′s destructor called.\n"; }
          int Geta(){ return a; }
        };
        class B: public A{
        public:
          B(){ b=0;cout<<"B′s defanlt constructor called.\n"; }
          B(int i,int j,int k):A(i),aa(j){ b=k;  cout<<"B′s constructor called.\n"; }
          void print();
          ~B(){ cout<<"B′s destructor called.\n"; }
        private:
          int b;
          A aa;                //子对象,或称为成员对象
        };
       void B::print(){
          A::print();
          cout<<b<<"，"<<aa.Geta()<<endl;
        }
        void main(){
          B bb[2]={B(1,2,5),B(3,4,7)};
          for(int i=0;i<2;i++) bb[i].print();
        }


运行结果：
A's constructor called.
A's constructor called.
B's constructor called.
A's constructor called.
A's constructor called.
B's constructor called.
1,5,2
3,7,4
B's destructor called.
A's destructor called.
A's destructor called.
B's destructor called.
A's destructor called.
A's destructor called.


我想问下，为什么在子对象调用构造函数的时候，调用的是
 A(int i){ a=i;cout<<"A′s constructor called.\n"; }
而不是
 A(){ a=0;cout<<"A′s defanlt constructor called.\n"; }
子对象aa不是不带参数吗？
后面析构函数调用同问。。。。不懂啊，到底什么时候调用缺省构造函数和缺省析构函数？

那你写 aa(j) 是干什么的呀

子对象aa是带参数的。
以main function的B(1, 2, 5)为例子：
B(1, 2, 5) =  
                B(1,2,5)
                : A(1)
                , aa(2)
                {
                  b=5;  
                  cout<<"B′s constructor called.\n";
                 }

于是，当B(1,2,5)被叫到时， contructor开始调出 private member variable A aa 的constructor A(int i)
导致第一个正式被打印出结果是A(int i){}里面的内容。


并且虽然不知道楼主想要问什么，不过继承和派生都没有用到。。。
先学一下virtual和protected member variable吧。

和上次的问题一模一样,都白和你讲了.

我上次说了那么多你都没看！ 痛心啊~~~~~~~~
你的 B bb 调用的是有参数的构造函数；所以a的构造也是调用的有参构造！！你试试 B b ； 看看结果就知道区别所在了！

试代码没什么啊，可是我不知道为什么会出现那样的结果。。。
其实我想问的就是，调用含参的构造或析构函数还是调用默认的构造或析构函数，到底看哪里啊？判断子对象是否含参数，到底看哪里的代码啊？

你的意思是说，判断子对象带不带参数，要看

B(int i,int j,int k):A(i),aa(j){ b=k;  cout<<"B′s constructor called.\n"; }

这一行代码？
也就是要看派生类构造函数初始化表中的子对象有没有参数？

请问楼主，你说的是不是这个意思
在class B 中写private A aa 就犹如在main函数中写
int main()
{
     A aa;
     return 0;
}
也就是说相当于是再class B中定义了一个变量
因为在main函数中有一个 A(){ a=0;cout<<"A′s defanlt constructor called.\n"; }的调用，所以B的构造函数B(int i,int j,int k):A(i),aa(j){ b=k;  cout<<"B′s constructor called.\n"; }
也应该有一个A′s defanlt constructor called.\n这样的东西出现

不是。。。没那么复杂。我就是看着

A aa;                //子对象,或称为成员对象

这行代码对aa没有初始化值，所以要调用那个没有参数的构造函数。。。
如果写的是

A aa（1）;                //子对象,或称为成员对象

我就用那个有参数的了。
因为我不知道从什么代码判断有参还是无参

那不就是我说的那个意思了，你把
class B: public A{
        private:
          int b;
          A aa;                //子对象,或称为成员对象
        };
中的A aa理解成相当于是在定义一个变量，所以就应该调用那个没有参数的A的构造函数
不然你这样试试
class B: public A{
        private:
          int b;
          A aa(1);                //子对象,或称为成员对象
        };
它肯定会给你提示错误的，所以就说明不是你理解的那个意思了嘛
它这样写
class B: public A{
        private:
          int b;
          A aa;                //子对象,或称为成员对象
        };
的意思不是在定义一个A变量，而是说B中含有A这个成员，而B中的A的初始化是在
B(int i,int j,int k):A(i),aa(j){ b=k;  cout<<"B′s constructor called.\n"; }这里面的aa(j)进行初始化，还是不懂你就这样写B(int i,int j,int k):A(i),aa(){ b=k;  cout<<"B′s constructor called.\n"; }或者这样写
B(int i,int j,int k):A(i){ b=k;  cout<<"B′s constructor called.\n"; }就能看到
A′s defanlt constructor called了