Können Tupel mit ungeordneten Containern ohne variadische Vorlagen in C 0x funktionieren?

C 0x-Tupel mit ungeordneten Containern zum Laufen bringen

Während das Erstellen ungeordneter Karten und Mengen mithilfe von Tupelschlüsseln unkompliziert sein sollte, kann die Anforderung einer benutzerdefinierten Hash-Funktion für Tupel mühsam sein. Aber gibt es eine Möglichkeit, dies zu vermeiden, ohne variadische Vorlagen zu verwenden?

Die Standardlösung

In C 0x kann eine generische Hash-Funktion für Tupel mithilfe des folgenden Codes definiert werden:

namespace std{
    namespace
    {
        // Code from boost
        // Reciprocal of the golden ratio helps spread entropy
        //     and handles duplicates.
        // See Mike Seymour in magic-numbers-in-boosthash-combine:
        //     http://stackoverflow.com/questions/4948780

        template <class T>
        inline void hash_combine(std::size_t&amp; seed, T const&amp; v)
        {
            seed ^= std::hash<T>()(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
        }

        // Recursive template code derived from Matthieu M.
        template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1>
        struct HashValueImpl
        {
          static void apply(size_t&amp; seed, Tuple const&amp; tuple)
          {
            HashValueImpl<Tuple, Index-1>::apply(seed, tuple);
            hash_combine(seed, std::get<Index>(tuple));
          }
        };

        template <class Tuple>
        struct HashValueImpl<Tuple,0>
        {
          static void apply(size_t&amp; seed, Tuple const&amp; tuple)
          {
            hash_combine(seed, std::get<0>(tuple));
          }
        };
    }

    template <typename ... TT>
    struct hash<std::tuple<TT...>> 
    {
        size_t
        operator()(std::tuple<TT...>&amp; tt) const
        {                                              
            size_t seed = 0;                             
            HashValueImpl<std::tuple<TT...>>::apply(seed, tt);    
            return seed;                                 
        }                                              
    };
}

Verwendung eines benutzerdefinierten Namespace

Um die Einhaltung des Standards sicherzustellen, wird empfohlen, die Hash-Funktion für Tupel in einem benutzerdefinierten Namespace zu definieren, um zu verhindern, dass sie automatisch von ADL erfasst wird. Dazu muss zunächst die Hash-Implementierung im benutzerdefinierten Namespace deklariert und anschließend der Rest des generischen Hash-Funktionscodes eingebunden werden:

namespace hash_tuple{

template <typename TT>
struct hash
{
    size_t
    operator()(TT const&amp; tt) const
    {                                              
        return std::hash<TT>()(tt);                                 
    }                                              
};
}

// ... Include the rest of the previous generic hash function code

Auf diese Weise können ungeordnete Zuordnungen und Mengen mit Tupelschlüsseln arbeiten, ohne auf ADL angewiesen zu sein. und der Standard wird vollständig eingehalten.

Das obige ist der detaillierte Inhalt vonKönnen Tupel mit ungeordneten Containern ohne variadische Vorlagen in C 0x funktionieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!