如何将成员函数赋值给基类函数指针？C++接口适配疑问

某库暴露了带函数指针的结构体用于底层接口实现：

struct Interface {
    int (*InterfaceFn) (int value);
};

库要求调用int InterfaceInit(struct Interface * iface)完成初始化，其中InterfaceFn是底层通信的核心函数，不能为nullptr。

我尝试通过继承Interface的类来实现适配，将成员函数赋值给该函数指针：

class Adapter : public Interface
{
public:
    Adapter();

    int adapter_function(int value)
    {
        std::cout << "\tadapter_function " << value << std::endl;
        return 0;
    }
};

Adapter::Adapter()
{
    std::cout << "Adapter constructor" << std::endl;
    this->InterfaceFn = &Adapter::adapter_function;    // 编译错误
}

查阅资料后得知，非静态成员函数无法直接赋值给普通函数指针。

我的问题是：有没有办法创建继承自Interface的类，让Adapter对象可以传入InterfaceInit函数，同时让结构体中的函数指针指向Adapter的非静态成员函数？或者这类问题需要用到适配器模式之外的其他设计模式？

1. 静态成员函数 + 实例关联（最简单的兼容方案） #

普通函数指针无法直接绑定对象实例，我们可以用静态成员函数做中转，同时维护一个关联的Adapter实例供它调用：

class Adapter : public Interface
{
public:
    Adapter() {
        // 将静态中转函数赋值给接口指针
        InterfaceFn = &Adapter::static_adapter_fn;
    }

    int adapter_function(int value) {
        std::cout << "\tadapter_function " << value << std::endl;
        return 0;
    }

private:
    // 线程局部存储，支持多线程下的多实例
    static thread_local Adapter* instance;

    static int static_adapter_fn(int value) {
        // 调用当前线程绑定实例的非静态成员函数
        return instance->adapter_function(value);
    }

public:
    // 绑定当前实例到线程局部存储
    void bind_instance() {
        instance = this;
    }
};

// 静态成员初始化
thread_local Adapter* Adapter::instance = nullptr;

// 使用示例
int main() {
    Adapter adapter;
    adapter.bind_instance();
    InterfaceInit(&adapter);
    return 0;
}

这种方式支持多线程下的多实例，可移植性强，是最常用的解决方案。

2. Thunk技术（支持多实例，但可移植性差） #

如果需要无限制的多实例且不依赖线程存储，可以用**Thunk（代码桩）**技术：在运行时生成一段小代码，将普通函数指针调用转换为对象成员函数的调用。但这种方式依赖平台和编译器，维护成本高。

示例（Windows平台简化版）：

#include <windows.h>

class Adapter : public Interface
{
public:
    Adapter() {
        // 申请可执行内存构造thunk
        uint8_t* thunk = reinterpret_cast<uint8_t*>(VirtualAlloc(nullptr, 16, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE));
        // 汇编指令：把this指针放入ecx（__thiscall调用约定），然后跳转到成员函数
        thunk[0] = 0xB9;
        *reinterpret_cast<Adapter**>(thunk + 1) = this;
        thunk[5] = 0xE9;
        *reinterpret_cast<int*>(thunk + 6) = reinterpret_cast<uint8_t*>(&Adapter::adapter_function) - (thunk + 10);
        
        InterfaceFn = reinterpret_cast<int(*)(int)>(thunk);
    }

    int adapter_function(int value) {
        std::cout << "\tadapter_function " << value << std::endl;
        return 0;
    }
};

这种方式适合对实例数量无上限要求的场景，但跨平台性差，不推荐通用项目使用。

3. 组合模式替代继承 #

如果允许不继承Interface，可以用组合代替继承，让Adapter持有Interface对象，避免继承耦合：

class Adapter
{
public:
    Adapter() {
        iface.InterfaceFn = &static_adapter_fn;
        thread_local_instance = this;
    }

    int adapter_function(int value) {
        std::cout << "\tadapter_function " << value << std::endl;
        return 0;
    }

    // 对外暴露Interface结构体指针供库调用
    Interface* get_interface() {
        return &iface;
    }

private:
    Interface iface;
    static thread_local Adapter* thread_local_instance;

    static int static_adapter_fn(int value) {
        return thread_local_instance->adapter_function(value);
    }
};

thread_local Adapter* Adapter::thread_local_instance = nullptr;

// 使用示例
int main() {
    Adapter adapter;
    InterfaceInit(adapter.get_interface());
    return 0;
}

这种方式符合“组合优于继承”的设计原则，降低了类之间的耦合度。

设计模式说明 #

你当前的思路本质上就是适配器模式，只是受限于C++函数指针的特性需要调整实现细节。如果追求通用性和可维护性，推荐用「静态中转函数+线程局部存储」的继承方案，或者组合模式的实现，这两种都属于适配器模式的变种，不需要额外引入其他设计模式。

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