C++unique_ptr数组操作与内存管理注意事项-C++-PHP中文网

使用unique_ptr<T[]>而非unique_ptr<T>管理数组，是因为前者会正确调用delete[]释放内存，避免内存泄漏和未定义行为。unique_ptr<T[]>专为数组设计，确保析构时调用数组形式的delete[]，而unique_ptr<T>仅调用delete，导致数组对象析构不完整。C++中单对象与数组的内存管理机制不同，必须匹配使用new/delete或new[]/delete[]。若用unique_ptr<T>管理new[]分配的数组，仅首元素被析构，其余内存泄露或损坏。因此，为保证安全，必须使用unique_ptr<T[]>形式。make_unique<T[]>(size)是创建此类智能指针的推荐方式，兼具简洁性与异常安全。该方式对基本类型零初始化，对类类型调用默认构造函数。若类无默认构造函数，需手动处理或改用vector。此外，unique_ptr<T[]>不支持operator*或operator->，仅能通过operator[]访问元素，且数组大小固定，不可动态扩容。高级用法包括自定义deleter以管理非new[]分配的内存（如malloc），通过.get()获取原始指针供C风格函数使用，以及通过移动语义转移所有权

c++unique_ptr数组操作与内存管理注意事项

C++中

unique_ptr

登录后复制

管理数组时，核心要点是必须使用

unique_ptr<T[]>

登录后复制

这种特化形式，而不是

unique_ptr<T>

登录后复制

。这确保了在对象生命周期结束时，能正确调用

delete[]

登录后复制

来释放数组内存，避免了内存泄露和未定义行为。

unique_ptr

登录后复制

的数组操作与内存管理，说白了，就是要把

unique_ptr

登录后复制

当成一个更安全的

new[]

登录后复制

和

delete[]

登录后复制

的组合。我个人觉得，这玩意儿就是为了解决我们经常忘记

delete[]

登录后复制

的“人性弱点”而生的。

#include <iostream>
#include <memory> // 包含 unique_ptr
#include <vector> // 也会提及 std::vector

// 一个简单的类，用来观察构造和析构
struct MyObject {
    int id;
    MyObject(int i = 0) : id(i) { std::cout << "MyObject " << id << " constructed.\n"; }
    ~MyObject() { std::cout << "MyObject " << id << " destructed.\n"; }
};

int main() {
    // 1. 正确使用 unique_ptr<T[]> 管理数组
    // C++14 引入的 std::make_unique 是创建 unique_ptr 的首选方式
    // 它对数组类型同样适用，并且提供了异常安全保证
    auto myIntArray = std::make_unique<int[]>(5); // 创建一个包含5个int的数组
    for (int i = 0; i < 5; ++i) {
        myIntArray[i] = i * 10; // 通过 operator[] 访问元素
    }
    std::cout << "First element of myIntArray: " << myIntArray[0] << "\n";
    std::cout << "Third element of myIntArray: " << myIntArray[2] << "\n";

    // 2. 管理自定义类型数组
    auto myObjectArray = std::make_unique<MyObject[]>(3); // 创建3个MyObject对象
    myObjectArray[0].id = 100;
    myObjectArray[1].id = 200;
    myObjectArray[2].id = 300;
    std::cout << "MyObjectArray element 0 ID: " << myObjectArray[0].id << "\n";

    // unique_ptr 离开作用域时，会自动调用 delete[] 释放内存
    // 对于 MyObject 数组，会依次调用每个 MyObject 的析构函数

    // 3. 也可以直接用 new[] 和 unique_ptr 构造函数，但不如 make_unique 异常安全
    // std::unique_ptr<double[]> myDoubleArray(new double[4]);
    // myDoubleArray[0] = 1.1;

    // 4. 获取原始指针，但所有权仍在 unique_ptr 手中
    double* rawPtr = new double[4];
    std::unique_ptr<double[]> myDoubleArray(rawPtr);
    myDoubleArray[0] = 1.1;
    std::cout << "Raw pointer access: " << myDoubleArray.get()[0] << "\n";
    // 注意：不要手动 delete rawPtr，它由 myDoubleArray 管理

    std::cout << "End of main function.\n";
    return 0;
}

登录后复制

为什么使用

unique_ptr<T[]>

登录后复制

而不是

unique_ptr<T>

登录后复制

来管理数组？

这背后其实有个很简单的道理：C++ 的内存释放机制是分单对象和数组的。当你

new

登录后复制

一个对象时，你用

delete

登录后复制

释放；当你

new[]

登录后复制

一个数组时，你必须用

delete[]

登录后复制

释放。如果搞错了，比如用

delete

登录后复制

去释放一个数组，那就触发了未定义行为。这就像你买了一辆车（单个对象），你开报废了就直接扔到报废场（

delete

登录后复制

）；但如果你买了一队车（数组），你得一辆一辆地处理（

delete[]

登录后复制

），或者至少是通知报废场这是批量的。

unique_ptr<T>

