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

C++类虚析构函数的必要性

2023-02-074.0k 阅读

C++ 类虚析构函数的概念

在 C++ 中，析构函数是类的特殊成员函数，用于在对象生命周期结束时释放对象所占用的资源，比如动态分配的内存等。而虚析构函数则是在析构函数声明前加上 virtual 关键字。

当一个类被设计为基类，并且可能会通过基类指针或引用操作派生类对象时，虚析构函数就变得非常重要。例如，考虑以下简单的类层次结构：

class Base {
public:
    ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

在上述代码中，Base 类有一个普通的析构函数，Derived 类从 Base 类派生，并且有自己的析构函数。当我们通过 Base 类指针来删除 Derived 类对象时，会出现意想不到的情况。

int main() {
    Base* ptr = new Derived();
    delete ptr;
    return 0;
}

在上述 main 函数中，我们创建了一个 Derived 类对象，并使用 Base 类指针指向它。然后通过 Base 类指针调用 delete。此时，输出结果只会是 “Base destructor”，Derived 类的析构函数不会被调用。这是因为普通的析构函数不会进行动态绑定，编译器根据指针的静态类型（这里是 Base*）来决定调用哪个析构函数。

如果将 Base 类的析构函数声明为虚析构函数，即：

class Base {
public:
    virtual ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

int main() {
    Base* ptr = new Derived();
    delete ptr;
    return 0;
}

此时，输出结果将是 “Derived destructor” 然后是 “Base destructor”。这是因为虚析构函数利用了 C++ 的动态绑定机制，在运行时根据对象的实际类型（这里是 Derived）来调用正确的析构函数。在调用 Derived 类的析构函数后，会自动调用基类 Base 的析构函数，这符合对象销毁的顺序，即先销毁派生类部分，再销毁基类部分。

内存泄漏问题与虚析构函数

简单内存分配场景下的内存泄漏

内存泄漏是使用 C++ 时需要特别注意的问题之一，而虚析构函数与内存泄漏紧密相关。考虑一个更实际的例子，假设 Derived 类在构造函数中动态分配了内存：

class Base {
public:
    ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
private:
    int* data;
public:
    Derived() {
        data = new int[10];
        std::cout << "Derived constructor" << std::endl;
    }
    ~Derived() {
        delete[] data;
        std::cout << "Derived destructor" << std::endl;
    }
};

当我们使用 Base 类指针来操作 Derived 类对象，并在不使用虚析构函数的情况下删除对象时：

int main() {
    Base* ptr = new Derived();
    delete ptr;
    return 0;
}

此时，Derived 类中动态分配的数组 data 不会被释放，因为 Derived 类的析构函数没有被调用，从而导致内存泄漏。

复杂对象组合场景下的内存泄漏

内存泄漏问题在更复杂的对象组合场景下可能更加隐蔽。假设有如下类结构：

class Component {
public:
    Component() {
        std::cout << "Component constructor" << std::endl;
    }
    ~Component() {
        std::cout << "Component destructor" << std::endl;
    }
};

class Base {
public:
    ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
private:
    Component* component;
public:
    Derived() {
        component = new Component();
        std::cout << "Derived constructor" << std::endl;
    }
    ~Derived() {
        delete component;
        std::cout << "Derived destructor" << std::endl;
    }
};

在这个例子中，Derived 类包含一个 Component 类的指针，并在构造函数中分配内存，在析构函数中释放内存。如果我们像之前一样，通过 Base 类指针删除 Derived 类对象，而 Base 类没有虚析构函数：

int main() {
    Base* ptr = new Derived();
    delete ptr;
    return 0;
}

不仅 Derived 类的析构函数不会被调用，导致 Component 对象没有被释放，还会因为 Component 对象没有被正确销毁，可能引发进一步的问题，比如该对象持有其他资源也未被释放等。

容器中对象的内存泄漏

在使用容器存储对象指针时，虚析构函数的缺失也会导致内存泄漏。例如，使用 std::vector 存储 Base 类指针，实际指向 Derived 类对象：

#include <vector>

class Base {
public:
    ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

int main() {
    std::vector<Base*> vec;
    vec.push_back(new Derived());
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        delete *it;
    }
    return 0;
}

在上述代码中，由于 Base 类没有虚析构函数，在删除 vec 中的指针时，只有 Base 类的析构函数会被调用，Derived 类的析构函数不会被调用，从而导致内存泄漏。

多态与虚析构函数

多态的概念与实现

多态是 C++ 面向对象编程的重要特性之一，它允许通过基类指针或引用调用派生类的函数，实现运行时的行为决策。多态的实现依赖于虚函数和动态绑定机制。当一个函数在基类中声明为虚函数，并且在派生类中被重写时，通过基类指针或引用调用该函数，实际调用的是派生类中的函数版本，这就是动态绑定。

例如：

class Base {
public:
    virtual void print() {
        std::cout << "Base print" << std::endl;
    }
};

class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived print" << std::endl;
    }
};

