Les tuples peuvent-ils fonctionner avec des conteneurs non ordonnés sans modèles variadiques en C 0x ?

Faire fonctionner des tuples C 0x avec des conteneurs non ordonnés

Bien que la création de cartes et d'ensembles non ordonnés à l'aide de clés de tuple devrait être simple, exiger une fonction de hachage personnalisée pour les tuples peut être fastidieux. Mais existe-t-il un moyen d'éviter cela sans utiliser de modèles variadiques ?

La solution standard

En C 0x, une fonction de hachage générique pour les tuples peut être définie à l'aide du code ci-dessous :

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

Utiliser un espace de noms personnalisé

Pour garantir le respect de la norme, il est recommandé de définir la fonction de hachage pour des tuples dans un espace de noms personnalisé, l'empêchant d'être automatiquement récupéré par ADL. Cela nécessite d'abord de déclarer l'implémentation du hachage dans l'espace de noms personnalisé, puis d'inclure le reste du code de la fonction de hachage générique :

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

De cette façon, les cartes et les ensembles non ordonnés peuvent fonctionner avec des clés tuple sans compter sur ADL, et la norme est pleinement respectée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!