3

问题：

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

例如

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

2 回答 2

2

不知道你到底想要什么，但......

传递 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> );
 }
于 2020-08-02T11:23:50.663 回答
1

这个 ？

#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

于 2020-08-02T10:05:49.613 回答