具有任何参数列表的函数的通用仿函数

Question

我需要实现一个函子，它在实例化时接受任何（！）函数指针，分析参数类型，存储指针，并在调用operator（）时对指针执行某些操作。最简单的情况是，使用其参数调用函数。

我尝试将函数指针转换为 std::function 之类的内容，但收到错误：

error: invalid use of incomplete type ‘struct std::function<void (*)(...)>’
/usr/include/c++/4.6/functional:1572:11: error: declaration of ‘struct std::function<void(*)(...)>’

我正在使用 gcc 4.6.1，使用 -std=c++0x 进行编译

这是一个最小的示例：

#include <functional>

using namespace std;
typedef void (*F_vararg)(...);
class Foo
{
    public:
        template<typename... ARGS> Foo(function<F_vararg(ARGS... args)> f);
        ~Foo(){}
        template<typename... ARGS>void operator()(ARGS... args);
    private:
        F_vararg m_f;
};

template<typename... ARGS> 
Foo::Foo(function<F_vararg(ARGS... args)> f)
{
    m_f = f;
}

template<typename... ARGS>
void Foo::operator()(ARGS... args)
{
    m_f(args...);
}

void func1(double *a1, double *a2, double *b)
{    //do something 
}

int main(void)
{
    Foo func1_functor((std::function<void (*)(...)>)(func1));

    double a1[3] = {2.,3.,4.};
    double a2[3] = {2.2,3.2,4.2};
    double b[3] = {1.5,2.5,3.5};

    func1_functor(a1,a2,b);

    return 0;
}

这不会编译... 如果我没有将构造函数声明为模板，而是使用“F_vararg f”作为参数，并相应地调整实例化中的转换，它可以工作（应该吗？），但我没有机会（？）获得有关func1 的参数我需要的函子的构造函数。

我错过了什么吗？还有其他方法可以做到这一点吗？

先感谢您 ！！！

干杯，史蒂芬

编辑 哇，太快了！我需要它来推迟函数的执行。函子（或另一个类）应该能够决定是否以及何时运行函数。决定它将使用从参数列表中收集的信息。

我看过 std::bind 但我想不出一种方法来实现我想要的......

Answer 1

丢失 typedef。采用可变参数的函数是特定类型，它与采用类型化参数的函数不兼容，并且不能在以后指定参数类型。

这应该可行：

template<typename... ARGS> Foo(function<void(*)(ARGS... args)> f);

当然，您真正需要的是模板化类，这样您就可以记住函数需要哪些参数。

#include <functional>

template<typename... ARGS>
class Foo
{
    std::function<void(ARGS...)> m_f;
public:
    Foo( std::function<void(ARGS...)> f ) : m_f(f) {}
    void operator()(ARGS... args) const { m_f(args...); }
};

template<typename... ARGS>
Foo<ARGS...> MakeFoo(void(*f)(ARGS...)) { return Foo<ARGS...>(f); }

void func1(double *a1, double *a2, double *b)
{    //do something 
}

int main(void)
{
    auto func1_functor = MakeFoo(func1);

    double a1[3] = {2.,3.,4.};
    double a2[3] = {2.2,3.2,4.2};
    double b[3] = {1.5,2.5,3.5};

    func1_functor(a1,a2,b);

    return 0;
}

演示：http://ideone.com/fnUg2

Answer 2

为了实现类型安全，Foo 还应该对参数的类型进行编码。这个问题没有完全指定用例，所以我不确定是否需要能够传递“无类型”Foos，并且仍然让每个人以某种方式记住（在运行时）其参数的类型是什么。无论如何，这段代码将与问题中给出的示例一起使用。

#include<utility>

template<typename FunctionType>
struct Foo {
        FunctionType f;
        Foo(FunctionType f_) : f(f_) {}

        template<typename... Args>
        void operator() (Args&&... args) {
                f(  std::forward<Args>(args)... );
        }
};

template<typename FunctionType>
Foo<FunctionType> foo(FunctionType f) {
        return Foo<FunctionType>(f);
}

void func1(double *, double *, double *)
{    //do something 
}


int main() {
        auto x = foo(func1);
        double d[3] = {2,3,4};
        func1(d, d, d);
        x(d, d, d);
}