【C++ 筆記】動態記憶體（new / delete） - part 29
===

目錄（Table of Contents）：

[TOC]

---

很感謝你點進來這篇文章。

你好，我並不是什麼 C++、程式語言的專家，所以本文若有些錯誤麻煩請各位鞭大力一點，我極需各位的指正及指導！！本系列文章的性質主要以詼諧的口吻，一派輕鬆的態度自學程式語言，如果你喜歡，麻煩留言說聲文章讚讚吧！

動態記憶體（Dynamic Memory）
---

### 什麼是動態記憶體？

當我們宣告一個變數的時候，編譯器會依據這個變數所屬的資料型態，自動配置其記憶體空間。這些資源都是配置於記憶體的堆疊區（stack），生命週期僅止於函數執行期間，當函數執行完成後就會自動清除。

另外，一旦配置後，就不能被刪除或更改他的大小。所以這時候動態記憶體就出現了。

在 C++ 中，記憶體分為兩部分（from [菜鳥教程](https://www.runoob.com/cplusplus/cpp-dynamic-memory.html)）：

- 堆疊區（stack）：在函數內部宣告的所有變數都將佔用堆積記憶體。
- **堆積區（heap）：程式中未使用的記憶體，在程式執行時可用於動態配置記憶體。**

動態記憶體配置是在程式執行時配置記憶體的過程，這可以讓開發者在程式執行期間預留一些記憶體，依據開發者的需求去用它，然後再把記憶體給釋放以用於其他目的。

而上述所預留的「記憶體」就是所謂的「**堆積區**」記憶體。

### 動態記憶體的用處

- 當你不確定一個陣列的大小時。
- 可用來實作如 linked-list, trees 等這些資料結構。
- 於需要高效率的記憶體管理的複雜程式當中。

### 動態記憶體的實作方式

C++ 提供兩種運算子，用於動態記憶體的配置與釋放：

- 配置：`new`。
- 釋放：`delete`。

`new` / `delete` 運算子
---

以下是 `new` 運算子的通用語法：

new data-type

data-type 可為任意內建資料型態，`class`、`struct` 這兩個自訂資料型態也可以。

先來看個簡單的小範例：

#include <iostream>

using namespace std;

int main() {
    int* p = new int(10);
    cout << "數值為: " << *p << endl;
    delete p;
    return 0;
}

Output：

數值為: 10

以上用 new 運算子配置一個內建的資料型態 int，值為 10，給指標 p。

為什麼 `new` 所配置的記憶體通常要用指標接收呢？如果不用 `new`，而是直接宣告變數並賦值，如 `int x = 10;`，這樣變數會配置在堆疊區（stack），而不是堆積區（heap），就不是動態記憶體配置了，自然失去使用 `new` 的意義。

另外 `new int(10)` 會回傳 `int*` 型態，你不用指標也不行。

最後要有個好習慣，就是寫 `delete` 手動釋放記憶體，避免記憶體洩漏。

### 陣列的動態記憶體配置

先來看範例：

#include <iostream>

using namespace std;

int main(){
    int *arr = new int[5];
    
    for (int i = 0; i < 5; ++i){
        arr[i] = i * 2;
    }
    
    for (int i = 0; i < 5; ++i){
        cout << arr[i] << " ";
    }
    
    cout << endl;
    
    delete[] arr;
    
    return 0;
}

Output：

0 2 4 6 8

要為陣列做動態記憶體配置，需要將 `new int(5)` 寫成 `new int[5]`，表示要對陣列做動態記憶體配置。

因此在釋放記憶體的時候，也要寫成 `delete[]`，避免未定義行為。

### 二維陣列的動態記憶體配置

二維陣列的動態記憶體配置就複雜了一點，`int** arr = new int*[rows];` 就用到了雙重指標（指向指標的指標：`int**`），讓每一列（`arr[i][j]` 的 `[i]`）都是 `int*` 型態。

之後還要再配置一次，就是下面的 for loop，讓每一行（`arr[i][j]` 的 `[j]`）都配置到。

#include <iostream>

using namespace std;

int main(){
    int rows = 2;
    int cols = 3;
    
    int** arr = new int*[rows];
    
    for (int i = 0; i < rows; ++i){
        arr[i] = new int [cols];
    }
    
    for (int i = 0; i < rows; ++i){
        for (int j = 0; j < cols; ++j){
            arr[i][j] = i * j;
        }
    }
    
    cout << "陣列內容 : " << endl;
    
    for (int i = 0; i < rows; ++i){
        for (int j = 0; j < cols; ++j){
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
    
    for (int i = 0; i < rows; ++i){
        delete[] arr[i];
    }
    delete[] arr;
    
    return 0;
}

Output：

陣列內容 : 
0 0 0 
0 1 2

### 那...三維陣列呢？

就是三重指標（`int***`），然後再跑雙層迴圈配置動態記憶體，如下所示：

int m = 5;
int n = 4;
int k = 3;

// 配置
int*** arr = new int **[m];

for (int i = 0; i < m; ++i){
    arr[i] = new int *[n];
    for (int j = 0; j < n; ++j){
        arr[i][j] = new int [k];
    }
}

// 釋放
for (int i = 0; i < m; ++i){
    for (int j = 0; j < n; ++j){
        delete[] arr[i][j];
    }
    delete[] arr[i];
}
delete[] arr;

### 物件的動態記憶體配置

基本上跟簡單的內建資料型態沒啥差別。

#include <iostream>

using namespace std;

class Student{
public:
    string name;
    int age;
    
    Student (string n, int a) : name(n), age(a) {}
    
    void display(){
        cout << "姓名 : " << name << ", 年齡 : " << age << endl;
    }
};

int main(){
    Student* s = new Student("LukeTseng", 18);
    s->display();
    delete s;
    return 0;
}

Output：

姓名 : LukeTseng, 年齡 : 18

執行時記憶體不夠了怎麼辦？
---

若堆積區中沒有足夠的記憶體可以去配置，還繼續用 `new` 去配置的話，就會拋出例外 `std::bad_alloc`，除非將 `nothrow` 與 `new` 運算子一起使用，會回傳 `nullptr`。

那在使用程式前，`nothrow` 跟 `new` 一起使用可以用來做個檢查，如：

int *p = new (nothrow) int;
if (!p) {
    cout << "Memory allocation failed\n";
}

From [GeeksForGeeks](https://www.geeksforgeeks.org/new-and-delete-operators-in-cpp-for-dynamic-memory/)。

跟動態記憶體有關的一些錯誤
---

### 記憶體洩漏（Memory Leaks）

這其實就是最後沒把記憶體釋放的結果，所以要養成好習慣，在程式結束前用 delete 釋放掉記憶體。

另外如果記憶體位址遺失，記憶體會一直保持配置狀態（與上述狀態相同）直到程式執行。

那有哪些狀況是記憶體位址遺失呢？

1. 指標被覆蓋或重新指定

int* p = new int(10);
p = new int(20);      // 原本指向 10 的記憶體無法再被釋放 -> 洩漏

2. 指標變數離開作用域（Scope）

void foo() {
    int* p = new int(30);
    // 函式結束，p 被銷毀，記憶體遺失
}

3. 動態陣列的部分元素位址遺失

int* arr = new int[5];
arr++; // 錯誤：位址不再指向起始位置，釋放時會錯誤
delete[] arr; // 未定義行為

4. 指標遺失於容器中或函式回傳錯誤方式

int* create() {
    int* p = new int(40);
    return nullptr; // 原本的記憶體未回傳，無法釋放
}

C++ 11 有 `std::unique_ptr` 、 `std::shared_ptr` 等類別，稱為 smart pointer，可更好的協助動態記憶體配置，礙於篇幅，本篇暫不談。

### 迷途指標（Dangling Pointers）

在 C++ 中，迷途指標（Dangling Pointer）是指「**指向無效記憶體位址的指標**」。這種情況通常發生在指標曾指向一個合法的記憶體位址，但那塊記憶體已經被釋放或超出作用範圍，而指標本身還存在，造成錯誤的存取行為。

哪些是迷途指標的成因呢？

1. 指標指向已被 delete 的記憶體

int* p = new int(10);
delete p;      // 記憶體已釋放
*p = 5;        // 未定義行為：p 是迷途指標

2. 指標指向作用域外的區域變數

int* getPointer() {
    int x = 20;
    return &x;   // x 在函式結束後即被銷毀，指標成為迷途指標
}

3. 多個指標指向同一記憶體，卻重複釋放

int* p1 = new int(30);
int* p2 = p1;

delete p1;
*p2 = 10;       // p2 是迷途指標

用個白話的例子來說明迷途指標：假設指標是一把鑰匙，記憶體是你的房子，然後有一天惠惠發神經用爆裂魔法把你家炸了（記憶體釋放），此時的你如同迷途的羔羊，站在你家門前，喔不，~~你已經沒門了XD~~，然後你手舉著鑰匙還想要開門，這就是迷途指標。

解決方式有兩種：

1. 用 nullptr 初始化指標，釋放記憶體後再次指定為 nullptr。
2. 用 smart pointer。（`std::unique_ptr` 、 `std::shared_ptr`）

### 雙重釋放（Double Deletion）

顧名思義就是對同一塊動態配置的記憶體執行兩次 `delete` 或 `delete[]`。

解決方式與迷途指標相同。

### new / delete與 malloc() / free() 混用

`malloc()`、`free()` 是 C-style 的動態記憶體配置與釋放，只能選擇 C++ style 或 C-style 一個使用，因為這兩個都不相容。

另外 C++ 也有支援上述兩個函數，但用 new 跟 delete 會比那兩個函數好、又安全。

總結
---

C++ 記憶體分成兩大塊區域：

| 區域 | 說明 |
| --------- | -------------------------- |
| 堆疊區 stack | 函式內部變數，生命週期短，編譯器自動配置與釋放。 |
| 堆積區 heap | 執行期間可手動配置與釋放的記憶體空間，用於動態記憶體。 |

new / delete：

| 操作 | 功能 |
| -------- | ----------------------- |
| `new` | 在堆積區配置記憶體，回傳指標。 |
| `delete` | 釋放 `new` 配置的記憶體，避免記憶體洩漏（所以記得每次程式結束前要釋放記憶體）。 |

:::info
為什麼 `new` 要搭配指標使用？
因為 `new` 回傳的是指向堆積區的記憶體位址，必須用指標來接收，否則會失去動態記憶體配置的意義。
:::

單一變數的配置：

int* p = new int(10);
delete p;

陣列配置：

int* arr = new int[5];
delete[] arr;

二維陣列：

- 配置

int** arr = new int*[rows];
for (int i = 0; i < rows; ++i)
    arr[i] = new int[cols];

- 釋放

for (int i = 0; i < rows; ++i)
    delete[] arr[i];
delete[] arr;

三維陣列：

- 配置

int*** arr = new int**[m];
for (int i = 0; i < m; ++i)
    for (int j = 0; j < n; ++j)
        arr[i][j] = new int[k];

- 釋放

for (int i = 0; i < m; ++i) {
    for (int j = 0; j < n; ++j) {
        delete[] arr[i][j];
    }
    delete[] arr[i];
}
delete[] arr;

物件的配置：

Student* s = new Student("LukeTseng", 18);
delete s;

例外處理（記憶體不足）：

int* p = new (nothrow) int;
if (!p) cout << "配置失敗";

### 常見錯誤

| 問題類型 | 說例 |
| ----------- | ------------------------------------------------------- |
| 記憶體洩漏 | 忘記釋放、或位址遺失：`p = new int(20); // 沒釋放舊的`。 |
| 迷途指標 | 使用已釋放或作用域外的指標：`int* p = new int; delete p; *p = 5;`。 |
| 雙重釋放 | 對同一記憶體重複 delete：`delete p1; delete p2;`（若 p1 == p2）。 |
| 混用 new/free | `new` 必須配 `delete`，`malloc()` 必須配 `free()`，不可交叉使用。 |

### 解決方案

| 做法 | 說明 |
| ---------------- | ---------------------------------------- |
| 指標初始化為 `nullptr` | 可避免未定義行為與迷途指標。 |
| 使用 smart pointer | `std::unique_ptr`、`shared_ptr` 等更安全的管理方式。 |

參考資料
---

[[Day 04] 用C++ 設計程式中的系統櫃：動態配置記憶體 | iT 邦幫忙::一起幫忙解決難題，拯救 IT 人的一天](https://ithelp.ithome.com.tw/m/articles/10287425)

[new 與 delete](https://openhome.cc/Gossip/CppGossip/newDelete.html)

[new and delete Operators in C++ For Dynamic Memory - GeeksforGeeks](https://www.geeksforgeeks.org/new-and-delete-operators-in-cpp-for-dynamic-memory/)

[bad_alloc in C++ - GeeksforGeeks](https://www.geeksforgeeks.org/cpp/bad_alloc-in-cpp/)

[Memory leak in C++ - GeeksforGeeks](https://www.geeksforgeeks.org/cpp/memory-leak-in-c-and-how-to-avoid-it/)

[Dangling Pointers in C++ - GeeksforGeeks](https://www.geeksforgeeks.org/cpp/dangling-pointers-in-cpp/)

[C++ 动态内存 | 菜鸟教程](https://www.runoob.com/cplusplus/cpp-dynamic-memory.html)