C++面向对象编程之析构详解

概述

在C++面向对象编程中，析构函数是一种特殊的成员函数，它在对象被销毁时调用。析构函数通常用于在对象被销毁前，释放对象所占用的资源，如动态分配的内存空间、文件句柄等。

析构函数的函数名与类名相同，但前面加上 "~" 符号，且析构函数没有返回值和参数。

class MyClass {
public:
    MyClass();
    ~MyClass(); //析构函数
};

析构函数的调用时机

析构函数的调用时机有两种情况：
1. 对象被销毁时自动调用
2. 手动调用

当对象被销毁时，析构函数会自动调用，这种情况下，析构函数仅被调用一次。

MyClass obj;
// obj被销毁时，析构函数自动调用

如果需要手动调用析构函数，可以使用 delete 操作符，delete 操作符会自动调用对象的析构函数，释放对象所占用的所有资源。

MyClass* pObj = new MyClass();
// 后续处理...
delete pObj;
// 手动调用析构函数，释放资源

析构函数的执行顺序

当一个对象被销毁时，所有成员变量的析构函数和基类的析构函数按照它们的声明顺序相反的顺序逐个调用。

class A {
public:
    A() {
        cout << "A Constructor" << endl;
    }
    ~A() {
        cout << "A Destructor" << endl;
    }
};

class B {
protected:
    A a1;
public:
    B() {
        cout << "B Constructor" << endl;
    }
    ~B() {
        cout << "B Destructor" << endl;
    }
};

class C : public B {
public:
    A a2;
    C() {
        cout << "C Constructor" << endl;
    }
    ~C() {
        cout << "C Destructor" << endl;
    }
};

C obj_C;
// 输出以下内容：
// A Constructor
// A Constructor
// B Constructor
// A Constructor
// C Constructor
// C Destructor
// A Destructor
// A Destructor
// B Destructor
// A Destructor

某些情况下需要手动实现析构函数

在一些情况下，需要手动实现析构函数来释放资源。比如，当类中有指针类型的成员变量时，需要手动释放堆内存。

class MyClass {
public:
    MyClass();
    ~MyClass();
private:
    int* pData;
};

MyClass::MyClass() {
    pData = new int[10];
}

MyClass::~MyClass() {
    delete[] pData;
}

示例说明

示例 1

#include <iostream>
using namespace std;

class MyClass {
public:
    MyClass() {
        cout << "MyClass Constructor" << endl;
    }
    ~MyClass() {
        cout << "MyClass Destructor" << endl;
    }
};

int main() {
    MyClass obj;
    return 0;
}

// 输出以下内容：
// MyClass Constructor
// MyClass Destructor

在这个示例中，定义了一个 MyClass 类，其中定义了一个构造函数和析构函数。在 main 函数中，定义了一个 MyClass 对象，执行完 main 函数后，该对象会被销毁，此时析构函数会自动调用，输出 "MyClass Destructor"。

示例 2

#include <iostream>
using namespace std;

class A {
public:
    A() {
        cout << "A Constructor" << endl;
    }
    ~A() {
        cout << "A Destructor" << endl;
    }
};

class B {
protected:
    A a1;
public:
    B() {
        cout << "B Constructor" << endl;
    }
    ~B() {
        cout << "B Destructor" << endl;
    }
};

class C : public B {
public:
    A a2;
    C() {
        cout << "C Constructor" << endl;
    }
    ~C() {
        cout << "C Destructor" << endl;
    }
};

int main() {
    C obj_C;
    return 0;
}

// 输出以下内容：
// A Constructor
// A Constructor
// B Constructor
// A Constructor
// C Constructor
// C Destructor
// A Destructor
// A Destructor
// B Destructor
// A Destructor

在这个示例中，定义了三个类：A、B、C，分别在构造函数和析构函数中输出对象的创建和销毁过程。在 main 函数中，定义了一个 C 对象，执行完 main 函数后，该对象会被销毁，此时析构函数会自动调用，并按照从子类到父类的顺序逐个调用，输出相应的信息。