时间戳

首页 > 解决方案 > 如何在没有辅助功能模板的情况下检索可变参数模板参数？

c++ - 如何在没有辅助功能模板的情况下检索可变参数模板参数？

问题描述

假设我有

template<int ...>
struct Ints { };

class MyClass
{
public:
    Ints<1, 2, 3> get() { return Ints<1, 2, 3>(); }
};

我想做的很简单。

template <class T>
vector<int> MyFunc1(T& x)
{
    Ints<S...> result = x.get();
    vector<int> t = { S... };
    return t;
}

有点像这样。（这里MyClass可以是一个例子T。）显然，对于编译器S...似乎无效。

template <class T, int... S>
vector<int> MyFunc2(T& x)
{
    Ints<S...> result = x.get();
    vector<int> t = { S... };
    return t;
}

这也不起作用。我认为从get()变得S...具体且可自动演绎，但编译器无法识别它。（我不确定，但 C++ 不会在函数内部推断模板参数，而只是推断参数和返回类型）

我发现的唯一方法是使用另一个函数来找出是什么int...。

template <int ...S>
vector<int> temp(Ints<S...> not_used)
{
    return { S... };
}

template <class T>
vector<int> MyFunc3(T& x)
{
    auto result = x.get();
    return temp(result);
}

它运行良好，但需要另一个额外的辅助函数，它只提供语法清晰的方式来匹配S...使用的模板。

我真的很想在单一功能中做到这一点。每当我想检索参数包时，我真的必须定义辅助函数吗？

编辑：Ints并且MyFunc只是玩具示例。我想知道检索模板参数的一般方法！

标签： c++templatesvariadic-templates

解决方案

理想的界面是什么样的？

如果给定一个 type 变量，Ints<S...>理想情况下，我们可以S...尽可能少地修改使用。

在这种情况下，我们可以设计一个接口，允许我们使用参数包作为可变参数函数或 lambda 的输入，甚至可以将这些值作为模板参数重用。

提议的接口[动态案例/整数作为值传递]

静态案例和动态案例都有类似的界面，但是动态案例稍微干净一些，并且可以更好地介绍。给定变量和函数，我们使用包含在变量定义中的参数包来应用函数。

Ints<1, 2, 3> ints;

// Get a vector from ints
// vec = {1, 2, 3}
auto vec = ints | [](auto... S) { return std::vector {S...}; };

// Get an array from ints
// arr = {1, 2, 3}
auto arr = ints | [](auto... S) { return std::array {S...}; }; 

// Get a tuple from ints
// tup = {1, 2, 3}
auto tup = ints | [](auto... S) { return std::make_tuple(S...); };

// Get sum of ints using a fold expression
auto sum = ints | [](auto... S) { return (S + ...); };

它是一种简单、统一的语法，允许我们将S其用作参数包。

编写这个接口

这部分也很简单。我们取一个类型为 的变量Ints<S...>和一个函数，并将该函数与 一起应用S...。

template<int... S, class Func>
auto operator|(Ints<S...>, Func&& f) {
    return f(S...); 
}

提议的接口[静态案例/可用作模板参数的整数]

