MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

C++子类析构时调用父类析构函数的情况

2022-09-252.9k 阅读

C++子类析构时调用父类析构函数的情况

一、面向对象编程中的继承与析构

在C++的面向对象编程中，继承是一个核心特性，它允许一个类（子类或派生类）继承另一个类（父类或基类）的属性和方法。这种机制极大地提高了代码的复用性和可维护性。然而，当涉及到对象生命周期的管理，特别是析构函数的调用时，情况变得相对复杂。析构函数用于在对象销毁时执行清理工作，比如释放内存、关闭文件等资源。在继承体系中，了解子类析构时如何调用父类析构函数至关重要，这关系到程序的正确性和资源管理的有效性。

二、C++析构函数基础

在深入探讨子类析构时调用父类析构函数的情况之前，先来回顾一下C++析构函数的基本概念。

（一）析构函数的定义与特性

  1. 定义：析构函数是一个特殊的成员函数，它的名字与类名相同，但前面加上波浪号~。例如，对于类MyClass，其析构函数定义为~MyClass()。
  2. 特性：
    • 析构函数没有参数，也没有返回值（包括void）。
    • 一个类只能有一个析构函数。如果没有显式定义析构函数，编译器会自动生成一个默认析构函数。默认析构函数执行的是成员变量的析构函数，如果成员变量是对象类型，会调用其对应的析构函数；对于基本数据类型成员变量，默认析构函数不执行任何操作。
    • 析构函数在对象生命周期结束时自动被调用，例如对象超出作用域、被显式删除（对于动态分配的对象）等情况。

（二）析构函数的作用

  1. 资源清理：最主要的作用是清理对象在生命周期中分配的资源。例如，如果一个类在构造函数中分配了动态内存（使用new运算符），那么在析构函数中必须使用delete运算符释放这些内存，以避免内存泄漏。
  2. 关闭文件等操作：如果类在运行过程中打开了文件、网络连接等资源，析构函数可以负责关闭这些资源，确保资源的正确释放和程序的正常结束。

下面通过一个简单的例子来展示析构函数的基本使用：

#include <iostream>
class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor called." << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor called." << std::endl;
    }
};
int main() {
    MyClass obj;
    return 0;
}

在上述代码中，当MyClass对象obj在main函数中创建时，构造函数被调用，输出MyClass constructor called.。当obj超出main函数的作用域时，析构函数被自动调用，输出MyClass destructor called.。

三、继承体系下的析构函数

（一）继承的基本概念回顾

在C++中，子类通过以下语法继承父类：

class Parent {
    // 父类成员
};
class Child : public Parent {
    // 子类成员
};

这里Child类以public方式继承Parent类，意味着Child类可以访问Parent类的public和protected成员。

（二）子类析构函数与父类析构函数的关系

  1. 默认调用情况：当子类对象被销毁时，会自动调用子类的析构函数。在子类析构函数执行完毕后，会自动调用父类的析构函数。这是C++编译器的默认行为，无需显式调用。
  2. 原因：这种机制保证了对象的资源清理顺序与构造顺序相反。在构造对象时，先调用父类构造函数，再调用子类构造函数，以确保对象的初始化是从父类到子类逐步完成的。而在析构时，先调用子类析构函数，再调用父类析构函数，保证资源的释放也是从子类到父类的顺序，这样可以避免父类析构时访问到子类已释放的资源。

下面通过一个简单的继承示例来展示这种默认调用情况：

#include <iostream>
class Parent {
public:
    Parent() {
        std::cout << "Parent constructor called." << std::endl;
    }
    ~Parent() {
        std::cout << "Parent destructor called." << std::endl;
    }
};
class Child : public Parent {
public:
    Child() {
        std::cout << "Child constructor called." << std::endl;
    }
    ~Child() {
        std::cout << "Child destructor called." << std::endl;
    }
};
int main() {
    Child obj;
    return 0;
}

在上述代码中，当Child对象obj创建时，先调用Parent类的构造函数，输出Parent constructor called.，然后调用Child类的构造函数，输出Child constructor called.。当obj超出作用域被销毁时，先调用Child类的析构函数，输出Child destructor called.，然后调用Parent类的析构函数，输出Parent destructor called.。

四、显式调用父类析构函数

虽然在大多数情况下，编译器会自动在子类析构函数执行完毕后调用父类析构函数，但在某些特殊情况下，可能需要显式调用父类析构函数。

