web-dev-qa-db-fra.com

carte des vecteurs en STL?

Je veux avoir une carte des vecteurs, (mais je ne veux pas utiliser de pointeur pour le vecteur interne), est-ce 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é le pointeur pour le vecteur, comme suit, ce serait bien, mais je me demande si je peux éviter d'utiliser le pointeur et utiliser la structure de données ci-dessus (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>));
c++stl
24
chen

La première structure de données fonctionnera. Vous voudrez peut-être typedef une partie du code pour faciliter le travail futur:

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

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

ou (merci quamrana ):

map[10] = MyClassSet();
30
fbrereto

Oui, mais votre deuxième ligne devrait être:

map.insert(pair<int, vector<MyClass> >(10, vector<MyClass>()));

Cela insère une paire composée de l'entier 10 et d'un vecteur vide. Les deux seront copiés, et si vous avez affaire à de gros vecteurs, vous devrez faire attention aux copies.

Aussi: n'appelez pas les variables "map" pendant que using namespace std. Tu me fais peur ;-)

18
Steve Jessop

En utilisant les typedefs de fbrereton, vous pouvez également faire ceci:

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 économise un peu le bruit de ligne.

6
quamrana

Utilisez la fonction d'échange 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);
6
Kurt Krueckeberg

Vous devriez lire les messages d'erreur de compilation. Ils vous donnent généralement toutes les informations dont vous avez besoin.
Votre code donne une erreur 'illegal use of this type as an expression' dans cette chaîne. Cela signifie que vous utilisez du type, pas un objet. Pour utiliser un objet, vous pouvez simplement ajouter () pour appeler le constructeur sans argument.

map.insert(pair<int, vector<MyClass> >(10, vector<MyClass>()));

Au fait, vous pouvez utiliser std :: make_pair pour créer des paires. Il déduit les types d'arguments, donc pas besoin de les indiquer explicitement.

map.insert( make_pair( 10, vector<MyClass>() ) );
4
Kirill V. Lyadvinsky

Vous pouvez utiliser les opérateurs [].
Ceux-ci insèrent 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 de temps après la construction, alors:

std::vector<MyClass>&  v = map[10];

Maintenant, il est construit et vous avez une référence locale à l'objet.

3
Martin York

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 cela a été inséré, vous pouvez faire:

const auto result = map.emplace(myid, MyClassSet());
return (result.second) 
? "Is_OK"
: "Maybe "+myid+" exists\n";

Et voici le vaisseau amiral de c ++ 11 et des cartes .... comment insérer dans cette carte une paire si elle 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);

J'espère donner une information utile !!!

3
GutiMac

Il vous manque juste une paire de parenthèses:

map.insert(pair<int, vector<MyClass> >(10, vector<MyClass>()));

Par ailleurs, il existe une fonction d'assistance std :: make_pair qui s'occupe de déduire les arguments du modèle:

map.insert(make_pair(10, vector<MyClass>()));

Envisager d'utiliser un pointeur vers un vecteur alloué dynamiquement à la place est une assez mauvaise idée, car cela vous rendra responsable de la gestion de l'instance. De plus, étant donné que la carte ne doit jamais déplacer son contenu en mémoire, il n'y a rien non plus à gagner en termes de performances.

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

pousser des objets dans un vecteur de type MyClass

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

accès aux fonctions membres à l'aide de vector_index

0
VIPK