STL Map avec un vecteur pour la clé

Je travaille avec des données binaires que j'ai stocké dans arbitrairement long de tableaux d'entiers non signés. J'ai trouvé que j'ai des doublons dans les données, et suis à la recherche à ignorer les doublons dans le court terme et retirez ce bug est en cause dans le long terme.

Je suis à la recherche lors de l'insertion de chaque jeu de données dans une carte avant de la stocker, mais seulement si elle n'a pas été trouvé dans la carte pour commencer avec. Ma première pensée a été d'avoir une carte de cordes et de l'utilisation memcpy comme un marteau pour forcer les services de renseignements dans un tableau de caractères, puis copiez-la dans une chaîne de caractères et de stocker la chaîne de caractères. Cela a échoué car une bonne partie de mes données contient plusieurs octets de 0 (aka NULL) à l'avant des données pertinentes, donc une majorité de très réel de données a été jetée.

Ma prochaine tentative est prévue pour être std::map<std::vector<unsigned char>,int>mais je me suis rendu compte que je ne sais pas si la carte insérer une fonction.

Est-ce faisable, même si mal conseillé, ou est-il une meilleure façon d'aborder ce problème?

Modifier

Ainsi, il a été fait remarquer que je n'ai pas de rendre clair ce que je fais, voici donc un espoir meilleure description.

Je suis en train de travailler sur la génération d'un minimum spanning tree, étant donné que j'ai un certain nombre d'arbres contenant de la fin effective des nœuds, je travaille avec. L'objectif est de venir avec la sélection des arbres qui a la durée la plus courte et qui couvre tous les nœuds finaux, où les arbres choisis de partager au plus un nœud avec les uns des autres et sont tous connectés. Je suis en basant mon approche hors d'un arbre de décision binaire, mais en y apportant quelques changements à l'espérons, permettre plus de parallélisme.

Plutôt que de prendre de l'arbre binaire approche que j'ai choisi de faire un vecteur de bits de des entiers non signés pour chaque jeu de données, où 1 dans une position de bit indique que l'inclusion de l'arbre correspondant.

Par exemple, si juste arbre 0 ont été inclus dans un 5 arbre dataset je voudrais commencer par

00001

À partir d'ici, je peux générer:

00011

00101

01001

10001

Chacun de ceux-ci peuvent ensuite être traitées en parallèle, depuis aucun d'entre eux dépendent les uns des autres. Je fais cela pour tous les arbres isolés (00010, 00100, etc..) et devrait, je n'ai pas pris le temps de le prouver formellement, être en mesure de générer toutes les valeurs dans la plage de 0,2^n) une fois et une seule fois.

J'ai commencé à remarquer que de nombreux ensembles de données ont été en prenant beaucoup plus de temps que je pensais qu'ils le devraient, et a permis une sortie de débogage à regarder tous les résultats générés, et un rapide script Perl plus tard, il a été confirmé que j'avais de multiples processus de génération de la même sortie. Depuis lors, j'ai essayé de résoudre où les doublons sont à venir à partir avec très peu de succès, et je suis en espérant que cela fonctionne assez bien pour me laisser vérifier les résultats qui sont générés sans, parfois, de 3 jours d'attente sur les calculs.

source d'informationauteur jthecie

c++map search stl vector

14

Vous n'aurez pas de problèmes avec cela, comme std::vector vous offre le "==", "<" et ">" opérateurs:

http://en.cppreference.com/w/cpp/container/vector/operator_cmp
6

La conditions pour être une clé dans std::map sont satisfaits par std::vectordonc oui, vous pouvez le faire. Sonne comme une bonne solution temporaire (facile à code, minimum de tracas) -- mais vous savez ce qu'ils disent: "il n'y a rien de plus permanent que temporaire".
2

Qui devrait fonctionner, comme Renan Greinert points, vector<> remplit les conditions pour être utilisé comme un map clé.

Vous dites aussi:

Je suis à la recherche lors de l'insertion de chaque jeu de données dans une carte avant de la stocker,
mais seulement si elle n'a pas été trouvé dans la carte pour commencer avec.

Ce n'est généralement pas ce que vous voulez faire, car cela impliquerait de faire un find() sur la carte, et si elle ne trouve pas, puis de faire un insert() opération. Ces deux opérations ont essentiellement pour trouver deux fois. Il vaut mieux juste pour essayer et insérer les éléments dans la carte. Si la clé est déjà là, l'opération échoue, par définition. Si votre code devrait ressembler à ceci:
```
#include <vector>
#include <map>
#include <utility>

//typedefs help a lot to shorten the verbose C++ code
typedef std::map<std::vector<unsigned char>, int> MyMapType;

std::vector<unsigned char> v = ...; //initialize this somehow
std::pair<MyMapType::iterator, bool> result = myMap.insert(std::make_pair(v, 42));
if (result.second)
{
   //the insertion worked and result.first points to the newly 
   //inserted pair
}
else
{
   //the insertion failed and result.first points to the pair that
   //was already in the map
}
```

Pourquoi avez-vous besoin d'une std::map pour qui? Peut-être que je manque un certain point, mais ce que sur l'utilisation d'un std::vector avec le find algorithme de examplained ici?

Cela signifie, que vous ajoutez à votre unsigned ints du vecteur et de la recherche plus tard, pour cela, par exemple,

std::vector<unsigned int> collector; //vector that is substituting your std::map
for(unsigned int i=0; i<myInts.size(); ++i) {  //myInts are the long ints you have
    if(find(collector.begin(), collector.end(), myInts.at(i)==collector.end()) {
         collector.push_back(myInts.at(i));
    }
}

Vous devez vous connecter pour publier un commentaire.