Map mit Listen

*D*Evil

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

int main () 
{

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

   std::copy(map[42].begin(), map[42].end(), std::ostream_iterator<int>(std::cout, " "));
}

...

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

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

NoPanic2007

Das sieht gut aus!!! Danke

*D*Evil

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);

Braunstein

Das wird wohl nicht gehen. map hat schließlich keine random access iteratoren

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

NoPanic2007

Wenn man das Ganze dynamisch machen möchte, wie sieht das dann aus?

#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);

}

Braunstein

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

*D*Evil

dabei ist eine std::map schon ein dynamischer Container?! Was solln das ?!

Braunstein

Das ist natürlich die Frage.
Man sollte dynamische Speicherverwaltung nur anwenden, wenn man sie unbedingt braucht.

NoPanic2007

Kann das mal jemand erläutern!?

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

Braunstein

Ja klar bist du dann auf der sichern Seite (was immer das sein mag). Wir verstehen hier nur nicht, warum du unbedingt eine map dynamisch erstellen willst. Das macht hier einfach keinen Sinn.

NoPanic2007

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

Braunstein

Noch mal. Warum willst du eine map dynamisch erstellen? Was genau brauchst du was du nicht mit Referenzen machen kannst?

Simon2

NoPanic2007 schrieb:

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.

NoPanic2007

Okay, verstehe! Merci.

pumuckl

Wenn du dann auch noch den Teil des Programms, der nur ab und an benutzt wird, in eine eigene Funktion auslagerst und dort die Map lokal erzeugst, dann wird der Speicherplatz wie beabsichtigt nur dann belet wenn er gebraucht wird und automatisch nach Beenden der Funktion wieder verlassen. Damit sparst du gegenueber der dynamischen Verwaltung nicht nur den Arbeitsaufwand fuer new und delete sondern auch noch die 4 Byte fuer den Pointer