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

该应用程序类似于使用非默认可构造类型（无可变参数模板）填充 std::array：我也有一个不可默认构造的类型，因此我需要在数组初始化时计算实际值. 然而，与这个问题相反，对我来说，这些值不仅是指数的函数，也是前面值的函数。使用循环比使用一系列函数调用更容易构建我的值。所以我在一个循环中构造元素并将它们放在一个向量中，然后我想使用该向量的最终状态来初始化数组。

以上似乎编译和工作正常，但也许有办法改进它。

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

相关问题：

• 将 std::vector 复制到 std::array 中，它不假定没有默认构造函数的类型，因此在默认初始化之后复制在那里是可行的，但对我来说不是。
• 使用非默认可构造类型（无可变参数模板）填充 std::array ，该类型从其索引独立计算每个元素，因此它试图避免中间容器。答案使用可变参数模板，即使标题要求避免它们。

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())。