Enum-Klasse kann nicht als unordered_map-Schlüssel verwendet werden

Ich habe eine Klasse, die eine Aufzählungsklasse enthält.

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

Wenn ich dann den folgenden Code in einer anderen Klasse implementiere ...

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

... Ich erhalte einen Kompilierungsfehler.

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

Was verursacht hier den Fehler?

Ich benutze ein Funktorobjekt, um den Hash von zu berechnen enum class:

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

Jetzt können Sie es als 3. Template-Parameter von verwenden std::unordered_map:

enum class MyEnum {};

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

Sie müssen also keine Spezialisierung std::hashangeben. Der Abzug der Vorlagenargumente erledigt den Job. Darüber hinaus können Sie das Wort verwenden usingund Ihr eigenes erstellen unordered_map, das std::hashoder EnumClassHashje nach KeyTyp Folgendes verwendet:

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>>;

Jetzt können Sie MyUnorderedMapmit enum classoder einem anderen Typ verwenden:

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

Theoretisch HashTypekönnte man das gebrauchen std::underlying_typeund dann EnumClassHashwird das nicht nötig sein. Das könnte so etwas sein, aber ich habe es noch nicht versucht :

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

Wenn std::underlying_typeWerke verwendet werden, könnte dies ein sehr guter Vorschlag für den Standard sein.

Dies wurde als Fehler im Standard angesehen und in C ++ 14 behoben: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2148

Dies ist in der Version von libstdc ++ behoben, die mit gcc ab 6.1 ausgeliefert wird: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60970 .

Es wurde 2013 in clangs libc ++ behoben: http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20130902/087778.html

Eine sehr einfache Lösung wäre, ein Hash-Funktionsobjekt wie das folgende bereitzustellen:

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

Das ist alles für einen Enum-Schlüssel, ohne dass eine Spezialisierung auf std :: hash erforderlich ist.

Fügen Sie dies dem Header hinzu, der MyEnumClass definiert:

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

Wie KerrekSB hervorhob, müssen Sie eine Spezialisierung angeben, std::hashwenn Sie Folgendes verwenden möchten std::unordered_map:

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 ) );
        }
    };
}

Wenn Sie verwenden std::unordered_map, wissen Sie, dass Sie eine Hash-Funktion benötigen. Für integrierte STLTypen oder Typen sind Standardeinstellungen verfügbar, nicht jedoch für benutzerdefinierte. Wenn Sie nur eine Karte benötigen, warum versuchen Sie es nicht std::map?

Versuchen

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