C++ 如何将类中的函数作为参数传递给C+中同一类中的另一个函数+；11?

下面的极简主义代码用于说明我的问题。这些代码不能编译。如何使用lambda表达式或

std:：bind

将函数成员作为参数传递？非常感谢你的帮助

#include <iostream>

using namespace std;
class ABC{
private:
    int x =3;
    int add2num(int a, int b){
        return a+b+x;
    }

    int worker(int &fun(int a, int b), int a, int b){
        return fun(a,b);
    }
public:
    int doSomething(int a, int b){
        return worker(add2num, a, b);
    }
};

int main() {
    ABC test;
    cout << test.doSomething(3,5) << endl;
    return 0;
}

#包括
使用名称空间std；
ABC班{
私人：
int x=3；
int add2num（int a，int b）{
返回a+b+x；
}
内特工作者（内特和乐趣（内特a，内特b），内特a，内特b）{
返回乐趣（a、b）；
}
公众：
内部剂量测量（内部a、内部b）{
返回工人（添加2名，a、b）；
}
};
int main（）{
ABC试验；
cout一种可能的方法，使用std:：bind和std:：function（C++11）：

#包括
#包括
使用名称空间std:：占位符；
ABC班
{
私人：
int x=3；
int add2num（int a，int b）
{
返回a+b+x；
}
int-worker（标准：：函数fun，int-a，int-b）
{
返回乐趣（a、b）；
}
公众：
内部剂量测量（内部a、内部b）
{
返回工作者（std：：bind（&ABC：：add2num，this，_1，_2），a，b）；
}
};
int main（）
{
ABC试验；
std:：cout您可以在没有lambda或
std:：bind的情况下实现您的目标，如下所示：

#include <iostream>

using namespace std;
class ABC{
private:
    int x =3;
    int add2num(int a, int b){
        return a+b+x;
    }

    int worker(int (ABC::*fun)(int a, int b), int a, int b){
        return (this->*fun)(a,b);
    }
public:
    int doSomething(int a, int b){
        return worker(&ABC::add2num, a, b);
    }
};

int main() {
    ABC test;
    cout << test.doSomething(3,5) << endl;
    return 0;
}

#包括
使用名称空间std；
ABC班{
私人：
int x=3；
int add2num（int a，int b）{
返回a+b+x；
}
内部工作者（内部（ABC:*乐趣）（内部a，内部b），内部a，内部b）{
返回（本->*乐趣）（a、b）；
}
公众：
内部剂量测量（内部a、内部b）{
返回工人（&ABC:：add2num，a，b）；
}
};
int main（）{
ABC试验；
cout调整代码片段以使用lambda函数

#include <iostream>
#include <functional>

using namespace std;
class ABC{
private:
    int x =3;
    int add2num(int a, int b){
        return a+b+x;
    }

   int worker(std::function<int(int, int)> fun, int a, int b){
       return fun(a,b);
   }
public:
   int doSomething(int a, int b){
     auto func = [&](int a, int b) -> int { return add2num(a,b); };
     return worker(func, a, b);
   }
};

int main() {
    ABC test;
    cout << test.doSomething(3,5) << endl;
    return 0;
}

#包括
#包括
使用名称空间std；
ABC班{
私人：
int x=3；
int add2num（int a，int b）{
返回a+b+x；
}
int-worker（标准：：函数fun，int-a，int-b）{
返回乐趣（a、b）；
}
公众：
内部剂量测量（内部a、内部b）{
自动函数=[&]（inta，intb）->int{return add2num（a，b）；}；
返回工人（func、a、b）；
}
};
int main（）{
ABC试验；
cout使用lambda和模板：

#include <iostream>
#include <functional>

using namespace std;
class ABC{
private:
    int x =3;
    int add2num(int a, int b){
        return a+b+x;
    }

   template<class functor_t>
   int worker(const functor_t& fun, int a, int b){
       return fun(a,b);
   }

public:
   int doSomething(int a, int b) {
     return worker([this](int a, int b){ return add2num(a, b); }, a, b);
   }

};

int main() {
    ABC test;
    cout << test.doSomething(3,5) << endl;
    return 0;
}

代码的其余部分不需要触摸，因为
worker
仍然是一个模板，因此可以接受任何可调用的类型。
这将是对paweldac答案的评论，但我没有足够的声誉

更好的lambda将使用捕获列表中的“this”进行初始化（请参阅）：

另外，每次调用lambda时，都会初始化代码。<不需要这个，你可以考虑一种方法来初始化<代码> FUNC一次。
如果你声明“代码> ADD2NUM／代码>为静态，这将起作用。
#include <iostream>
#include <functional>

using namespace std;
class ABC{
private:
    int x =3;
    int add2num(int a, int b){
        return a+b+x;
    }

   template<class functor_t>
   int worker(const functor_t& fun, int a, int b){
       return fun(a,b);
   }

public:
   int doSomething(int a, int b) {
     return worker([this](int a, int b){ return add2num(a, b); }, a, b);
   }

};

int main() {
    ABC test;
    cout << test.doSomething(3,5) << endl;
    return 0;
}

   int doSomething(int a, int b) {
     namespace ph = std::placeholders;

     return worker(std::bind(&ABC::add2num, this, ph::_1, ph::_2), a, b);
   }

int doSomething(int a, int b)
{
    auto func = [this](int a, int b) -> int { return add2num(a,b); };
    return worker(func, a, b);
}