c++ - 可变参数模板的类型推导

Question

问题:

我想要一个采用可变数字的类的推导指南 由可变参数模板构造的对象。

例如

template<typename... Ts>
struct y {
    using values_t = std::tuple<Ts...>;
    values_t values;

    constexpr y(const Ts... values): values( { values... } ) { }
};

我现在想提供一个推导指南，这样如果我调用:

y y { { 1, 2, 3 }, { 'a', 'b', 'c' } };

我将得到一个类型的对象:

y<y<int, int, int>, y<char, char, char>> y { { 1, 2, 3 }, { 'a', 'b', 'c' } };

因此每次我只提供一个初始化列表作为参数， 它应该被推断为“y”对象。

简单类的例子:

如果我只有一个具有一个模板参数的类，我可以通过以下方式实现:

template<typename T>
struct x {
    T value;

    constexpr x(const T value): value(value) { }
};

template<typename T>
x(const std::initializer_list<T>) -> x<x<T>>;

//works -> x x { { 1 } };

编辑:

以下也应该起作用:

y y { { 1, 'a' } };
//resolves to -> y<y<int, char>> y { { 1, 'a' } };

Answer 1

不确定您到底想要什么，但是...

通过 C 风格的数组而不是初始化列表怎么样？

它需要一些 helper (也许可以简化一点)

template <typename T, std::size_t>
using getType = T;

template <typename T, std::size_t ... Is>
auto getY (std::index_sequence<Is...>)
   -> y<getType<T, Is>...>;

template <typename T, std::size_t N>
using proY = decltype(getY<T>(std::make_index_sequence<N>{}));

但是这个推导指南应该适用于嵌套同质的情况

template <std::size_t ... Dims, typename ... Ts>
y ( Ts const (&...arr)[Dims] ) -> y<proY<Ts, Dims>...>;

下面是一个完整的编译示例

#include <tuple>
#include <iostream>

template <typename... Ts>
struct y
 {
   using values_t = std::tuple<Ts...>;

   values_t values;

   constexpr y (Ts const & ... vs) : values({ vs... })
    { }
 };

template <typename T, std::size_t>
using getType = T;

template <typename T, std::size_t ... Is>
auto getY (std::index_sequence<Is...>)
   -> y<getType<T, Is>...>;

template <typename T, std::size_t N>
using proY = decltype(getY<T>(std::make_index_sequence<N>{}));

template <std::size_t ... Dims, typename ... Ts>
y ( Ts const (&...arr)[Dims] ) -> y<proY<Ts, Dims>...>;

int main()
 {
   using T0 = decltype(y{ { 1, 2 }, { 'a', 'b', 'c' },
                          {1.0, 2.0, 3.0, 4.0} });
   using T1 = y<y<int, int>, y<char, char, char>,
                y<double, double, double, double>>;

   static_assert( std::is_same_v<T0, T1> );
 }