当指针具有可选参数时如何传递函数指针？

Question

我试图将函数指针作为另一个函数的参数传递，但函数指针本身可能有也可能没有参数（使其与我搜索的其他问题不同）。

代码按原样工作，但我的问题是我试图使用单个函数并传递每个不同的函数指针，但我下面有 3 个不同的函数来传递每个函数指针。我想摆脱 3 个不同的函数定义，因为除了传入的函数指针（基本上，3 个 execute_func() 定义的副本）之外，它们都是相同的。这是我到目前为止所拥有的，但这似乎不对我应该需要三个 execute_func() 调用。

class A { ... };
class B { ... };

class Test {
    private:
        std::function<void()> fp;
        std::function<void(MyA &)> fp;
        std::function<void(MyB &)> fp;
    // ...
};

// Here I create a function pointer for each of my calls.
Test::Test() {
    fp = std::bind(&Test::do_this, this);
    fp_a = std::bind(&Test::do_a, this, std::placeholders::_1);
    fp_b = std::bind(&Test::do_b, this, std::placeholders::_1);
}

// Here my intention was to have only 1 execute_func() call and I would 
// pass in the pointer to the function that I want to call.
Test::test_it()
{
    A a;
    B b;

    execute_func(fp);
    execute_func(fp_a, a);
    execute_func(fp_b, b);
}

// I was hoping to only need one function, but so far
// have needed 3 functions with diff signatures to make it work.
bool Test::execute_func(std::function<void()> fp) {
    // ... more code here before the fp call
    fp();
    // ... them more common code here.
}

bool Test::execute_func(std::function<void(MyA &)> fp, MyA &a) { 
    // ... more common code here 
    fp(a);
    // ... and more common code here
}

bool Test::execute_func(std::function<void(MyB &)> fp, MyB &b) {  
    // ... more common code here 
    fp(b);
    // ... and more common code here.
}

// And of course the execute_func() calls call these members as passed in.
bool Test::do_this() { ... }
bool Test::do_a(MyA &a) { ... }
bool Test::do_b(MyB &b) { ... }

想到我哪里出错了？

Answer 1

为此，您可以使用variadic template。

template<typename Ret, typename... Args>
bool Test::execute_func(Ret fp(Args&&...), Args&&... args)
{
    // do stuff
    fp(args...);
    // do more stuff
}

我在这里使用的是普通函数指针而不是 std::function，这是 IMO 的巴洛克风格，完全没有必要（这是 C++ 没有 lambda 时的遗物）。但这是相同的想法。

template<typename Ret, typename... Args>
bool Test::execute_func(const std::function<Ret(Args&&...)> &fp, Args&&... args) { }

编辑： Jarod42 points out，您可以使其适用于函数指针 std::function 和任何其他可调用对象，如下所示：

template<typename Func, typename... Args>
bool Test::execute_func(Func &&fp, Args&&... args)
{
    // do stuff
    fp(args...);
    // do more stuff
}

为了使其更加通用，您可以使用std::invoke 调用fp 而不是直接调用它，这还允许fp 成为成员函数或数据成员（实例指针在第一个后续论据）。

template<typename Func, typename... Args>
bool Test::execute_func(Func &&fp, Args&&... args)
{
    // do stuff
    std::invoke(fp, args...);
    // do more stuff
}

前面的例子也可以等价写

template<typename... InvokeArgs>
bool Test::execute_func(InvokeArgs&&... iargs)
{
    // do stuff
    std::invoke(iargs...);
    // do more stuff
}