內存泄漏是嵌入式系統開發中一個嚴峻的問題，尤其在資源有限的環境中。
與桌面應用程序不同，嵌入式系統通常具有嚴格的內存限制，即使是小規模的內存泄漏也可能迅速導致系統崩潰或功能異常。
內存泄漏是指程序在申請內存后，無法釋放已經不再使用的內存空間，通常發生在程序員創建了一個新的內存塊，但忘記在使用完之后釋放它。
在嵌入式C++開發中，內存泄漏的常見原因包括：
場景一：忘記釋放動態分配的內存
這是最常見的內存泄漏原因。當使用new關鍵字分配內存后，如果沒有調用delete操作符釋放內存，就會導致內存泄漏。
void?someFunction()?{? ??int* ptr =?new?int(10);?// 分配內存? ??// 沒有 delete，導致內存泄漏}
在這個例子中，someFunction函數分配了一個整數指針ptr，但在函數結束時沒有釋放這個內存。
當函數返回時，ptr將被銷毀，但分配的內存仍然存在，無法被訪問，從而導致內存泄漏。
確保在不再需要內存時調用delete釋放它。
void?someFunction()?{? ??int* ptr =?new?int(10);?// 分配內存? ? delete ptr;?// 釋放內存}
或者，使用智能指針自動管理內存：
void?someFunction()?{? ??std::unique_ptrptr(new?int(10));?// 使用智能指針? ??// 智能指針會自動釋放內存}
場景二：異常情況下的內存泄漏
當函數執行過程中發生異常，可能會導致提前退出，而未釋放之前分配的內存，從而造成內存泄漏。
void?someFunction()?{? ??int* ptr =?new?int(10);?// 分配內存? ??// 可能在此處引發異常? ? someFunctionThatThrows();?}
如果someFunctionThatThrows()函數拋出異常，控制流會直接跳到catch塊或函數外，而不會執行后續的代碼。
這意味著ptr指向的內存將永遠不會被釋放，導致內存泄漏。
使用try-catch塊捕獲異常，并確保在異常情況下釋放已分配的內存。
void?someFunction()?{? ??int* ptr = nullptr;? ??try?{? ? ? ? ptr =?new?int(10);?// 分配內存? ? ? ? someFunctionThatThrows();?// 可能拋出異常的函數? ? }?catch(...) {? ? ? ? delete ptr;?// 釋放內存? ? ? ??throw;?// 重新拋出異常? ? }}
或者，使用智能指針自動管理內存：
void?someFunction() {? ??std::unique_ptrptr;? ??try?{? ? ? ? ptr =?std::unique_ptr(new?int(10));?// 分配內存? ? ? ??someFunctionThatThrows();?// 可能拋出異常的函數? ? }?catch(...) {? ? ? ??// 智能指針會自動釋放內存，即使拋出異常? ? ? ??throw;?// 重新拋出異常? ? }}
場景三：循環引用導致的內存泄漏
在使用共享指針（shared_ptr）時，對象之間的循環引用可能導致內存泄漏，因為每個共享指針都引用對方，導致引用計數永遠不為零。
class?Node?{public:? ? std::shared_ptrnext;? ? std::shared_ptrprev;};int?main()?{? ??std::shared_ptrnode1(new?Node());? ??std::shared_ptrnode2(new?Node());? ? node1->next = node2;? ? node2->prev = node1;? ??// 此時node1和node2互相引用，無法被自動釋放? ??return?0;}
在這個例子中，node1和node2互相引用，導致它們的引用計數永遠不為零，無法被自動釋放，從而導致內存泄漏。
使用弱指針（weak_ptr）打破循環引用：
class?Node?{public:? ? std::shared_ptrnext;? ? std::weak_ptrprev;};int?main()?{? ??std::shared_ptrnode1(new?Node());? ??std::shared_ptrnode2(new?Node());? ? node1->next = node2;? ? node2->prev = node1;? ??// 當node1被銷毀后，node2的prev將不再有效? ??return?0;}
場景四：遞歸調用過深導致的堆棧崩潰
在C/C++編程中，堆棧崩潰是一種常見的錯誤，它通常是由于遞歸調用過深、內存溢出或者棧上分配的大量數據導致棧空間耗盡而引發的。
void?recursiveFunction(int?depth)?{? ??int?array[1000];?// 在棧上分配大量數據? ??if?(depth 1000) {? ? ? ? recursiveFunction(depth +?1);? ? }}int?main()?{? ? recursiveFunction(0);?// 可能導致棧溢出? ??return?0;}
在這個例子中，recursiveFunction函數遞歸調用自身1000次，并且每次在棧上分配一個大小為1000的整數數組。這可能導致棧溢出，引發堆棧崩潰。
場景五：使用不規范的庫接口
某些舊庫或API可能需要顯式內存管理，使用不當可能導致內存泄漏。
void?someFunction()?{? ??char* buffer = someOldAPIFunction();?// 分配內存? ??// 使用緩沖區? ??// 沒有釋放內存}
在這個例子中，someOldAPIFunction()函數可能在堆上分配了一個字符緩沖區，并返回指針。
如果調用者沒有顯式釋放這個內存，就會導致內存泄漏。
確保在不再需要內存時調用適當的釋放函數：
void?someFunction()?{? ??char* buffer = someOldAPIFunction();?// 分配內存? ??// 使用緩沖區? ? free(buffer);?// 釋放內存}