登录后复制

内部默认使用的是

delete

登录后复制

操作符，它期望管理的是一个单个的对象。而

unique_ptr<T[]>

登录后复制

则专门被设计成使用

delete[]

登录后复制

操作符。如果你不小心写成了

std::unique_ptr<int> ptr(new int[10]);

登录后复制

，那么当

ptr

登录后复制

离开作用域时，它会尝试调用

delete ptr.get();

登录后复制

，而不是

delete[] ptr.get();

登录后复制

。结果就是，只有数组的第一个元素会被正确析构（如果是自定义类型），而其余元素的内存可能得不到释放，更糟糕的是，这会造成堆损坏，程序行为变得不可预测。这种错误在运行时往往难以察觉，直到程序崩溃或者出现奇怪的内存错误。所以，为了安全和正确性，务必为数组类型加上

[]

登录后复制

。

立即学习“C++免费学习笔记（深入）”；

std::make_unique

登录后复制

在数组场景下的正确用法与注意事项

std::make_unique

登录后复制

是 C++14 引入的一个非常棒的工具，用来创建

unique_ptr

登录后复制

。它不仅代码更简洁，而且更重要的是，它提供了异常安全保证。对于数组，它的用法也很直观：

auto my_array = std::make_unique<T[]>(size);

登录后复制

这里的

size

登录后复制

就是你想要创建的数组元素的数量。

正确用法示例：

#include <memory>
#include <iostream>

int main() {
    // 创建一个包含10个整数的数组，并自动初始化为0
    auto int_array = std::make_unique<int[]>(10);
    std::cout << "int_array[0] before assignment: " << int_array[0] << std::endl; // 输出0

    // 创建一个包含5个自定义对象的数组
    struct Widget {
        int id;
        Widget() : id(0) { std::cout << "Widget default constructed.\n"; }
        Widget(int i) : id(i) { std::cout << "Widget " << id << " constructed.\n"; }
        ~Widget() { std::cout << "Widget " << id << " destructed.\n"; }
    };
    auto widget_array = std::make_unique<Widget[]>(5); // 调用5次默认构造函数
    widget_array[0].id = 1;
    widget_array[1].id = 2;
    std::cout << "widget_array[0].id: " << widget_array[0].id << std::endl;

    // 注意：make_unique<T[]>(size) 对于基本类型会进行零初始化，
    // 对于类类型会调用默认构造函数。
    // 如果类没有默认构造函数，或者你需要自定义初始化逻辑，
    // 你可能需要手动循环赋值，或者考虑使用 std::vector。

    // 错误示范（编译不通过或行为不符合预期）：
    // auto bad_array = std::make_unique<int>(10); // 这是创建单个 int，不是数组
    // auto another_bad = std::make_unique<int[]>(); // 数组大小必须指定
    return 0;
}

登录后复制

注意事项：

如此AI写作

AI驱动的内容营销平台，提供一站式的AI智能写作、管理和分发数字化工具。

137

查看详情

初始化行为：
```
make_unique<T[]>(size)
```
登录后复制
对基本类型（如
```
int
```
登录后复制
,
```
double
```
登录后复制
）会执行零初始化。对类类型，它会调用元素的默认构造函数。如果你的类没有可访问的默认构造函数，或者你需要传递参数进行构造，
```
make_unique
```
登录后复制
数组就不是那么直接适用了。在这种情况下，你可能需要手动分配
```
new T[size]
```
登录后复制
然后用
```
unique_ptr
```
登录后复制
包装，或者，更常见的做法是，转向使用
```
std::vector
```
登录后复制
。
异常安全：
```
make_unique
```
登录后复制
的主要优势之一是异常安全。它将内存分配和
```
unique_ptr
```
登录后复制
构造放在一个表达式中，避免了在
```
new
```
登录后复制
成功但
```
unique_ptr
```
登录后复制
构造失败时导致的内存泄露。如果你手动写
```
std::unique_ptr<T[]>(new T[size])
```
登录后复制
，在某些复杂场景下，中间的某些操作如果抛出异常，可能会导致
```
new T[size]
```
登录后复制
分配的内存无法被正确释放。
无参数构造：
```
make_unique<T[]>()
```
登录后复制
是不允许的，你必须提供数组的大小。

unique_ptr

登录后复制

数组的常见陷阱与高级内存管理技巧

即便

unique_ptr<T[]>

登录后复制

很好用，但它也不是万能药，使用时还是有些坑需要避开，同时也有一些高级用法能让它更灵活。

常见陷阱：

混淆
unique_ptr<T>
登录后复制
和
unique_ptr<T[]>
登录后复制
：这是最致命的陷阱，前面已经详细说过了，忘记

[]

登录后复制

几乎必然导致内存问题。

// 错误示范：会导致未定义行为和内存泄露
// std::unique_ptr<int> bad_ptr(new int[10]); // 编译可能通过，但运行时会出错

登录后复制

