在C++中,如何使用泛型类型的映射避免显式的向下转换？

#include <iostream>
#include <map>

// 定义一个基类
class Base {
public:
    virtual ~Base() {}
};

// 定义两个派生类
class Derived1 : public Base {
public:
    void func1() {
        std::cout << "Derived1::func1()" << std::endl;
    }
};

class Derived2 : public Base {
public:
    void func2() {
        std::cout << "Derived2::func2()" << std::endl;
    }
};

// 定义一个泛型类型的映射
std::map<std::string, Base*> typeMap;

// 注册派生类到映射中
template<typename T>
void registerType(const std::string& typeName) {
    typeMap[typeName] = new T();
}

// 获取映射中的对象，并进行类型检查
template<typename T>
T* getType(const std::string& typeName) {
    Base* base = typeMap[typeName];
    if (base) {
        return dynamic_cast<T*>(base);
    }
    return nullptr;
}

int main() {
    // 注册派生类到映射中
    registerType<Derived1>("Derived1");
    registerType<Derived2>("Derived2");

    // 获取映射中的对象，并进行类型转换
    Derived1* d1 = getType<Derived1>("Derived1");
    if (d1) {
        d1->func1();
    }

    Derived2* d2 = getType<Derived2>("Derived2");
    if (d2) {
        d2->func2();
    }

    return 0;
}