C++ 內(nèi)存管理是程序設(shè)計的核心環(huán)節(jié)，直接影響程序的性能、穩(wěn)定性和安全性。C++ 不像 Java、Python 等語言有自動垃圾回收機制，而是需要開發(fā)者手動管理動態(tài)內(nèi)存（或通過智能指針等機制自動管理）。

1、C++ 內(nèi)存分區(qū)

圖示：

+-----------------------+
|       棧 (Stack)      | <- 高地址，向下增長
+-----------------------+
|          ↓            |
|                       |
|          ↑            |
+-----------------------+
|       堆 (Heap)       | <- 低地址，向上增長
+-----------------------+
| 全局/靜態(tài)區(qū) (Global)   |
+-----------------------+
|   常量區(qū) (Constants)   |
+-----------------------+
|   代碼區(qū) (Code/Text)   |
+-----------------------+ 

2、棧

• 特點：
  • 空間較小（通常幾 MB），由操作系統(tǒng)自動分配和釋放，遵循“先進后出”（FILO）原則。
  • 分配速度極快（僅需移動棧指針），適合存儲短期存在的變量（如函數(shù)內(nèi)的局部變量）。

void stackExample() {
    int x = 10; // `x` 在棧上分配
    std::string name = "Alice"; // `name` 對象本身在棧上，但其內(nèi)部的動態(tài)數(shù)據(jù)可能在堆上
    double data[100]; // 數(shù)組 `data` 在棧上分配（如果100很大，可能導(dǎo)致棧溢出）
} // 作用域結(jié)束，`x`, `name`, `data` 被自動銷毀。
   // `std::string` 的析構(gòu)函數(shù)會被調(diào)用，釋放它可能占用的堆內(nèi)存。

注意：不要返回指向棧內(nèi)存的指針或引用！

int* dangerousFunction() {
    int localVar = 42;
    return &localVar; // 嚴(yán)重錯誤！返回后 localVar 已被銷毀，指針懸空。
}

3、堆

• 特點：
  • 空間較大（通常幾 GB），生命周期由開發(fā)者控制（需手動申請和釋放），分配/釋放速度較慢（涉及內(nèi)存塊查找、鏈表維護等）。
  • 內(nèi)存地址不連續(xù)，頻繁分配/釋放可能產(chǎn)生內(nèi)存碎片。

3.1 動態(tài)分配與釋放：new / delete

new 運算符完成兩件事：1) 在堆上分配足夠的內(nèi)存；2) 在該內(nèi)存上構(gòu)造對象（調(diào)用構(gòu)造函數(shù)）。
delete 運算符也完成兩件事：1) 調(diào)用對象的析構(gòu)函數(shù)；2) 釋放該對象占用的內(nèi)存。

// 動態(tài)分配一個 int，并初始化為 5
int* ptr = new int(5); 
// 動態(tài)分配一個 MyClass 對象，調(diào)用其構(gòu)造函數(shù)
MyClass* objPtr = new MyClass("Name", 10); 
// ... 使用 ptr 和 objPtr ...
// 釋放內(nèi)存
delete ptr;    // 釋放 int
delete objPtr; // 調(diào)用 ~MyClass()，然后釋放內(nèi)存
ptr = nullptr; // 良好實踐：釋放后立即置空，防止懸空指針
objPtr = nullptr;

3.2 分配/釋放對象數(shù)組

// 動態(tài)分配一個包含10個int的數(shù)組
int* arrayPtr = new int[10]; 
// 動態(tài)分配3個MyClass對象，調(diào)用它們的默認(rèn)構(gòu)造函數(shù)
MyClass* objArrayPtr = new MyClass[3]; 
// ... 使用數(shù)組 ...
// 釋放數(shù)組內(nèi)存。必須使用 delete[]！
delete[] arrayPtr;     // 正確：釋放數(shù)組
delete[] objArrayPtr;  // 正確：調(diào)用每個元素的析構(gòu)函數(shù)，然后釋放內(nèi)存
// delete objArrayPtr; // 災(zāi)難性錯誤！行為未定義。只會調(diào)用第一個元素的析構(gòu)函數(shù)，然后錯誤地釋放內(nèi)存。

3.3 new/delete和malloc/free

C++ 提供兩種動態(tài)內(nèi)存管理方式：C 語言兼容的 malloc/free，以及 C++ 特有的 new/delete。

重要規(guī)則： 絕對不要混用！ 用 new 分配的內(nèi)存必須用 delete 釋放；用 malloc() 分配的內(nèi)存必須用 free() 釋放。

3.3.1 malloc/free（C 風(fēng)格）

函數(shù)原型：

void* malloc(size_t size);  // 分配 size 字節(jié)的內(nèi)存，返回 void*（需強轉(zhuǎn)）
void free(void* ptr);       // 釋放 ptr 指向的內(nèi)存（ptr 必須是 malloc 分配的地址）

