c++ - 使用 std::vector 进行 std::array 初始化

Question

假设我有一个 std::vector的大小在编译时已知，我想把它变成一个 std::array .我该怎么做？是否有执行此操作的标准函数？

我目前为止最好的解决方案是:

template<class T, std::size_t N, class Indexable, std::size_t... Indices>
std::array<T, N> to_array_1(const Indexable& indexable, std::index_sequence<Indices...>) {
  return {{ indexable[Indices]... }};
}

template<class T, std::size_t N, class Indexable>
std::array<T, N> to_array(const Indexable& indexable) {
  return to_array_1<T, N>(indexable, std::make_index_sequence<N>());
}

std::array<Foo, 123> initFoos {
  std::vector<Foo> lst;
  for (unsigned i = 0; i < 123; ++i)
    lst.push_back(getNextFoo(lst));
  return to_array<Foo, 123>(lst); // passing lst.begin() works, too
}

应用类似于Populate std::array with non-default-constructible type (no variadic templates) :我也有一个不可默认构造的类型，所以我需要在数组初始化时计算实际值。然而与那个问题相反，对我来说，这些值不仅是指数的函数，而且是前面值的函数。与一系列函数调用相比，使用循环可以更轻松地构建我的值。所以我在一个循环中构建元素并将它们放在一个 vector 中，然后我想使用该 vector 的最终状态来初始化数组。

上面的代码似乎可以编译并且工作正常，但也许有改进的方法。

1. 也许我可以巧妙地使用一些我不知道的标准库功能。
2. 也许我可以以某种方式避免辅助函数。
3. 也许我可以用某种方式来表述它，使其适用于元素的移动语义，而不是上面使用的复制语义。
4. 也许我可以使用 operator[] 来避免随机访问, 而是仅使用前向迭代器语义，这样它就可以用于 std::set或 std::forward_list也作为输入。
5. 也许我应该停止使用 std::vector而是使用 std::array<std::optional<T>, N> 表达我的目标相反，使用 C++17 或一些等效的实现。

相关问题:

• Copy std::vector into std::array它不假定没有默认构造函数的类型，因此在默认初始化后进行复制在那里是可行的，但对我来说不可行。
• Populate std::array with non-default-constructible type (no variadic templates)它根据其索引独立计算每个元素，因此它尽量避免使用中间容器。答案使用可变参数模板，即使标题要求避免使用它们。

Answer 1

我建议:

template<typename T, typename Iter, std::size_t... Is>
constexpr auto to_array(Iter& iter, std::index_sequence<Is...>)
-> std::array<T, sizeof...(Is)> {
    return {{ ((void)Is, *iter++)... }};
}

template<std::size_t N, typename Iter,
         typename T = typename std::iterator_traits<Iter>::value_type>
constexpr auto to_array(Iter iter)
-> std::array<T, N> {
    return to_array<T>(iter, std::make_index_sequence<N>{});
}

这从迭代器中推断出元素类型，并将复制与移动语义留给调用者——如果调用者想要移动，他们可以通过 std::move_iterator 选择加入。或类似的:

auto initFoos() {
    constexpr unsigned n{123};

    std::vector<Foo> lst;
    for (unsigned i{}; i != n; ++i) {
        lst.push_back(getNextFoo(lst));
    }

    // copy-init array elements
    return to_array<n>(lst.cbegin());

    // move-init array elements
    return to_array<n>(std::make_move_iterator(lst.begin()));
}

Online Demo

---

编辑:如果有人想覆盖推导的元素类型，如评论中所示，那么我建议:

template<typename T, typename Iter, std::size_t... Is>
constexpr auto to_array(Iter& iter, std::index_sequence<Is...>)
-> std::array<T, sizeof...(Is)> {
    return {{ ((void)Is, T(*iter++))... }};
}

template<std::size_t N, typename U = void, typename Iter,
         typename V = typename std::iterator_traits<Iter>::value_type,
         typename T = std::conditional_t<std::is_same<U, void>{}, V, U>>
constexpr auto to_array(Iter iter)
-> std::array<T, N> {
    return to_array<T>(iter, std::make_index_sequence<N>{});
}

这使得元素类型可选，但使它成为第二个参数而不是第一个参数，因此用法看起来像 to_array<N, Bar>(lst.begin())而不是 to_array<Bar, N>(lst.begin()) .