C++入门教程（六十二）：派生类对象的生命周期

小古银的官方网站（完整教程）：http://www.xiaoguyin.com/
C++入门教程视频：https://www.bilibili.com/video/av20868986/

目录

派生类对象的生命周期

基础示例 1

#include <iostream>

class baseclass
{
public:
    baseclass(void)
    {
        std::cout << "基类构造函数执行中" << std::endl;
    }
    ~baseclass(void)
    {
        std::cout << "基类析构函数执行中" << std::endl;
    }
};

class derivedclass : public baseclass
{
public:
    derivedclass(void)
    {
        std::cout << "派生类构造函数执行中" << std::endl;
    }
    ~derivedclass(void)
    {
        std::cout << "派生类析构函数执行中" << std::endl;
    }
};

int main(void)
{
    {
        derivedclass obj;
    }
    return 0;
}

输出结果：

基类构造函数执行中
派生类构造函数执行中
派生类析构函数执行中
基类析构函数执行中

基础讲解 1

由输出结果可以看出，当不显式调用基类的构造函数时，对象创建的时候也会调用基类的无参构造函数。

而调用顺序是：当对象创建的时候，先调用基类的构造函数，然后再调用派生类的构造函数；当对象销毁的时候，先调用派生类的析构函数，接着调用基类的析构函数。这样就可以保证派生类对象的数据不会错乱。

基础示例 2

#include <iostream>
#include <string>

class baseclass
{
public:
    baseclass(void)
    {
        std::cout << "基类第一个构造函数执行中" << std::endl;
    }
    baseclass(int)
    {
        std::cout << "基类第二个构造函数执行中" << std::endl;
    }
    ~baseclass(void)
    {
        std::cout << "基类析构函数执行中" << std::endl;
    }
};

class derivedclass : public baseclass
{
public:
    derivedclass(void)
    {
        std::cout << "派生类第一个构造函数执行中" << std::endl;
    }
    derivedclass(int)
    {
        std::cout << "派生类第二个构造函数执行中" << std::endl;
    }
    ~derivedclass(void)
    {
        std::cout << "派生类析构函数执行中" << std::endl;
    }
};

int main(void)
{
    {
        derivedclass obj;
    }
    std::cout << std::endl;

    {
        derivedclass obj(1);
    }
    std::cout << std::endl;
    return 0;
}

输出结果：

基类第一个构造函数执行中
派生类第一个构造函数执行中
派生类析构函数执行中
基类析构函数执行中

基类第一个构造函数执行中
派生类第二个构造函数执行中
派生类析构函数执行中
基类析构函数执行中

基础讲解 2

为了区分基类和派生类的不同的构造函数，所以使用了参数重载了构造函数。因此，构造函数的参数可以忽略。

从输出结果可以知道，只要没有写明调用基类的哪个构造函数，都会调用基类的无参构造函数。如果上面代码删除无参构造函数，即删除基类第一个构造函数，那么编译将会错误。因为编译器要为两个派生类的构造函数添加调用基类无参构造函数的代码，却找不到基类的无参构造函数，不能创建和初始化基类的成员，所以报错。

而调用顺序也是：当对象创建的时候，先调用基类的构造函数，然后再调用派生类的构造函数；当对象销毁的时候，先调用派生类的析构函数，接着调用基类的析构函数。这样就可以保证派生类对象的数据不会错乱。

基础示例 3

#include <iostream>
#include <string>

class baseclass
{
public:
    baseclass(void)
    {
        std::cout << "基类第一个构造函数执行中" << std::endl;
    }
    baseclass(int)
    {
        std::cout << "基类第二个构造函数执行中" << std::endl;
    }
    ~baseclass(void)
    {
        std::cout << "基类析构函数执行中" << std::endl;
    }
};

