医生:这是穷人的性病。

让我们把std::unique_ptr<T[]>看作一个容器。实际上，由于缺少size字段，不能直接作为容器使用，它在标准库中可用的容器的“参数空间”中占据了一个点，而这个点不被其他合适的容器共享——即使在混合中添加Boost也不行。

如果你看看我对广泛可用的类向量/连续容器的比较，并寻找与std::unique_ptr相同的特性:

堆上的分配 容量在编译时不固定 在建造后不能改变容量(没有完全清理集装箱)

你会发现除了std::dynarray，没有其他容器提供所有这些;但它实际上不在标准库中——它本应被纳入c++ 14，但最终被拒绝了。

我不仅仅是在猜测。甚至在《SO》中，人们也偶尔这样描述事物;参见@KerrekSB 2013年对这个问题的回答。

在一些Windows Win32 API调用中可以找到一个常见的模式，其中使用std::unique_ptr<T[]>可以派上用场，例如，当你调用一些Win32 API(将在该缓冲区中写入一些数据)时，不知道输出缓冲区应该有多大:

// Buffer dynamically allocated by the caller, and filled by some Win32 API function.
// (Allocation will be made inside the 'while' loop below.)
std::unique_ptr<BYTE[]> buffer;

// Buffer length, in bytes.
// Initialize with some initial length that you expect to succeed at the first API call.
UINT32 bufferLength = /* ... */;

LONG returnCode = ERROR_INSUFFICIENT_BUFFER;
while (returnCode == ERROR_INSUFFICIENT_BUFFER)
{
    // Allocate buffer of specified length
    buffer.reset( BYTE[bufferLength] );
    //        
    // Or, in C++14, could use make_unique() instead, e.g.
    //
    // buffer = std::make_unique<BYTE[]>(bufferLength);
    //

    //
    // Call some Win32 API.
    //
    // If the size of the buffer (stored in 'bufferLength') is not big enough,
    // the API will return ERROR_INSUFFICIENT_BUFFER, and the required size
    // in the [in, out] parameter 'bufferLength'.
    // In that case, there will be another try in the next loop iteration
    // (with the allocation of a bigger buffer).
    //
    // Else, we'll exit the while loop body, and there will be either a failure
    // different from ERROR_INSUFFICIENT_BUFFER, or the call will be successful
    // and the required information will be available in the buffer.
    //
    returnCode = ::SomeApiCall(inParam1, inParam2, inParam3, 
                               &bufferLength, // size of output buffer
                               buffer.get(),  // output buffer pointer
                               &outParam1, &outParam2);
}

if (Failed(returnCode))
{
    // Handle failure, or throw exception, etc.
    ...
}

// All right!
// Do some processing with the returned information...
...

与std::vector和std::array相反，std::unique_ptr可以拥有一个NULL指针。 这在使用期望数组或NULL的C api时非常方便:

void legacy_func(const int *array_or_null);

void some_func() {    
    std::unique_ptr<int[]> ptr;
    if (some_condition) {
        ptr.reset(new int[10]);
    }

    legacy_func(ptr.get());
}

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).

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

在我看来，与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.

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