如何在期望有自由函数的地方传递成员函数？

问题如下：考虑这段代码：

#include <iostream>


class aClass
{
public:
    void aTest(int a, int b)
    {
        printf("%d + %d = %d", a, b, a + b);
    }
};

void function1(void (*function)(int, int))
{
    function(1, 1);
}

void test(int a,int b)
{
    printf("%d - %d = %d", a , b , a - b);
}

int main (int argc, const char* argv[])
{
    aClass a();

    function1(&test);
    function1(&aClass::aTest); // <-- How should I point to a's aClass::test function?

    return 0;
}

我如何使用a的aClass::test作为参数function1？我坚持这样做。

我想访问该班的成员。

使用函数指针没有任何问题。但是，指向非静态成员函数的指针与普通函数指针不同：成员函数需要在作为隐式参数传递给函数的对象上调用。因此，您上面的成员函数的签名是

void (aClass::*)(int, int)

而不是您尝试使用的类型

void (*)(int, int)

一种方法可能是制作成员函数，static在这种情况下，不需要调用任何对象，并且可以将其与类型一起使用void (*)(int, int)。

如果您需要访问类的任何非静态成员， 并且需要坚持使用函数指针，例如，由于该函数是C接口的一部分，则最好的选择是始终将a传递给带有void*函数指针的函数并调用您的成员通过转发函数从中获取对象void*，然后调用该成员函数。

在适当的C ++接口中，您可能需要看一下让函数采用模板化参数的函数对象，以使用任意类类型。如果不希望使用模板化接口，则应使用类似以下内容的方法std::function<void(int, int)>：您可以为这些创建合适的可调用函数对象，例如，使用std::bind()。

使用模板参数作为类类型或适当类型的类型安全方法std::function<...>比使用void*接口因为它们消除了由于转换为错误类型而导致的错误可能性。

为了阐明如何使用函数指针来调用成员函数，下面是一个示例：

// the function using the function pointers:
void somefunction(void (*fptr)(void*, int, int), void* context) {
    fptr(context, 17, 42);
}

void non_member(void*, int i0, int i1) {
    std::cout << "I don't need any context! i0=" << i0 << " i1=" << i1 << "\n";
}

struct foo {
    void member(int i0, int i1) {
        std::cout << "member function: this=" << this << " i0=" << i0 << " i1=" << i1 << "\n";
    }
};

void forwarder(void* context, int i0, int i1) {
    static_cast<foo*>(context)->member(i0, i1);
}

int main() {
    somefunction(&non_member, 0);
    foo object;
    somefunction(&forwarder, &object);
}

@Pete Becker的答案很好，但是您也可以在不将class实例作为显式参数传递给function1C ++ 11的情况下执行此操作：

#include <functional>
using namespace std::placeholders;

void function1(std::function<void(int, int)> fun)
{
    fun(1, 1);
}

int main (int argc, const char * argv[])
{
   ...

   aClass a;
   auto fp = std::bind(&aClass::test, a, _1, _2);
   function1(fp);

   return 0;
}

指向成员函数的指针不同于指向函数的指针。为了通过指针使用成员函数，您需要一个指向它的指针（显然是）和一个对象来应用它。所以合适的版本function1是

void function1(void (aClass::*function)(int, int), aClass& a) {
    (a.*function)(1, 1);
}

并称之为：

aClass a; // note: no parentheses; with parentheses it's a function declaration
function1(&aClass::test, a);

从2011年开始，如果您可以更改function1，请按照以下步骤进行操作：

#include <functional>
#include <cstdio>

using namespace std;

class aClass
{
public:
    void aTest(int a, int b)
    {
        printf("%d + %d = %d", a, b, a + b);
    }
};

template <typename Callable>
void function1(Callable f)
{
    f(1, 1);
}

void test(int a,int b)
{
    printf("%d - %d = %d", a , b , a - b);
}

int main()
{
    aClass obj;

    // Free function
    function1(&test);

    // Bound member function
    using namespace std::placeholders;
    function1(std::bind(&aClass::aTest, obj, _1, _2));

    // Lambda
    function1([&](int a, int b) {
        obj.aTest(a, b);
    });
}

（现场演示）

还要注意，我修复了损坏的对象定义（aClass a();声明了一个函数）。

