C++智能指针哈希支持无序容器中使用-C++-PHP中文网

C++智能指针哈希支持无序容器中使用

P粉602998670

发布： 2025-09-06 09:02:01

原创

620人浏览过

C++智能指针需自定义哈希和相等函数才能作为无序容器的键，因默认按指针地址比较；应解引用比较对象内容，并处理空指针情况，同时注意shared_ptr的循环引用风险及性能优化。

c++智能指针哈希支持无序容器中使用

C++智能指针可以直接作为键值用于无序容器，但需要自定义哈希函数和相等比较函数。核心在于让哈希函数基于智能指针指向的对象的实际内容，而不是指针本身。

解决方案

要让智能指针在无序容器中工作，你需要提供自定义的哈希函数和相等比较函数。这通常涉及解引用智能指针，然后基于其指向的对象进行哈希和比较。以下是一个使用

std::unique_ptr

登录后复制

的例子，但概念适用于其他智能指针，如

std::shared_ptr

登录后复制

。

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

struct MyObject {
    int value;
    MyObject(int v) : value(v) {}
    bool operator==(const MyObject& other) const {
        return value == other.value;
    }
};

// 自定义哈希函数
struct MyObjectHash {
    size_t operator()(const std::unique_ptr<MyObject>& obj) const {
        if (obj) {
            return std::hash<int>()(obj->value);
        } else {
            return 0; // 或者其他合适的默认值
        }
    }
};

// 自定义相等比较函数
struct MyObjectEqual {
    bool operator()(const std::unique_ptr<MyObject>& a, const std::unique_ptr<MyObject>& b) const {
        if (!a && !b) return true; // 都为空
        if (!a || !b) return false; // 一个为空，一个不为空
        return *a == *b; // 比较指向的对象
    }
};

int main() {
    std::unordered_set<std::unique_ptr<MyObject>, MyObjectHash, MyObjectEqual> mySet;

    mySet.insert(std::unique_ptr<MyObject>(new MyObject(10)));
    mySet.insert(std::unique_ptr<MyObject>(new MyObject(20)));
    mySet.insert(std::unique_ptr<MyObject>(new MyObject(10))); // 重复值

    std::cout << "Set size: " << mySet.size() << std::endl; // 输出: Set size: 2

    // 查找元素
    std::unique_ptr<MyObject> searchObj(new MyObject(20));
    auto it = mySet.find(std::move(searchObj)); // 注意这里移动了searchObj的所有权
    if (it != mySet.end()) {
        std::cout << "Found object with value: " << (*it)->value << std::endl; // 输出: Found object with value: 20
    } else {
        std::cout << "Object not found." << std::endl;
    }

    return 0;
}

登录后复制

这个例子展示了如何使用

std::unique_ptr

登录后复制

，并提供了自定义的哈希和相等比较函数。关键点在于哈希函数和相等比较函数需要解引用智能指针，并基于其指向的对象的实际值进行操作。

为什么需要自定义哈希和相等比较函数？

默认情况下，

std::unordered_set

登录后复制

或

std::unordered_map

登录后复制

会使用指针的值（即内存地址）进行哈希和比较。如果你想基于智能指针指向的对象的实际内容来判断相等性，就需要提供自定义的哈希函数和相等比较函数。否则，即使两个智能指针指向的对象具有相同的值，它们也会被认为是不同的键，因为它们的指针地址不同。

立即学习“C++免费学习笔记（深入）”；

如何处理智能指针为空的情况？

在哈希函数和相等比较函数中，需要特别处理智能指针为空的情况。例如，如果智能指针为空，你可以返回一个默认的哈希值（比如0），或者在相等比较函数中，将两个空指针视为相等。确保你的实现能够正确处理空指针，避免出现空指针解引用错误。在上面的例子中，我们展示了一种处理

unique_ptr

登录后复制

为空的方法。

使用

std::shared_ptr

登录后复制

时有什么不同？

对于

std::shared_ptr

登录后复制

，哈希和相等比较函数的实现方式基本相同，只是需要注意

std::shared_ptr

登录后复制

的生命周期管理。当你复制

std::shared_ptr

登录后复制

时，引用计数会增加，因此在哈希和比较函数中复制

std::shared_ptr

登录后复制

是安全的。但是，你需要确保在容器中的

std::shared_ptr

登录后复制

不会过早地被销毁，否则可能会导致悬挂指针。

Gnomic智能体平台

国内首家无需魔法免费无限制使用的ChatGPT4.0，网站内设置了大量智能体供大家免费使用，还有五款语言大模型供大家免费使用~

查看详情

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

struct MyObject {
    int value;
    MyObject(int v) : value(v) {}
    bool operator==(const MyObject& other) const {
        return value == other.value;
    }
};

// 自定义哈希函数
struct MyObjectHash {
    size_t operator()(const std::shared_ptr<MyObject>& obj) const {
        if (obj) {
            return std::hash<int>()(obj->value);
        } else {
            return 0; // 或者其他合适的默认值
        }
    }
};

// 自定义相等比较函数
struct MyObjectEqual {
    bool operator()(const std::shared_ptr<MyObject>& a, const std::shared_ptr<MyObject>& b) const {
        if (!a && !b) return true; // 都为空
        if (!a || !b) return false; // 一个为空，一个不为空
        return *a == *b; // 比较指向的对象
    }
};

int main() {
    std::unordered_set<std::shared_ptr<MyObject>, MyObjectHash, MyObjectEqual> mySet;

    mySet.insert(std::make_shared<MyObject>(10));
    mySet.insert(std::make_shared<MyObject>(20));
    mySet.insert(std::make_shared<MyObject>(10)); // 重复值

    std::cout << "Set size: " << mySet.size() << std::endl;

    // 查找元素
    std::shared_ptr<MyObject> searchObj = std::make_shared<MyObject>(20);
    auto it = mySet.find(searchObj);
    if (it != mySet.end()) {
        std::cout << "Found object with value: " << (*it)->value << std::endl;
    } else {
        std::cout << "Object not found." << std::endl;
    }

    return 0;
}

登录后复制

使用

std::shared_ptr

登录后复制

时，不需要像

std::unique_ptr

登录后复制

那样使用

std::move

登录后复制

转移所有权，因为

std::shared_ptr

登录后复制

可以安全地复制。

性能考虑

自定义哈希函数和相等比较函数可能会影响无序容器的性能。确保你的哈希函数能够产生良好的哈希值分布，避免过多的哈希冲突。如果哈希冲突过多，无序容器的查找性能可能会下降到O(n)。此外，相等比较函数的性能也很重要，因为它会在哈希冲突时被频繁调用。尽量使相等比较函数尽可能高效。

如何避免内存泄漏？

在使用智能指针时，内存泄漏的风险大大降低，但仍然需要注意一些细节。确保你正确地使用了智能指针，避免循环引用等问题。例如，在使用

std::shared_ptr

登录后复制

时，如果两个对象相互持有对方的

std::shared_ptr

登录后复制

，可能会导致循环引用，从而导致内存泄漏。为了避免循环引用，可以使用

std::weak_ptr

登录后复制

来打破循环。

#include <iostream>
#include <memory>

struct B; // 前向声明

struct A {
    std::shared_ptr<B> b;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

struct B {
    std::weak_ptr<A> a; // 使用 weak_ptr 打破循环引用
    ~B() { std::cout << "B destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->b = b;
    b->a = a; // 循环引用

    // a 和 b 都会被销毁，避免内存泄漏
    return 0;
}

登录后复制

在这个例子中，

登录后复制

使用