c++++内存管理的黄金法则是“谁分配，谁释放”，核心在于明确资源所有权并使用raii原则。1. 推荐使用智能指针（如std::unique_ptr、std::shared_ptr和std::weak_ptr）代替手动new/delete，自动管理内存释放；2. 避免内存泄漏需避免裸指针、确保异常安全、合理使用容器及定期代码审查；3. 循环引用导致的内存泄漏可通过std::weak_ptr打破共享所有权循环，确保对象正确析构。
c++内存管理的黄金法则可以归结为：谁分配，谁释放。核心在于清晰界定资源的所有权和释放责任，避免内存泄漏和悬挂指针。
解决方案：
C++内存管理的核心在于理解和应用RaiI（Resource Acquisition Is Initialization）原则，并明确资源的所有权。这意味着在对象构造时获取资源，在对象析构时释放资源。
立即学习“C++免费学习笔记（深入）”；
资源释放责任界定，简单来说，就是谁new的，谁delete。但是，在复杂的程序中，直接使用new/delete容易出错。所以，更推荐使用智能指针，将资源管理交给编译器。
智能指针如何简化资源管理？
智能指针，如std::unique_ptr、std::shared_ptr和std::weak_ptr，是C++中管理动态分配内存的强大工具。它们通过自动管理内存的释放，极大地简化了资源管理，并降低了内存泄漏的风险。std::unique_ptr适用于独占所有权，std::shared_ptr适用于共享所有权，而std::weak_ptr则用于观察std::shared_ptr管理的对象，但不参与所有权。使用智能指针，可以避免手动delete操作，当智能指针超出作用域时，会自动释放其管理的内存。
例如：
#include <memory> int main() { // 使用 unique_ptr，独占所有权 std::unique_ptr<int> uniquePtr(new int(10)); // 当 uniquePtr 离开作用域时，会自动释放 int(10) 的内存 // 使用 shared_ptr，共享所有权 std::shared_ptr<int> sharedPtr1(new int(20)); std::shared_ptr<int> sharedPtr2 = sharedPtr1; // 共享所有权 // 当 sharedPtr1 和 sharedPtr2 都离开作用域时，int(20) 的内存才会被释放 return 0; }
如何避免内存泄漏？
避免内存泄漏的关键在于确保所有动态分配的内存最终都能被释放。除了使用智能指针外，还需要注意以下几点：
- 避免裸指针： 尽可能避免直接使用new和delete，优先使用智能指针。
- 异常安全： 在可能抛出异常的代码中，确保资源能够被正确释放。RAII原则在这里尤为重要。
- 容器的使用： 当使用容器存储指针时，考虑使用智能指针容器，如std::vector<:unique_ptr>>。
- 代码审查： 定期进行代码审查，查找潜在的内存泄漏问题。
一个常见的错误是忘记在异常处理程序中释放内存。例如：
void processData() { int* data = new int[100]; try { // ... 一些可能抛出异常的操作 if (/* 发生错误 */) { throw std::runtime_error("处理数据时出错"); } // ... delete[] data; // 如果 try 块中抛出异常，这行代码不会执行 } catch (const std::exception& e) { // 处理异常，但忘记释放 data 指向的内存 // 内存泄漏！ std::cerr << "发生异常: " << e.what() << std::endl; //throw; // 重新抛出异常（可选） } }
使用 RAII 可以避免这个问题：
#include <memory> void processData() { std::unique_ptr<int[]> data(new int[100]); // 使用 unique_ptr 管理内存 try { // ... 一些可能抛出异常的操作 if (/* 发生错误 */) { throw std::runtime_error("处理数据时出错"); } // ... } catch (const std::exception& e) { // 处理异常 std::cerr << "发生异常: " << e.what() << std::endl; //throw; // 重新抛出异常（可选） } // data 在离开作用域时会自动释放，即使抛出异常 }
如何处理循环引用导致的内存泄漏？
循环引用是指两个或多个对象互相持有对方的std::shared_ptr，导致引用计数永远不为零，从而无法释放内存。解决循环引用的方法通常是使用std::weak_ptr。std::weak_ptr是一种弱引用，它不会增加引用计数，因此不会阻止对象的释放。
例如，考虑一个父子关系的场景：
#include <iostream> #include <memory> #include <vector> class Child; // 前向声明 class Parent { public: std::vector<std::shared_ptr<Child>> children; ~Parent() { std::cout << "Parent 析构" << std::endl; } }; class Child { public: std::shared_ptr<Parent> parent; // 使用 shared_ptr 会导致循环引用 ~Child() { std::cout << "Child 析构" << std::endl; } }; int main() { std::shared_ptr<Parent> parent = std::make_shared<Parent>(); std::shared_ptr<Child> child = std::make_shared<Child>(); parent->children.push_back(child); child->parent = parent; // 循环引用 // parent 和 child 离开作用域，但不会被析构，因为存在循环引用 return 0; }
将Child类中的std::shared_ptr
#include <iostream> #include <memory> #include <vector> class Child; // 前向声明 class Parent { public: std::vector<std::shared_ptr<Child>> children; ~Parent() { std::cout << "Parent 析构" << std::endl; } }; class Child { public: std::weak_ptr<Parent> parent; // 使用 weak_ptr 避免循环引用 ~Child() { std::cout << "Child 析构" << std::endl; } }; int main() { std::shared_ptr<Parent> parent = std::make_shared<Parent>(); std::shared_ptr<Child> child = std::make_shared<Child>(); parent->children.push_back(child); child->parent = parent; // 不再是循环引用 // parent 和 child 离开作用域，会被正确析构 return 0; }
现在，当parent和child离开作用域时，它们会被正确析构，避免了内存泄漏。std::weak_ptr允许Child访问Parent，但不会增加Parent的引用计数。在使用parent之前，需要使用parent.lock()来获取一个std::shared_ptr。如果Parent已经被销毁，parent.lock()会返回一个空的std::shared_ptr。
