std :: constructeurs unordered_set

Question

J'ai regardé les constructeurs de unordered_set. Est-ce qu'il n'est pas possible de construire un unordered_set avec une instance d'allocateur personnalisée SANS définir le nombre de segments de hachage? Je préfère vraiment ne pas jouer avec les détails d'implémentation parce que je veux un allocateur personnalisé, et le type ne fournit aucune définition pour la valeur par défaut. MSDN donne seulement trois surcharges pour le constructeur, dont aucune n'est terriblement utile.

Editer: Merde sacrée. Mon implémentation STL de std :: hash ne se spécialise pas pour les chaînes avec un type d'allocateur personnalisé - elle ne peut faire que les typedefs explicites std :: string et std :: wstring. Je veux dire, je peux comprendre ne pas vouloir essayer de hacher les chaînes de caractères aléatoires, mais juste parce qu'il a un allocateur personnalisé? Cela me dégoûte.

tokens(std::unordered_set<string>().bucket_count(), std::hash<string>(), std::equal_to<string>(), stl_wrapper::hash_set<string>::allocator_type(this)) 
template<typename Char, typename CharTraits, typename Allocator> class std::hash<std::basic_string<Char, CharTraits, Allocator>> 
    : public std::unary_function<std::basic_string<Char, CharTraits, Allocator>, std::size_t> { 
public: 
    size_t operator()(const std::basic_string<Char, CharTraits, Allocator>& ref) const { 
     return std::hash<std::basic_string<Char, CharTraits>>()(std::basic_string<Char, CharTraits>(ref.begin(), ref.end())); 
    } 
}; 

Résout les problèmes, mais les constructions redondantes et la copie? Ewwwww.

Answer 1

C'est étrange, mais vous avez raison. Je suppose que la pensée était qu'il est trop difficile de supporter toutes les combinaisons de paramètres possibles, avec des valeurs par défaut.

La meilleure façon que je peux penser à gérer est de construire un unordered_set vide avec tous les paramètres par défaut, obtenir le nombre de seau par défaut de l'aide unordered_set::bucket_count, et ensuite utiliser que comme entrée lorsque vous instancier le conteneur que vous voulez réellement.

unordered_set<int> temp; 
size_t buckets = temp.bucket_count; 
unordered_set<string> actual(buckets, Hash(), Pred(), 
    YourAllocator(param1 /*, etc */)); 

Answer 2

Puisque vous écrivez le Allocator, il est logique de contrôler le nombre de seaux trop, après tout les deux sont liés la mémoire :)

Steve a donné au cœur de la méthode si vous ne voulez pas à, maintenant laissez-moi vous propose une fonction d'assistance :)

template <typename T> 
size_t number_buckets() 
{ 
    std::unordered_set<T> useless; 
    return useless.bucket_count(); 
} 

Et avec cela, une aide peu (simple):

template <typename T, typename Hash, typename Pred, typename Allocator> 
std::unordered_set<T,Hash,Pred,Allocator> 
    make_unordered_set(Hash const& hash, Pred const& pred, Allocator const& alloc) 
{ 
    static size_t const nbBuckets = number_buckets<T>(); 
    return std::unordered_set<T,Hash,Pred,Allocator>(nbBuckets, hash, pred, alloc); 
} 

fonctionne assez bien avec auto:

auto set = make_unordered_set<std::string>(Hash(), Pred(), Allocator(1,2,3)); 

Vous pouvez aussi, bien sûr, il suffit de déchirer la constante de votre mise en œuvre préférée.