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

Question

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太大,手工重复值也很难看.

Answer 1

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

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;

在线演示

希望有所帮助.

Answer 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。