（一）特殊情况举例

  1. 多重继承：在多重继承的情况下，一个子类可能从多个父类继承。当需要在子类析构函数中进行特定的清理操作，并且希望在执行这些操作之前或之后明确调用某个父类的析构函数时，就可能需要显式调用。
  2. 复杂资源管理：如果子类和父类的资源管理存在复杂的依赖关系，例如子类的某些资源释放需要父类处于特定状态，可能需要在子类析构函数中显式调用父类析构函数来控制资源释放的顺序。

（二）显式调用语法

在子类析构函数中，可以使用Parent::~Parent()的语法来显式调用父类的析构函数。需要注意的是，这种显式调用通常在子类析构函数内部的合适位置进行，而不是代替编译器的默认调用。编译器仍然会在子类析构函数结束时自动调用父类析构函数，显式调用只是在子类析构函数执行过程中额外执行一次父类析构函数的操作。

下面通过一个多重继承的例子来展示显式调用父类析构函数：

#include <iostream>
class Parent1 {
public:
    Parent1() {
        std::cout << "Parent1 constructor called." << std::endl;
    }
    ~Parent1() {
        std::cout << "Parent1 destructor called." << std::endl;
    }
};
class Parent2 {
public:
    Parent2() {
        std::cout << "Parent2 constructor called." << std::endl;
    }
    ~Parent2() {
        std::cout << "Parent2 destructor called." << std::endl;
    }
};
class Child : public Parent1, public Parent2 {
public:
    Child() {
        std::cout << "Child constructor called." << std::endl;
    }
    ~Child() {
        std::cout << "Before explicit call to Parent1 destructor." << std::endl;
        Parent1::~Parent1();
        std::cout << "After explicit call to Parent1 destructor." << std::endl;
        std::cout << "Child destructor finishing." << std::endl;
    }
};
int main() {
    Child obj;
    return 0;
}

在上述代码中，Child类从Parent1和Parent2多重继承。在Child类的析构函数中，显式调用了Parent1类的析构函数。程序输出结果如下：

Parent1 constructor called.
Parent2 constructor called.
Child constructor called.
Before explicit call to Parent1 destructor.
Parent1 destructor called.
After explicit call to Parent1 destructor.
Child destructor finishing.
Parent2 destructor called.
Parent1 destructor called.

可以看到，显式调用Parent1类的析构函数后，编译器在Child类析构函数结束时仍然会自动调用Parent1和Parent2类的析构函数。

五、虚析构函数与子类析构

（一）虚析构函数的引入

当使用基类指针或引用指向派生类对象时，如果基类的析构函数不是虚函数，可能会导致内存泄漏等问题。这是因为通过基类指针删除派生类对象时，只会调用基类的析构函数，而不会调用派生类的析构函数。

考虑以下代码：

#include <iostream>
class Parent {
public:
    Parent() {
        std::cout << "Parent constructor called." << std::endl;
    }
    ~Parent() {
        std::cout << "Parent destructor called." << std::endl;
    }
};
class Child : public Parent {
public:
    Child() {
        std::cout << "Child constructor called." << std::endl;
    }
    ~Child() {
        std::cout << "Child destructor called." << std::endl;
    }
};
int main() {
    Parent* ptr = new Child();
    delete ptr;
    return 0;
}

在上述代码中，通过Parent类指针ptr指向Child类对象，并使用delete ptr来释放内存。由于Parent类的析构函数不是虚函数，此时只会调用Parent类的析构函数，输出：

Parent constructor called.
Child constructor called.
Parent destructor called.

可以看到，Child类的析构函数没有被调用，这可能会导致Child类在构造函数中分配的资源无法释放，从而造成内存泄漏。

（二）虚析构函数的作用

为了解决上述问题，C++引入了虚析构函数。当基类的析构函数声明为虚函数时，通过基类指针或引用删除派生类对象时，会首先调用派生类的析构函数，然后再调用基类的析构函数，确保资源的正确释放。

修改上述代码，将Parent类的析构函数声明为虚函数：

#include <iostream>
class Parent {
public:
    Parent() {
        std::cout << "Parent constructor called." << std::endl;
    }
    virtual ~Parent() {
        std::cout << "Parent destructor called." << std::endl;
    }
};
class Child : public Parent {
public:
    Child() {
        std::cout << "Child constructor called." << std::endl;
    }
    ~Child() {
        std::cout << "Child destructor called." << std::endl;
    }
};
int main() {
    Parent* ptr = new Child();
    delete ptr;
    return 0;
}

此时输出结果为：

Parent constructor called.
Child constructor called.
Child destructor called.
Parent destructor called.

可以看到，Child类的析构函数被正确调用，资源得到了正确释放。

