继承和派生（2）：析构和构造_default constructor called.-优快云博客

本文链接：https://blog.youkuaiyun.com/haoaoweitt/article/details/81565998

本文详细解析了派生类构造函数的工作原理，包括如何初始化基类子对象及成员对象，并通过实例展示了构造函数的调用顺序。此外，还介绍了派生类析构函数的执行过程及注意事项。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、构造函数

派生类的对象的数据结构是由基类中说明的数据成员和派生类中说明的数据成员共同构成。将派生类的对象中由基类中说明的数据成员和操作所构成的封装体称为基类子对象，它由基类中的构造函数进行初始化。

构造函数不能够被继承，因此，派生类的构造函数必须通过调用基类的构造函数来初始化基类子对象。所以，在定义派生类的构造函数时除了对自己的数据成员进行初始化外，还必须负责调用基类构造函数使基类数据成员得以初始化。如果派生类中还有子对象时，还应包含对子对象初始化的构造函数。

注意：构造函数的调用顺序：先祖先(基类) ，再客人(成员对象)，后自己(派生类) 。

案例一：

#include <iostream>
using namespace std;
class A
{ public:
    A(){a=0; cout<<"A's default constructor called."<<endl;}  //缺省的构造函数
    A(int i){a=i; cout<<"A's constructor called."<<endl;}    //含参数的构造函数
    ~A(){cout<<"A's destructor called."<<endl;}            //析构函数
    void Print() const {cout<<a<<". ";}
    int Geta(){return a;}
private:
	int a;
};
class B:public A
{ public:
   B(){b=0; cout<<"B's default constructor called."<<endl;}
   B(int i, int j, int k);
  ~B(){cout<<"B's destructor called."<<endl;}
   void Print();
private:
	int b; A aa;
};

B::B(int i, int j, int k):A(i),aa(j)  //I初始化基类，j初始化子对象，k初始化B的数据成员b
{
	b=k;
cout<<"B's constructor called."<<endl;
}

void B::Print()
{ A::Print();
cout<<b<<". "<<aa.Geta()<<endl;
}

int main()
{
	B bb[2];
	//bb[0]=B(1,2,5); 
	//bb[1]=B(3,4,7);
	for(int i=0;i<2;i++)
		bb[i].Print();

	return 0;
}

运行结果：

案例二：

#include <iostream>
using namespace std;
class A
{ public:
    A(){a=0; cout<<"A's default constructor called." <<"此时的a="<<a<<endl;}  //缺省的构造函数
    A(int i){a=i; cout<<"A's constructor called." <<"此时的a="<<a<<endl;}    //含参数的构造函数
    ~A(){cout<<"A's destructor called." <<"此时的a="<<a<<endl;}            //析构函数
    void Print() const {cout<<a<<". ";}
    int Geta(){return a;}
private:
	int a;
};
class B:public A
{ public:
   B(){b=0; cout<<"B's default constructor called."<<"此时的b="<<b<<endl;}
   B(int i, int j, int k);
  ~B(){cout<<"B's destructor called." <<"此时的b="<<b<<endl;}
   void Print();
private:
	int b; A aa;
};

B::B(int i, int j, int k):A(i),aa(j)  //I初始化基类，j初始化子对象，k初始化B的数据成员b
{
	b=k;
cout<<"B's constructor called."<<endl;
}

void B::Print()
{ A::Print();
cout<<b<<". "<<aa.Geta()<<endl;
}

int main()
{
	B bb[2];
	bb[0]=B(1,2,5); 
	bb[1]=B(3,4,7);
	for(int i=0;i<2;i++)
		bb[i].Print();

	return 0;
}

运行结果：

二、析构函数

当对象被删除时，派生类的析构函数被执行。由于析构函数也不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。

在派生类中是否定义析构函数与基类无关。若派生类对象在退出其作用域前,有数据需要做善后工作,就需要定义析构函数。基类的析构函数不会因派生类没有析构函数而得不到执行，它们各自是独立的。若基类、成员类、派生类都有析构函数，则执行的顺序是：先自己(派生类)，再客人(成员对象)，后祖先(基类)。其顺序与执行构造函数时的顺序正好相反。

参考例子：

#include <iostream> 
using namespace std;
class M 
{ public: 
    M(){m1=m2=0;}    
	M(int i,int j){m1=i;m2=j;}     
	void print(){cout<<m1<<", "<<m2<<", ";}     
	~M(){cout<<"M's destructor called."<<endl;}     
  private:        
	  int m1,m2; 
};
class N:public M 
{ public:     
   N(){n=0;}     
   N(int i, int j, int k);  
   void print()  
   { M::print(); cout<<n<<endl; }  
   ~N(){cout<<"N's destructor called"<<endl;}
  private:  
	int n; 
}; 

N::N(int i,int j,int k):M(i,j),n(k) {  }

int  main() 
{  
	N n1(5,6,7), n2(-2,-3,-4); 
	n1.print();  
	n2.print(); 
	return 0;
}

运行结果：