Question

这是我很久以前想到的一个有趣的问题。给定struct具有基础聚合：

#include <array>

template <typename T, size_t N>
struct A
{
   constexpr A() = default;

   template <typename ... Ts>
   constexpr A(const T& value, const Ts& ... values); // magic

   std::array<T, N> arr; // aggregate
};

如何将variadic模板构造函数A(const T& value, const Ts& ... values)实现为

接受T类型和另一个A<T, N>
根据传递的参数
尊重聚合的容量
支持C ++ 14 constexpr规则，不引入任何运行时开销

满足上述要求，可以执行以下操作：

int main()
{
   A<int, 3> x(1, 2, 3);
   A<int, 2> y(1, 2);

   A<int, 6> a(x, 1, 2, 3);
   A<int, 6> b(1, x, 2, 3);
   A<int, 6> c(1, 2, x, 3);
   A<int, 6> d(1, 2, 3, x);
   A<int, 6> e(x, x);
   A<int, 6> f(y, y, y);

   return 0;
}

Answer 1

这是一种有效的方法，但几乎肯定可以改进。

我们有A的构造函数，它接受一个参数包，将每个元素转换为一个元组，将元组连接在一起形成一个大元组，然后简单地使用来自该大元组的聚合初始化。以下所有内容均为constexpr，为简洁起见，我省略了它。

首先我们进行转换：

template <class... Us>
A(Us const&... us)
: A(std::tuple_cat(as_tuple(us)...))
{ }

使用：

// single argument
template <class U>
auto as_tuple(U const& u) {
    return std::forward_as_tuple(u);
}

// aggregate argument
template <size_t M>
auto as_tuple(A<T, M> const& a) {
    return as_tuple(a, std::make_index_sequence<M>{});
}

template <size_t M, size_t... Is>
auto as_tuple(A<T, M> const& a, std::index_sequence<Is...> ) {
    return std::forward_as_tuple(std::get<Is>(a.arr)...);
}

然后我们从那里初始化：

template <class... Us, class = std::enable_if_t<(sizeof...(Us) <= N)>>
A(std::tuple<Us...> const& t)
: A(t, std::index_sequence_for<Us...>{})
{ }

template <class... Us, size_t... Is>
A(std::tuple<Us...> const& t, std::index_sequence<Is...> )
: arr{{std::get<Is>(t)...}}
{ }

Demo

Answer 2

@Barry的答案肯定是正确的，也是可以接受的。但它需要一些C ++ 14库添加（你可能也可以在C ++ 11中自己编写），总体上需要一些好的tuple - 和元编程fu。

让我们将多个参数视为“范围范围”，其中范围只是指针和大小。标量参数只是一个size-1范围，A<T, N>参数是size-N范围。

template<class T>
struct Range
{
    T const* data_;
    std::size_t size_;

    constexpr T const* begin() const noexcept { return data_; }
    constexpr T const* end() const noexcept { return data_ + size_; }
    constexpr std::size_t size() const noexcept { return size_; }
};

template<class T>
constexpr Range<T> as_range(T const& t)
{
    return { &t, 1 };
}

template<class T, std::size_t N>
struct A;

template<class T, std::size_t N>
constexpr Range<T> as_range(A<T, N> const& a)
{
    return { a.arr, N };    
}

然后，您可以简单地对所有范围的所有元素进行双循环

template <typename T, size_t N>
struct A
{
    T arr[N]; // aggregate

    constexpr A() = default;

    template <typename U, typename... Us>
    constexpr A(U const u, Us const&... us)
    : 
        arr{}
    {
        Range<T> rngs[1 + sizeof...(Us)] { as_range(u), as_range(us)... };
        auto i = 0;
        for (auto const& r : rngs)
            for (auto const& elem : r)
                arr[i++] = elem;
        assert(i == N);                
    }
};

Array#replace在编译时工作（需要GCC＆gt; = 6.0或Clang＆gt; = 3.4）

template <class T, size_t N>
void print(A<T, N> const& a) {
    for (T const& t : a.arr) {
        std::cout << t << ' ';
    }
    std::cout << '\n';
}

int main()
{
    constexpr A<int, 3> x(1, 2, 3);
    constexpr A<int, 2> y(1, 2);

    constexpr A<int, 6> a(x, 1, 2, 3);
    constexpr A<int, 6> b(1, x, 2, 3);
    constexpr A<int, 6> c(1, 2, x, 3);
    constexpr A<int, 6> d(1, 2, 3, x);
    constexpr A<int, 6> e(x, x);
    constexpr A<int, 6> f(y, y, y);

    print(a); // 1 2 3 1 2 3
    print(b); // 1 1 2 3 2 3
    print(c); // 1 2 1 2 3 3 
    print(d); // 1 2 3 1 2 3
    print(e); // 1 2 3 1 2 3
    print(f); // 1 2 1 2 1 2    
}

通过可变参数模板进行通用聚合初始化

2 个答案: