Вычет типа для вариативных c шаблонов

Question

Проблема:

Я хочу иметь руководство по дедукции для класса, который принимает переменное количество объектов, созданных с помощью вариативного c шаблона.

Например,

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».

Пример с простым классом:

Если у меня есть только класс с одним параметром шаблона I можно добиться этого с помощью:

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

EDIT:

Также должно работать следующее:

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

Answer 1

Не уверен, что понимаете, что именно вы хотите, но ...

А как насчет передачи массивов в стиле C вместо списков инициализаторов?

Требовалось немного помощников ( возможно, можно немного упростить)

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

Answer 2

Это?

#include <tuple>
#include <iostream>

using namespace std;

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

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

template<typename ... T>
Y( const std::initializer_list<T>&... ) -> Y< std::initializer_list<T>... >;

int main() {
    Y y { {1, 2, 3}, {'a', 'b'}, {1.5, 100.223, 10.1, 5.6, 6.6} };
    Y y2{ 19, 1.4, 'a'};

    std::cout << "y:" << sizeof(y) << "  y2:" << sizeof(y2);
}

https://godbolt.org/z/vrGdWb