C++析构函数

一、概述

析构函数是一种特殊的成员函数，用于在对象的生命周期结束时执行清理操作。析构函数的主要作用是释放对象在其生命周期内分配的资源，如内存、文件句柄等，从而避免资源泄漏。析构函数与构造函数相对应，在对象被销毁时自动调用。

二、特点

1. 名称与类名相同，但前面带有波浪号 ~：析构函数的名称与类名相同，只是前面有一个波浪号 ~。
2. 没有参数和返回类型：析构函数不能接受参数，也没有返回类型。
3. 每个类只能有一个析构函数：与构造函数不同，一个类只能有一个析构函数，不能重载。
4. 自动调用：当对象的生命周期结束时（例如对象超出作用域或显式调用 delete 时），析构函数会被自动调用。

三、析构函数的定义与使用

#include <iostream>
#include <string>

class Person {
private:
    std::string name;
    int age;

public:
    // 构造函数
    Person(std::string newName, int newAge) : name(newName), age(newAge) {
        std::cout << "Constructor called for " << name << std::endl;
    }

    // 析构函数
    ~Person() {
        std::cout << "Destructor called for " << name << std::endl;
    }

    // 打印个人信息的成员函数
    void printInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    // 创建一个 Person 对象
    Person person1("Alice", 30);
    person1.printInfo();

    {
        // 创建另一个 Person 对象
        Person person2("Bob", 25);
        person2.printInfo();
    } // person2 在这里超出作用域，析构函数被调用

    // person1 在 main() 结束时超出作用域，析构函数被调用
    return 0;
}

在这个示例中，Person 类有一个构造函数和一个析构函数。构造函数在对象创建时被调用，初始化对象的属性。析构函数在对象销毁时被调用，用于执行清理操作。在 main() 函数中，当 person1 和 person2 对象的生命周期结束时，析构函数会自动被调用，输出相应的信息。

四、自定义析构函数

#include <iostream>

class DynamicArray {
private:
    int* array;
    int size;

public:
    // 构造函数：动态分配内存
    DynamicArray(int s) : size(s) {
        array = new int[size];
        std::cout << "Constructor: Array of size " << size << " created." << std::endl;
    }

    // 析构函数：释放动态分配的内存
    ~DynamicArray() {
        delete[] array;
        std::cout << "Destructor: Array of size " << size << " destroyed." << std::endl;
    }

    // 打印数组的成员函数
    void printArray() {
        for (int i = 0; i < size; ++i) {
            std::cout << array[i] << " ";
        }
        std::cout << std::endl;
    }

    // 设置数组元素的成员函数
    void setElement(int index, int value) {
        if (index >= 0 && index < size) {
            array[index] = value;
        }
    }
};

int main() {
    // 创建一个 DynamicArray 对象
    DynamicArray arr(5);

    // 设置数组元素
    for (int i = 0; i < 5; ++i) {
        arr.setElement(i, i * 10);
    }

    // 打印数组
    arr.printArray();

    // DynamicArray 对象在 main() 函数结束时被销毁，析构函数被调用
    return 0;
}

在这个示例中，DynamicArray 类中定义了一个构造函数和一个自定义的析构函数：

• 构造函数：DynamicArray(int s) 动态分配一个大小为 s 的整数数组。
• 析构函数：~DynamicArray() 释放动态分配的内存，避免内存泄漏。

在 main() 函数中，当 arr 对象超出作用域时，析构函数会自动被调用，释放数组所占用的内存。