（三）虚析构函数的实现原理

虚析构函数的实现依赖于C++的虚函数表机制。每个包含虚函数的类都有一个虚函数表（vtable），其中存储了虚函数的地址。当对象被创建时，会有一个指向虚函数表的指针（vptr）。当通过基类指针调用虚函数时，实际上是通过对象的vptr找到对应的虚函数表，然后根据虚函数表中存储的函数地址来调用实际的函数。对于虚析构函数，同样遵循这个机制，确保在删除对象时能够正确调用到派生类的析构函数。

六、纯虚析构函数

（一）纯虚析构函数的定义

纯虚析构函数是一种特殊的虚析构函数，它在声明时被赋值为0，并且在类外必须有定义。定义纯虚析构函数的语法如下：

class Base {
public:
    virtual ~Base() = 0;
};
Base::~Base() {
    // 纯虚析构函数的实现
}

（二）纯虚析构函数的使用场景

  1. 抽象基类：在设计抽象基类时，有时希望基类不能被实例化，同时提供一个统一的析构函数接口供派生类调用。纯虚析构函数可以满足这种需求，使得基类成为抽象类（不能被实例化），同时确保派生类在析构时能够正确调用基类的析构函数。
  2. 强制派生类实现清理逻辑：通过定义纯虚析构函数，可以强制派生类实现自己的析构逻辑，同时也能保证基类的清理工作得以执行。

下面通过一个示例展示纯虚析构函数的使用：

#include <iostream>
class Shape {
public:
    virtual ~Shape() = 0;
    virtual double area() const = 0;
};
Shape::~Shape() {
    std::cout << "Shape destructor called." << std::endl;
}
class Circle : public Shape {
public:
    Circle(double r) : radius(r) {}
    ~Circle() {
        std::cout << "Circle destructor called." << std::endl;
    }
    double area() const override {
        return 3.14 * radius * radius;
    }
private:
    double radius;
};
int main() {
    Shape* shape = new Circle(5.0);
    std::cout << "Area of circle: " << shape->area() << std::endl;
    delete shape;
    return 0;
}

在上述代码中，Shape类是一个抽象基类，它有一个纯虚析构函数和一个纯虚函数area。Circle类继承自Shape类并实现了area函数和自己的析构函数。当通过Shape类指针删除Circle类对象时，会先调用Circle类的析构函数，再调用Shape类的析构函数。

七、析构函数调用顺序的总结与注意事项

（一）总结调用顺序

  1. 普通继承：当子类对象被销毁时，首先调用子类的析构函数，然后自动调用父类的析构函数。
  2. 多重继承：在多重继承中，析构函数的调用顺序与构造函数的调用顺序相反。先调用子类的析构函数，然后按照从左到右的顺序调用各个父类的析构函数（如果有显式调用父类析构函数，会在显式调用处额外执行一次相应父类的析构函数操作，但编译器仍会在子类析构函数结束时按顺序自动调用所有父类析构函数）。
  3. 虚析构函数：当通过基类指针或引用删除派生类对象，且基类析构函数为虚函数时，首先调用派生类的析构函数，然后调用基类的析构函数。

（二）注意事项

  1. 避免内存泄漏：确保在析构函数中正确释放对象在生命周期中分配的所有资源，特别是在继承体系中，要注意子类和父类资源的正确释放顺序。如果基类析构函数不是虚函数，通过基类指针删除派生类对象可能会导致内存泄漏，应将基类析构函数声明为虚函数。
  2. 合理使用显式调用：虽然在大多数情况下编译器会自动处理父类析构函数的调用，但在某些复杂场景下，如多重继承和特殊资源管理需求时，可能需要显式调用父类析构函数。显式调用时要注意调用的位置和时机，避免重复释放资源或导致其他未定义行为。
  3. 纯虚析构函数的定义：如果一个类定义了纯虚析构函数，必须在类外提供其实现，否则链接时会报错。同时，包含纯虚析构函数的类是抽象类，不能被实例化。

通过深入理解C++子类析构时调用父类析构函数的各种情况，开发者能够更加准确地管理对象的生命周期，避免资源泄漏等问题，编写出健壮、高效的C++程序。在实际编程中，根据具体的业务需求和对象的资源管理特点，合理运用析构函数的调用机制，是保证程序正确性和稳定性的重要环节。无论是简单的继承关系，还是复杂的多重继承和虚函数场景，都需要仔细考虑析构函数的设计和调用顺序，以确保程序能够正确地释放资源，避免潜在的内存错误和未定义行为。