ich habe hier ein ziemlich komisches verhalten was mich jetzt schon einen Tag gekostet hat.
Ich moechte einen Graphen erstellen und benutze zum speichern der Knoten Vectoren in den jeweiligen Objekten und noch einen Vector um alle Knoten zu speichern.

class Node {

  int nummer;
  vector<Node> * to;
  ...
}

int main() {

vector<Node> * allNodes;
Node * actual;
...
}

Ich hoffe man kann die Datenstrucktur so erkennen.
Also mit actual zeige ich auf einen Knoten in allNodes um den zu veraendern und neue Links hinzuzufuegen.
Wenn dabei ein neuer Knoten entsteht wird er zusaetzlich zum anhaengen in den Node::to vector auch noch in allNodes angehaengt.

Das Problem ist jetzt, dass sich wenn ich einen Node in allNodes anhaenge und sich der Vector dafuer vergroessern muss sich Main::actual um ein Objekt in allNodes verschiebt, also auf das naechste Objekt im vector zeigt.

Wieso passiert dass ? Das hat doch bestimmt was mit den Speicherbereichen zu tun oder ?

size_t actual;

//Zugriff dann über:
Node& node = allNodes[actual];

Und ja, der Node-Zeiger wird ungültig beim Vergrößern, d.h. internem Umkopieren des std::vectors. (es kann sogar sein, daß er auf einen freigegebenen Bereich zeigt und es dann zu einer Speicherschutzverletzung kommen kann - oder aber sonstigem undefinierten Verhalten!!!)

Viele Fragen

Wenn ich schreibe:

Node & h = all[1];

sagt er mir

error: invalid initialization of reference of type ‘Node&’ from expression of type ‘std::vector<Node, std::allocator<Node> >’

Wofuer benutzt man dann ueberhaupt Vector ?

Wofuer benutzt man dann ueberhaupt Vector ?

Dort wo die konstante Zugriffszeit auf ein Element eine Rolle spielt, respektive wichtig ist. (Du must nicht die Hälfte aller Elemente passieren, wenn du das in der Mitte willst. Bei einer Liste ist das aber so).

Dann ist das doch keine Lösung

also ich brauche schnellen Zugriff auf jedes Objekt und ob ein Objekt in der Liste enthalten ist muss ich auch gelegentlich wissen.

also ich brauche schnellen Zugriff auf jedes Objekt

Sequentieller Container wie std::vector , std::deque : O(1)
Assoziativer Container wie std::set , std::map : O(log(n))

eicon111 schrieb:

und ob ein Objekt in der Liste enthalten ist muss ich auch gelegentlich wissen.

Sequentieller (unsortierter) Container: O(n)
Assoziativer Container: O(log(n))

Da du nur gelegentlich Elemente suchst, kannst du die lineare Zeitkomplexität dafür wahrscheinlich in Kauf nehmen. Ansonsten ausprobieren und Zeit messen...

Noch zum schnellen Zugriff auf jedes Objekt: Wirklich jedes beliebige? Sprichst du einzelne über den Index an?

Aus Java kenne ich ein HashSet was mir einen Zugriff und Suche in O(1) gewaehrleistet hat.
Sowas waere eine tolle Sache, ich hab da auch schon was gefunden komme aber nicht klar damit weil man da so viel selber einstellen muss Hashfunktion usw.

Also so war es gemeint:

vector<Node> allNodes;
size_t current;

//Zugriff dann über:
Node& node = allNodes[current];

Bei einem Zeiger müsstest du halt noch vorher dereferenzieren:

vector<Node> *allNodes;
size_t current;

//Zugriff dann über:
Node& node = (*allNodes)[current];

Gehört aber alles zu den Grundlagen der STL-Programmierung...

Zieh dir mal ein halbes Jahr C++ Grundlagen rein.

Ok mach ich.

i-am-tired schrieb:

sonst hilft vllt auch ein Konstrukt wie std::vector<shared_ptr<Node> > nodes;
dann kannste auch die Nachbarknoten als Vektor von shared_ptr auf Nodes verlinken... und hast trotzdem automatisches _aufräumen_ dabei

Das hoert sich interessant an, aber was sind shared_ptr ? hab ich noch nichts von gehoert.

Ich hab mich mal mit der std::hash_map auseinander gesetzt und benutze die jetzt, ist fuer meine Anwendung wohl das beste.
Danke fuer die vielen hilfreichen Antworten!

Gruesse

Also so war es gemeint:

vector<Node> allNodes;
size_t current;

//Zugriff dann über:
Node& node = allNodes[current];

...
Gehört aber alles zu den Grundlagen der STL-Programmierung...

Darf man mal naiv fragen, was die Referenz hier dem Zeiger voraus hat, wenn der Vektor umkopiert wird?

vector<Node> allNodes;
size_t current;

//Zugriff dann über:
Node& node = allNodes[current];

Ich meine hier besonders die Referenz. Hast du dir das gut überlegt?

Ok, etwas länger:
Die Referenz soll ja nur beim Zugriff temporär darauf benutzt werden - nicht als Member. Es ging ja darum, warum ein "Node-Zeiger" schlecht ist und darum besser ein Index als Variable benutzt werden soll.
Und ich habe nur gezeigt, wie man dann auf ein Element des std::vector mit Hilfe der Index-Variablen zugreift...

Daher ist auch ein Iterator nicht geeignet, ein aktuelles Element zu speichern (denn auch dieser wird beim internen Vergrößern (= Umkopieren) ungültig).

So, mehr habe ich hierzu nicht zu sagen -)

Ich meine hier besonders die Referenz. Hast du dir das gut überlegt?

Die Referenz wird ja nur gefährlich, wenn man während ihrer Lebensdauer den Container verändert und sie danach noch dereferenziert. Ich deklariere teilweise auch lokale Referenzen auf Containerelemente, z.B. wenn der Index komplexer berechnet wird.