*试图使用 `operator

或

登录后复制

operator->

：**

登录后复制

unique_ptr<T[]>

类型没有定义

登录后复制

operator*

或

登录后复制

operator->

。因为它代表的是一个数组的首地址，而不是一个单个对象。你只能通过

登录后复制

operator[]` 来访问数组元素。

auto my_array = std::make_unique<int[]>(5);
// int val = *my_array; // 编译错误！
// my_array->some_method(); // 编译错误！
int val = my_array[0]; // 正确

登录后复制

数组大小的不可变性： 一旦
```
unique_ptr<T[]>
```
登录后复制
被创建，其所管理的数组大小就是固定的。你不能像
```
std::vector
```
登录后复制
那样动态改变其大小。如果需要动态调整大小，
```
std::vector
```
登录后复制
几乎总是更好的选择。
```
unique_ptr<T[]>
```
登录后复制
更适合那些生命周期内大小不变的动态数组。

高级内存管理技巧：

自定义 Deleter：

unique_ptr

登录后复制

最强大的特性之一就是支持自定义 deleter。这意味着你可以让它管理任何通过非

new

登录后复制

new[]

登录后复制

分配的资源，只要你提供一个函数或 lambda 表达式来告诉它如何释放。这在与 C 风格 API 交互时特别有用。

#include <memory>
#include <iostream>
#include <cstdlib> // For malloc and free

// 假设我们有一个C风格的函数，它返回一个由malloc分配的int数组
int* create_c_array(size_t size) {
    return static_cast<int*>(std::malloc(size * sizeof(int)));
}

// 自定义deleter，用于free C风格内存
struct FreeDeleter {
    void operator()(int* ptr) const {
        std::cout << "Calling custom FreeDeleter for array.\n";
        std::free(ptr);
    }
};

int main() {
    // 使用自定义deleter管理malloc分配的内存
    std::unique_ptr<int[], FreeDeleter> managed_c_array(create_c_array(10));
    if (managed_c_array) {
        managed_c_array[0] = 100;
        std::cout << "Managed C array element 0: " << managed_c_array[0] << std::endl;
    }

    // 也可以使用lambda作为deleter
    auto lambda_managed_array = std::unique_ptr<double[], decltype([](double* p){
        std::cout << "Calling lambda deleter for array.\n";
        std::free(p);
    })>(static_cast<double*>(std::malloc(5 * sizeof(double))));
    if (lambda_managed_array) {
        lambda_managed_array[0] = 3.14;
        std::cout << "Lambda managed array element 0: " << lambda_managed_array[0] << std::endl;
    }

    return 0;
}

登录后复制

这里需要注意的是，自定义 deleter 的类型会成为

unique_ptr

登录后复制

类型的一部分，这会影响类型推断和函数签名。

获取原始指针 (

.get()

登录后复制

)：当你需要将

unique_ptr

登录后复制

管理的数组传递给期望 C 风格数组指针（

T*

登录后复制

）的函数时，可以使用

.get()

登录后复制

方法获取原始指针。但切记，这只是借用指针，所有权仍在

unique_ptr

登录后复制

手中，不要在外部

delete

登录后复制

这个指针。

void process_raw_array(int* arr, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        arr[i] *= 2;
    }
}

int main() {
    auto my_array = std::make_unique<int[]>(5);
    for (int i = 0; i < 5; ++i) my_array[i] = i + 1;

    process_raw_array(my_array.get(), 5); // 传递原始指针
    std::cout << "After processing: " << my_array[0] << ", " << my_array[1] << std::endl;
    return 0;
}

登录后复制

所有权转移：
```
unique_ptr
```
登录后复制
的“独占”特性意味着它不能被复制，但可以被移动。这意味着你可以将
```
unique_ptr<T[]>
```
登录后复制
从一个函数返回，或者将其所有权转移给另一个
```
unique_ptr
```
登录后复制
。
```
std::unique_ptr<int[]> create_and_return_array(size_t size) {
    auto arr = std::make_unique<int[]>(size);
    for (size_t i = 0; i < size; ++i) {
        arr[i] = static_cast<int>(i * 10);
    }
    return arr; // 返回时发生移动
}

int main() {
    auto received_array = create_and_return_array(3);
    std::cout << "Received array element 0: " << received_array[0] << std::endl;

    std::unique_ptr<int[]> another_array;
    another_array = std::move(received_array); // 显式移动所有权
    // received_array 现在为空
    std::cout << "Another array element 1: " << another_array[1] << std::endl;
    return 0;
}
```
登录后复制
总的来说，
```
unique_ptr<T[]>
```
登录后复制
提供了一种 RAII 风格的动态数组管理方式，特别适合那些生命周期内大小不变的数组。但对于更灵活的动态数组需求，
```
std::vector
```
登录后复制
往往是更优的选择，它提供了更多功能，如动态调整大小、迭代器支持、边界检查等，并且在性能上通常也能达到甚至超越手动管理。选择哪一个，主要看你的具体需求和对内存控制的精细程度。