奇妙的(继承类对象)构造与析构顺序调用

 

 

//=================================================构造函数=======================================================

 

#include "stdio.h"
#include "iostream.h"

class A
{
public:
 A()
 {
  a=0;
  cout<<"调用A类的无参构造函数A()"<<endl;
 }
 A(int i)
 {
  a=i;
  cout<<"调用A类的带参构造函数A(int)"<<endl;
 }
 ~A()
 {
  cout<<"调用A类的析构函数"<<endl;
 }
 void Print() const
 {
  cout<<a<<",";
 }
 int Geta()
 {
  return a;
 }
private:
 int a;
};
//用类B继承类A
class B:public A
{
public:
 B()
 {
  b=0;
  cout<<"调用B类的无参构造函数B()"<<endl;
 }
 B(int i,int j,int k);
 ~B()
 {
  cout<<"调用B类的析构函数"<<endl;
 }
 void Print();
private:
 int b;
 A oa; //父类对象为子类成员变量.
};
B::B(int i,int j,int k)
{
 b=k;
 cout<<"调用B类的带参构造函数B(int,int,int)"<<endl;
}
void B::Print()
{
 A::Print();
 cout<<b<<","<<oa.Geta()<<endl;
}
void main()
{
 B ob[3];
 cout<<endl;
 ob[0]=B(1,2,3);
 cout<<endl;
 ob[1]=B(4,5,6);
 cout<<endl;
 ob[2]=B();
 cout<<endl;
 for(int i=0;i<3;i++)
  ob[i].Print();
 getchar();
}

 

//=================================================析构函数=======================================================

#include "stdio.h"
#include "iostream.h"
class M
{
public:
 M()
 {
  cout<<"M的无参构造函数被调用"<<endl;
  m1=m2=0;
 }
 M(int i,int j)
 {
  cout<<"M的有参构造函数被调用"<<endl;
  m1=i;
  m2=j;
 }
 ~M()
 {
  cout<<"M的析构函数被调用"<<endl;
 }
 void print()
 {
  cout<<m1<<","<<m2<<",";
 }
private:
 int m1,m2;
};
class N:public M
{
public:
 N()
 {
  cout<<"N的无参构造函数被调用"<<endl;
  n=0;
 }
 N(int i,int j,int k);
 ~N()
 {
  cout<<"N的析构函数被调用"<<endl;
 }
 void print()
 {
  M::print();
  cout<<n<<endl;
 }
private:
 int n;
};
N::N(int i,int j,int k):M(i,j),n(k)
{
 cout<<"N的有参构造函数被调用"<<endl;
}
void main()
{
 N n1(1,2,3),n2(4,5,6);
 n1.print();
 n2.print();
 n1.~N();
 n2.~N();
 getchar();
}

 

====================================================================================================================================

#include <iostream>
using namespace std;

class A
{
public:
 A()
 {
  cout<<"调用类 A 构造函数!"<<endl;
 }
 ~A()
 {
  cout<<"调用类 A 析构函数!"<<endl;
 }
 int aa;
};
class B:public A
{
public:
 B()
 {
  cout<<"调用类 B 构造函数!"<<endl;
 }
 B(int _a)
 {
  a=_a;
  cout<<"调用类 B 有参构造函数!"<<endl;
 }
 ~B()
 {
  cout<<"调用类 B 析构函数!"<<endl;
 }
 A b;
 int a;
};

void main()
{
 B a(3);
 cout<<"\t\t\t程序结束才回调用析构函数哦!"<<endl;
}