vielleicht ist dies ja ein Standardproblem, und falls mich jemand auf entprechende Literatur hinweisen kann, waere ich sehr dankbar.

Ich moechte einen Baum aufbauen und verschiedene Pfade durch Pfade durch den Baum speichern (um sie spaeter bearbeiten zu koennen). Ich weiss zur Zeit der Implementierung noch nicht, wieviele Kinder ein Knoten bekommt, deswegen habe ich sie als vector<Foo> vorliegen, etwa so:

class Foo {
  [...]
  private: std::vector<Foo>  children;
  [...]
}

Um die Pfade zu speichern, benutze ich einen

vector<vector<Foo*> > paths;

(oder auch einen iterator statt Foo*).

Das Problem:
Wenn 'children' ueber seine Kapazitaet waechst, werden die Zeiger in 'paths', die auf die Foos in dem entsprechenden vector zeigen, ungueltig.

Ich sehe drei Moeglichkeiten:

1. Bevor ich ein 'children' durch push_back o.ae. veraendere, vergleiche ich capacity() und size(). Wenn der vector vergroessert werden muss, passe ich die entsprechenden Zeiger an - das erscheint mir sehr, sehr aufwendig, v.a. das Herausfinden, welche Zeiger aus paths gerade auf das 'children' zeigen, welches veraendert wird.
2. Ich reserviere viel Platz fuer 'children', damit es waehrend der Laufzeit nicht zu einem 'resize' kommt - falls doch, koennte ich eine exception werfen und das Programm zumindest abbrechen lassen
3. Ich lasse 'children' ganz weg und speichere die Wege durch den Baum direkt als Objecte, also 'vector<vector<Foo>> - dadurch wird der Baum jedoch doppelt und dreifach gespeichert.

Obwohl mein Baum vermutlich nicht sehr gross wird, so dass 2)+3) moeglich waeren, bin ich mit diesen beiden Punkten als Loesung sehr unzufrieden.
Und bei Punkt 1 koennte ich dann doch auf Fortran oder C zurueckgreifen und statische Arrays benutzen. Das wirkt mir auch nicht korrekt.

Die Frage:

Kann mir jemand sagen, wie man so ein Problem korrekt und elegant in C++ implementiert?
Vielen Dank fuer jegliche Hinweise

std::vector<int&> refs;

Das allein erzeugt schon Unmengen an Fehlermeldungen.
Der zweite Versuch,

std::vector<int> refs;
int i = 4;
int &r = i;

refs.push_back(r);

Speichert (wie erwartet) eine Kopie von r, und nicht r selber, so dass Aenderungen an i oder r nicht in refs widergespiegelt werden.

Koennte ich da noch einen Hinweis bekommen, bitte?

Vielen Dank!

Das funktioniert ohne Probleme!

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec;
    std::vector<int*> vptr;

    vec.reserve(3);

    for(int run = 0; run < 2; ++run) {
        std::cout << "Kapazitaet von vec: " << vec.capacity()
            << " Groesse: " << vec.size() << '\n';
        for(int i = 0; i < 3; ++i) {
            vec.push_back(i);
            vptr.push_back(& vec.back());
        }

        // Kontrolle:
        std::cout << "Adressenvergleich:\n";
        for (unsigned int i = 0; i < vec.size(); ++i) {
            std::cout << "vec[" << i << "]: " << &(vec[i])
                << " vptr[" << i << "]: " << vptr[i] << '\n';
        }
    }

    return 0;
}

Ausgabe:

Kapazitaet von vec: 3 Groesse: 0
Adressenvergleich:
vec[0]: 0x804c008 vptr[0]: 0x804c008
vec[1]: 0x804c00c vptr[1]: 0x804c00c
vec[2]: 0x804c010 vptr[2]: 0x804c010
Kapazitaet von vec: 3 Groesse: 3
Adressenvergleich:
vec[0]: 0x804c1e8 vptr[0]: 0x804c008
vec[1]: 0x804c1ec vptr[1]: 0x804c00c
vec[2]: 0x804c1f0 vptr[2]: 0x804c010
vec[3]: 0x804c1f4 vptr[3]: 0x804c1f4
vec[4]: 0x804c1f8 vptr[4]: 0x804c1f8
vec[5]: 0x804c1fc vptr[5]: 0x804c1fc

Beim zweiten Durchlauf muss 'vec' vergroessert werden. Da er dadurch an einen nichtdefinierten, neuen Bereich im Speicher verschoben wird (damit er weiter zusammenhaengend bleiben kann), verlieren die gespeicherten Zeiger ihre Bedeutung.
Ich muesste vor jeden 'vec.push_back' die Kapazitaet abfragen, und wenn sie die Groesse des vectors erreicht hat, vptr neu erstellen, nachdem vec reallokiert wurde.
Das suchte ich zu vermeiden.

Als Lösung kannst du entweder verhindern, daß der Vector neuen Speicher anfordert (dazu sagst du ihm vorher per reserve(), wieviel er benötigen wird), oder einen anderen Container verwenden (wenn du nur mit push_back() Elemente einfügen willst, geht ein deque<>, ansonsten mußt du eine list<> verwenden).

Das Problem kannst du mit vector'en nicht lösen - die Adresse der Elemente ändert sich, wenn der Vector mehr Speicherplatz anfordern muß.

Das hatte ich ja auch schon erkannt und beschrieben.

CStoll schrieb:

Als Lösung kannst du entweder verhindern, daß der Vector neuen Speicher anfordert (dazu sagst du ihm vorher per reserve(), wieviel er benötigen wird),

Mit reserve() kann ich nur die Mindest-Kapazitaet festlegen, nicht verhindern, dass der vector darueber hinaus waechst.

CStoll schrieb:

oder einen anderen Container verwenden (wenn du nur mit push_back() Elemente einfügen willst, geht ein deque<>, ansonsten mußt du eine list<> verwenden).

deque scheint mein Problem zu loesen. Vielen Dank!

CStoll schrieb:

Als Lösung kannst du entweder verhindern, daß der Vector neuen Speicher anfordert (dazu sagst du ihm vorher per reserve(), wieviel er benötigen wird),

Mit reserve() kann ich nur die Mindest-Kapazitaet festlegen, nicht verhindern, dass der vector darueber hinaus waechst.

Nein, dafür mußt du selber sorgen. (Der Ansatz mit reserve() funktioniert nur, wenn du vorher die maximale Füllung deines Vector's kennst)

CStoll schrieb:

oder einen anderen Container verwenden (wenn du nur mit push_back() Elemente einfügen willst, geht ein deque<>, ansonsten mußt du eine list<> verwenden).

deque scheint mein Problem zu loesen. Vielen Dank!

Na dann ist es doch in Ordnung

(Aber Jesters Vorschlag hat auch etwas für sich, wenn du dich persönlich um die Speicherverwaltung kümmern willst)

Kann ich sicher davon ausgehen, dass die Elemente ihre Adresse waehrend der Laufzeit des Programmes / innerhalb des Scopes nicht aendern, oder koennte die Compiler-abhaengig sein?