int main() {
    Base* ptr = new Derived();
    ptr->print();
    delete ptr;
    return 0;
}

在上述代码中，Base 类的 print 函数声明为虚函数，Derived 类重写了 print 函数。通过 Base 类指针调用 print 函数时，实际调用的是 Derived 类的 print 函数，这体现了多态性。

虚析构函数在多态中的作用

虚析构函数在多态的场景下起着至关重要的作用。析构函数本质上也是类的成员函数，在多态的情况下，当通过基类指针删除派生类对象时，需要确保调用的是派生类的析构函数，以正确释放派生类对象的资源。

如果没有虚析构函数，就会破坏多态的完整性。例如，在前面关于 Base 和 Derived 类的例子中，如果 Base 类没有虚析构函数，在通过 Base 类指针删除 Derived 类对象时，就无法正确调用 Derived 类的析构函数，这与多态的动态绑定机制相悖。

从底层原理来看，C++ 的虚函数表（vtable）存储了虚函数的地址。当一个对象被创建时，会有一个指向虚函数表的指针（vptr）。对于基类指针指向派生类对象的情况，通过 vptr 可以在运行时找到派生类中虚函数的地址并调用。虚析构函数同样依赖于这个机制，当 Base 类的析构函数是虚函数时，在通过 Base 类指针删除 Derived 类对象时，会根据对象实际的 vptr 找到 Derived 类的析构函数并调用。

纯虚析构函数

在一些情况下，我们可能会定义纯虚析构函数。纯虚析构函数是在基类中声明为纯虚的析构函数，并且基类必须提供该纯虚析构函数的实现。例如：

class Base {
public:
    virtual ~Base() = 0;
};

Base::~Base() {
    std::cout << "Base pure virtual destructor" << std::endl;
}

