Question

我已经编写了我的代码的简化版本来说明我的问题。在我的程序中，很多其他的东西都在代码中，这就是为什么我需要在类中有一些函数。我不知道如何定义参数，以便最终调用foo的f2。

如果这是解决问题的唯一方法，我可以在testClass中使用f0，但我不知道如何编写它。

#include <iostream>
using namespace std;

class testClass {
public:
    void f1();
    void f2(int i);

} foo;

void f0(void (*f)(int)) {
    (*f)(1337); // f = a pointer to f2, which is sent from f1
}

void testClass::f2(int i) {
    cout << i;
}

void testClass::f1() {
    f0(&f2);
}

int i;
int main() {
    foo.f1(); // I want foo.f1 to call f0 which should call foo.f2()
    cin >> i;
}

如果我要删除testClass ::和foo。它会起作用。但由于我不能这样做，我应该如何在f0中正确定义参数？我应该如何在f1中正确调用f0？

请帮忙！

Answer 1

为此使用std :: function，或模板化所有内容并使用std::bind。

http://en.cppreference.com/w/cpp/utility/functional/function

无论如何，你需要bind使成员函数适应void(int)签名：

<强> Live On Coliru

#include <iostream>
#include <functional>
using namespace std;

typedef std::function<void(int)> F;

class testClass {
public:
    void f1();
    void f2(int i);

} foo;

void f0(F f) {
    (f)(1337); // f = a pointer to f2, which is sent from f1
}

void testClass::f2(int i) {
    cout << i;
}

void testClass::f1() {
    f0(std::bind(&testClass::f2, this, std::placeholders::_1));
}

int main() {
    foo.f1(); // I want foo.f1 to call f0 which should call foo.f1()
    int i;
    cin >> i;
}

如果您决定要获得更多性能，并且不介意隐含标头实现的功能：

<强> Live On Coliru

template <typename F>
void f0(F f) {
    (f)(1337); // f = a pointer to f2, which is sent from f1
}

Answer 2

非静态成员函数需要调用“this”对象，它们不能像顶级或静态成员一样被调用。因此，您需要f0的额外参数，并调整语法以适应成员函数调用。

void f0(testClass *obj, void (testClass::*f)(int)) {
  (obj->*f)(1337);
}

更改f1也传递this。

void testClass::f1() {
    f0(this, &testClass::f2);
}

Answer 3

首先，在这里，你似乎只是简单地说

returnValue someClass::f1{
f2(1337)
}

其次，如果你仍然需要（出于某种原因）以这种方式实现它，我建议使用模板：

template <Class T>
void f0 (T pointerToTFunction){
pointerToTFunction(1335)l
}

class testClass{

void testClass::f2(int i) {
    cout << i;
}

void testClass::f1() {
    f0<void(*testClass::A)(int)>(&testClass::f2);
}

}

Answer 4

C ++ 11，模板和lambdas。

#include <iostream>
using namespace std;

class testClass {
public:
   void f1();
   void f2(int i);
} foo;

template <class F>
void f0(F&& f)
{
    f(1337);
}

void testClass::f2(int i) {
   cout << i;
}

void testClass::f1() {
   f0([&](int x){f2(x);});
}

int i = 1;
int main() {
   foo.f1();
}

类函数指针作为静态函数中的参数

4 个答案: