在 unordered_set 中存储多态对象答案

【问题标题】：storing polymorphic objects in unordered_set在 unordered_set 中存储多态对象
【发布时间】：2019-09-17 14:04:57
【问题描述】：

假设我有一个基类

struct Base {
    int x;
};

而且我知道有一个派生自Base 的Derived 类，但目前我无法获得它的定义（它存在于下游模块中）。

现在我有一个unordered_set<Base*>，它将存储Base 和Derived 对象的混合。如果我没有指定自定义散列函数，这个 unordered_set 是否可以正常工作（即按元素的实际类型散列元素，以便具有相同 x 但在某些其他派生字段中不同的两个 Derived 对象被视为不同)?

假设我确实需要一个自定义散列函数，因为我还没有 Derived 的定义，我希望将我的散列函数写为 Base 的虚拟成员函数，以便 Derived 可以简单当unordered_set 调用它时，覆盖该函数以执行它自己的哈希。这可能吗？或者对于此类问题是否有其他首选/已建立的解决方案？

【问题讨论】：

这是XY problem吗？
我刚刚编辑了我的问题，希望现在更清楚......我确实想要一个有效的 unordered_set，尽管虚拟哈希函数可能不是正确的解决方案。

标签： c++ hash unordered-set

【解决方案1】：

是的，你可以这样做：

#include <iostream>
#include <functional>
#include <unordered_set>
#include <memory>

struct Base {
    int x;

    virtual size_t hash() const {
        return std::hash<int>()(x);
    }
};

// just some Derived example
struct Derived : Base {
    int y;

    // performing hashing for a pair of integers
    virtual size_t hash() const override {
        return std::hash<int>()(x) ^ std::hash<int>()(y);
    }
};

struct Hasher {
    size_t operator()(const Base* ptr) const {
        return ptr->hash();
    }
};

struct CheckEq {
    bool operator()(Base* lhs, Base* rhs) const {
        auto dLhs = dynamic_cast<Derived*>(lhs);
        auto dRhs = dynamic_cast<Derived*>(rhs);

        // different types
        if ((dLhs == nullptr) != (dRhs == nullptr)) {
            return false;
        }

        // both Base
        if (dLhs == nullptr && dRhs == nullptr) {
            return lhs->x == rhs->x;
        }

        // both Derived
        return dLhs->x == dRhs->x && dLhs->y == dRhs->y;
    }
};

int main() {
    std::unordered_set<
        Base*,
        Hasher,  // struct with defined size_t operator()(const Base*) const, returning hash of object
        CheckEq  // struct with defined bool operator(const Base*, const Base*) const for additional checking whether 2 objects with same hashes are different
    > set;

    // checking if it works
    auto objBase1 = std::make_unique<Base>();
    objBase1->x = 5;
    auto objBase2 = std::make_unique<Base>();
    objBase2->x = 5;
    auto objBase3 = std::make_unique<Base>();
    objBase3->x = 6;

    auto objDerived1 = std::make_unique<Derived>();
    objDerived1->x = 5;
    objDerived1->y = 6;
    auto objDerived2 = std::make_unique<Derived>();
    objDerived1->x = 5;
    objDerived1->y = 6;
    auto objDerived3 = std::make_unique<Derived>();
    objDerived1->x = 50;
    objDerived1->y = 60;

    set.insert(objBase1.get());
    set.insert(objBase2.get());
    set.insert(objBase3.get());
    set.insert(objDerived1.get());
    set.insert(objDerived2.get());
    set.insert(objDerived3.get());

    std::cout << set.size() << std::endl;  // prints 4

    return 0;
}

UPD。在我看来你需要将对象存储在某个地方，所以

std::unordered_set<
    std::unique_ptr<Base>,  // or shared_ptr
    Hasher,
    CheckEq
> set;

可能是一个更好的主意。

【讨论】：