class Derived : public Base {
public:
    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

纯虚析构函数的存在主要是为了确保基类是抽象类，同时也为派生类提供了正确的析构函数调用机制。当通过 Base 类指针删除 Derived 类对象时，首先会调用 Derived 类的析构函数，然后调用 Base 类的纯虚析构函数实现。

纯虚析构函数的使用场景通常是在基类作为抽象概念，不应该被实例化，同时需要为派生类提供统一的析构行为规范的情况下。例如，在设计一个图形类的层次结构时，基类 Shape 可以定义为抽象类，包含纯虚析构函数，而具体的 Circle、Rectangle 等派生类从 Shape 派生，并实现自己的析构函数来释放与图形相关的资源。

继承体系中的虚析构函数

多层继承中的虚析构函数

在多层继承的体系中，虚析构函数的重要性更加凸显。假设有如下多层继承结构：

class Base {
public:
    ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Intermediate : public Base {
public:
    ~Intermediate() {
        std::cout << "Intermediate destructor" << std::endl;
    }
};

class Derived : public Intermediate {
public:
    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

当我们通过 Base 类指针删除 Derived 类对象，而 Base 类没有虚析构函数时：

int main() {
    Base* ptr = new Derived();
    delete ptr;
    return 0;
}

只有 Base 类的析构函数会被调用，Intermediate 类和 Derived 类的析构函数都不会被调用，这将导致 Intermediate 类和 Derived 类所占用的资源无法正确释放。

如果在 Base 类中声明虚析构函数：

class Base {
public:
    virtual ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Intermediate : public Base {
public:
    ~Intermediate() {
        std::cout << "Intermediate destructor" << std::endl;
    }
};

class Derived : public Intermediate {
public:
    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

int main() {
    Base* ptr = new Derived();
    delete ptr;
    return 0;
}

此时，析构函数的调用顺序将是 Derived 类析构函数、Intermediate 类析构函数，最后是 Base 类析构函数，这样就保证了对象在多层继承体系下的正确销毁。

虚析构函数与菱形继承

菱形继承是一种特殊的继承结构，可能会导致一些问题，虚析构函数在这种情况下也起着重要作用。考虑如下菱形继承结构：

class A {
public:
    ~A() {
        std::cout << "A destructor" << std::endl;
    }
};

class B : public A {
public:
    ~B() {
        std::cout << "B destructor" << std::endl;
    }
};

class C : public A {
public:
    ~C() {
        std::cout << "C destructor" << std::endl;
    }
};

class D : public B, public C {
public:
    ~D() {
        std::cout << "D destructor" << std::endl;
    }
};

在这个菱形继承结构中，如果 A 类没有虚析构函数，当通过 A 类指针删除 D 类对象时，可能会出现未定义行为。因为 D 类从 B 和 C 间接继承了 A 类，可能会存在多个 A 类子对象，这在销毁对象时会产生混乱。

如果将 A 类的析构函数声明为虚析构函数：

class A {
public:
    virtual ~A() {
        std::cout << "A destructor" << std::endl;
    }
};

class B : public A {
public:
    ~B() {
        std::cout << "B destructor" << std::endl;
    }
};

class C : public A {
public:
    ~C() {
        std::cout << "C destructor" << std::endl;
    }
};

class D : public B, public C {
public:
    ~D() {
        std::cout << "D destructor" << std::endl;
    }
};

当通过 A 类指针删除 D 类对象时，会正确调用 D 类、B 类、C 类和 A 类的析构函数，并且 A 类的析构函数只会被调用一次，从而避免了由于菱形继承带来的对象销毁问题。

虚析构函数与多重继承

多重继承是指一个类从多个基类继承。在多重继承的情况下，虚析构函数同样是必要的。例如：

class Base1 {
public:
    ~Base1() {
        std::cout << "Base1 destructor" << std::endl;
    }
};

class Base2 {
public:
    ~Base2() {
        std::cout << "Base2 destructor" << std::endl;
    }
};

class Derived : public Base1, public Base2 {
public:
    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

当通过 Base1 类指针或 Base2 类指针删除 Derived 类对象时，如果 Base1 和 Base2 类没有虚析构函数，可能会导致 Derived 类的析构函数无法正确调用，进而导致资源泄漏。

将 Base1 和 Base2 类的析构函数声明为虚析构函数：

class Base1 {
public:
    virtual ~Base1() {
        std::cout << "Base1 destructor" << std::endl;
    }
};

class Base2 {
public:
    virtual ~Base2() {
        std::cout << "Base2 destructor" << std::endl;
    }
};

class Derived : public Base1, public Base2 {
public:
    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

这样，无论通过 Base1 类指针还是 Base2 类指针删除 Derived 类对象，都能正确调用 Derived 类及其基类的析构函数，保证对象的正确销毁。

虚析构函数的性能考虑

虚析构函数带来的额外开销

虚析构函数虽然解决了对象销毁时的重要问题，但也带来了一些额外的性能开销。由于虚析构函数依赖于虚函数表机制，每个包含虚函数（包括虚析构函数）的类对象都会有一个指向虚函数表的指针（vptr），这会增加对象的大小。在 32 位系统上，vptr 通常占用 4 个字节，在 64 位系统上，vptr 通常占用 8 个字节。

例如，对于一个简单的类：

class Simple {
public:
    int value;
};

这个类对象的大小通常是 4 个字节（假设 int 是 4 个字节）。而如果将其析构函数声明为虚析构函数：

class Simple {
public:
    int value;
    virtual ~Simple() {}
};

此时，对象的大小会增加到 12 个字节（4 个字节的 int 加上 8 个字节的 vptr，在 64 位系统下）。

在调用虚析构函数时，由于需要通过虚函数表查找实际的析构函数地址，这也会带来一定的时间开销。与调用普通析构函数相比，虚析构函数的调用涉及到间接寻址，会增加指令的执行周期。

何时可以不使用虚析构函数

虽然虚析构函数在很多情况下是必要的，但在某些特定场景下，可以不使用虚析构函数以避免性能开销。

