如何构建键为抽象基类的std::unordered_map？

嘿，我来帮你梳理下这段代码的问题，以及怎么修复它：

首先，你的代码有两个核心问题：

• 抽象类无法实例化：你的基类B是抽象类（包含纯虚函数SomeMethod()），C++明确禁止创建抽象类的对象。而std::unordered_map<B, int>要求键是B类型的对象，当你尝试insert({*d1,5})时，会试图复制构造一个B对象，这直接违反了抽象类的规则，编译阶段就会报错。
• 对象切片问题：就算B不是抽象类，直接存储值类型也会出问题——*d1是D1对象，复制到B类型的键时，会被"切片"，只保留基类部分的内容，派生类的特有数据和多态特性都会丢失，完全达不到你存储派生类实例的目的。

修复方案：用指针/智能指针作为键 #

我们需要存储派生类对象的指针（而不是值），这样既不会触发抽象类的实例化，也能避免对象切片，同时保留多态特性。下面给两种常用的实现方式：

方案1：使用原始指针（需手动管理内存）

#include <unordered_map>

class B {
public:
    virtual void SomeMethod() = 0; // 纯虚函数建议加上virtual，更清晰规范
    virtual ~B() = default; // 基类必须加虚析构，确保删除指针时正确调用派生类析构
};

class D1 : public B {
public:
    void SomeMethod() override {} // 实现纯虚函数
};

class D2 : public B {
public:
    void SomeMethod() override {}
};

int main() {
    std::unordered_map<B*, int> myMap; 
    D1* d1 = new D1();
    D2* d2 = new D2();
    
    myMap.insert({d1, 5});
    myMap.insert({d2, 8});
    
    // 用完记得手动释放内存，避免泄漏
    delete d1;
    delete d2;
    return 0;
}

这里用B*作为键，存储的是派生类对象的地址，完全符合抽象类指针的使用规则，也不会丢失派生类的信息。

方案2：使用智能指针（推荐，自动管理内存）

如果不想手动管理内存，用std::unique_ptr或std::shared_ptr是更好的选择。注意std::unordered_map默认没有智能指针的哈希函数，所以可以用std::map（它依赖比较运算符，智能指针原生支持）：

#include <map>
#include <memory>

class B {
public:
    virtual void SomeMethod() = 0;
    virtual ~B() = default;
};

class D1 : public B {
public:
    void SomeMethod() override {}
};

class D2 : public B {
public:
    void SomeMethod() override {}
};

int main() {
    std::map<std::unique_ptr<B>, int> myMap; 
    // 直接用make_unique创建派生类对象，自动管理生命周期
    myMap.insert({std::make_unique<D1>(), 5});
    myMap.insert({std::make_unique<D2>(), 8});
    
    // 不需要手动delete，智能指针会在离开作用域时自动释放内存
    return 0;
}

如果一定要用std::unordered_map，可以给std::unique_ptr<B>自定义哈希函数：

#include <unordered_map>
#include <memory>

class B {
public:
    virtual void SomeMethod() = 0;
    virtual ~B() = default;
};

class D1 : public B {
public:
    void SomeMethod() override {}
};

class D2 : public B {
public:
    void SomeMethod() override {}
};

// 为std::unique_ptr<B>自定义哈希函数，基于底层指针的哈希值
template<>
struct std::hash<std::unique_ptr<B>> {
    size_t operator()(const std::unique_ptr<B>& ptr) const {
        return std::hash<B*>()(ptr.get());
    }
};

int main() {
    std::unordered_map<std::unique_ptr<B>, int> myMap; 
    myMap.insert({std::make_unique<D1>(), 5});
    myMap.insert({std::make_unique<D2>(), 8});
    
    return 0;
}

补充细节 #

你原来的代码还有个小疏漏：纯虚函数void SomeMethod() = 0;加上virtual关键字会更规范（虽然C++允许省略，但可读性会差一些）；另外基类必须声明虚析构函数，否则删除基类指针时会导致派生类的析构函数不被调用，引发内存泄漏。

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