调用具有未知数量参数的可变参数函数

Calling a variadic function with an unknown number of parameters

本文关键字：参数 变参 函数 未知数 调用      更新时间：2023-10-16

假设我有一个接受可变数量的参数的函数：我想从其他地方调用这个函数，构建参数列表，但事先不知道我需要多少个参数。

抱歉，这没有得到很好的解释，希望这段代码让我的问题更清楚：

void foo(int n, ...) {
    va_list vl;
    va_start(vl,n);
    for (int i = 0; i<n; i++) {
      // Do something to each passed variable
    }
}

从这个函数调用该函数：

void bar(int howManyParams) {
  // Here I want to call foo() with howManyParams parameters
  // (values are irrelevant for the question)
  // 
  // I.e. for howManyParams = 1, we should call foo(0)
  //      for howManyParams = 2, we should call foo(0,0)
  //      for howManyParams = 3, we should call foo(0,0,0)
  // etc.
  //
}

实际上，在运行时构建一个可变长度的参数列表 - 这是我很确定你正在尝试做的事情 - 非常棘手。 在标准 C 中根本没有办法做到这一点，但您可以尝试各种技巧。

也许最好的是 http://sourceware.org/libffi/的"外部函数接口库"。

另请参阅C FAQ列表中的问题15.13：http://c-faq.com/varargs/invvarargs.html

另请参阅之前的 Stackoverflow 问题：
C 具有未知参数
的后期绑定如何通过指针在 C 中传递多个参数来调用函数？

您将需要一个终止参数，它可能是 NULL 或其他什么，不应该出现在您的真实参数中。在函数内部，您可以遍历参数，直到达到终止 NULL 或您选择表示结束的任何其他值。

如果无法保留特殊值来指示列表的末尾，请为每个参数传递 2 个参数。 有点浪费，但确实允许在没有值限制的情况下按顺序自动生成代码。

foo(0);
foo(1, Params1, 0);
foo(1, Params1, 1, Params2, 0);
foo(1, Params1, 1, Params2, 1, Params3, 0);

在运行时执行 OP 要求的更简单的方法可能是依赖标准容器，如 std::vector s 和其他容器。

无论如何，为了完整起见，下面是一个示例，说明如何在编译时创建可变参数包，并在以后用于调用函数：

#include<utility>
#include<tuple>
#include<iostream>
auto params(std::index_sequence<0>) {
    return std::tuple<std::size_t>{};
}
template<std::size_t I, std::size_t... O>
auto params(std::index_sequence<I, O...>) {
    auto tup = std::tuple<std::size_t>{ sizeof...(O) };
    auto seq = std::make_index_sequence<sizeof...(O)>{};
    return std::tuple_cat(tup, params(seq));
}
void foo() {
    std::cout << "done." << std::endl;
}
template<typename Arg, typename... Args>
void foo(Arg &&arg, Args&&... args) {
    std::cout << "arg: " << arg << ", still to be elaborated: " << sizeof...(Args) << std::endl;
    foo(std::forward<Args>(args)...);
}
template<typename... Args, std::size_t... Indexes>
void invoke(std::tuple<Args...> &tup, std::index_sequence<Indexes...>) {
    foo(std::get<Indexes>(tup)...);
}
template<std::size_t N>
void bar(std::integral_constant<std::size_t, N> size) {
    auto seq = std::make_index_sequence<N>{};
    auto tup = params(seq);
    invoke(tup, seq);
}
int main() {
    bar(std::integral_constant<std::size_t, 3>{});
    bar(std::integral_constant<std::size_t, 5>{});
}

不幸的是，由于必须在编译时完全解决它，因此 bar 函数的参数本身不能成为std::size_t。
相反，可以使用std::integral_constant来执行此操作。

当我需要做这样的事情时，我让它与"开关风扇"一起工作。

switch( n ){
case 1:  foo(0);     break;
case 2:  foo(0,0);   break;
case 3:  foo(0,0,0); break;
}
相关文章：