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。
