无需使用模板，能否从基类获取派生类并实现用户无感知调用

针对你的需求——无需显式引用派生类即可调用其专属方法，同时通过Manager按类型字符返回对应实例，这里提供两种实用方案：

方案一：访问者模式（符合开闭原则） #

核心思路是通过访问者类封装派生类专属方法的调用逻辑，基类提供统一的accept接口，将自身传递给访问者，避免用户直接持有派生类指针或引用其头文件。

代码实现 #

1. 基类与访问者声明

// Base.h
class BaseVisitor;

class Base {
public:
    virtual ~Base() = default;
    virtual char type() const = 0; // 用于类型匹配
    virtual void accept(BaseVisitor& visitor) = 0;
};

// BaseVisitor.h
#include "Base.h"

// 仅前向声明派生类，无需暴露完整定义
class Derived_A;
class Derived_B;

class BaseVisitor {
public:
    virtual ~BaseVisitor() = default;
    virtual void visit(Derived_A* obj) = 0;
    virtual void visit(Derived_B* obj) = 0;
};

2. 派生类实现

// Derived_A.h
#include "Base.h"
#include "BaseVisitor.h"

class Derived_A : public Base {
public:
    char type() const override { return 'A'; }
    void foo_A() { /* 你的业务逻辑 */ }
    void accept(BaseVisitor& visitor) override {
        visitor.visit(this);
    }
};

// Derived_B.h
#include "Base.h"
#include "BaseVisitor.h"

class Derived_B : public Base {
public:
    char type() const override { return 'B'; }
    void foo_B() { /* 你的业务逻辑 */ }
    void accept(BaseVisitor& visitor) override {
        visitor.visit(this);
    }
};

3. Manager类实现

// Manager.h
#include <vector>
#include "Base.h"

class Manager {
private:
    static std::vector<Base*> objects;
public:
    static void addObject(Base* obj) {
        objects.push_back(obj);
    }

    static Base* getDerived(char type) {
        for (auto obj : objects) {
            if (obj->type() == type) {
                return obj;
            }
        }
        return nullptr;
    }
};

// 静态成员初始化
std::vector<Base*> Manager::objects;

4. 用户端调用（无需引用派生类头文件）

// main.cpp
#include "Manager.h"
#include "BaseVisitor.h"
#include <iostream>

// 自定义访问者，封装专属方法调用
class FooCaller : public BaseVisitor {
public:
    void visit(Derived_A* obj) override {
        obj->foo_A();
        std::cout << "Executed Derived_A::foo_A" << std::endl;
    }
    void visit(Derived_B* obj) override {
        obj->foo_B();
        std::cout << "Executed Derived_B::foo_B" << std::endl;
    }
};

int main() {
    // 提前向Manager添加实例（这里仅示例，实际可通过工厂等方式创建）
    Manager::addObject(new Derived_A());
    Manager::addObject(new Derived_B());

    // 获取实例并调用专属方法
    if (auto obj = Manager::getDerived('A')) {
        FooCaller caller;
        obj->accept(caller);
    }

    if (auto obj = Manager::getDerived('B')) {
        FooCaller caller;
        obj->accept(caller);
    }

    return 0;
}

优点 #

• 符合开闭原则：新增派生类时，仅需添加对应的visit方法和派生类的accept实现，无需修改现有Manager或用户端代码
• 用户端完全无需引用派生类头文件，仅依赖Base和BaseVisitor

方案二：注册式方法映射（灵活轻量） #

核心思路是在派生类中注册专属方法的包装函数，Manager维护类型字符到方法的映射表，用户直接通过Manager调用指定类型的方法，无需接触派生类。

代码实现 #

1. Manager类实现

// Manager.h
#include <vector>
#include <unordered_map>
#include <functional>
#include <string>
#include "Base.h"

class Manager {
private:
    static std::vector<Base*> objects;
    static std::unordered_map<char, std::unordered_map<std::string, std::function<void(Base*)>>> method_map;
public:
    static void addObject(Base* obj) {
        objects.push_back(obj);
    }

    // 模板方法，用于派生类注册专属方法
    template<typename Derived>
    static void register_method(char type, const std::string& method_name, std::function<void(Derived*)> func) {
        method_map[type][method_name] = [func](Base* obj) {
            if (auto derived = dynamic_cast<Derived*>(obj)) {
                func(derived);
            }
        };
    }

    // 对外暴露的调用接口
    static void call_method(char type, const std::string& method_name) {
        auto* obj = getDerived(type);
        if (!obj) return;

        auto type_it = method_map.find(type);
        if (type_it == method_map.end()) return;

        auto method_it = type_it->second.find(method_name);
        if (method_it == type_it->second.end()) return;

        method_it->second(obj);
    }

    static Base* getDerived(char type) {
        for (auto obj : objects) {
            if (obj->type() == type) {
                return obj;
            }
        }
        return nullptr;
    }
};

// 静态成员初始化
std::vector<Base*> Manager::objects;
std::unordered_map<char, std::unordered_map<std::string, std::function<void(Base*)>>> Manager::method_map;

2. 派生类注册方法（在cpp文件中完成，避免头文件依赖）

// Derived_A.cpp
#include "Derived_A.h"
#include "Manager.h"

// 静态注册，程序启动时自动执行
namespace {
    bool register_methods() {
        Manager::register_method<Derived_A>('A', "foo_A", [](Derived_A* obj) {
            obj->foo_A();
        });
        return true;
    }
    bool registered = register_methods();
}

// Derived_B.cpp
#include "Derived_B.h"
#include "Manager.h"

namespace {
    bool register_methods() {
        Manager::register_method<Derived_B>('B', "foo_B", [](Derived_B* obj) {
            obj->foo_B();
        });
        return true;
    }
    bool registered = register_methods();
}

3. 用户端调用（极简）

// main.cpp
#include "Manager.h"
#include <iostream>

int main() {
    Manager::addObject(new Derived_A());
    Manager::addObject(new Derived_B());

    // 直接调用，无需任何派生类依赖
    Manager::call_method('A', "foo_A");
    Manager::call_method('B', "foo_B");

    return 0;
}

优点 #

• 用户端代码极度简洁，仅需知道类型字符和方法名
• 新增方法或派生类时，仅需添加注册逻辑，侵入性低

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