C++如何在智能指针中管理动态数组-C++-PHP中文网

最推荐使用 std::unique_ptr<T[]> 管理动态数组，因其能自动调用 delete[] 避免内存泄漏；若需共享所有权，可用带自定义删除器的 std::shared_ptr；但多数情况下应优先选用 std::vector，因其兼具自动管理、丰富接口与优良性能。

c++如何在智能指针中管理动态数组

在C++中，管理动态数组与智能指针结合使用，最直接且推荐的方式是利用

std::unique_ptr<T[]>

登录后复制

。它专为动态数组设计，能确保在对象生命周期结束时自动调用正确的

delete[]

登录后复制

操作，从而避免内存泄漏。如果确实需要共享所有权，

std::shared_ptr

登录后复制

也能做到，但它需要一个自定义的删除器来正确处理数组释放。不过，话说回来，在大多数现代C++场景里，

std::vector

登录后复制

往往是更安全、更方便且性能同样出色的默认选择。

解决方案

当我们需要在堆上分配一个动态数组时，传统的做法是使用

new T[size]

登录后复制

，然后手动

delete[]

登录后复制

。这极易出错，稍不留神就会忘记释放内存，或者更糟的是，用

delete

登录后复制

而非

delete[]

登录后复制

释放数组，导致未定义行为。智能指针的出现就是为了解决这类问题。

std::unique_ptr<T[]>

登录后复制

：独占所有权的最佳选择

这是管理动态数组最直接、最安全的方法，尤其当你确定数组的生命周期与智能指针的生命周期完全绑定，且没有其他地方需要共享该数组时。

std::unique_ptr

登录后复制

有一个特化版本

std::unique_ptr<T[]>

登录后复制

，它明确知道自己管理的是一个数组，因此在析构时会自动调用

delete[]

登录后复制

。

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

#include <memory>
#include <iostream>

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

int main() {
    // 创建一个包含10个int的动态数组
    std::unique_ptr<int[]> arr_ptr = std::make_unique<int[]>(10); // C++14及更高版本推荐
    // 或者 C++11 风格：
    // std::unique_ptr<int[]> arr_ptr(new int[10]); 

    for (int i = 0; i < 10; ++i) {
        arr_ptr[i] = i + 1; // 像普通数组一样访问元素
    }

    std::cout << "Original array elements: ";
    for (int i = 0; i < 10; ++i) {
        std::cout << arr_ptr[i] << " ";
    }
    std::cout << std::endl;

    // 可以获取原始指针传递给C风格API
    process_data(arr_ptr.get(), 10);

    std::cout << "Processed array elements: ";
    for (int i = 0; i < 10; ++i) {
        std::cout << arr_ptr[i] << " ";
    }
    std::cout << std::endl;

    // arr_ptr超出作用域时，会自动调用 delete[] arr_ptr.get()
    return 0;
}

登录后复制

std::make_unique<int[]>(10)

登录后复制

是C++14引入的，它避免了显式

new

登录后复制

，并提供了异常安全保证，我个人觉得，这是更现代、更安全的写法。

std::shared_ptr

登录后复制

与自定义删除器：共享所有权

如果你的动态数组需要被多个

std::shared_ptr

登录后复制

实例共享，那么情况就稍微复杂一点。

std::shared_ptr

登录后复制

的默认删除器只会调用

delete

登录后复制

，而不是

delete[]

登录后复制

。这意味着，如果你直接这样用：

std::shared_ptr<int> shared_arr(new int[10]);

登录后复制

，那么在

shared_arr

登录后复制

析构时，会调用

delete

登录后复制

而不是

delete[]

登录后复制

，这会导致未定义行为。

正确的做法是提供一个自定义的删除器（通常是一个lambda表达式），明确告诉

std::shared_ptr

登录后复制

如何释放数组内存：

#include <memory>
#include <iostream>
#include <vector> // 后面会提到

int main() {
    // 使用自定义删除器管理动态数组
    std::shared_ptr<int> shared_arr(new int[10], [](int* p) {
        std::cout << "Custom deleter called for shared_arr, deleting array." << std::endl;
        delete[] p;
    });

    for (int i = 0; i < 10; ++i) {
        shared_arr.get()[i] = (i + 1) * 10; // 通过get()获取原始指针访问
    }

    // 可以创建其他shared_ptr实例共享所有权
    std::shared_ptr<int> another_shared_arr = shared_arr;

    std::cout << "Shared array elements: ";
    for (int i = 0; i < 10; ++i) {
        std::cout << shared_arr.get()[i] << " ";
    }
    std::cout << std::endl;

    // 当所有shared_ptr实例都超出作用域时，自定义删除器会被调用一次
    return 0;
}

登录后复制

这里有个细节，

std::shared_ptr<int>

登录后复制

而不是

std::shared_ptr<int[]>

登录后复制

。这是因为

std::shared_ptr

登录后复制

没有像

std::unique_ptr

登录后复制

那样为数组提供特化版本。因此，当你使用

std::shared_ptr

登录后复制

管理数组时，你实际上是管理一个指向数组第一个元素的指针，并依赖自定义删除器来正确地释放整个数组。访问元素时，你需要通过

