使用 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)：我也有一个不可默认构造的类型，所以我需要在数组初始化时计算实际值。然而，与这个问题相反，对我来说，这些值不仅是索引的函数，而且是前面值的函数。与一系列函数调用相比，我可以更轻松地使用循环来构建我的值。所以我在一个循环中构造元素并将它们放在一个向量中，然后我想使用该向量的最终状态来初始化数组。

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

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

---

编辑：如果想要覆盖推导的元素类型，如 cmets 所示，那么我建议：

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