在一些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::unique_ptr<bool[]>，它位于HDF5库(用于高效二进制数据存储的库，在科学中使用很多)中。一些编译器(在我的例子中是Visual Studio 2015)提供std::vector<bool>的压缩(通过在每个字节中使用8个bool)，这对于HDF5之类的东西来说是一个灾难，它不关心这种压缩。对于std::vector<bool>， HDF5最终会因为压缩而读取垃圾。

猜猜谁在那里进行救援，在std::vector不起作用的情况下，我需要干净地分配一个动态数组?: -)

允许和使用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<…> -结果将尝试使用不完整的类型，这是一个编译时错误。

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

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