Obtient la valeur de hachage unordered_set et est-elle constante?

Question

Est-il possible de trouver la valeur de hachage (hachage) pour un élément dans un unordered_set?

Par exemple;

unordered_set<string> errorStates; 
errorStates.insert("File does not exist"); 

// Can I get the hash of this key? 
int ERR_FILE_NOT_EXISTS = errorStates.keyHash("File does not exist"); 

serait également le hachage pour File does not exist toujours le même? Est-ce que le hachage serait le même si je cours mon programme et insère 20 valeurs dans errorStates et quand j'exécute le programme et insère 200? L'idée est que le hash sera l'identifiant d'erreur unique et écrira le hash dans un fichier.

Je crée une classe Status pour renvoyer facilement les résultats d'erreur/succès des fonctions et obtenir un message d'erreur d'un code d'erreur - voir ci-dessous pour sa mise en œuvre partielle. Mais peut-être existe-t-il un meilleur moyen plus approprié?

//usage 
Status evtState = onMouseMove(); 
Status copyState = fileCopy(); 

class Status 
{ 
public: 
    static STATE registerState(const tstring &stateMsg) 
    { 
     states.emplace(stateMsg); 
     return states.hashValue(stateMsg); 
    } 

    Status(const STATE &state) : state(state) {} 
    ~Status() {} 

    string toString() 
    { 
     unordered_set<tstring>::const_iterator ele = states.find(state); 

     return (ele != states.end()) ? *ele : "Undefined"; 
    } 

    ostream& operator<<(Status& obj) 
    { 
     return cout << obj.toString(); 
    } 

private: 
    static unordered_set<tstring> states; 

    const STATE state; 
}; 

Answer 1

Il est possible de récupérer la fonction de hachage à partir d'un std::unordered_set et l'utiliser pour trouver la valeur de hachage d'une clé.

size_t h = myset.hash_function()("hello world"); 

Est-ce que le hachage de même si je lance mon programme et insérer 20 valeurs dans errorStates et quand je lance le programme et insérer 200?

La fonction de hachage par défaut pour un std::unordered_set<T> est std::hash<T>. Une des exigences pour ce modèle de classe indique:

La valeur retournée est fonction uniquement sur le k argument pour la durée du programme. [Note: Ainsi toutes les évaluations de l'expression h (k) avec la même valeur pour k donnent le même résultat pour un étant donné l'exécution du programme. Note -end]

Avec h étant un std::hash<T> et k étant un T. Mon interprétation de ceci est que dans toute exécution unique du programme la valeur de hachage pour une clé particulière sera la même. Cependant, sur une séquence d'exécutions, l'expression h(k) n'a pas besoin d'être la même.

Par conséquent le nombre de valeurs insérées ne changera pas la valeur de hachage d'une clé, mais uniquement dans une exécution particulière. Vous ne pouvez pas supposer que la valeur de hachage d'une clé restera la même sur plusieurs exécutions.

Answer 2

Puis-je obtenir le hachage de cette clé?

Bien sûr:

size_t hashval = errorState.hash_function()("File does not exist"); 

Est-ce que le hachage pour le fichier n'existe pas toujours la même chose? Le hachage serait-il le même si j'exécutais mon programme et insérais 20 valeurs dans errorStates et quand j'exécutais le programme et insérais 200?

Il ne changera pas au cours d'une seule exécution du programme. L'ajout de milliers d'éléments supplémentaires au std::set ne modifiera pas la valeur de hachage d'une clé. Toutefois, si vous réexécutez le même programme, les valeurs de hachage peuvent être différentes (randomisation de hachage q.v.). Et si vous exécutez le programme sur une machine différente ou même avec une implémentation de bibliothèque standard différente ...

L'idée est le hachage sera l'ID d'erreur unique et écrire le hachage dans un fichier.

Cela ne fonctionnera pas pour deux raisons:

1. Comme mentionné ci-dessus, les valeurs de hachage peut être différent dans deux exécutions différentes du même programme. Donc, ils ne devraient pas être persistés.

2. Les valeurs de hachage ne sont pas uniques. Il est tout à fait possible (et assez courant) que deux clés différentes aient la même valeur de hachage. Ceci est appelé "collision de hachage". (Voir "paradoxe d'anniversaire").