我问了一个类似的问题（C ++ openframeworks从其他类传递void），但是我发现的答案更清楚了，因此在这里为以后的记录做解释：

使用std :: function更容易，如：

 void draw(int grid, std::function<void()> element)

然后调用为：

 grid.draw(12, std::bind(&BarrettaClass::draw, a, std::placeholders::_1));

甚至更简单：

  grid.draw(12, [&]{a.draw()});

在其中创建一个lambda，该lambda调用通过引用捕获对象的对象

我将成员函数设为静态，并且可以正常工作：

#include <iostream>

class aClass
{
public:
    static void aTest(int a, int b)
    {
        printf("%d + %d = %d\n", a, b, a + b);
    }
};

void function1(int a,int b,void function(int, int))
{
    function(a, b);
}

void test(int a,int b)
{
    printf("%d - %d = %d\n", a , b , a - b);
}

int main (int argc, const char* argv[])
{
    aClass a;

    function1(10,12,test);
    function1(10,12,a.aTest); // <-- How should I point to a's aClass::test function?

    getchar();return 0;
}

不知道为什么要通过这种极其简单的解决方案：

#include <stdio.h>

class aClass
{
public:
    void aTest(int a, int b)
    {
        printf("%d + %d = %d\n", a, b, a + b);
    }
};

template<class C>
void function1(void (C::*function)(int, int), C& c)
{
    (c.*function)(1, 1);
}
void function1(void (*function)(int, int)) {
  function(1, 1);
}

void test(int a,int b)
{
    printf("%d - %d = %d\n", a , b , a - b);
}

int main (int argc, const char* argv[])
{
    aClass a;

    function1(&test);
    function1<aClass>(&aClass::aTest, a);
    return 0;
}

输出：

1 - 1 = 0
1 + 1 = 2

如果您实际上不需要使用该实例a （即您可以像@mathengineer的answer那样使其静态化），则只需传递一个非捕获的lambda即可。（衰减到函数指针）

#include <iostream>

class aClass
{
public:
   void aTest(int a, int b)
   {
      printf("%d + %d = %d", a, b, a + b);
   }
};

void function1(void (*function)(int, int))
{
    function(1, 1);
}

int main()
{
   //note: you don't need the `+`
   function1(+[](int a,int b){return aClass{}.aTest(a,b);}); 
}

魔盒

注意：如果aClass构建成本高或有副作用，这可能不是一个好方法。

您现在可以停止敲打头了。这是成员函数的包装程序，以纯C函数作为参数来支持现有函数。指令是这里的关键。thread_local

http://cpp.sh/9jhk3

// Example program
#include <iostream>
#include <string>

using namespace std;

typedef int FooCooker_ (int);

// Existing function
extern "C" void cook_10_foo (FooCooker_ FooCooker) {
    cout << "Cooking 10 Foo ..." << endl;
    cout << "FooCooker:" << endl;
    FooCooker (10);
}

struct Bar_ {
    Bar_ (int Foo = 0) : Foo (Foo) {};
    int cook (int Foo) {
        cout << "This Bar got " << this->Foo << endl;
        if (this->Foo >= Foo) {
            this->Foo -= Foo;
            cout << Foo << " cooked" << endl;
            return Foo;
        } else {
            cout << "Can't cook " <<  Foo << endl;
            return 0;
        }
    }
    int Foo = 0;
};

// Each Bar_ object and a member function need to define
// their own wrapper with a global thread_local object ptr
// to be called as a plain C function.
thread_local static Bar_* BarPtr = NULL;
static int cook_in_Bar (int Foo) {
    return BarPtr->cook (Foo);
}

thread_local static Bar_* Bar2Ptr = NULL;
static int cook_in_Bar2 (int Foo) {
    return Bar2Ptr->cook (Foo);
}

int main () {
  BarPtr = new Bar_ (20);
  cook_10_foo (cook_in_Bar);

  Bar2Ptr = new Bar_ (40);
  cook_10_foo (cook_in_Bar2);

  delete BarPtr;
  delete Bar2Ptr;
  return 0;
}

请对此方法的任何问题发表评论。

其他答案无法调用现有的普通C函数：http : //cpp.sh/8exun