理想的界面是什么样子的？

如果给定一个类型为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 useS.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状态。

假设我有一些值为 10 的ConstInt。我可以直接使用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

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

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

在 C++2a 中，您可以使用模板化 lambda 在函数中定义您的帮助程序，如下所示：

auto v = []<std::size_t...Is>(std::index_sequence<Is...>){return std::vector{Is...};}(seq);
//         ^^^^^^^^^^^^^^^^^^ New in C++2a

演示

如果不使用/创建帮助程序模板，则需要其他方法来提供值。

我能想到的最简单、规范和最通用的方法是将它们放在同一个类范围内，这样你的Ints结构就变成了：

template<int ...ints>
struct Ints {
constexpr static std::initializer_list<int> vals = {ints...};
};

由于它是constexpr因此应在编译时对其进行评估，而不会产生运行时成本。 现在，您将能够执行以下操作：

return std::vector<int>(ints.vals);

我建议在struct Int中添加函数以获得不同的表示

#include <vector>
#include <array>
template<int ...values>
struct Ints {
auto getAsVector() const {
return std::vector<int>({ values... });
}
constexpr auto getAsArray() const {
return std::array<int, sizeof...(values)>({ values... });
}
};
class MyClass
{
public:
Ints<1, 2, 3> get() { return Ints<1, 2, 3>(); }
};
int main() {
MyClass a;
auto array = a.get().getAsVector();
return array.size();
}