特點：

• 僅分配內(nèi)存，不調(diào)用對象的構(gòu)造函數(shù)；釋放內(nèi)存時，不調(diào)用析構(gòu)函數(shù)（僅適用于基本類型，不適合類對象）。
• 需手動計算內(nèi)存大?。ㄈ?nbsp;malloc(sizeof(int) * 5)）。

示例：

int* p = (int*)malloc(sizeof(int)); // 分配 int 大小的內(nèi)存（未初始化）
*p = 10;                            // 手動賦值
free(p);                            // 釋放內(nèi)存（p 變?yōu)橐爸羔?，建議置空）
p = nullptr;

3.3.2 new/delete（C++ 風(fēng)格）

new/delete 是 C++ 對動態(tài)內(nèi)存管理的增強，不僅分配/釋放內(nèi)存，還會自動調(diào)用對象的構(gòu)造函數(shù)和析構(gòu)函數(shù)，是管理類對象的首選方式。

基本用法：

// 1. 分配單個對象
MyClass* obj = new MyClass(10);  // 調(diào)用 MyClass(int) 構(gòu)造函數(shù)
delete obj;                      // 調(diào)用 MyClass 析構(gòu)函數(shù)，釋放內(nèi)存

// 2. 分配數(shù)組（必須用 new[] 和 delete[] 匹配）
MyClass* arr = new MyClass[5];   // 調(diào)用 5 次 MyClass 默認(rèn)構(gòu)造函數(shù)
delete[] arr;                    // 調(diào)用 5 次 MyClass 析構(gòu)函數(shù)，釋放數(shù)組

new 的底層原理：
new 操作分兩步：

調(diào)用 operator new(size_t) 分配內(nèi)存（類似 malloc）；

在分配的內(nèi)存上調(diào)用對象的構(gòu)造函數(shù)。

delete 的底層原理：
delete 操作分兩步：

調(diào)用對象的析構(gòu)函數(shù)；

調(diào)用 operator delete(void*) 釋放內(nèi)存（類似 free）。

3.4 常見動態(tài)內(nèi)存錯誤

3.4.1 內(nèi)存泄漏 (Memory Leak)

