std :: constructeurs unordered_set

Question

J'ai regardé les constructeurs de unordered_set. Est-il pas possible de construire un unordered_set avec une instance de allocateur personnalisé sans définir le nombre de seaux de hachage? Je préfèrerais ne plaisante pas avec les détails de mise en œuvre parce que je veux un allocateur personnalisé et le type ne fournit aucune définition pour la valeur par défaut. MSDN ne donne que trois comme pour le constructeur surcharges, dont aucun ne sont terriblement utiles.

Edit: Bordel. Ma mise en œuvre de la STL de std :: hachage ne se spécialisera pour les chaînes avec un allocateur personnalisé type- il ne peut faire les typedefs explicites std :: string et std :: wstring. Je veux dire, je ne comprends pas vouloir essayer de chaînes de caractères aléatoires de hachage, mais juste parce qu'il a un allocateur personnalisé? Ce dégoûts moi.

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ésolve 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 est qu'il est exagéré de soutenir toutes les combinaisons de paramètres possibles, avec les 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, un peu (simple) aide:

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

Travaux 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 application préférée.