Std::unique_ptr支持数组，例如:
std::unique_ptr<int[]> p(new int[10]);
但这是必要的吗?可能使用std::vector或std::array更方便。
你觉得这个结构有什么用处吗?
当前回答
我对公认答案的精神再怎么反对也不为过。“最后的手段”?远非如此!
在我看来，与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.
其他回答
有些人无法奢侈地使用std::vector，即使是使用分配器。有些人需要一个动态大小的数组，所以std::array已经失效。有些人从已知返回数组的代码中获取数组;这段代码不会被重写为返回一个向量或其他东西。
通过允许unique_ptr<T[]>，您可以满足这些需求。
简而言之，您可以在需要时使用unique_ptr<T[]>。当其他选择都不适合你的时候。这是最后的手段。
这里有权衡，您可以选择与您想要的匹配的解决方案。我能想到的是:
初始大小
vector和unique_ptr<T[]>允许在运行时指定大小 数组只允许在编译时指定大小
调整
array和unique_ptr<T[]>不允许调整大小 向量是
存储
vector和unique_ptr<T[]>将数据存储在对象之外(通常在堆上) 数组将数据直接存储在对象中
复制
数组和向量允许复制 unique_ptr<T[]>不允许复制
交换/移动
vector和unique_ptr<T[]>有O(1)次交换和移动操作 数组有O(n)次交换和移动操作，其中n是数组中元素的数量
指针/引用/迭代器失效
array ensures pointers, references and iterators will never be invalidated while the object is live, even on swap() unique_ptr<T[]> has no iterators; pointers and references are only invalidated by swap() while the object is live. (After swapping, pointers point into to the array that you swapped with, so they're still "valid" in that sense.) vector may invalidate pointers, references and iterators on any reallocation (and provides some guarantees that reallocation can only happen on certain operations).
概念和算法的兼容性
array和vector都是容器 unique_ptr<T[]>不是容器
我不得不承认，对于基于策略的设计来说，这似乎是一个重构的机会。
std::vector可以被复制，而unique_ptr<int[]>允许表示数组的唯一所有权。另一方面，Std::array要求在编译时确定大小，这在某些情况下可能是不可能的。
我对公认答案的精神再怎么反对也不为过。“最后的手段”?远非如此!
在我看来，与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.
与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());
}
