能否用std::bind将成员函数指针转换为普通函数指针用作回调？

Great question—this is a super common pain point when working with C++ callbacks that expect plain function pointers, especially since member functions carry that hidden this pointer under the hood. Let's break this down clearly:

First: Why std::bind won't work for this #

The short answer is: you can't directly convert the result of std::bind to a plain function pointer. Here's why:
std::bind returns a stateful callable object (it stores your this pointer and any bound arguments). A plain function pointer is stateless—it's just an address to code, with no built-in way to hold extra data like an instance pointer. These are fundamentally different types, so there's no valid conversion between them.

So what's the reliable solution? #

The most safe and widely used approach is to use a static member function as an adapter (assuming your callback API lets you pass a user-defined "context" pointer—most well-designed callback APIs include this parameter). Here's how it works:

Step 1: Create a static adapter function #

This static function acts as a middleman: it accepts the callback arguments plus a void* to hold your class instance, then casts that pointer back to your class type and calls the actual member function.

#include <iostream>

// Assume this is the external callback API we need to integrate with
void RegisterRequestCallBack(void (*callback)(int, void*), void* userData);

class MyClass {
public:
    void HandleRequest(int requestId) {
        std::cout << "Handling request " << requestId << " in instance " << this << std::endl;
    }

    // Static adapter—matches the plain function pointer signature expected by the API
    static void CallbackAdapter(int requestId, void* userData) {
        // Cast the void* back to our class instance
        MyClass* instance = static_cast<MyClass*>(userData);
        // Delegate to the actual member function
        instance->HandleRequest(requestId);
    }
};

Step 2: Register the adapter with your instance #

When registering the callback, pass the static adapter function and a pointer to your class instance as the user data:

int main() {
    MyClass myInstance;
    // Register the adapter, passing our instance as context data
    RegisterRequestCallBack(&MyClass::CallbackAdapter, &myInstance);
    return 0;
}

What if the callback API doesn't support user data? #

If the API doesn't let you pass a context pointer (a poor design, but sometimes unavoidable), you could use a global or static variable to hold your class instance pointer. Warning: This is not thread-safe and will break if you have multiple instances of your class.

Example:

MyClass* g_MyInstance = nullptr;

void GlobalCallback(int requestId) {
    if (g_MyInstance) {
        g_MyInstance->HandleRequest(requestId);
    }
}

// Usage:
MyClass myInstance;
g_MyInstance = &myInstance;
RegisterRequestCallBack(&GlobalCallback);

Bonus: Lambda alternatives #

If you don't need to access class members (no this required), a captureless lambda can be implicitly converted to a plain function pointer:

// Captureless lambda works here
auto callbackLambda = [](int requestId) {
    std::cout << "Handling request " << requestId << " from lambda" << std::endl;
};
RegisterRequestCallBack(callbackLambda);

But if you capture this (or any variables), the lambda becomes stateful—just like std::bind—and it can't be converted to a plain function pointer.

Final Takeaway #

std::bind can't directly give you a plain function pointer, but a static adapter function (paired with a user data pointer) is the standard, safe way to bridge member functions and plain function pointer callbacks. It keeps your code thread-safe and works with multiple instances of your class.

内容的提问来源于stack exchange，提问作者code_fodder