带有可变参数的 C++ 泛型函数调用

Question

在我的项目中，我有不同类型的输入参数数量不同的函数。由于这些函数是库的一部分，因此我无法更改它们的定义或主体。

void methodA(boolean p1, int p2, long p3){
    ... some unrelevant code here ...
}

void methodB(int p1, int p2, int p3, long p4){
    ... some unrelevant code here too ...
}

int methodC(long p4){
    ...
}

在我的项目中，我需要一个方法，它可以接收其中一个函数的地址。此外，它接收格式良好的参数列表（适合第一个参数中的函数）。那么这个方法就得用传递的参数调用传递的函数。

这是我现在所拥有的：（我已经稍微简化了代码以使我的想法清晰）

void intercaller(void* some_func_address, ...){

    // VARARGS parameters extractor
    va_list listPointer;
    va_start( listPointer, some_func_address );

    int p1 = va_arg( listPointer, int );
    int p2 = va_arg( listPointer, int );
    int p3 = va_arg( listPointer, int );
    long p4 = va_arg( listPointer, long );

    // TODO: THIS IS NOT GENERIC CALL , CANN ONLY CALL METHOD B
    ((void (*)( int , int , int , long )) some_func_address)( p1 , p2 , p3 , p4 );

    va_end( listPointer );
}

我的问题是实际的函数调用。函数调用中的参数列表应该是通用的，并且应该能够包含不同数量的参数，遗憾的是我不知道该怎么做......我试过像这里一样传递可变参数列表：

((void (*)( va_list )) some_func_address)( listPointer);

但这会弄乱被调用函数中的参数...

所以我的问题是：有没有办法以通用方式调用具有给定参数的给定函数？也许我需要某种 typedeff 或包装函数？

Answer 1

va_args 对我来说仍然有点黑魔法，但我相信 va_start 的第二个 arg 应该是被调用函数的第一个 arg。我不明白你的“clazz”是什么。我相信您应该将 va_start 称为：

va_start( listpointer, some_func_address ); 

代替：

va_start( listPointer, clazz );

Answer 2

如果您还没有std::invoke，请使用variadic templates。要很好地处理void 函数，请使用SFINAE。

template<typename R, typename... Args>
auto call(R(*function)(Args...), Args... args) -> typename std::enable_if<!std::is_same<R, void>::value, R>::type {
    return function(args...);
}

template<typename... Args>
void call(void (*function)(Args...), Args... args) {
    function(args...);
}

例子：

void a() {
    std::cout << 'a';
}

void b(int a) {
    std::cout << "b:" << a;
}

int c(int a) {
    return a;
}

int main() {
    call(a);
    call(b, 1);
    std::cout << "c:" << call(c, 2);
}

不要忘记#include <type_traits> 为std::enable_if 和std::is_same。

Try it online!

Answer 3

这对你有帮助吗？

#include <stdarg.h>

template <typename T>
T extract(va_list& list)
{
    return va_arg(list, T);
}

template<typename Result, typename ... Parameters>
Result call(Result(*function)(Parameters...), va_list& list)
{
    return function(extract<Parameters>(list)...);
}

void f1(int x, int y)
{
    std::cout << x << ' ' << y << std::endl;
}

void f2(double x, double y)
{
    std::cout << x << ' ' << y << std::endl;
}

void interceptor(void* f, ...)
{
    va_list list;
    va_start(list, f);
    if(f == &f1)
    {
        call(f1, list);
    }
    else if(f == f2)
    {
        call(f2, list);
    }
    va_end(list);
}

int main(int argc, char* argv[])
{
    interceptor((void*)&f1, 7, 7);
    interceptor((void*)&f2, 10.12, 12.10);
    return 0;
}

我个人更喜欢将代表函数的枚举传递给拦截器函数而不是 void* 指针并在内部使用 switch/case。

如果你可以让拦截器成为一个模板函数，它会变得更加容易（完全放弃call模板函数）：

template<typename Result, typename ... Parameters>
void interceptor(Result(*function)(Parameters...), ...)
{
    va_list list;
    va_start(list, function);
    function(extract<Parameters>(list)...);
    va_end(list);
}

int main(int argc, char* argv[])
{
    interceptor(&f1, 7, 7);
    interceptor(&f2, 10.12, 12.10);
    return 0;
}

Answer 4

现在来自你的另一个question，这个呢：

_{（旁注：引用的问题告诉（在 cmets 中） void* 指针来自一些自定义映射，因此据我所知，将它们替换为其他不应该有任何问题适当的指针/类——我将要做的……）}

#include <stdarg.h>

class FunctionWrapper
{
public:
    virtual ~FunctionWrapper() { }
    virtual void operator()(va_list&) = 0;
};

template<typename Result, typename ... Parameters>
class FWrapper : public FunctionWrapper
{
    Result (*mFunction)(Parameters...);
    template <typename T>
    T extract(va_list& list)
    {
        return va_arg(list, T);
    }
public:
    FWrapper(Result (*function)(Parameters...))
            : mFunction(function)
    { }
    virtual void operator()(va_list& list)
    {
        static_cast<void>(mFunction(extract<Parameters>(list)...));
    }
};

// facilitates creating the wrappers:
template<typename Result, typename ... Parameters>
FunctionWrapper* createWrapper(Result (*function)(Parameters...))
{
    return new FWrapper<Result, Parameters ...>(function);
}

void f1(int x, int y)
{
    std::cout << x << ' ' << y << std::endl;
}

void f2(double x, double y)
{
    std::cout << x << ' ' << y << std::endl;
}

// e. g.:
FunctionWrapper* gWrappers[] = { createWrapper(&f1), createWrapper(&f2) };
// from your other question: you'd fill the wrappers into the map you mentioned there:
// map[whatever] = createWrapper(&function);

void interceptor(FunctionWrapper* wrapper, ...)
{
    va_list list;
    va_start(list, wrapper);
    (*wrapper)(list);
    va_end(list);
}

int main(int argc, char* argv[])
{
    interceptor(gWrappers[0], 7, 7);
    interceptor(gWrappers[1], 10.12, 12.10);

    return 0;
}

这通过多态性解决了这个问题：一个函数包装类模板类（我们需要一个非模板基类，以便能够将所有模板实例放入数组或映射中；这是你原来的——但实际上是非法的– void* 提供的指针），将 va_list 解析为参数并调用原始函数...