如果 T 不是默认可构造的，如何优雅地初始化 std::array<T, n>？答案

【问题标题】：How to initialize std::array<T, n> elegantly if T is not default constructible?如果 T 不是默认可构造的，如何优雅地初始化 std::array<T, n>？
【发布时间】：2016-10-18 03:38:54
【问题描述】：

我如何初始化std::array<T, n>如果 T 不是默认可构造的？

我知道可以这样初始化它：

T t{args};
std::array<T, 5> a{t, t, t, t, t};

但n对我来说是模板参数：

template<typename T, int N>
void f(T value)
{
    std::array<T, N> items = ??? 
}

即使不是模板，如果n 太大，手动重复值也是相当难看的。

【问题讨论】：

是的，你可以写一两个函数来生成它们。
'fill()` 会有帮助吗？
@Arun，不。它只能在已经构建的数组上调用。
std::array 是一个聚合，你无能为力
@Nawaz：非常有创意。似乎没有你能做的太多，尽管你可以做到这一点:) +1

标签： c++ arrays templates c++11 initialization

【解决方案1】：

给定 N，您可以使用名为 genseq_t<> 的生成器生成名为seq<0,1,2,3,...N-1> 的序列类型，然后执行以下操作：

template<typename T, int N>
void f(T value)
{
     //genseq_t<N> is seq<0,1,...N-1>
     std::array<T, N> items = repeat(value, genseq_t<N>{});
}

其中repeat 定义为：

template<typename T, int...N>
auto repeat(T value, seq<N...>) -> std::array<T, sizeof...(N)> 
{
   //unpack N, repeating `value` sizeof...(N) times
   //note that (X, value) evaluates to value
   return {(N, value)...}; 
}

其余的定义为：

template<int ... N>
struct seq
{
   using type = seq<N...>;

   static const std::size_t size = sizeof ... (N);

   template<int I>
   struct push_back : seq<N..., I> {};
};

template<int N>
struct genseq : genseq<N-1>::type::template push_back<N-1> {};

template<>
struct genseq<0> : seq<> {};

template<int N>
using genseq_t = typename genseq<N>::type;

Online demo

希望对您有所帮助。

【讨论】：

感谢您发布此信息。我知道我以前见过这样的事情，但我还没有完全完成我尝试的解决方案。
为什么valuelist 和integral_constant 放在一边？
@Yakk：这样你就可以知道列表的大小。 valuelist<0,1,2,3>::value 是 4。在这个例子中，这不是必需的，但有这个功能很好。
您不需要拥有seq 和所有其他样板，标准已经有std::integer_sequence。请参阅ideone.com/yEWZVq（任务略有不同，但方法相同）。

【解决方案2】：

遗憾的是，这里的现有答案不适用于不可复制的类型。所以我接受了@Nawaz 的回答并对其进行了修改：

#include <utility>
#include <array>


template<typename T, size_t...Ix, typename... Args>
std::array<T, sizeof...(Ix)> repeat(std::index_sequence<Ix...>, Args &&... args) {
   return {{((void)Ix, T(args...))...}};
}

template<typename T, size_t N>
class initialized_array: public std::array<T, N> {
public:
    template<typename... Args>
    initialized_array(Args &&... args)
        : std::array<T, N>(repeat<T>(std::make_index_sequence<N>(), std::forward<Args>(args)...)) {}
};

请注意，这是一个std::array 子类，因此可以轻松编写

class A { 
    A(int, char) {}
}

...

class C {
    initialized_array<A, 5> data;

    ...

    C(): data(1, 'a') {}
}

无需重复类型和大小。当然，这种方式也可以实现为函数initialize_array。

【讨论】：

不要在这里使用完美转发——最终你必须复制它们。只需使用const Args&... args。

【解决方案3】：

以下将解决您的问题：

#if 1 // Not in C++11, but in C++1y (with a non linear better version)

template <std::size_t ...> struct index_sequence {};

template <std::size_t I, std::size_t ...Is>
struct make_index_sequence : make_index_sequence<I - 1, I - 1, Is...> {};

template <std::size_t ... Is>
struct make_index_sequence<0, Is...> : index_sequence<Is...> {};

#endif

namespace detail
{
    template <typename T, std::size_t ... Is>
    constexpr std::array<T, sizeof...(Is)>
    create_array(T value, index_sequence<Is...>)
    {
        // cast Is to void to remove the warning: unused value
        return {{(static_cast<void>(Is), value)...}};
    }
}

template <std::size_t N, typename T>
constexpr std::array<T, N> create_array(const T& value)
{
    return detail::create_array(value, make_index_sequence<N>());
}

所以测试一下：

struct NoDefaultConstructible {
    constexpr NoDefaultConstructible(int i) : m_i(i) { }
    int m_i;
};

int main()
{
    constexpr auto ar1 = create_array<10>(NoDefaultConstructible(42));
    constexpr std::array<NoDefaultConstructible, 10> ar2 = create_array<10>(NoDefaultConstructible(42));

    return 0;
}

【讨论】：