C++析构函数何时调用

一、对象实例化

当我们创建一个对象的实例并初始化时，该对象的构造函数会被调用，而当该对象的生命周期结束时，该对象的析构函数会被调用。

例如，我们创建一个名为person的Person对象实例，代码如下：

class Person{
public:
    Person() {
        std::cout << "构造函数调用" << std::endl;
    }
    ~Person() {
        std::cout << "析构函数调用" << std::endl;
    }
};
int main(){
    Person person;
    return 0;
}

上述代码中，当我们创建一个名为person的Person对象实例时，构造函数就会被调用，并输出“构造函数调用”这句话，而当程序结束时，析构函数会被调用，并输出“析构函数调用”这句话。

二、对象销毁

对象在何时销毁也会影响析构函数的调用，例如当对象是在函数内创建的时候，在函数结束的时候，对象会被销毁，从而触发析构函数的调用。

例如，我们将Person对象放到一个函数中去，代码如下：

#include 

class Person{
public:
    Person() {
        std::cout << "构造函数调用" << std::endl;
    }
    ~Person() {
        std::cout << "析构函数调用" << std::endl;
    }
};

void func(){
    Person person;
}
int main(){
    func();
    return 0;
}

上面的代码中，当我们调用func函数时，person对象会在函数结束时被销毁，从而触发析构函数的调用，输出“析构函数调用”这句话。

三、动态内存分配

C++允许在堆上（动态）分配内存，通过使用new和delete操作符来实现。当使用new操作符创建对象时，对象的构造函数会被调用，而当使用delete操作符来释放对象的内存时，析构函数会被调用。

例如，我们动态分配了一个Person对象，并且之后将其释放，代码如下：

class Person{
public:
    Person() {
        std::cout << "构造函数调用" << std::endl;
    }
    ~Person() {
        std::cout << "析构函数调用" << std::endl;
    }
};

int main(){
    Person * person = new Person();
    delete person;
    return 0;
}

上述代码中，我们使用new操作符动态创建了一个Person对象，并输出“构造函数调用”，而当我们使用delete操作符销毁对象时，析构函数就会被调用，从而输出“析构函数调用”这句话。

四、异常

异常机制可以使程序更加健壮，但是在异常抛出时需要注意析构函数的调用。当异常被抛出时，系统将回收动态分配的内存，并调用相关对象的析构函数。

例如，我们在上面的动态内存分配示例中，使用try-catch语句包含delete操作符，并在其中抛出了一个异常，代码如下：

class Person{
public:
    Person() {
        std::cout << "构造函数调用" << std::endl;
    }
    ~Person() {
        std::cout << "析构函数调用" << std::endl;
    }
};

int main(){
    Person * person = new Person();
    try{
        delete person;
        throw "抛出异常";
    } catch (const char* msg) {
        std::cerr << msg << std::endl;
    }
    return 0;
}

在上述代码中，当我们抛出异常时，系统将回收动态分配的内存，并且调用相关对象的析构函数，从而输出“析构函数调用”这句话。

五、类继承

当类中存在继承关系时，子类的析构函数会在父类的析构函数之后被调用。

例如，我们创建一个名为Student的子类并继承自Person类，代码如下：

class Person{
public:
    Person() {
        std::cout << "Person构造函数调用" << std::endl;
    }
    virtual ~Person() {
        std::cout << "Person析构函数调用" << std::endl;
    }
};
class Student : public Person {
public:
    Student() {
        std::cout << "Student构造函数调用" << std::endl;
    }
    ~Student() {
        std::cout << "Student析构函数调用" << std::endl;
    }
};

int main(){
    Student student;
    return 0;
}

上述代码中，在创建Student对象时输出“Person构造函数调用”，并在类继承中Student类的析构函数被Person类的析构函数之后被调用，从而输出“Student析构函数调用”和“Person析构函数调用”这两句话。