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

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

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

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

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

与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());
}

在一些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...
...

当你只能通过一个现有的API(窗口消息或线程相关的回调参数)插入一个指针时，它们可能是正确的答案，这些指针在被“捕捉”到另一边后具有一定的生命周期，但与调用代码无关:

unique_ptr<byte[]> data = get_some_data();

threadpool->post_work([](void* param) { do_a_thing(unique_ptr<byte[]>((byte*)param)); },
                      data.release());

我们都希望事情对自己有利。c++是其他时候用的。

std::vector可以被复制，而unique_ptr<int[]>允许表示数组的唯一所有权。另一方面，Std::array要求在编译时确定大小，这在某些情况下可能是不可能的。