logo标签列表

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

c++arraystemplatesc++11initialization
26

如果T没有默认构造函数，我该如何初始化std::array<T, n>？

我知道可以这样初始化:

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 很大，手动重复值仍然很丑陋。

是的，你可以编写一个或两个函数来生成它们。 - chris
'fill()`会有帮助吗？ - Arun
1
std::array 是一个聚合体，关于它你能做的事情并不是很多。 - David Rodríguez - dribeas
@DavidRodríguez-dribeas：我提供了一种解决方案。请查看并发表评论。 - Nawaz
1
@Nawaz：非常有创意。看起来你不能做太多事情，但你可以做到这一点 :) +1 - David Rodríguez - dribeas
显示剩余3条评论
5个回答
28

给定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;

在线演示

希望这有所帮助。

1
谢谢您发布这个。我知道我以前见过类似的东西，但我没有完成尝试解决它。 - chris
为什么valuelist是一个integral_constant（作为旁注）？ - Yakk - Adam Nevraumont
@Yakk：这样你就可以知道列表的大小。在这个例子中，valuelist<0,1,2,3>::value是4。虽然在这个例子中不需要，但拥有这个功能还是很好的。 - Nawaz
3
您不需要自己编写 seq 等样板代码，标准库已经提供了 std::integer_sequence。请参见 https://ideone.com/yEWZVq （任务略有不同，但方法相同）。 - Mikhail
6
很遗憾，这里的现有答案对于不可复制的类型无效。所以我采用了@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。 - L. F.
2
以下内容将解决您的问题：
#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;
}
1
受到@Nawaz的启发，这个更简洁，并更好地利用了标准：https://godbolt.org/z/d6a7eq8T5。
#include <array>
#include <type_traits>

#include <fmt/format.h>
#include <fmt/ranges.h>

// Inspired by https://dev59.com/VWMl5IYBdhLWcg3wVlpf#18497366 

//! Return a std::array<T, Sz> filled with
//! calls to fn(i) for i in the integer sequence:
template <typename Int, Int...N, typename Fn>
[[nodiscard]] constexpr auto 
transform_to_array(std::integer_sequence<Int, N...>, Fn fn) {
    return std::array{(static_cast<void>(N), fn(N))...}; 
}

//! Repeated application of nullary fn:
template <std::size_t N, typename Fn>
[[nodiscard]] constexpr auto 
generate_n_to_array(Fn fn) -> std::array<decltype(fn()), N> {
    return transform_to_array(
        std::make_integer_sequence<std::size_t, N>(),
        [&](std::size_t) { return fn(); }
    );
}

int main() {
    static constexpr std::array<int, 3> a = generate_n_to_array<3>(
        [i = 0]() mutable { return 2 * (i++); }
    );
    fmt::print("{}\n", a);    
}
这不应该是 auto a = etc. etc. 吗？ - einpoklum
0

已经有许多很好的答案了，这里只想提一点： 大多数答案两次使用了N：一次在数组<T,N>中，一次在repeat/genseq/generate/无论你叫什么的函数中...

既然我们本来就使用单个值，看起来我们可以避免重复两次大小，方法如下：

#include <iostream>
#include <array>
#include <type_traits>

// Fill with a value -- won't work if apart from non-default-constructible, the type is also non-copyable...
template <typename T>
struct fill_with {
    T fill;
    constexpr fill_with(T value) : fill{value} {}

    template <typename... Args>
    constexpr fill_with(std::in_place_type_t<T>, Args&&... args) : fill{ T{std::forward<Args>(args)...} } {}

    template <typename U, size_t N>
    constexpr operator std::array<U, N> () { 
        return [&]<size_t... Is>(std::index_sequence<Is...>) {
            return std::array{ ((void)Is, fill)... };
        }(std::make_index_sequence<N>{});
    }
};


// A little more generic, but requires C++17 deduction guides, otherwise using it with lambdas is a bit tedious
template <typename Generator>
struct construct_with {
    Generator gen;
    template <typename F> constexpr construct_with(F && f) : gen{std::forward<F>(f)} {}

    template <typename U, size_t N>
    constexpr operator std::array<U, N> () { 
        return [&]<size_t... Is>(std::index_sequence<Is...>) {
            return std::array{ ((void)Is, gen())... };
        }(std::make_index_sequence<N>{});
    }
};

template <typename F>
construct_with(F&&) -> construct_with<F>;


struct A {
    A(int){}
    A(A const&) = delete;
};

int main() {
    std::array<int, 7> arr = fill_with<int>{ 7 };
    std::array<int, 7> arr = fill_with{ 7 }; // Ok since C++17
    // or you can create a maker function to wrap it in pre-c++17 code, as usual.
    std::array<A, 7> as = construct_with{[]{ return A{7}; }};
    for (auto & elem : arr) std::cout << elem << '\n';
}

注意：这里我使用了一些 C++20 的构造，这可能或可能不是你的问题，但从一个构造更改到另一个构造非常简单。
我还建议尽可能使用 和 std::index_sequence 以及 std 中的所有其他序列来避免重复发明轮子。
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接