我需要一个运行时已知大小的容器，无需调整大小。 std::unique_ptr<T[]>将是一个有用的，但没有封装大小的成员。同时std::array仅用于编译类型大小。因此，我需要这些类的一些组合，没有/最小的开销。
是否有符合我需求的标准课程，即将推出的C ++ 20中的内容？
使用你建议的std::unique_ptr<T[]>分配内存，但要使用它 - 从原始指针和元素数量构造一个std::span（在C ++ 20中;在C ++ 20之前的gsl::span），并传递跨度（按值） ; spans是引用类型，类型）。跨度将为您提供容器的所有花束和口哨：大小，迭代器，范围，工作。
#include <span>
// or:
// #include <gsl/span>
int main() {
// ... etc. ...
{
size_t size = 10e5;
auto uptr { std::make_unique<double[]>(size) };
do_stuff_with_the_doubles(std::span<int> my_span { uptr.get(), size });
}
// ... etc. ...
}
有关跨度的更多信息，请参阅：
使用std::vector。这是STL中运行时大小的数组的类。
它可以让你调整大小或将元素推入其中：
auto vec = std::vector<int>{};
vec.resize(10); // now vector has 10 ints 0 initialized
vec.push_back(1); // now 11 ints
评论中陈述的一些问题：
vector有一个过多的接口
std::array也是如此。你在std::array中有20多个函数，包括运算符。
只是不要使用你不需要的东西。您不需要支付您不会使用的功能。它甚至不会增加你的二进制大小。
vector将强制初始化调整大小的项目。据我所知，不允许使用
operator[]索引> = size（尽管调用reserve）。
这不是它的用途。在保留时，您应该使用resize或通过将元素推入其中来调整矢量大小。你说vector会强制初始化元素，但问题是你不能在未构造的对象上调用operator=，包括int。
这是使用reserve的示例：
auto vec = std::vector<int>{};
vec.reseve(10); // capacity of at least 10
vec.resize(3); // Contains 3 zero initialized ints.
// If you don't want to `force` initialize elements
// you should push or emplace element into it:
vec.emplace_back(1); // no reallocation for the three operations.
vec.emplace_back(2); // no default initialize either.
vec.emplace_back(3); // ints constructed with arguments in emplace_back
请记住，这种分配和用例很有可能，编译器可能会完全忽略向量中元素的构造。您的代码可能没有开销。
如果您的代码符合非常精确的性能规范，我建议您测量并分析。如果您没有这样的规范，很可能这是过早优化。内存分配的成本完全取决于逐个初始化元素所花费的时间。
程序的其他部分可能会被重构，以获得比简单的初始化可以提供给你更多的性能。事实上，妨碍它可能会阻碍优化并使您的程序变慢。
使用std::vector。如果您想要删除更改尺寸的可能性，请将其包裹起来。
template <typename T>
single_allocation_vector : private std::vector<T>, public gsl::span<T>
{
single_allocation_vector(size_t n, T t = {}) : vector(n, t), span(vector::data(), n) {}
// other constructors to taste
};
有关std::dynarray的东西是proposed for C ++ 14：
std :: dynarray是一个序列容器，它封装了一个在构造时固定的大小的数组，并且在整个对象的生命周期内不会改变。
但是有too many issues并没有成为标准的一部分。
因此STL目前没有这样的容器。你可以继续使用带有initial size的向量。
不幸的是，在C ++ 20中没有添加新容器（至少没有我知道的容器）。但是，我同意这样的容器非常有用。虽然只使用std::vector<T>与reserve()和emplace_back()通常会做得很好，但与使用普通的new T[]相比，它确实会产生较差的代码，因为使用emplace_back()似乎会抑制矢量化。如果我们使用具有初始大小的std::vector<T>，编译器似乎无法优化元素的值初始化，即使整个向量将在之后被覆盖。 Play with an example here。
例如，您可以使用包装器
template <typename T>
struct default_init_wrapper
{
T t;
public:
default_init_wrapper() {}
template <typename... Args>
default_init_wrapper(Args&&... args) : t(std::forward<Args>(args)...) {}
operator const T&() const { return t; }
operator T&() { return t; }
};
和
std::vector<no_init_wrapper<T>> buffer(N);
避免普通类型的无用初始化。这样做seems to lead to code与普通的std::unique_ptr版本一样好。我不建议这样做，因为它使用起来非常丑陋和古怪，因为你必须使用包装元素的向量。
我想现在最好的选择就是滚动你自己的容器。这可以作为一个起点（谨防错误）：
template <typename T>
class dynamic_array
{
public:
using value_type = T;
using reference = T&;
using const_reference = T&;
using pointer = T*;
using const_pointer = const T*;
using iterator = T*;
using const_iterator = const T*;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
private:
std::unique_ptr<T[]> elements;
size_type num_elements = 0U;
friend void swap(dynamic_array& a, dynamic_array& b)
{
using std::swap;
swap(a.elements, b.elements);
swap(a.num_elements, b.num_elements);
}
static auto alloc(size_type size)
{
return std::unique_ptr<T[]> { new T[size] };
}
void checkRange(size_type i) const
{
if (!(i < num_elements))
throw std::out_of_range("dynamic_array index out of range");
}
public:
const_pointer data() const { return &elements[0]; }
pointer data() { return &elements[0]; }
const_iterator begin() const { return data(); }
iterator begin() { return data(); }
const_iterator end() const { return data() + num_elements; }
iterator end() { return data() + num_elements; }
const_reverse_iterator rbegin() const { return std::make_reverse_iterator(end()); }
reverse_iterator rbegin() { return std::make_reverse_iterator(end()); }
const_reverse_iterator rend() const { return std::make_reverse_iterator(begin()); }
reverse_iterator rend() { return std::make_reverse_iterator(begin()); }
const_reference operator [](size_type i) const { return elements[i]; }
reference operator [](size_type i) { return elements[i]; }
const_reference at(size_type i) const { return checkRange(i), elements[i]; }
reference at(size_type i) { return checkRange(i), elements[i]; }
size_type size() const { return num_elements; }
constexpr size_type max_size() const { return std::numeric_limits<size_type>::max(); }
bool empty() const { return std::size(*this) == 0U; }
dynamic_array() = default;
dynamic_array(size_type size)
: elements(alloc(size)), num_elements(size)
{
}
dynamic_array(std::initializer_list<T> elements)
: elements(alloc(std::size(elements))), num_elements(std::size(elements))
{
std::copy(std::begin(elements), std::end(elements), std::begin(*this));
}
dynamic_array(const dynamic_array& arr)
{
auto new_elements = alloc(std::size(arr));
std::copy(std::begin(arr), std::end(arr), &new_elements[0]);
elements = std::move(new_elements);
num_elements = std::size(arr);
}
dynamic_array(dynamic_array&&) = default;
dynamic_array& operator =(const dynamic_array& arr)
{
return *this = dynamic_array(arr);
}
dynamic_array& operator =(dynamic_array&&) = default;
void swap(dynamic_array& arr)
{
void swap(dynamic_array& a, dynamic_array& b);
swap(*this, arr);
}
friend bool operator ==(const dynamic_array& a, const dynamic_array& b)
{
return std::equal(std::begin(a), std::end(a), std::begin(b));
}
friend bool operator !=(const dynamic_array& a, const dynamic_array& b)
{
return !(a == b);
}
};