C ++：为嵌套的内部受保护的类定义哈希函数

2024-05-10 • 问答

我正在尝试为内部类编写哈希函数，该内部类是较大类的受保护成员。此外，哈希函数应使用内部类的受保护成员（在这种情况下为字符串）。因此，这是没有哈希函数的情况：

class MasterClass
{
    public:
    // Blah blah blah
    protected:

        class InternalClass
        {
            public:
            // Blah blah blah 2
            protected:
                string m_Value;
        };

        unordered_map<InternalClass,uint> m_Example_Map;
};

由于我将InternalClass用作MasterClass中unordered_map的键，因此需要定义哈希函数。

我正在使用以下参考文献：

但是我在头上。我最好的猜测是这样的：

class MasterClass::InternalClass;
namespace std
{
    template<> struct hash<MasterClass::InternalClass>
    {
    public:
        size_t operator()(const MasterClass::InternalClass& i_Internal) const;
    };
}

class MasterClass
{
    public:
    // Blah blah blah
    protected:

        class InternalClass
        {
            public:
            // Blah blah blah 2
            protected:
                string m_Value;
        };

        unordered_map<InternalClass,uint> m_Example_Map;

        friend struct std::hash<MasterClass::InternalClass>::operator()(const MasterClass::InternalClass& i_Name) const;
};

namespace std
{
    template<> size_t hash<MasterClass::InternalClass>::operator()(const MasterClass::InternalClass& i_Internal) const
    {
        return(std::hash<std::string>{}(*i_Internal.m_Value);
    }
}

但是，这充满了编译器错误，包括“无效的朋友声明”和“类“ std :: hash”的显式专门化”必须在第一次使用之前（在“ C：\ Program Files（x86）第719行\ microsoft Visual Studio \ 2017 \ Enterprise \ VC \ Tools \ MSVC \ 14.16.27023 \ include \ type_traits“）”

如何为受保护的内部类定义哈希函数（使用内部类的受保护成员）？

我想这就是你想要的：

class MasterClass
{
public:
    // Blah blah blah
protected:

    class InternalClass; // Forward declaration needed for friend declaration

    class MyHash
    {
    public:
        size_t operator()(const MasterClass::InternalClass& i_Internal) const;
    };

    class InternalClass
    {
    public:
        // Blah blah blah 2
    protected:
        std::string m_Value;

        friend size_t MasterClass::MyHash::operator()(const MasterClass::InternalClass& i_Internal) const; // firend to allow access to m_value
    };

    std::unordered_map<InternalClass,unsigned,MyHash> m_Example_Map;
};

// Implementation of hash
size_t MasterClass::MyHash::operator()(const MasterClass::InternalClass& i_Internal) const
{
    return std::hash<std::string>{}(i_Internal.m_Value);
}

我还要问，为什么protected？ protected使派生类可以访问项目。您可能已经简化了这些内容，但如果不想使用，请使用private。

我认为std::hash并没有实现这一目标的方法，因为在定义std::hash之前，您需要先定义MasterClass的专业化（因为它必须位于命名空间范围以及m_Example_Map类型的实例化都需要它），并且在定义特殊化之前，您需要定义MasterClass，因为它需要内部类类型。

但是std::unordered_map不需要使用std::hash。您可以改为提供自己的哈希函子：

class MasterClass
{
    public:
    // Blah blah blah
    protected:

        class InternalClass
        {
            public:
                // Blah blah blah 2
                struct hash {
                    auto operator()(const InternalClass& v) const {
                        return std::hash<std::string>{}(v.m_Value);
                    }
                };
                bool operator==(const InternalClass& other) const {
                    return m_Value == other.m_Value;
                }
            protected:
                string m_Value;
        };

        unordered_map<InternalClass,uint,InternalClass::hash> m_Example_Map;
};

C ++：为嵌套的内部受保护的类定义哈希函数

zy870226 回答：C ++：为嵌套的内部受保护的类定义哈希函数

大家都在问