使用unique_ptr而非unique_ptr管理数组，是因为前者会正确调用delete[]释放内存，避免内存泄漏和未定义行为。unique_ptr专为数组设计，确保析构时调用数组形式的delete[]，而unique_ptr仅调用delete，导致数组对象析构不完整。C++中单对象与数组的内存管理机制不同，必须匹配使用new/delete或new[]/delete[]。若用unique_ptr管理new[]分配的数组，仅首元素被析构，其余内存泄露或损坏。因此，为保证安全，必须使用unique_ptr形式。make_unique(size)是创建此类智能指针的推荐方式，兼具简洁性与异常安全。该方式对基本类型零初始化，对类类型调用默认构造函数。若类无默认构造函数，需手动处理或改用vector。此外，unique_ptr不支持operator*或operator->，仅能通过operator[]访问元素，且数组大小固定，不可动态扩容。高级用法包括自定义deleter以管理非new[]分配的内存（如malloc），通过.get()获取原始指针供C风格函数使用，以及通过移动语义转移所有权
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就是你想要创建的数组元素的数量。
正确用法示例：
Web Accessibility (WCAG 2 AA))
下载
将 WCAG 2 AA 无障碍标准应用于设计系统、UI 组件和网页——通过可运行的验证器进行对比度计算，采用设计 token 模式使颜色天生可访问，设定排版和焦点状态规则，并提供语义检查清单。适用于构建或审查 UI。
#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;
}注意事项：
-
初始化行为：
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类型没有定义
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
往往是更优的选择，它提供了更多功能，如动态调整大小、迭代器支持、边界检查等，并且在性能上通常也能达到甚至超越手动管理。选择哪一个，主要看你的具体需求和对内存控制的精细程度。
