本文主要是介绍C++中的析构函数，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
目录
摘要
动态内存管理
关键点
总结
摘要
析构函数（Destructor）是类的一种特殊成员函数，它在对象生命周期结束时被自动调用，用于执行清理操作。用途包括释放动态分配的内存、关闭文件、释放资源等。析构函数的名称与类名相同，但前面加上波浪号（~），且不接受任何参数，也没有返回值。
当`main`函数结束时，`obj`对象的析构函数会被自动调用：
#include <iostream>class MyClass {
public:MyClass() {std::cout << "Constructor called" << std::endl;}~MyClass() {std::cout << "Destructor called" << std::endl;}
};int main() {MyClass obj;return 0;
}
动态内存管理
析构函数通常用于释放在构造函数中分配的动态内存，以避免内存泄漏。
析构函数中使用`delete[]`来释放构造函数中使用`new`分配的内存：
#include <iostream>class MyClass {
private:int* data;
public:MyClass(int size) {data = new int[size];std::cout << "Constructor called" << std::endl;}~MyClass() {delete[] data;std::cout << "Destructor called" << std::endl;}
};int main() {MyClass obj(10);return 0;
}
关键点
1. 析构函数的虚函数特性：
如果一个类有可能被继承，并且会通过基类指针删除派生类对象，那么基类的析构函数应该声明为虚函数。这确保了删除派生类对象时，会正确调用派生类的析构函数。如果基类的析构函数不是虚函数，那么通过基类指针删除派生类对象时，只会调用基类的析构函数，导致资源泄漏。
#include <iostream>class Base {
public:Base() {std::cout << "Base Constructor called" << std::endl;}virtual ~Base() {std::cout << "Base Destructor called" << std::endl;}
};class Derived : public Base {
public:Derived() {std::cout << "Derived Constructor called" << std::endl;}~Derived() {std::cout << "Derived Destructor called" << std::endl;}
};int main() {Base* obj = new Derived();delete obj; // 调用派生类的析构函数return 0;
}
2. 避免析构函数中抛出异常：
析构函数中如果抛出异常的话，可能会导致程序崩溃。因为在堆栈展开（stack unwinding）过程中，如果析构函数再次抛出异常，会导致`std::terminate`被调用。因此，析构函数中应尽量避免抛出异常，即使可以通过`noexcept(false)`明确声明析构函数可能抛出异常。
#include <iostream>class MyClass {
public:~MyClass() noexcept(false) { // 明确声明可能抛出异常throw std::runtime_error("Exception in Destructor");}
};int main() {try {MyClass obj;} catch (const std::exception& e) {std::cout << "Caught exception: " << e.what() << std::endl;}return 0;
}
3. 对象资源管理：
使用RAII（Resource Acquisition Is Initialization）技术，将资源的获取和释放封装在对象的构造和析构函数中，确保资源的正确释放。通过RAII技术，确保在对象生命周期结束时自动关闭文件。
#include <iostream>
#include <fstream>class FileWrapper {
private:std::ofstream file;
public:FileWrapper(const std::string& filename) {file.open(filename);if (!file.is_open()) {throw std::runtime_error("Failed to open file");}}~FileWrapper() {if (file.is_open()) {file.close();}}void write(const std::string& data) {file << data;}
};int main() {try {FileWrapper fw("example.txt");fw.write("Hello, World!");} catch (const std::exception& e) {std::cout << "Caught exception: " << e.what() << std::endl;}return 0;
}
4. 处理资源的共享和转移：
在C++中，使用智能指针（如`std::unique_ptr`和`std::shared_ptr` -- C++中的智能指针类别-CSDN博客）可以自动管理对象的生命周期来自动管理资源，减少手动内存管理的复杂性。
- 使用`std::unique_ptr`管理独占资源。
#include <iostream>
#include <memory>class MyClass {
public:MyClass() {std::cout << "Constructor called" << std::endl;}~MyClass() {std::cout << "Destructor called" << std::endl;}
};void uniquePtrExample() {std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>();
}int main() {uniquePtrExample();return 0;
}
- 使用`std::shared_ptr`管理共享资源。
#include <iostream>
#include <memory>class MyClass {
public:MyClass() {std::cout << "Constructor called" << std::endl;}~MyClass() {std::cout << "Destructor called" << std::endl;}
};void sharedPtrExample() {std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();{std::shared_ptr<MyClass> ptr2 = ptr1;std::cout << "Use count: " << ptr1.use_count() << std::endl;}std::cout << "Use count after scope: " << ptr1.use_count() << std::endl;
}int main() {sharedPtrExample();return 0;
}
总结
1. 析构函数：用于释放资源和执行清理操作，在对象生命周期结束时自动调用。
2. 虚析构函数：在基类中定义虚析构函数，确保通过基类指针删除派生类对象时正确调用派生类的析构函数。
3. 避免异常：析构函数中应避免抛出异常，以防止程序崩溃。
4. RAII：通过RAII技术，将资源管理封装在对象的构造和析构函数中，确保资源的正确释放。
5. 智能指针：使用`std::unique_ptr`和`std::shared_ptr`等智能指针来自动管理对象的生命周期，减少内存管理的复杂性和错误风险。
这篇关于C++中的析构函数的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
