如何从单个值和指定长度生成递归函数参数列表？

当然可以不用pack expression来生成参数列表！借助数组或者元组完全能搞定你的需求，我给你分享两种实用的实现方式：

核心思路是借助std::index_sequence生成编译期索引，把数组的每个元素提取出来，自动展开成函数参数列表传给你的fold expression相乘函数。

先看完整代码：

#include <array>
#include <utility>

// 你用fold expression实现的数值相乘辅助函数
template<typename... Args>
auto multiply(Args... args) {
    return (args * ...); // 递归式fold expression实现相乘
}

// 内部辅助函数：通过索引序列展开数组元素
template<typename T, std::size_t N, std::size_t... Is>
auto multiply_array_impl(const std::array<T, N>& arr, std::index_sequence<Is...>) {
    // 这里的arr[Is]...是借助索引序列生成的参数列表，不是手动写的pack expression
    return multiply(arr[Is]...);
}

// 对外调用接口：自动生成对应长度的索引序列
template<typename T, std::size_t N>
auto multiply_array(const std::array<T, N>& arr) {
    return multiply_array_impl(arr, std::make_index_sequence<N>{});
}

// 使用示例
int main() {
    std::array<int, 4> nums = {2, 3, 4, 5};
    auto result = multiply_array(nums); // 计算2*3*4*5=120
    return 0;
}

解释 #

• std::make_index_sequence<N>会在编译期生成一个包含0到N-1的索引序列，相当于帮你自动生成了对应长度的"参数位置标记"
• 在multiply_array_impl里，arr[Is]...会把数组的每个元素按索引提取出来，展开成multiply(arr[0], arr[1], ..., arr[N-1])的形式，完美适配你的fold expression函数

如果你用元组来存储参数，C++17引入的std::apply可以直接帮你把元组的所有元素拆成函数参数，一步到位，代码更简洁。

完整代码示例：

#include <tuple>
#include <utility>

// 你的fold expression相乘函数
template<typename... Args>
auto multiply(Args... args) {
    return (args * ...);
}

// 使用示例
int main() {
    // 用元组存储任意类型、任意长度的参数
    std::tuple<int, double, float> nums = {2, 3.5, 4.0f};
    // std::apply自动把元组元素拆成参数传给multiply
    auto result = std::apply(multiply, nums); // 计算2*3.5*4.0=28.0
    return 0;
}

解释 #

std::apply的作用就是接收一个函数和一个元组，自动将元组的元素作为参数逐个传入函数，完全不需要你手动处理参数展开的问题，非常适合你的场景。

如果你的需求是生成长度为n的参数列表（比如生成1到n的整数序列），可以结合编译期工具自动生成数组或元组：

比如生成长度为5的序列并相乘：

// 生成数组形式的序列
template<std::size_t N>
constexpr auto generate_sequence_array() {
    std::array<int, N> arr{};
    for (std::size_t i = 0; i < N; ++i) {
        arr[i] = static_cast<int>(i + 1);
    }
    return arr;
}

// 使用
constexpr auto arr_result = multiply_array(generate_sequence_array<5>()); // 1*2*3*4*5=120

// 生成元组形式的序列
template<std::size_t N>
constexpr auto generate_sequence_tuple() {
    return std::apply([](auto... is) {
        return std::make_tuple((is + 1)...);
    }, std::make_index_sequence<N>{});
}

// 使用
constexpr auto tuple_result = std::apply(multiply, generate_sequence_tuple<5>());

这两种方式都完全避开了手动写pack expression，而是借助数组/元组和C++标准库的编译期工具来实现参数列表的生成与传递，完美匹配你的需求。

内容的提问来源于stack exchange，提问作者Casey