ich möchte in einem "Map" neben "Int" Schlüsseln "list" bzw. "vector" Werte speichern. Ich suche eine Möglichkeit nachträglich listenelemente zu einem exitierenden Schlüssel einzutragen. Im folgende Code habe ich das versucht, nur werden durch "cout" nur die ersten zwei Elemente ausgegeben. Wie kann man das hinbekommen?

#include <iostream>
#include <string>
#include <list>
#include <map>
#include <utility>

using namespace std;

int main () {

    list<int> Liste;
    map<int, list<int> > myMap;

    Liste.push_back(11);
    Liste.push_back(22);

    myMap.insert(pair<int, list<int> >(42, Liste));

    Liste.push_back(33);
    Liste.push_back(44);
    Liste.push_back(55);

    for(list<int>::iterator it= myMap[42].begin(); it != myMap[42].end(); it++) 
        cout << *itera << endl;

return 0;
}

Danke für Hilfe!

Jo

Beim insert wird die Liste kopiert. Die Liste in der map weiß also nichts von den neu hinzugefügten Elementen. Du mußt die Liste in der map ansprechen.

myMap[42].push_back(33);
    myMap[42].push_back(44);
    myMap[42].push_back(55);

in dem Moment, wo du die Liste in die Map packst, wird von der Liste eine Kopie angefertigt. Die Kopie wird in die Map getan.

Du arbeitest da also mit einer anderen Liste weiter, nicht mit der, die in der Map ist.

Eine Lösung ist, Zeiger auf Listen zu verwenden:

std::map<int, std::list<int>*> myMap;

std::list<int>* p_list = new std::list<int>;

p_list->push_back(11);
p_list->push_back(22);

myMap[42] = p_list;

p_list->push_back(33);
p_list->push_back(44);
p_list->push_back(55);

// usw.

Da musst du nur nachher aufpassen, dass du die Listen auch mit delete wieder löschst!

so nicht?!

for(list<int>*::iterator it = myMap[42].begin(); it != myMap[42].end(); it++)
cout << *it << endl;

list<int>*::iterator

Was soll das denn sein?
Der Stern gehört da ja nun wirklich nicht hin!

Das geht dann natürlich so:

for(list<int>::iterator it = myMap[42]->begin(); it != myMap[42]->end(); it++)
{
    cout << *it << endl;
}

...

for (std::size_t i = 0; i < 10; ++i)
        map[42].push_back(i * 10 + i);

Was macht den map[42] genau? sucht das immer in der map nach nem key 42?
Dann wäre das aber sehr langsam

oO dann mach halt

std::map<std::size_t, std::list<int> >::iterator it = map.begin() + 42;
(*it).push_back(11);

std::map<std::size_t, std::list<int> >::iterator it = map.find(42);

#include <iostream>
#include <list>
#include <map>
#include <utility>
#include <iterator>
#include <algorithm>

int main () 
{

    std::list<int> list;
    typedef std::map<std::size_t, std::list<int> > myMap;
    myMap* map;

    map->insert(std::make_pair(42, list));
    for (std::size_t i = 0; i < 10; ++i)
        map[42].->(??????)push_back(i * 10 + i);

}

Wenn ich delete map; mache, bin ich dann auf der sicheren Seite? Oder wird da irgendwas nicht abgeräumt?

das ganze soll in ein grösseres programm eingegliedert werden und nur eventuell benutzt werden...

(Ich setze mal voraus, dass es Dir um "Speicherplatzminimierung" geht)
map verwaltet seine Elemente sowieso schon dynamisch (ist IIRC zwar nicht vorgeschrieben aber gängige Praxis) und sein "Verwaltungsteil" ist nicht besonders groß - da "spart" man am falschen Ende, wenn man die Map selbst per new allozierst.
Du kannst ja mal mit einem "sizeof()" nachsehen, wie viel Speicherplatz die map verwendet - ich bin sicher: Ist zu vernachlässigen.
Gleichzeitig kaufst Du Dir aber Probleme mit der dynamischen Speicherverwaltung ein (new ist sehr "laufzeitfressend", Verwaltung von new/delete ist aufwendig, Code wird durch Verwendung von "->"bzw. "*." unübersichtlich, ....), die es nicht wert sind.

Gruß,

Simon2.