如前所述，静态案例与动态案例具有相似的界面，并且在概念上不会有太多的延伸。从用户的角度来看，唯一的区别是我们不使用S...作为参数包，而是ll use将 S.value...` 作为包。

对于每个值，我们希望将其封装在以该值为模板的相应类型中。这允许我们在 constexpr 上下文中访问它。

template<int Value>
struct ConstInt {
    constexpr static int value = Value;
};

为了将它与动态情况区分开来，我将重载/而不是|. 否则，它们的行为相似。实现与动态情况几乎相同，只是值被包装在ConstInt类中，并且每个都有自己的类型。

template<int... S, class F>
auto operator/(Ints<S...>, F&& func) {
    return func(ConstInt<S>()...); 
}

静态使用这个接口

C++ 允许我们使用与非静态成员相同的语法访问类的静态成员，而不会丢失constexpr状态。

假设我有一些ConstInt值为 10。我可以直接I.value用作模板参数，也可以使用decltype(I)::value：

// This is what'll be passed in as a parameter
ConstInt<10> I;

std::array<int, I.value> arr1;
std::array<int, decltype(I)::value> arr2; 
// Both have length 10

因此，扩展参数包非常简单，最终与动态情况几乎相同，唯一的区别是.value附加到S. 下面显示的是来自动态案例的示例，这次使用的是静态案例语法：

Ints<1, 2, 3> ints;

// Get a vector from ints
auto vec = ints | [](auto... S) { return std::vector {S.value...}; };

// Get an array from ints
// arr = {1, 2, 3}
auto arr = ints | [](auto... S) { return std::array {S.value...}; }; 

// Get a tuple from ints
auto tup = ints | [](auto... S) { return std::make_tuple(S.value...); };

// Get sum of ints using a fold expression
auto sum = ints | [](auto... S) { return (S.value + ...); };

那么有什么新东西呢？因为value是 constexpr，S.value所以可以简单地用作模板参数。在此示例中，我们使用S.value以下方法对元组进行索引std::get：

auto tupA = std::make_tuple(10.0, "Hello", 3); 

auto indicies = Ints<2, 0, 1>{};

// tupB = {3, 10.0, "Hello"}
auto tupB = indicies / [&](auto... S) { 
    return std::make_tuple(std::get<S.value>(tupA)...);
};

在这个例子中，我们将序列中的每个元素平方，并返回一个新序列：

auto ints = Ints<0, 1, 2, 3, 4, 5>(); 

// ints_squared = Ints<0, 1, 4, 9, 16, 25>(); 
auto ints_squared = ints / [](auto... S) {
    return Ints<(S.value * S.value)...>(); 
};

避免运算符重载的替代解决方案

如果你想避免运算符重载，我们可以从函数式编程中获得一些灵感，用函数处理事情unpack，写成这样：

template<int... vals>
auto unpack(Ints<vals...>) {
    return [](auto&& f) { return f(vals...); }; 
}

// Static case
template<int... vals>
auto unpack_static(Ints<vals...>) {
    return [](auto&& f) { return f(ConstInt<vals>()...); }; 
}

那么是什么unpack？这个函数接受一堆值，它返回一个函数，该函数接受另一个函数并将该函数与 vals 作为输入一起应用。

该unpack函数允许我们将这些值作为参数应用于不同的函数。

我们可以将结果分配给一个名为 的变量apply_ints，然后我们可以使用它apply_ints来处理所有特定的用例：

Ints<1, 2, 3> ints; //this variable has our ints

auto apply_ints = unpack(ints); // We use this function to unpack them

我们可以重写之前的例子，这次使用apply_ints：

// Get a vector from ints
// vec = {1, 2, 3}
auto vec = apply_ints([](auto... S) { return std::vector {S...}; });

// Get an array from ints
// arr = {1, 2, 3}
auto arr = apply_ints([](auto... S) { return std::array {S...}; }); 

// Get a tuple from ints
// tup = {1, 2, 3}
auto tup = apply_ints([](auto... S) { return std::make_tuple(S...); });

// Get sum of ints using a fold expression
auto sum = apply_ints([](auto... S) { return (S + ...); });

附录

本附录简要概述了如何更普遍地使用此语法（例如在使用多个单独的参数包时）。

奖励示例：将两个单独包中的值配对

为了让您更好地了解此接口的灵活性，这里有一个示例，我们使用它来配对来自两个单独包的值。

Ints<1, 2, 3> intsA;
Ints<10, 20, 30> intsB;

// pairs = {{1, 10}, {2, 20}, {3, 30}}
auto pairs = intsA | [&](auto... S1) {
    return intsB | [&](auto... S2) {
        return std::vector{ std::pair{S1, S2}... }; 
    };
};

注意： MSVC 和 GCC 都编译这个例子没有问题，但是 clang 对此感到窒息。我认为 MSVC 和 GCC 是正确的，但我不确定。

奖励示例：获取二维时间表

这个例子稍微复杂一些，但我们也可以创建二维数组，这些数组从不同包中的所有值组合中提取。

在这种情况下，我使用它来创建时间表。

Ints<1, 2, 3, 4, 5, 6, 7, 8, 9> digits;

auto multiply = [](auto mul, auto... vals) {
    return std::vector{(mul * vals)...}; 
};

auto times_table = digits | [&](auto... S1) {
    return digits | [&](auto... S2) {
        return std::vector{ multiply(S1, S2...)... };
    };
};

推荐阅读