get()

登录后复制

方法获取原始指针，然后进行指针算术或使用下标操作符。

std::vector

登录后复制

：大多数情况下的首选

我个人认为，除非有非常特殊的原因，比如需要与C风格API高度兼容，或者对内存布局有极致的控制需求，否则

std::vector

登录后复制

几乎总是管理动态数组的最佳选择。它提供了RAII（资源获取即初始化），自动内存管理，以及丰富的API（如迭代器、容量管理、元素访问方法等），并且通常在性能上与原始数组不相上下。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec(10); // 创建一个包含10个int的动态数组

    for (int i = 0; i < 10; ++i) {
        vec[i] = i * 100; // 像普通数组一样访问元素
    }

    std::cout << "Vector elements: ";
    for (int i = 0; i < vec.size(); ++i) {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;

    // vec超出作用域时，会自动释放内存
    return 0;
}

登录后复制

std::vector

登录后复制

内部已经处理了内存的分配和释放，并且提供了类型安全和边界检查（在调试模式下）。它的接口设计也更加现代化和易用。

为什么不能直接用

std::unique_ptr<T>

登录后复制

管理数组？

这是一个非常常见的误区，我见过不少新手会犯这样的错误。核心问题在于

std::unique_ptr<T>

登录后复制

和

std::unique_ptr<T[]>

登录后复制

在析构时调用的内存释放函数不同。

当你声明

std::unique_ptr<T> ptr(new T[size]);

登录后复制

时，你创建了一个

unique_ptr

登录后复制

，它被设计来管理单个对象

登录后复制

。因此，当

ptr

登录后复制

超出作用域时，它的析构函数会调用

delete ptr.get();

登录后复制

。

MagicStudio

图片处理必备效率神器！为你的图片提供神奇魔法

102

查看详情

然而，如果你用

new T[size]

登录后复制

分配了一个数组，正确的释放方式是

delete[] ptr.get();

登录后复制

。

所以，当

delete

登录后复制

被用于释放通过

new[]

登录后复制

分配的内存时，就会导致未定义行为（Undefined Behavior, UB）。这意味着程序可能会崩溃，可能会泄漏内存，也可能表面上看起来正常运行，但在未来的某个时刻，在某个不相关的代码路径中，问题会突然暴露出来，这种错误调试起来非常痛苦。

简单来说，

delete

登录后复制

和

delete[]

登录后复制

不是可以互换的。

delete

登录后复制

针对单个对象，

delete[]

登录后复制

针对数组。它们在底层可能执行完全不同的操作，例如

new[]

登录后复制

可能会在实际数据之前存储数组的大小信息，而

delete[]

登录后复制

会利用这些信息。如果只调用

delete

登录后复制

，这些信息可能不会被正确处理，导致内存损坏。

// 错误的示例，会导致未定义行为！
std::unique_ptr<int> bad_array_ptr(new int[10]); 
// 当 bad_array_ptr 析构时，会调用 delete (int*) 而不是 delete[] (int*)
// 这就是问题所在。

登录后复制

所以，请务必记住：管理动态数组，要用

std::unique_ptr<T[]>

登录后复制

，而不是

std::unique_ptr<T>

登录后复制

。这是C++类型系统和内存管理规则的一个重要细节。

在

std::shared_ptr

登录后复制

中管理动态数组需要注意什么？

正如前面提到的，

std::shared_ptr

登录后复制

在设计上没有为数组提供像

std::unique_ptr

登录后复制

那样的特化版本。这意味着，如果你想用

std::shared_ptr

登录后复制

来管理

new T[size]

登录后复制

分配的动态数组，你必须提供一个自定义的删除器。

最关键的注意事项就是：不要忘记自定义删除器，并且确保删除器调用的是

delete[]

登录后复制

。

// 错误示范：没有自定义删除器
// std::shared_ptr<int> my_shared_array(new int[5]); // 同样是未定义行为！

// 正确示范：使用lambda表达式作为自定义删除器
std::shared_ptr<int> my_shared_array_correct(new int[5], [](int* p) {
    std::cout << "Custom deleter for shared_ptr array called." << std::endl;
    delete[] p; // 确保是 delete[]
});

登录后复制

自定义删除器是一个可调用对象（函数指针、函数对象或lambda），它接受一个原始指针作为参数，并负责释放该指针指向的资源。

std::shared_ptr

登录后复制

会在最后一个引用计数归零时调用这个删除器。

如果你忘记提供自定义删除器，

std::shared_ptr

登录后复制

会使用其默认的删除器，它会调用

delete

登录后复制

。这和

std::unique_ptr<T>

登录后复制

犯的错误一样，导致未定义行为。

此外，需要注意的是，当使用

std::shared_ptr

登录后复制

管理数组时，你通常需要通过

get()

登录后复制

方法获取原始指针来访问数组元素，例如

my_shared_array_correct.get()[i]

登录后复制

。这是因为

std::shared_ptr<T>

登录后复制

的

operator[]

登录后复制

没有为数组语义重载，它只是一个指向单个

