是否有用于具有固定运行时确定大小的数组的标准 C++ 类？

Question

我需要一个运行时已知大小且无需调整大小的容器。 std::unique_ptr<T[]> 会很有用，但没有封装的 size 成员。同时std::array 仅用于编译类型大小。因此，我需要这些类的一些组合，而没有/最小的开销。

是否有满足我需要的标准类，也许在即将到来的 C++20 中？

Answer 1

使用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

---

cmets中提到的一些问题：

vector 接口过多

std::array 也是如此。 std::array 包括运算符在内有 20 多个函数。

只是不要使用你不需要的东西。您无需为不会使用的功能付费。它甚至不会增加您的二进制文件大小。

vector 将在调整大小时强制初始化项目。据我所知，对于 >= size 的索引，不允许使用 operator[]（尽管调用了 reserve）。

这不是它的用途。保留时，您应该使用resize 或通过将元素推入其中来调整向量的大小。你说vector会强制将元素初始化到其中，但问题是你不能在非构造对象上调用operator=，包括int。

这是一个使用储备的例子：

auto vec = std::vector<int>{};

vec.reserve(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

---

请记住，这种分配和用例的可能性很高，编译器可能会完全忽略向量中元素的构造。您的代码中可能没有开销。

如果您的代码符合非常精确的性能规范，我建议您measure 和 profile。如果您没有这样的规范，很可能这是过早的优化。内存分配的成本完全衡量的是逐个初始化元素所花费的时间。

您的程序的其他部分可能会被重构以获得比简单的初始化所能提供的更多的性能。事实上，妨碍它可能会阻碍优化并使您的程序变慢。

Answer 2

按照您的建议使用std::unique_ptr<T[]> 分配内存，但要使用它- 从原始指针和元素数构造std::span（在C++20 中；gsl::span 在 C++20 之前） ，并传递跨度（按值；跨度是引用类型，有点）。跨度将为您提供容器的所有花里胡哨：大小、迭代器、范围、工作。

#include <span>
// or:
// #include <gsl/span>

int main() {

    // ... etc. ...

    {
        size_t size = 10e5;
        auto uptr { std::make_unique<double[]>(size) };
        std::span<int> my_span { uptr.get(), size };
        do_stuff_with_the_doubles(my_span);
    }

    // ... etc. ...
}

有关跨度的更多信息，请参阅：

What is a "span" and when should I use one?

Answer 3

使用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
};

Answer 4

对于 C++14，std::dynarray 是 proposed：

std::dynarray 是一个序列容器，它封装数组，其大小在构造时固定，并且在对象的整个生命周期内都不会改变。

但有 too many issues 并没有成为标准的一部分。

所以目前 STL 中不存在这样的容器。您可以继续使用带有initial size 的向量。

Answer 5

不幸的是，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);
    }
};