class derivedclass : public baseclass
{
public:
    derivedclass(void)
    {
        std::cout << "派生类第一个构造函数执行中" << std::endl;
    }
    derivedclass(int)
        : baseclass(1)
    {
        std::cout << "派生类第二个构造函数执行中" << std::endl;
    }
    ~derivedclass(void)
    {
        std::cout << "派生类析构函数执行中" << std::endl;
    }
};

int main(void)
{
    {
        derivedclass obj;
    }
    std::cout << std::endl;

    {
        derivedclass obj(1);
    }
    std::cout << std::endl;
    return 0;
}

输出结果：

基类第一个构造函数执行中
派生类第一个构造函数执行中
派生类析构函数执行中
基类析构函数执行中

基类第二个构造函数执行中
派生类第二个构造函数执行中
派生类析构函数执行中
基类析构函数执行中

基础讲解 3

为了区分基类和派生类的不同的构造函数，所以使用了参数重载了构造函数。因此，构造函数的参数可以忽略。

由输出结果可以看出，只要手动添加了需要调用基类的哪个构造函数，那么编译器就不会为它添加调用基类无参构造函数的代码。

基础示例 4

#include <iostream>
#include <string>

class testclass
{
public:
    testclass(void)
    {
        std::cout << "测试构造函数执行中" << std::endl;
    }
    ~testclass(void)
    {
        std::cout << "测试析构函数执行中" << std::endl;
    }
};

class baseclass
{
public:
    baseclass(void)
    {
        std::cout << "基类构造函数执行中" << std::endl;
    }
    ~baseclass(void)
    {
        std::cout << "基类析构函数执行中" << std::endl;
    }
};

class derivedclass : public baseclass
{
public:
    derivedclass(void)
    {
        std::cout << "派生类第一个构造函数执行中" << std::endl;
    }
    derivedclass(int)
        : baseclass()
    {
        std::cout << "派生类第二个构造函数执行中" << std::endl;
    }
    derivedclass(int, int)
        : test()
        , baseclass()
    {
        std::cout << "派生类第三个构造函数执行中" << std::endl;
    }
    ~derivedclass(void)
    {
        std::cout << "派生类析构函数执行中" << std::endl;
    }
private:
    testclass test;
};

int main(void)
{
    {
        derivedclass obj;
    }
    std::cout << std::endl;

    {
        derivedclass obj(1);
    }
    std::cout << std::endl;

    {
        derivedclass obj(1, 1);
    }
    std::cout << std::endl;
    return 0;
}

输出结果：

基类构造函数执行中
测试构造函数执行中
派生类第一个构造函数执行中
派生类析构函数执行中
测试析构函数执行中
基类析构函数执行中

基类构造函数执行中
测试构造函数执行中
派生类第二个构造函数执行中
派生类析构函数执行中
测试析构函数执行中
基类析构函数执行中

基类构造函数执行中
测试构造函数执行中
派生类第三个构造函数执行中
派生类析构函数执行中
测试析构函数执行中
基类析构函数执行中

基础讲解 4

为了区分基类和派生类的不同的构造函数，所以使用了参数重载了构造函数。因此，构造函数的参数可以忽略。

用派生类第一个构造函数和派生类第二个构造函数进行对比，可知无论是否写出基类构造函数调用代码，它的执行顺序都是先执行完基类构造函数，再创建和初始化派生类的成员变量；释放则是先释放派生类的成员变量内存，再调用基类的析构函数。

用派生类第二个构造函数和派生类第三个构造函数进行对比，可知它的调用顺序和初始化列表的顺序无关。

派生类生命周期总结

如果派生类构造函数没有显式调用基类构造函数，那么编译器就会在初始化列表中添加调用基类无参构造函数的代码；如果派生类构造函数显式地调用了基类构造函数，那么就会执行提供的基类构造函数。

派生类对象的创建顺序：基类成员变量创建和初始化 → 基类构造函数执行 → 派生类成员变量创建和初始化 → 派生类构造函数执行。

派生类对象的释放顺序：派生类析构函数执行 → 派生类成员变量释放 → 基类析构函数执行 → 基类成员变量释放。