登录后复制

的智能指针。

虽然

std::shared_ptr

登录后复制

提供了这种灵活性，但它也带来了一定的开销。

std::shared_ptr

登录后复制

需要维护一个控制块来存储引用计数和删除器等信息，这会占用额外的内存。而且，引用计数的增减通常涉及到原子操作，这在多线程环境下会引入同步开销。因此，除非你确实需要共享动态数组的所有权，否则

std::unique_ptr<T[]>

登录后复制

或

std::vector

登录后复制

往往是更轻量级的选择。

什么时候应该优先考虑

std::vector

登录后复制

而不是智能指针管理动态数组？

在我看来，这是一个非常实际的问题，也是现代C++编程中一个重要的设计决策。我几乎可以说，在绝大多数情况下，

std::vector

登录后复制

都应该成为你管理动态数组的首选，而不是直接使用智能指针来包装

new T[]

登录后复制

。

以下是我个人总结的一些理由，说明为什么

std::vector

登录后复制

常常是更好的选择：

RAII 的完整实现与自动内存管理：
```
std::vector
```
登录后复制
内部已经完美地实现了RAII。你不需要担心
```
new
```
登录后复制
和
```
delete[]
```
登录后复制
的配对，它会自动处理内存的分配和释放。这大大减少了内存泄漏和悬空指针的风险。
丰富的API和功能：
```
std::vector
```
登录后复制
不仅仅是一个内存容器，它是一个功能完备的序列容器。它提供了：
- 动态大小调整： 你可以方便地添加或删除元素，
```
std::vector
```
  登录后复制
  会自动处理内存的重新分配。这是
```
new T[]
```
  登录后复制
  无法直接提供的。
- 迭代器支持： 可以轻松地与STL算法（如
```
std::sort
```
  登录后复制
  ,
```
std::for_each
```
  登录后复制
  等）配合使用。
- 边界检查：
```
at()
```
  登录后复制
  方法提供运行时边界检查（尽管
```
operator[]
```
  登录后复制
  不提供，但调试时可以帮助发现问题）。
- 容量管理：
```
capacity()
```
  登录后复制
  ,
```
reserve()
```
  登录后复制
  ,
```
shrink_to_fit()
```
  登录后复制
  等方法可以让你更好地控制内存使用。
- 构造函数和赋值操作： 提供了方便的复制、移动语义。
类型安全：
```
std::vector<T>
```
登录后复制
明确表示它包含
```
T
```
登录后复制
类型的元素，并提供类型安全的访问。
性能通常足够好： 很多人可能误以为
```
std::vector
```
登录后复制
会有很大的性能开销。但实际上，现代C++编译器对
```
std::vector
```
登录后复制
的优化非常到位。它的元素是连续存储的，这与原始数组一样，因此缓存局部性很好。对于绝大多数应用来说，
```
std::vector
```
登录后复制
的性能表现与原始数组几乎没有区别，甚至在某些情况下可能因为更好的内存管理策略而表现更优。
与现代C++生态系统的无缝集成：
```
std::vector
```
登录后复制
是STL的核心组件，与C++标准库中的其他部分（如算法、迭代器）配合得天衣无缝。

那么，什么时候会考虑智能指针管理

new T[]

登录后复制

呢？

C风格API的互操作性： 当你需要将一个动态数组的原始指针传递给一个只接受
```
T*
```
登录后复制
或
```
void*
```
登录后复制
的C风格函数或库时，
```
std::unique_ptr<T[]>::get()
```
登录后复制
或
```
std::shared_ptr<T>::get()
```
登录后复制
就可以派上用场。虽然
```
std::vector<T>::data()
```
登录后复制
也能提供这个功能，但在某些特定场景下，智能指针可能更直接。
极度内存敏感或特殊分配需求： 某些非常底层或嵌入式系统编程中，你可能需要使用自定义的内存分配器（例如，从预分配的内存池中分配），而这些分配器可能不兼容
```
std::vector
```
登录后复制
的默认行为。在这种情况下，手动
```
new T[size]
```
登录后复制
并用智能指针管理可能是一种选择。但这非常罕见，且需要深入理解内存管理。
遗留代码的现代化： 如果你正在处理大量使用
```
new T[]
```
登录后复制
的遗留C++代码，并且希望逐步引入RAII，那么将这些裸指针包装到
```
std::unique_ptr<T[]>
```
登录后复制
或
```
std::shared_ptr<T>
```
登录后复制
（带自定义删除器）中，是一个相对低风险的重构策略。

总而言之，我的建议是：总是从

std::vector

登录后复制

开始考虑。只有当
std::vector
登录后复制
明确无法满足你的特定需求（通常是与C接口的深度集成或极端的自定义内存管理）时，才转向
std::unique_ptr<T[]>
登录后复制
。而
std::shared_ptr
登录后复制
管理动态数组，则是在需要共享所有权且必须使用
new T[]
登录后复制
时的最后手段。这样做能让你的代码更健壮、更易读、更易维护。

以上就是C++如何在智能指针中管理动态数组的详细内容，更多请关注php中文网其它相关文章！