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> );
 }