如何在C++中使用指针调用任意类的任意方法？

你想要的对象指针+方法指针统一调用任意类方法的方案是完全可行的，核心在于解决不同类成员函数指针的类型差异问题——因为C++中每个类的成员函数指针都是独特类型，无法直接存入同一容器，因此需要通过类型擦除来封装成统一的可调用接口。

核心思路：用类型擦除统一调用接口 #

我们可以用std::function作为统一的包装器，把“对象指针+成员函数”的组合转换成无类型差异的可调用对象，这样就能存入同一个容器，实现跨类的方法管理。

基础实现示例 #

以下是不依赖动态库的基础演示，先理解封装逻辑：

#include <functional>
#include <vector>
#include <iostream>

// 统一的方法包装类型：接收void*类型的对象指针，无返回值（可根据需求修改签名）
using GenericMethod = std::function<void(void*)>;
std::vector<GenericMethod> global_methods;

// 测试类1
class DemoClass {
public:
    void print_msg() { std::cout << "DemoClass: Hello from member method\n"; }
};

// 测试类2
class AnotherClass {
public:
    void show_value() { std::cout << "AnotherClass: Value is 42\n"; }
};

// 模板工具函数：将成员函数包装成GenericMethod
template <typename T, void (T::*MemberFunc)()>
void wrap_member_func(void* obj_ptr) {
    // 把void*转换回对应类的指针，调用成员函数
    static_cast<T*>(obj_ptr)->*MemberFunc();
}

int main() {
    // 创建类实例
    DemoClass* demo = new DemoClass();
    AnotherClass* another = new AnotherClass();

    // 将不同类的成员函数封装后加入统一容器
    global_methods.emplace_back(wrap_member_func<DemoClass, &DemoClass::print_msg>);
    global_methods.emplace_back(wrap_member_func<AnotherClass, &AnotherClass::show_value>);

    // 遍历调用所有方法（注意传入对应类的对象指针）
    for (auto& method : global_methods) {
        method(demo);   // 调用DemoClass的方法
        method(another);// 调用AnotherClass的方法
    }

    // 清理资源
    delete demo;
    delete another;
    return 0;
}

绑定对象的简化版本 #

如果希望直接绑定对象，不用每次调用都传指针，可以把对象和方法一起封装成无参数的可调用对象：

using BoundMethod = std::function<void()>;
std::vector<BoundMethod> bound_methods;

// 绑定对象和成员函数
bound_methods.emplace_back(std::bind(&DemoClass::print_msg, demo));
bound_methods.emplace_back(std::bind(&AnotherClass::show_value, another));

// 直接调用，无需传指针
for (auto& method : bound_methods) {
    method();
}

适配动态库（dlopen）场景 #

在动态加载类的场景中，需要注意C++名字修饰问题，通常用extern "C"导出类的创建/销毁函数，以及方法的包装函数：

动态库代码（demo_lib.cpp）

#include <iostream>

extern "C" {
    class DemoClass {
    public:
        void test() { std::cout << "DemoClass::test() from dynamic library\n"; }
    };

    // 导出创建对象的C风格函数
    DemoClass* create_demo() {
        return new DemoClass();
    }

    // 导出销毁对象的函数
    void destroy_demo(DemoClass* obj) {
        delete obj;
    }

    // 导出包装后的方法调用函数
    void call_demo_test(void* obj) {
        static_cast<DemoClass*>(obj)->test();
    }
}

主程序加载动态库并调用

#include <dlfcn.h>
#include <functional>
#include <vector>
#include <iostream>

using GenericMethod = std::function<void(void*)>;
std::vector<GenericMethod> methods;

int main() {
    // 加载动态库
    void* lib_handle = dlopen("./libdemo.so", RTLD_LAZY);
    if (!lib_handle) {
        std::cerr << "Load library failed: " << dlerror() << '\n';
        return 1;
    }

    // 获取创建对象的函数
    using CreateDemoFn = DemoClass*(*)();
    CreateDemoFn create_demo = reinterpret_cast<CreateDemoFn>(dlsym(lib_handle, "create_demo"));
    if (!create_demo) {
        std::cerr << "Get symbol failed: " << dlerror() << '\n';
        dlclose(lib_handle);
        return 1;
    }

    // 获取包装后的方法调用函数
    using CallDemoTestFn = void(*)(void*);
    CallDemoTestFn call_test = reinterpret_cast<CallDemoTestFn>(dlsym(lib_handle, "call_demo_test"));
    methods.emplace_back(call_test);

    // 创建对象并调用方法
    DemoClass* demo = create_demo();
    methods[0](demo);

    // 清理资源
    using DestroyDemoFn = void(*)(DemoClass*);
    DestroyDemoFn destroy_demo = reinterpret_cast<DestroyDemoFn>(dlsym(lib_handle, "destroy_demo"));
    destroy_demo(demo);

    dlclose(lib_handle);
    return 0;
}

关键注意事项 #

1. 类型安全问题：因为使用了void*转换，必须确保传入的对象指针类型与方法对应的类一致，否则会触发未定义行为（UB）。如果需要更强的类型安全，可以用std::any存储对象指针，但调用时仍需明确类型。
2. 继承场景处理：如果是继承体系，若调用的是虚函数，直接用基类指针即可；若非虚函数，仍需转换为实际派生类的指针才能调用。
3. 动态库导出规范：必须用extern "C"导出函数，避免C++名字修饰导致dlsym无法找到符号。

这种方案完全可以替代原有的模板方案，无需为每个类单独维护容器，大幅简化跨类、动态加载场景下的方法管理逻辑。

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