Làm cách nào tôi có thể chuyển một hàm thành viên trong đó một hàm miễn phí được mong đợi?

Câu hỏi là như sau: hãy xem xét đoạn mã này:

#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;
}

Làm cách nào để sử dụng a's aClass::testlàm đối số function1? Tôi bị mắc kẹt trong việc này.

Tôi muốn truy cập một thành viên của lớp học.

Không có gì sai khi sử dụng con trỏ hàm. Tuy nhiên, con trỏ đến các hàm thành viên không tĩnh không giống như các con trỏ hàm thông thường: các hàm thành viên cần được gọi trên một đối tượng được truyền như một đối số ngầm định cho hàm. Chữ ký của chức năng thành viên của bạn ở trên, do đó

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

thay vì loại bạn cố gắng sử dụng

void (*)(int, int)

Một cách tiếp cận có thể bao gồm việc tạo hàm thành viên statictrong trường hợp đó nó không yêu cầu bất kỳ đối tượng nào được gọi và bạn có thể sử dụng nó với kiểu void (*)(int, int).

Nếu bạn cần truy cập bất kỳ thành viên không tĩnh nào trong lớp của mình và bạn cần gắn với con trỏ hàm, ví dụ: vì hàm là một phần của giao diện C, tùy chọn tốt nhất của bạn là luôn chuyển một void*hàm cho hàm của bạn, lấy con trỏ hàm và gọi thành viên của bạn thông qua một hàm chuyển tiếp lấy một đối tượng từ void*và sau đó gọi hàm thành viên.

Trong một giao diện C ++ thích hợp, bạn có thể muốn xem hàm của bạn có đối số mẫu cho các đối tượng hàm để sử dụng các kiểu lớp tùy ý. Nếu việc sử dụng một giao diện mẫu là không mong muốn, bạn nên sử dụng một cái gì đó như std::function<void(int, int)>: bạn có thể tạo một đối tượng chức năng có thể gọi phù hợp cho chúng, ví dụ: sử dụng std::bind().

Các phương pháp tiếp cận kiểu an toàn bằng cách sử dụng đối số mẫu cho kiểu lớp hoặc kiểu phù hợp std::function<...>sẽ thích hợp hơn là sử dụng void*giao diện vì chúng loại bỏ khả năng xảy ra lỗi do truyền sang kiểu sai.

Để làm rõ cách sử dụng con trỏ hàm để gọi một hàm thành viên, đây là một ví dụ:

// 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);
}

Câu trả lời của @Pete Becker là tốt nhưng bạn cũng có thể làm điều đó mà không cần chuyển đối tượng classdưới dạng tham số rõ ràng đến function1trong C ++ 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;
}

Một con trỏ tới hàm thành viên khác với một con trỏ tới hàm. Để sử dụng một hàm thành viên thông qua một con trỏ, bạn cần một con trỏ tới nó (hiển nhiên) và một đối tượng để áp dụng nó. Vì vậy, phiên bản thích hợp của function1sẽ là

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

và gọi nó là:

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

Kể từ năm 2011, nếu bạn có thể thay đổi function1, hãy làm như vậy, như sau:

#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);
    });
}

( bản demo trực tiếp )

Cũng lưu ý rằng tôi đã sửa định nghĩa đối tượng bị hỏng của bạn ( aClass a();khai báo một hàm).

Tôi đã hỏi một câu hỏi tương tự ( C ++ openframeworks chuyển void từ các lớp khác ) nhưng câu trả lời tôi tìm thấy rõ ràng hơn, vì vậy đây là lời giải thích cho các bản ghi trong tương lai:

nó dễ dàng hơn để sử dụng hàm std :: như trong:

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

và sau đó gọi là:

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

hoặc thậm chí dễ dàng hơn:

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

nơi bạn tạo một lambda gọi đối tượng chụp nó bằng tham chiếu

Tôi đã đặt hàm thành viên là tĩnh và tất cả đều hoạt động:

#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;
}

Không chắc tại sao giải pháp cực kỳ đơn giản này đã được thông qua:

#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;
}

Đầu ra:

1 - 1 = 0
1 + 1 = 2

Nếu bạn thực sự không cần sử dụng cá thể a (nghĩa là bạn có thể làm cho nó tĩnh như câu trả lời của @mathengineer ), bạn có thể chỉ cần chuyển vào lambda không chụp. (phân rã thành con trỏ hàm)

#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);}); 
}

Wandbox

lưu ý: nếu aClasstốn kém chi phí xây dựng hoặc có tác dụng phụ, đây có thể không phải là cách tốt.

Bạn có thể ngừng đập đầu ngay bây giờ. Đây là trình bao bọc cho hàm thành viên để hỗ trợ các hàm hiện có lấy các hàm C thuần túy làm đối số. thread_localchỉ thị là chìa khóa ở đây.

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;
}

Vui lòng bình luận về bất kỳ vấn đề nào với cách tiếp cận này.

Các câu trả lời khác không gọi được cácC hàm đơn giản hiện có : http://cpp.sh/8exun