Không thể sử dụng lớp enum làm khóa unirdered_map

Tôi có một lớp chứa một lớp enum.

class Shader {
public:
    enum class Type {
        Vertex   = GL_VERTEX_SHADER,
        Geometry = GL_GEOMETRY_SHADER,
        Fragment = GL_FRAGMENT_SHADER
    };
    //...

Sau đó, khi tôi triển khai mã sau trong một lớp khác ...

std::unordered_map<Shader::Type, Shader> shaders;

... Tôi gặp lỗi biên dịch.

...usr/lib/c++/v1/type_traits:770:38: 
Implicit instantiation of undefined template 'std::__1::hash<Shader::Type>'

Điều gì gây ra lỗi ở đây?

Tôi sử dụng một đối tượng functor để tính toán băm của enum class:

struct EnumClassHash
{
    template <typename T>
    std::size_t operator()(T t) const
    {
        return static_cast<std::size_t>(t);
    }
};

Bây giờ bạn có thể sử dụng nó làm tham số mẫu thứ 3 của std::unordered_map:

enum class MyEnum {};

std::unordered_map<MyEnum, int, EnumClassHash> myMap;

Vì vậy, bạn không cần phải cung cấp một chuyên môn hóa std::hash, suy luận đối số mẫu thực hiện công việc. Hơn nữa, bạn có thể sử dụng từ usingvà tự unordered_mapsử dụng từ này std::hashhoặc EnumClassHashtùy thuộc vào Keyloại:

template <typename Key>
using HashType = typename std::conditional<std::is_enum<Key>::value, EnumClassHash, std::hash<Key>>::type;

template <typename Key, typename T>
using MyUnorderedMap = std::unordered_map<Key, T, HashType<Key>>;

Bây giờ bạn có thể sử dụng MyUnorderedMapvới enum classhoặc một loại khác:

MyUnorderedMap<int, int> myMap2;
MyUnorderedMap<MyEnum, int> myMap3;

Về mặt lý thuyết, HashTypecó thể sử dụng std::underlying_typevà sau đó EnumClassHashsẽ không cần thiết. Đó có thể là một cái gì đó như thế này, nhưng tôi chưa thử :

template <typename Key>
using HashType = typename std::conditional<std::is_enum<Key>::value, std::hash<std::underlying_type<Key>::type>, std::hash<Key>>::type;

Nếu sử dụng std::underlying_typecác công trình, có thể là một đề xuất rất tốt cho tiêu chuẩn.

Đây được coi là một khiếm khuyết trong tiêu chuẩn và đã được sửa trong C ++ 14: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2148

Điều này đã được khắc phục trong phiên bản vận chuyển libstdc ++ với gcc kể từ 6.1: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60970 .

Nó đã được sửa trong libc ++ của clang vào năm 2013: http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20130902/087778.html

Một giải pháp rất đơn giản là cung cấp một đối tượng hàm băm như sau:

std::unordered_map<Shader::Type, Shader, std::hash<int> > shaders;

Đó là tất cả đối với một khóa enum, không cần cung cấp chuyên môn hóa std :: hash.

Thêm điều này vào tiêu đề xác định MyEnumClass:

namespace std {
  template <> struct hash<MyEnumClass> {
    size_t operator() (const MyEnumClass &t) const { return size_t(t); }
  };
}

Như KerrekSB đã chỉ ra, bạn cần cung cấp chuyên môn std::hashnếu muốn sử dụng std::unordered_map, chẳng hạn như:

namespace std
{
    template<>
    struct hash< ::Shader::Type >
    {
        typedef ::Shader::Type argument_type;
        typedef std::underlying_type< argument_type >::type underlying_type;
        typedef std::hash< underlying_type >::result_type result_type;
        result_type operator()( const argument_type& arg ) const
        {
            std::hash< underlying_type > hasher;
            return hasher( static_cast< underlying_type >( arg ) );
        }
    };
}

Khi bạn sử dụng std::unordered_map, bạn biết bạn cần một hàm băm. Đối với các STLloại hoặc cài sẵn, có sẵn các giá trị mặc định, nhưng không có các giá trị mặc định do người dùng xác định. Nếu bạn chỉ cần một tấm bản đồ, tại sao bạn không thử std::map?

Thử

std::unordered_map<Shader::Type, Shader, std::hash<std::underlying_type<Shader::Type>::type>> shaders;