carte de vecteurs dans la STL?

Je veux avoir une carte de vecteurs, (mais je ne veux pas utiliser un pointeur pour l'interne vecteur), est-il possible?

//define my map of vector
map<int, vector<MyClass> > map;

//insert an empty vector for key 10. # Compile Error
map.insert(pair<int, vector<MyClass> >(10, vector<MyClass>));

Je sais que si j'ai utilisé un pointeur pour vecteur, comme suit, ce serait bien, mais je me demande si je peux l'éviter à l'aide du pointeur et l'utilisation au-dessus de la structure de données (je ne veux pas supprimer manuellement)

//define my map of vector
map<int, vector<MyClass>* > map;

//insert an empty vector for key 10.
map.insert(pair<int, vector<MyClass>* >(10, new vector<MyClass>));

InformationsquelleAutor chen | 2009-09-04

c++stl

La première structure de données fonctionne. Vous pourriez typedef une partie du code pour en faire le futur travail plus facile:

typedef std::vector<MyClass>      MyClassSet;
typedef std::map<int, MyClassSet> MyClassSetMap;

MyClassSetMap map;
map.insert(MyClassSetMap::value_type(10, MyClassSet()));

ou (grâce quamrana):

map[10] = MyClassSet();

InformationsquelleAutor fbrereto

18

Oui, mais votre deuxième ligne doit être:
```
map.insert(pair<int, vector<MyClass> >(10, vector<MyClass>()));
```
Cela insère une paire composée de l'entier 10, et un vecteur vide. Les deux seront copiés, et si vous faites affaire avec de grands vecteurs alors vous aurez envie d'être prudent sur les copies.

Aussi: ne pas appeler les variables "carte" alors que using namespace std. Tu me fais peur 😉
- C'est encore plus facile à écrire map.insert( std::make_pair( 10, vector<MyClass>() ) );
- oui, je voulais dire "doit" dans le sens de "se débarrasser de l'erreur de compilation". fbrereton aussi fait de bons points à rendre le code plus concis.
- +1 pour la relève "à l'aide de la carte avec espace de noms std" 🙂 me fait Peur aussi
- pourquoi ne pas utiliser le type de l'intérieur de la carte. map::value_type!
- C'est encore plus facile à utiliser l'opérateur []. (voir ci-dessous)
InformationsquelleAutor Steve Jessop
6

En utilisant les typedefs de fbrereton vous pouvez également le faire:
```
typedef std::vector<MyClass>      MyClassSet;
typedef std::map<int, MyClassSet> MyClassSetMap;

MyClassSetMap map;
map[10]=MyClassSet();
```
Vous pouvez utiliser operator[] au lieu de insert(). Cela permet d'économiser sur le bruit de la ligne un peu.
- Je pense que vous vouliez dire carte[10] = MyClassSet(); en Fait, il devrait également être possible d'écrire juste la carte[10]; (pour ajouter un petit élément de surprise).
- Oups, oui, je vais corriger ça!
- Cela dépend de comment cela s'appelle. Insérez peut être plus rapide si vous savez qu'il y aura pas de conflits.
InformationsquelleAutor quamrana

Utiliser la fonction de permutation pour ajouter efficacement votre vecteur.

map<int, vector<SomeClass> > Map;

vector<SomeClass> vec;
//...add elements to vec

Map[1] = vector<int>();
//swap the empty vector just inserted with your vector.
Map[1].swap(vec);

InformationsquelleAutor Kurt Krueckeberg

4

^{Vous devriez lire les compiler des messages d'erreur. Habituellement, ils vous donne toutes les informations dont vous avez besoin.}

Votre code provoque une erreur 'illegal use of this type as an expression' dans cette chaîne. Cela signifie que vous utilisez le type, pas un objet. Pour utiliser un objet, vous pouvez simplement ajouter () pour appeler le constructeur sans arguments.
```
map.insert(pair<int, vector<MyClass> >(10, vector<MyClass>()));
```
Par la façon dont vous pourriez utiliser std::make_pair de créer des paires. Il en déduit les types d'argument, donc pas besoin d'indiquer explicitement eux.
```
map.insert( make_pair( 10, vector<MyClass>() ) );
```
- +1 pour la suggestion de lecture d'erreurs du compilateur. Cependant, ils sont spécifique au compilateur. Avec GCC, l'erreur est "expected primary-expression before ...", ce qui l'OMI a un sens générique de "quelque chose ne va pas ici" - vous avez juste besoin de prendre un bon coup d'oeil au code pour le comprendre. (Essayer de compiler avec différents compilateurs pourrait être une bonne idée, j'ai eu des messages d'erreur qui ne sont pas seulement clair, mais trompeuse, e.g "deuxième paramètre, c'est mal" où l'erreur était dans le premier paramètre.)
InformationsquelleAutor Kirill V. Lyadvinsky
3

Vous pouvez utiliser le bouton [] des opérateurs.

Ces va insérer la valeur dans la carte.
```
map[10]; //create the 10 element if it does not exist
         //using the default constructor.
```
Si vous allez utiliser, peu après leur construction:
```
std::vector<MyClass>&  v = map[10];
```
Maintenant ses construit et vous avez une référence à l'objet.

InformationsquelleAutor Martin York
3

Permet d'utiliser un peu de c++11);)
```
typedef std::vector<MyClass>      MyClassSet;
typedef std::map<int, MyClassSet> MyClassSetMap;

MyClassSetMap map;
map.emplace(myid, MyClassSet());
```
Pour savoir si c'était insérée, vous pouvez le faire:
```
const auto result = map.emplace(myid, MyClassSet());
return (result.second) 
? "Is_OK"
: "Maybe "+myid+" exists\n"; 
```
Et voici le phare de c++11 et cartes.... comment insérer dans cette carte une paire si il n'existe pas, et si elle existe il suffit d'insérer un nouvel élément dans le vecteur....
```
const auto result = map.emplace(myid, MyClassSet());
result.first->second.emplace(objSet);
```
Je l'espère, de donner une information utile!!!
- Si ma mémoire est bonne, la carte de la classe ne fournit pas "emplace_back" fonction (relativement appartient à vecteur et autres contenants). carte en d'autres mains "fournit des emplace" et "emplace_hint" fonctions
- Oui, complètement d'accord. Ediited, Merci!
InformationsquelleAutor GutiMac
2

Vous manque juste une paire de parenthèses:
```
map.insert(pair<int, vector<MyClass> >(10, vector<MyClass>()));
```
D'ailleurs, il y a une aide de la fonction std::make_pair qui prend soin de déduire les arguments de modèle:
```
map.insert(make_pair(10, vector<MyClass>()));
```
Envisage d'utiliser un pointeur alloué dynamiquement vecteur lieu est plutôt une mauvaise idée, car cela vous rendra responsable de la gestion de l'instance. Aussi, puisque la carte ne doit jamais déplacer son contenu autour de la mémoire, il n'y a rien à gagner en terme de performance ni.

InformationsquelleAutor UncleBens

//define my map of vector
map<int, vector<MyClass> > map;
MyClass *ptr = new MyClass();
map[0].push_back(ptr);

pousser des objets dans le vecteur de type Maclasse

//usage; map[0][vector_index]
map[0][0]->MyClassMember;

accéder aux fonctions de membre à l'aide de vector_index

InformationsquelleAutor VIPK

Vous devez vous connecter pour publier un commentaire.