I have used unique_ptr<char[]> to implement a preallocated memory pools used in a game engine. The idea is to provide preallocated memory pools used instead of dynamic allocations for returning collision requests results and other stuff like particle physics without having to allocate / free memory at each frame. It's pretty convenient for this kind of scenarios where you need memory pools to allocate objects with limited life time (typically one, 2 or 3 frames) that do not require destruction logic (only memory deallocation).

为了回答人们认为你“必须”使用vector而不是unique_ptr，我在GPU上的CUDA编程中有一个案例，当你在Device中分配内存时，你必须使用一个指针数组(使用cudaMalloc)。 然后，当在Host中检索该数据时，必须再次寻找指针，unique_ptr可以很容易地处理指针。 将double*转换为vector<double>的额外成本是不必要的，并且会导致性能损失。

如果您需要一个不可复制构造的对象的动态数组，那么可以使用一个指向数组的智能指针。例如，如果您需要一个原子数组怎么办?

我对公认答案的精神再怎么反对也不为过。“最后的手段”?远非如此!

在我看来，与C语言和其他类似语言相比，c++最强大的特性之一是能够表达约束，以便在编译时检查它们，并防止意外误用。因此，在设计结构时，要问问自己它应该允许哪些操作。应该禁止所有其他用途，最好能够静态地(在编译时)实现这些限制，以免误用导致编译失败。

因此，当需要一个数组时，以下问题的答案指定了它的行为: 1. 它的大小是a)在运行时动态的，还是b)静态的，但只在运行时知道，还是c)静态的，在编译时知道? 2. 数组是否可以分配到堆栈上?

根据这些答案，我认为这是这种数组的最佳数据结构:

       Dynamic     |   Runtime static   |         Static
Stack std::vector      unique_ptr<T[]>          std::array
Heap  std::vector      unique_ptr<T[]>     unique_ptr<std::array>

是的，我认为unique_ptr<std::array>也应该被考虑，这两个都不是最后的工具。想想什么最适合你的算法。

所有这些都通过指向数据数组的原始指针(vector.data() / array.data() / uniquePtr.get())与普通C api兼容。

P. S. Apart from the above considerations, there's also one of ownership: std::array and std::vector have value semantics (have native support for copying and passing by value), while unique_ptr<T[]> can only be moved (enforces single ownership). Either can be useful in different scenarios. On the contrary, plain static arrays (int[N]) and plain dynamic arrays (new int[10]) offer neither and thus should be avoided if possible - which should be possible in the vast majority of cases. If that wasn't enough, plain dynamic arrays also offer no way to query their size - extra opportunity for memory corruptions and security holes.

您可能使用unique_ptr的一个原因是，如果您不想支付初始化数组值的运行时成本。

std::vector<char> vec(1000000); // allocates AND value-initializes 1000000 chars

std::unique_ptr<char[]> p(new char[1000000]); // allocates storage for 1000000 chars

// C++20 version:
auto p = std::make_unique_for_overwrite<char[]>(1000000);

std::vector构造函数和std::vector::resize()将对t进行值初始化，但new和std::make_unique_for_overwrite将默认初始化它们，这对于PODs来说意味着什么都不做。

参见c++ 11中的值初始化对象和std::vector构造函数

注意，vector::reserve在这里不是一个替代方案:在std::vector::reserve之后访问原始指针是安全的吗?

这和C程序员选择malloc而不是calloc的原因是一样的。

允许和使用std::unique_ptr<T[]>的另一个原因是，到目前为止还没有在响应中提到:它允许向前声明数组元素类型。

当您希望最小化头文件中的链式#include语句(以优化构建性能)时，这非常有用。

例如:

myclass.h:

class ALargeAndComplicatedClassWithLotsOfDependencies;

class MyClass {
   ...
private:
   std::unique_ptr<ALargeAndComplicatedClassWithLotsOfDependencies[]> m_InternalArray;
};

myclass.cpp:

#include "myclass.h"
#include "ALargeAndComplicatedClassWithLotsOfDependencies.h"

// MyClass implementation goes here

使用上面的代码结构，任何人都可以#include " MyClass .h"并使用MyClass，而不必包括MyClass::m_InternalArray所要求的内部实现依赖。

如果m_InternalArray被声明为std::array< alargeandcomplatedclasswithlotsofdependencies >，或者std::vector<…> -结果将尝试使用不完整的类型，这是一个编译时错误。