C++ unordered_map échouer lorsqu'il est utilisé avec un vecteur clé

Contexte: je suis en venant du monde Java et je suis assez novice en C++ et Qt.

Afin de jouer avec unordered_map, j'ai écrit le programme simple suivant:

#include <QtCore/QCoreApplication>
#include <QtCore>
#include <iostream>
#include <stdio.h>
#include <string>
#include <unordered_map>

using std::string;
using std::cout;
using std::endl;
typedef std::vector<float> floatVector;

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);

    floatVector c(10);
    floatVector b(10);

    for (int i = 0; i < 10; i++) {
        c[i] = i + 1;
        b[i] = i * 2;
    }

    std::unordered_map<floatVector, int> map;

    map[b] = 135;
    map[c] = 40;
    map[c] = 32;

    std::cout << "b -> " << map[b] << std::endl;
    std::cout << "c -> " << map[c] << std::endl;
    std::cout << "Contains? -> " << map.size() << std::endl;

    return a.exec();
}

Malheureusement, je suis en cours d'exécution dans ce qui suit d'erreur qui n'est pas inspirant. Il n'est même pas un numéro de ligne.

:-1: erreur: collect2: ld a retourné 1 code de sortie

Aucune idée de l'origine du problème?

Merci d'avance.

Vous avez besoin d'une fonction de hachage qui prend un vector<float>
Ce n'est pas un échec d'exécution.
C'était ce à quoi j'ai pensé que le problème était à venir. Cependant, il me semble qu'une classe de base comme vecteur doit avoir un défaut de fonction de hachage. Si ce n'est pas le cas, pourriez-vous m'expliquer comment fournir de l'un ou de m'indiquer un peu de matériel. Merci!!!!
Valable et intéressante question, mais je ne vois pas un cas d'utilisation où il sera intelligent pour utiliser une liste de clé dans une carte.
L'int est le résultat d'un gros calcul à partir de laquelle le vecteur est l'entrée. Le résultat une fois calculé besoin de l'accès à de nombreuses reprises et rapidement.

OriginalL'auteur Pierre-Antoine | 2012-05-01

c++c++11 qt unordered-map vector

26

§23.2.5, paragraphe 3, dit:

Non ordonnée de chaque conteneur associatif est paramétrée par Key, par une fonction du type d'objet Hash qui répond aux exigences de Hachage (17.6.3.4) et agit comme une fonction de hachage pour l'argument des valeurs de type Key, et par un prédicat binaire Pred qui induit une relation d'équivalence sur des valeurs de type Key.

À l'aide de vector<float> comme Key et ne fournissant pas explicite de hachage et de l'équivalence de prédicat types de moyens par défaut std::hash<vector<float>> et std::equal_to<vector<float>> sera utilisé.

La std::equal_to pour la relation d'équivalence est très bien, parce qu'il est un opérateur == pour les vecteurs, et c'est ce que std::equal_to utilise.

Il existe, cependant, aucune std::hash<vector<float>> de la spécialisation, et c'est sans doute que l'éditeur de liens d'erreur que vous n'avez pas de nous montrer le dit. Vous devez fournir votre propre hasher pour que cela fonctionne.

Un moyen facile d'écrire un tel hasher est d'utiliser boost::hash_range:
```
template <typename Container> //we can make this generic for any container [1]
struct container_hash {
    std::size_t operator()(Container const& c) const {
        return boost::hash_range(c.begin(), c.end());
    }
};
```
Ensuite, vous pouvez utiliser:
```
std::unordered_map<floatVector, int, container_hash<floaVector>> map;
```
Bien sûr, si vous avez besoin de différents sexes de la sémantique dans la carte, vous devez définir la valeur de hachage et de la relation d'équivalence de façon appropriée.

_{1. Cependant, évitez ce pour le hachage non ordonnée des conteneurs, comme les différentes commandes de produire différents de la cendre, et l'ordre dans non ordonnée conteneur n'est pas garanti.}

Merci beaucoup cela a résolu mon problème. Note pour les personnes qui auraient le même problème: pour utiliser boost::hash_range vous devez #include <boost/fonctionnel/de hachage.hpp>
C'est littéralement la première chose sur cette page de doc. ;-]
Je pense que ce que cela signifie, c'est que l'appel de hash_range (unordered_container) est une mauvaise idée, car il peut produire des résultats différents à chaque fois.
mais pourquoi ne map<vector<int>, int> travail?
C'est parce que la carte utilise le rouge et le noir des arbres à l'arrière-plan et n'est pas concerné par le type de données stockées. Alors que, unordered_map essentiellement besoin d'une fonction de hachage. Et il ne peut être calculée qu'une fois le type de données stockées dans le vecteur est avérée.

OriginalL'auteur R. Martinho Fernandes
2

J'ai trouvé R. Martinho Fernandes réponse inadaptée pour les compétitions de programmation, car la plupart du temps, vous aurez à traiter avec un IDE et ne peut pas utiliser une bibliothèque externe comme boost. Vous pouvez utiliser la méthode suivante si vous souhaitez faire le meilleur de la STL.

Comme déjà indiqué ci-dessus, il vous suffit d'écrire une fonction de hachage. Et il doit se spécialiser pour le type de données stockées dans votre vecteur. Suivants en fonction de hachage suppose int type de données:
```
struct VectorHasher {
    int operator()(const vector<int> &V) const {
        int hash=0;
        for(int i=0;i<V.size();i++) {
            hash+=V[i]; //Can be anything
        }
        return hash;
    }
};
```
Notez que vous pouvez utiliser tout type d'opération à générer un hachage. Vous avez juste besoin d'être créatif, de sorte que les collisions sont réduites au minimum. Par exemple, hash^=V[i], hash|=V[i], hash+=V[i]*V[i] ou même hash+=(V[i]<<i)*(V[i]<<i)*(V[i]<<i) sont valides jusqu'à ce que, bien sûr, votre hash n'a pas de débordement.

Enfin pour utiliser cette fonction de hachage avec votre unordered_map, l'initialiser comme suit:
```
unordered_map<vector<int>,bool,VectorHasher> hashMap;
```
OriginalL'auteur Chirag Arora

Vous devez vous connecter pour publier un commentaire.