#include <boost/unordered_map.hpp>

ausgewählt. Gibt es eine bessere Lösung?
Jetzt möchte ich Objekte der Klasse

#include "Junction.h"

dort speichern:

typedef boost::unordered_map<int, Junction> map;
map jhashmap;

(oder typedef boost::unordered_map<int, &Junction> map; ???)

Da ich noch ein blutiger Anfänger bin, weiß ich nicht genau wie ich dort ein Objekt speichern kann (das soll beliebig oft wiederholt werden können):

int id; float x, y;
Junction *new_junc = new Junction(id, x, y);
jhashmap[id] = new_junc;

(oder jhashmap[id] = Junction(id, x, y);)

Geht das überhaupt? Wie mach ich das richtig?
Gruß

ich glaub du meinst das so oder?

typedef boost::unordered_map<int, Junction*> map;
map jhashmap;

/**************/

int id; float x, y;
// ich geh mal davon aus das id an dieser Stelle dann einen Wert hat
Junction *new_junc = new Junction(id, x, y);
jhashmap[id] = new_junc;
// oder
jhashmap[id] = new Junction(id, x, y);

sonst:

typedef boost::unordered_map<int, Junction> map;
map jhashmap;

int id; float x, y;
Junction junc(id, x, y);
jhashmap[id] = junc;
// oder
jhashmap[id] = Junction(id, x, y);

Gibt es einen Grund dafuer, nicht die HashMap aus dem TR1 zu nehmen, sondern eine zusaetzliche Abhaengigkeit zu boost aufzubauen? Siehe std::tr1::unordered_map...

Ob jetzt tr1, den auch nicht jeder Compiler hat, oder boost, was eh quasi jeder irgendwann installiert hat, um die zusätzliche Abhängigkeit kommt man nicht drumrum. Die unordered_map ist die gleiche.

Ob jetzt tr1, den auch nicht jeder Compiler hat, oder boost, was eh quasi jeder irgendwann installiert hat, um die zusätzliche Abhängigkeit kommt man nicht drumrum. Die unordered_map ist die gleiche.

Ich schreibe auch gerade eine kleine Bibliothek, bei der ich bewusst nur Funktionalität aus TR1 und kein Boost einsetze, weil eben ein relativ grosser Teil der Benutzer Boost wahrscheinlich nicht haben wird. Da ich eigentlich nur function , bind , shared_ptr und array benötige, ist das auch relativ gut möglich. Allerdings merke ich, dass mir Dinge wie BOOST_FOREACH fehlen...

Aber sonst (besonders wenn man ein Projekt für sich selbst macht) spielt es wirklich keine grosse Rolle.

@Peppie ja die sind gesetzt.
genau so hab ich auch gelöst.

@pumuckl ich parse eine xml datei.
Die Anzahl an Junction ist nicht bekannt, kann man es anders machen?

@knivil,pumuckl,Nexus
ich benutze sowieso eine Vielzahl an Boost Bibliotheken.
Gibt es einen Unterschied was man inkludiert?
Von der Funktionalität her sind die doch gleich oder nicht?
Es wird nur an einigen Rechnern installiert, die dafür konfiguriert werden.

@all wo liegt denn der große Unterschied wie man das jetzt macht:

typedef boost::unordered_map<int, Junction*> map;
map jhashmap;
...
int id; float x, y; // werden gesetzt
jhashmap[id] = new Junction(id, x, y);

oder

typedef boost::unordered_map<int, Junction> map;
map jhashmap;
...
int id; float x, y; // werden gesetzt
jhashmap[id] = Junction(id, x, y);

??? ich weiß, dass die erste Version Pointer speichert.
Was speichert denn die 2. Referenzen? (ne oder?)
Speicherverbrauch? Was nimmt man normalerweise?
Vielen Dank im voraus!!!

Bei Zeigern hast du immer den Nachteil, daß du selber wieder für die Speicherfreigabe verantwortlich bist, d.h. beim Löschen von Elementen mußt du dann explizit 'delete' für das Element aufrufen. Daher verwendet man in dem Fall dann auch besser boost::shared_ptr (bzw. aus TR1), da sich diese Klasse selber um die Freigabe kümmert. Dies sähe dann so aus:

boost::unordered_map<int, boost::shared_ptr<Junction> >

Aber wie schon oben geschrieben, benutze besser die 2. Variante, d.h.

boost::unordered_map<int, Junction>

for (IterE = EdgeList.begin(); IterE != EdgeList.end(); ++IterE) {

   hashmap::const_iterator j_iter = junction_map.find(IterE->getFrom());

   if (j_iter != junction_map.end()) {
     cout << typeid ((*j_iter).second).name() << endl;
     cout << (*j_iter).second; // operator << für die Klasse Junktion ist überladen und gibt alles aus.
     cout << ((Junction)(*j_iter).second).getId() << endl;
     } else
        cout << "Junction not found!" << endl;
   }

In dem Beispiel läuft alles.
Ist das so State of the Art ? oder gibt es bessere Methoden?
Vielen Dank an alle!!!

Gibt es einen Grund dafuer, nicht die HashMap aus dem TR1 zu nehmen, sondern eine zusaetzliche Abhaengigkeit zu boost aufzubauen? Siehe std::tr1::unordered_map...

Boost zu benutzen, ist gar keine so blöde Idee, finde ich -- zumal MSVC und G++ sich nicht einigen konnten ( <unordered_map> versus <tr1/unordered_map> )