如何使用lambdas使用std ::函数与成员函数？

Question

我正在尝试在课堂内移动一些全局功能。当前的代码看起来像这样：

struct S{};

void f(S* s, int x, double d){}
void g(S* s, int x, double d){}
/*
...
...*/
void z(S* s, int x, double d){}

int main()
{
    function<void(S*, int, double)> fp;
    
    //switch(something)
    //case 1:
        fp = f;
    //case 2:
        fp = g;
    //case n:
        fp = z;
}

假设我想将上述代码更新为类似的代码（此代码bellow不编译）：

#include <iostream>
#include <functional>

using namespace std;

struct S
{
    void f(int x, double d){}
    void g(int x, double d){}
    /*
    ...
    ...*/
    void z(int x, double d){}    

    void method_that_has_some_logic_to_use_the_others_above(int x, double d)
    {
        function<void(int, double)> fp; // How do I have to declare here?
        //switch(something)
        //case 1:
        fp = f; // How can achieve something like this using lambdas here?
    //case 2:
        fp = g;
    //case n:
        fp = z;

        fp(x, d);
    }

};


int main()
{
    S s;
    s.method_that_has_some_logic_to_use_the_others_above(10, 5.0);
}

我使用std :: bind看到了一些解决方案，但在某个地方读取以避免使用它并更喜欢lambdas。我正在使用C ++ 17，但是我在Lambdas方面几乎没有经验，无法通过在其他答案中找到的示例来弄清楚如何解决它。

Answer 1

成员函数需要一个特定的类对象来调用，因此您需要做

function<void(S*, int, double)> fp = &S::f; 
fp(this, x, d);

或使用lambda捕获特定的类对象并在内部调用其成员函数

function<void(int, double)> fp = [this](int x, double d) { this->f(x, d); };
fp(x, d);

demo

Answer 2

注意：我正在提出另一种方法 。

---

只要您只是在成员函数之间选择具有相同签名以调用的给出 。开销可能并不重要，如果您需要扩展简单的会员功能调用，则确实具有更大的灵活性。另一方面，指针到会员功能提供了类似的功能，而无需开销。

缺点（对我来说）是语法。在这种情况下，类型为void（s ::*）（int，double），如果您不习惯指向成员，则很难阅读。最重要的是，被声明的变量在类型的中间进行，这再次损害了可读性。不过，如果您可以接受语法：

// Placeholder for the decision-making process:
char choose_fun() { return 'g'; }

// Same setup for `S` as in the question, except with the following added:
void S::other_method(int x, double d)
{
    void (S::* fp)(int, double);  // Manual type specification
    // decltype(&S::other_method) fp;  // Possibly easier to read

    switch (choose_fun()) {
        case 'f': fp = &S::f; break;
        case 'g': fp = &S::g; break;
        // ...
    }

    // More processing?

    // The syntax for invoking a pointer-to-member is also a bit weird.
    (this->*fp)(x, d);
}

---

实际上，如果设置的确与问题所示的简单（简单的switch来决定要拨打什么），我可能不会打扰任何一个指针或std :: function在此设置中。我将存储switch使用的值，然后通过助手函数调用功能。 （如果没有其他处理，则ether_method简化了助手功能。）

// The helper function.
void S::choose_method(char choice, int x, double d)
{
    switch (choice) {
        // Returning void is legal and takes the place of having a `break`.
        case 'f': return f(x, d);
        case 'g': return g(x, d);
        // ...
    }
}

// Now the other method needs very little code in addition to the additional
// processing, whatever that is. This also brings the code closer to the
// ideal of one task per function.
void S::other_method(int x, double d)
{
    char choice = choose_fun();

    // More processing
        
    choose_method(choice, x, d);
}