如何在父类中按名称调用子类方法？实现invoke函数方案咨询

C++本身没有原生的反射机制，所以要实现根据方法名动态调用子类成员函数，我们需要手动构建一个方法注册与分发的机制。下面是具体的实现思路和完整代码：

核心思路 #

• 给Base类添加一个静态方法注册表，用来存储方法名称到对应调用逻辑的映射
• 每个子类将自己的成员方法注册到这个注册表中（用CRTP模式简化注册流程）
• 在invoke方法中，根据传入的方法名查找注册表：找到则调用对应方法，找不到则抛出NoSuchMethod异常

完整代码实现 #

#include <unordered_map>
#include <functional>
#include <string>
#include <cstdio>
#include <stdexcept>

class Args {}; // 可根据需求扩展参数存储逻辑，比如添加键值对或variant
class NoSuchMethod : public std::exception {};

class Base {
private:
    // 静态注册表：方法名 -> 接收Base*和Args，返回Args的函数
    static std::unordered_map<std::string, std::function<Args(Base*, Args)>> method_registry;

protected:
    // 子类用来注册方法的静态工具函数
    template<typename Derived, typename Func>
    static void register_method(const std::string& name, Func func) {
        method_registry[name] = [func](Base* self, Args args) {
            // 安全转换Base指针为子类指针，调用目标方法
            return (static_cast<Derived*>(self)->*func)(args);
        };
    }

public:
    Args invoke(std::string name, Args a) {
        auto it = method_registry.find(name);
        if (it != method_registry.end()) {
            return it->second(this, a);
        }
        // 找不到对应方法时抛出异常
        throw NoSuchMethod();
    }

    virtual ~Base() = default; // 基类必须声明虚析构，避免内存泄漏
};

// 初始化静态注册表
std::unordered_map<std::string, std::function<Args(Base*, Args)>> Base::method_registry;

// CRTP模板：帮助子类自动完成类型绑定，简化注册代码
template<typename Derived>
class BaseCRTP : public Base {
protected:
    BaseCRTP() = default;
};

class One : public BaseCRTP<One> {
    int q;
public:
    One(int q_) : q(q_) {
        // 注册当前类的test方法
        register_method<One>("test", &One::test);
    };

    Args test(Args a) {
        printf("One::test() -> q = %d\n", q);
        return {};
    };
};

class Two : public BaseCRTP<Two> {
    std::string s;
public:
    Two(std::string s_) : s(s_) {
        // 注册当前类的test2方法
        register_method<Two>("test2", &Two::test2);
    };

    Args test2(Args a) {
        printf("Two::test2() -> s = %s\n", s.c_str());
        return {};
    };
};

// 测试用例
int main() {
    std::vector<Base*> objects = {new One(42), new Two("hello")};
    
    try {
        objects[0]->invoke("test", Args{});   // 调用One::test
        objects[1]->invoke("test2", Args{});  // 调用Two::test2
        objects[0]->invoke("test2", Args{});  // 触发NoSuchMethod异常
    } catch (const NoSuchMethod&) {
        printf("Caught NoSuchMethod exception\n");
    }

    // 清理动态分配的内存
    for (auto obj : objects) {
        delete obj;
    }
    return 0;
}

关键细节解释 #

1. 静态注册表：method_registry是Base类的静态成员，所有子类共享，存储方法名到lambda的映射，lambda负责将Base指针安全转换为子类指针并调用目标方法。
2. CRTP模式：BaseCRTP模板用来避免子类重复写类型转换的冗余代码，同时确保类型转换的安全性（我们明确知道Derived是当前子类）。
3. 方法注册：每个子类在构造函数中调用register_method，将自身的成员函数指针包装成可被Base类调用的统一接口函数。
4. invoke逻辑：通过注册表查找方法名，找到则执行对应逻辑，找不到直接抛出NoSuchMethod异常，完全符合需求。

可扩展方向 #

• 扩展Args类，用std::variant或键值对存储多类型参数，让方法能接收和返回实际业务数据。
• 给注册表添加线程安全保护（比如std::mutex），适配多线程场景。
• 实现方法注销逻辑，在子类析构时移除注册表中的对应条目（需注意动态对象的生命周期管理）。

内容的提问来源于stack exchange，提问作者Алексей Гутник