  1. 当类不会被继承时：如果一个类被设计为最终类，即不会有派生类，那么将其析构函数声明为虚函数是没有必要的。例如，一些工具类，它们提供特定的功能，并且不希望被继承扩展，如 std::string 类。std::string 类没有虚析构函数，因为它不打算被继承。

  2. 当对象的创建和销毁方式确定不涉及多态时：如果对象总是通过具体类的指针或引用进行操作，而不会通过基类指针或引用，那么虚析构函数也不是必需的。例如，在一个函数内部创建和销毁对象，并且对象的类型在编译时就确定，不会涉及到多态行为。

void someFunction() {
    Derived obj;
    // 对 obj 进行操作
}

在上述函数中，Derived 类对象 obj 的生命周期在函数内部，并且不会通过基类指针操作，所以 Derived 类及其基类不需要虚析构函数。

优化虚析构函数性能的方法

虽然虚析构函数会带来一定的性能开销，但在一些情况下，可以采取一些优化措施来减轻这种开销。

  1. 尽量减少虚函数表的查找次数：在设计类层次结构时，尽量避免不必要的虚函数调用。例如，将一些不涉及多态行为的函数设计为普通函数，而不是虚函数。这样在调用这些函数时，就不会涉及虚函数表的查找。

  2. 使用对象池技术：对象池技术可以减少对象的频繁创建和销毁。通过预先创建一定数量的对象，并在需要时从对象池中获取，使用完毕后放回对象池，避免了每次都通过 new 和 delete 操作。这样，虚析构函数的调用次数也会相应减少，从而减轻性能开销。

  3. 权衡内存和性能：在一些对性能要求极高的场景下，如果内存空间允许，可以考虑通过复制对象而不是使用指针和多态来操作对象。这样可以避免虚函数表带来的开销，但可能会占用更多的内存空间。

总结虚析构函数的必要性

虚析构函数在 C++ 类的设计中具有极其重要的地位。它确保了在多态场景下，通过基类指针或引用删除派生类对象时，能够正确调用派生类及其基类的析构函数，从而避免内存泄漏等严重问题。

在多层继承、菱形继承和多重继承等复杂的继承体系中，虚析构函数更是保证对象正确销毁的关键。虽然虚析构函数会带来一定的性能开销，但在大多数面向对象编程场景中，这种开销是为了换取程序的正确性和健壮性所必须付出的代价。

对于可能作为基类的类，尤其是那些设计用于多态操作的基类，将析构函数声明为虚析构函数是一种良好的编程习惯。只有在明确类不会被继承或对象的操作不涉及多态的情况下，才可以考虑不使用虚析构函数以优化性能。总之，正确使用虚析构函数是编写高质量、可靠的 C++ 代码的重要一环。