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<std::unique_ptr<MyObject>>。 - 代码审查： 定期进行代码审查，查找潜在的内存泄漏问题。
一个常见的错误是忘记在异常处理程序中释放内存。例如：
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<Parent> parent改为std::weak_ptr<Parent> parent可以解决这个问题：
#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。
