从组件的std::type_index获取派生最多的类型

#include <iostream>
#include <typeindex>
#include <unordered_map>
#include <vector>
#include <typeinfo>

// 基类
class Base {};

// 派生类
class Derived1 : public Base {};
class Derived2 : public Base {};
class Derived3 : public Derived1 {};

// 继承图节点
struct TypeInfoNode {
    std::type_index type;
    std::vector<TypeInfoNode*> children;
};

// 全局继承图
std::unordered_map<std::type_index, TypeInfoNode> inheritanceGraph;

// 注册类型到继承图
template<typename T>
void registerType() {
    static TypeInfoNode node{std::type_index(typeid(T))};
    inheritanceGraph[node.type] = node;
}

// 添加继承关系
template<typename BaseT, typename DerivedT>
void addInheritance() {
    auto& baseNode = inheritanceGraph[std::type_index(typeid(BaseT))];
    auto& derivedNode = inheritanceGraph[std::type_index(typeid(DerivedT))];
    baseNode.children.push_back(&derivedNode);
}

// 计算派生类数量
int countDerivedTypes(const TypeInfoNode& node) {
    int count = node.children.size();
    for (const auto& child : node.children) {
        count += countDerivedTypes(*child);
    }
    return count;
}

int main() {
    // 注册类型
    registerType<Base>();
    registerType<Derived1>();
    registerType<Derived2>();
    registerType<Derived3>();

    // 添加继承关系
    addInheritance<Base, Derived1>();
    addInheritance<Base, Derived2>();
    addInheritance<Derived1, Derived3>();

    // 查找派生最多的类型
    std::type_index mostDerivedType;
    int maxDerivedCount = 0;

    for (const auto& pair : inheritanceGraph) {
        int derivedCount = countDerivedTypes(pair.second);
        if (derivedCount > maxDerivedCount) {
            maxDerivedCount = derivedCount;
            mostDerivedType = pair.first;
        }
    }

    std::cout << "Most derived type: " << mostDerivedType.name() << " with " << maxDerivedCount << " derived types." << std::endl;

    return 0;
}