使用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
这种特化形式，而不是
unique_ptr
。这确保了在对象生命周期结束时，能正确调用
delete[]
来释放数组内存，避免了内存泄露和未定义行为。
unique_ptr
的数组操作与内存管理，说白了，就是要把
unique_ptr
当成一个更安全的
new[]
和
delete[]
的组合。我个人觉得，这玩意儿就是为了解决我们经常忘记
delete[]
的“人性弱点”而生的。
#include #include // 包含 unique_ptr#include // 也会提及 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 管理数组 // C++14 引入的 std::make_unique 是创建 unique_ptr 的首选方式 // 它对数组类型同样适用，并且提供了异常安全保证 auto myIntArray = std::make_unique(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(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 myDoubleArray(new double[4]); // myDoubleArray[0] = 1.1; // 4. 获取原始指针，但所有权仍在 unique_ptr 手中 double* rawPtr = new double[4]; std::unique_ptr 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
unique_ptr
而不是
unique_ptr
来管理数组？
这背后其实有个很简单的道理：C++ 的内存释放机制是分单对象和数组的。当你
new
一个对象时，你用
delete
释放；当你
new[]
一个数组时，你必须用
delete[]
释放。如果搞错了，比如用
delete
去释放一个数组，那就触发了未定义行为。这就像你买了一辆车（单个对象），你开报废了就直接扔到报废场（
delete
）；但如果你买了一队车（数组），你得一辆一辆地处理（
delete[]
），或者至少是通知报废场这是批量的。
unique_ptr
内部默认使用的是
delete
操作符，它期望管理的是一个单个的对象。而
unique_ptr
则专门被设计成使用
delete[]
操作符。如果你不小心写成了
std::unique_ptr ptr(new int[10]);
，那么当
ptr
离开作用域时，它会尝试调用
delete ptr.get();
，而不是
delete[] ptr.get();
。结果就是，只有数组的第一个元素会被正确析构（如果是自定义类型），而其余元素的内存可能得不到释放，更糟糕的是，这会造成堆损坏，程序行为变得不可预测。这种错误在运行时往往难以察觉，直到程序崩溃或者出现奇怪的内存错误。所以，为了安全和正确性，务必为数组类型加上
[]
。
立即学习“C++免费学习笔记（深入）”；
std::make_unique
std::make_unique
在数组场景下的正确用法与注意事项
std::make_unique
是 C++14 引入的一个非常棒的工具，用来创建
unique_ptr
。它不仅代码更简洁，而且更重要的是，它提供了异常安全保证。对于数组，它的用法也很直观：
auto my_array = std::make_unique(size);
这里的
size
就是你想要创建的数组元素的数量。
正确用法示例：
#include #include int main() { // 创建一个包含10个整数的数组，并自动初始化为0 auto int_array = std::make_unique(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(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(size) 对于基本类型会进行零初始化， // 对于类类型会调用默认构造函数。 // 如果类没有默认构造函数，或者你需要自定义初始化逻辑， // 你可能需要手动循环赋值，或者考虑使用 std::vector。 // 错误示范（编译不通过或行为不符合预期）： // auto bad_array = std::make_unique(10); // 这是创建单个 int，不是数组 // auto another_bad = std::make_unique(); // 数组大小必须指定 return 0;}
注意事项：
初始化行为：
make_unique(size)
对基本类型（如
int
,
double
）会执行零初始化。对类类型，它会调用元素的默认构造函数。如果你的类没有可访问的默认构造函数，或者你需要传递参数进行构造，
make_unique
数组就不是那么直接适用了。在这种情况下，你可能需要手动分配
new T[size]
然后用
unique_ptr
包装，或者，更常见的做法是，转向使用
std::vector
。异常安全：
make_unique
的主要优势之一是异常安全。它将内存分配和
unique_ptr
构造放在一个表达式中，避免了在
new
成功但
unique_ptr
构造失败时导致的内存泄露。如果你手动写
std::unique_ptr(new T[size])
，在某些复杂场景下，中间的某些操作如果抛出异常，可能会导致
new T[size]
分配的内存无法被正确释放。无参数构造：
make_unique()
是不允许的，你必须提供数组的大小。
unique_ptr
unique_ptr
数组的常见陷阱与高级内存管理技巧
即便
unique_ptr
很好用，但它也不是万能药，使用时还是有些坑需要避开，同时也有一些高级用法能让它更灵活。
常见陷阱：
混淆
unique_ptr
和
unique_ptr
： 这是最致命的陷阱，前面已经详细说过了，忘记
[]
几乎必然导致内存问题。
// 错误示范：会导致未定义行为和内存泄露// std::unique_ptr bad_ptr(new int[10]); // 编译可能通过，但运行时会出错
*试图使用 `operator
或
operator->
：**
unique_ptr
类型没有定义
operator*
或
operator->
。因为它代表的是一个数组的首地址，而不是一个单个对象。你只能通过
operator[]` 来访问数组元素。
auto my_array = std::make_unique(5);// int val = *my_array; // 编译错误！// my_array->some_method(); // 编译错误！int val = my_array[0]; // 正确
数组大小的不可变性： 一旦
unique_ptr
被创建，其所管理的数组大小就是固定的。你不能像
std::vector
那样动态改变其大小。如果需要动态调整大小，
std::vector
几乎总是更好的选择。
unique_ptr
更适合那些生命周期内大小不变的动态数组。
高级内存管理技巧：
自定义 Deleter：
unique_ptr
最强大的特性之一就是支持自定义 deleter。这意味着你可以让它管理任何通过非
new
/
new[]
分配的资源，只要你提供一个函数或 lambda 表达式来告诉它如何释放。这在与 C 风格 API 交互时特别有用。
#include #include #include // For malloc and free// 假设我们有一个C风格的函数，它返回一个由malloc分配的int数组int* create_c_array(size_t size) { return static_cast(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 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 <(static_cast(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(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
从一个函数返回，或者将其所有权转移给另一个
unique_ptr
。
std::unique_ptr create_and_return_array(size_t size) { auto arr = std::make_unique(size); for (size_t i = 0; i < size; ++i) { arr[i] = static_cast(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 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
提供了一种 RAII 风格的动态数组管理方式，特别适合那些生命周期内大小不变的数组。但对于更灵活的动态数组需求，
std::vector
往往是更优的选择，它提供了更多功能，如动态调整大小、迭代器支持、边界检查等，并且在性能上通常也能达到甚至超越手动管理。选择哪一个，主要看你的具体需求和对内存控制的精细程度。
以上就是C++unique_ptr数组操作与内存管理注意事项的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1474416.html
微信扫一扫 
支付宝扫一扫 