分配了內(nèi)存但忘記釋放。
cpp void leak() { int* ptr = new int(100); // ... 使用了 ptr ... return; // 忘記 delete ptr; 內(nèi)存泄漏！ }

3.4.2 懸空指針 (Dangling Pointer)

指針指向的內(nèi)存已被釋放。
cpp int* ptr = new int(50); delete ptr; // 內(nèi)存被釋放 *ptr = 10; // 錯誤！ptr 現(xiàn)在是懸空指針，解引用它是未定義行為。

3.4.3 雙重釋放 (Double Free)

對同一塊內(nèi)存釋放兩次。
cpp int* ptr = new int(50); delete ptr; delete ptr; // 災(zāi)難！未定義行為，通常導(dǎo)致程序崩潰。

3.4.4 野指針 (Wild Pointer)

未初始化的指針。
cpp int* ptr; // 野指針，指向隨機地址 *ptr = 10; // 極度危險！未定義行為。

4、全局/靜態(tài)區(qū)

特點：

• 全局變量和靜態(tài)變量（包括 static 局部變量）存儲于此，程序啟動時初始化，結(jié)束時銷毀。
• static 局部變量僅在首次進入函數(shù)時初始化，生命周期延續(xù)到程序結(jié)束。

示例：

int g_var = 10;         // 全局變量，存儲在全局區(qū)
static int s_var = 20;  // 靜態(tài)全局變量，存儲在全局區(qū)
void func() {
    static int s_local = 30; // 靜態(tài)局部變量，存儲在全局區(qū)（僅初始化一次）
}

5、常量區(qū)

• 特點：
  • 存儲字符串常量（如 "hello"）和 const 修飾的常量，內(nèi)容只讀（修改會導(dǎo)致未定義行為）。
• 示例：

const int c_var = 100;   // const 常量，存儲在常量區(qū)
char* str = "hello";     // "hello" 存儲在常量區(qū)，str 是棧上的指針

6、常見問題

• new/delete 和 malloc()/free() 有什么區(qū)別？
  • new/delete 關(guān)心對象生命周期（構(gòu)造/析構(gòu)），而 malloc/free 只關(guān)心內(nèi)存塊。絕對不要混用。
• 什么是內(nèi)存泄漏？如何避免？
  • 動態(tài)分配的內(nèi)存不再被使用，但未被釋放，導(dǎo)致內(nèi)存浪費，長期運行可能耗盡內(nèi)存。
• 避免方法：
  • 優(yōu)先使用棧對象：讓編譯器自動管理生命周期。
  • 使用智能指針：這是現(xiàn)代 C++ 最主要的手段。std::unique_ptr（獨占所有權(quán)）和 std::shared_ptr（共享所有權(quán)）會在析構(gòu)時自動釋放內(nèi)存。
  • 遵循 RAII 原則：將資源（內(nèi)存、文件句柄等）的獲取與對象的構(gòu)造函數(shù)綁定，釋放與析構(gòu)函數(shù)綁定。
  • 成對使用 new/delete 和 new[]/delete[]：確保分配和釋放方式匹配。
  • 使用工具檢測：如 Valgrind、AddressSanitizer (ASan)、Visual Studio 診斷工具等。
  • 為什么更推薦使用 std::make_shared 而不是直接 new？
  • 異常安全：如果函數(shù)參數(shù)在表達式求值過程中拋出異常，make_shared 能保證已分配的內(nèi)存會被釋放，而直接 new 可能會泄漏。
  • 性能：std::make_shared 通常只進行一次內(nèi)存分配，同時容納對象本身和控制塊（引用計數(shù)等）。而 shared_ptr(new T(...)) 需要兩次分配（一次給對象，一次給控制塊）。
• 如何從 weak_ptr 安全地訪問對象？
  • 使用 lock() 方法。它會返回一個 std::shared_ptr。如果原始對象還存在，這個 shared_ptr 是有效的；如果已被釋放，則返回一個空的 shared_ptr。必須檢查返回值。

std::weak_ptr<MyClass> weak = ...;
if (auto shared = weak.lock()) { // 檢查返回的shared_ptr是否為空
    // 對象還存在，可以安全使用 shared
    shared->doSomething();
} else {
    // 對象已被釋放
    std::cout << "Object is gone.\n";
}

• 什么是懸空指針 (Dangling Pointer) 和野指針 (Wild Pointer)？

懸空指針：指針指向的內(nèi)存已被釋放，但指針本身未被置空。解引用它是未定義行為

int* ptr = new int(10);
delete ptr; // 內(nèi)存釋放
// ptr 現(xiàn)在是懸空指針
*ptr = 20; // 未定義行為！
ptr = nullptr; // 良好實踐：釋放后立即置空。

野指針：未被初始化的指針，其值是隨機的垃圾地址。

int* ptr; // 野指針
*ptr = 10; // 極度危險！未定義行為。
int* ptr2 = nullptr; // 正確：總是初始化指針。

• delete 和 delete[] 的區(qū)別是什么？混用會怎樣？

delete：用于釋放 new 分配的單個對象。它會調(diào)用該對象的析構(gòu)函數(shù)。

delete[]：用于釋放 new[] 分配的對象數(shù)組。它會調(diào)用數(shù)組中每個元素的析構(gòu)函數(shù)，然后釋放整塊內(nèi)存。

混用的后果：未定義行為。最常見的后果是程序崩潰。

用 delete 釋放數(shù)組：只會調(diào)用第一個元素的析構(gòu)函數(shù)，然后錯誤地釋放內(nèi)存。

用 delete[] 釋放單個對象：會試圖析構(gòu)多個不存在的對象，導(dǎo)致內(nèi)存結(jié)構(gòu)被破壞。

• 什么是 RAII？它在 C++ 內(nèi)存管理中如何體現(xiàn)？

• RAII (Resource Acquisition Is Initialization)：資源獲取即初始化。是 C++ 最重要的編程理念之一。
• 核心思想：將資源（內(nèi)存、文件句柄、鎖等）的生命周期與對象的生命周期綁定。
  • 獲取資源：在對象的構(gòu)造函數(shù)中完成（例如，std::ifstream 打開文件，std::unique_ptr 分配內(nèi)存）。
  • 釋放資源：在對象的析構(gòu)函數(shù)中完成（例如，std::ifstream 關(guān)閉文件，std::unique_ptr 釋放內(nèi)存）。
• 優(yōu)勢：無論函數(shù)是正常返回還是因異常提前退出，局部對象都會在離開作用域時被析構(gòu)，從而保證資源一定能被釋放。智能指針是 RAII 用于內(nèi)存管理的完美體現(xiàn)。

• 設(shè)計一個 unique_ptr，你會考慮哪些方面？
  • 封裝一個原生指針作為成員。
  • 刪除拷貝構(gòu)造函數(shù)和拷貝賦值運算符（= delete）以實現(xiàn)獨占語義。
  • 實現(xiàn)移動構(gòu)造函數(shù)和移動賦值運算符（std::move）以支持所有權(quán)轉(zhuǎn)移。
  • 在析構(gòu)函數(shù)中調(diào)用刪除器（默認(rèn)是 delete）釋放資源。
  • 重載 operator* 和 operator-> 以提供指針式的訪問。
  • 提供 release(), reset(), get() 等成員函數(shù)。
  • （可選）支持自定義刪除器（作為模板參數(shù)的一部分）。

到此這篇關(guān)于C++ 內(nèi)存管理的文章就介紹到這了,更多相關(guān)C++ 內(nèi)存管理內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！