Ich hätte gerne das Array test[10] auch durch einen vector ersetzt, habe aber keine Ahnung wie ich das definieren und deklarien soll und nachher darauf zugreifen.
Oder ob es überhaupt geht.
Ich möchte das ich nicht von vorne herein wissen müssen wieviel test[] Arrays ich anlegen muss, evtl. will ich auch wieder welche löschen können.

Ich meine damit nicht die Unter-Vectoren test[0][UnterVector].irgendwas kann ich
wie einen Vector behandeln, aber
test[Array][x].irgendwas kann ich nur als Array benutzen.

Ich hoffe ich hab mich klar ausgedrückt.

struct mytest{
    int irgendwas;
    int sonstwas;
};

int main() {
    vector <mytest> test[ 10 ];
    mytest demo;

    demo.irgendwas = 1;
    demo.sonstwas = 2;
    test[0].push_back(demo);

    demo.irgendwas = 11;
    demo.sonstwas = 22;
    test[0].push_back(demo);

    demo.irgendwas = 100;
    demo.sonstwas = 200;
    test[1].push_back(demo);

    for (int i = 0 ;i <= 1 ; i++ ) {
        cout  <<  test[0][i].irgendwas << endl;
        cout  <<  test[0][i].sonstwas << endl;
    } 
    cout  <<  test[1][0].irgendwas << endl;
    cout  <<  test[1][0].sonstwas << endl;

}

Ich hoffe ich hab mich klar ausgedrückt.

nicht wirklich

willst du sowas?
vector< vector<mytest> > test;?

Nimm einen "vector<vector<mytest> > test;" (und pass die Größe hinterher mit resize() und ähnlichem an.

vector<vector<mytest> > test(10);

Jetzt hab ich nur noch ein Problem,

vector<vector<mytest> > test2(10);
mytest demo;
test[0].push_back(demo);

funktioniert wie oben, auch das auslesen
test[0][0] ... test[9][x]

aber wenn ich z.B.
test[2].clear() oder test[2].erase()
benutze, ist der Wert später immer noch drin.

benutze ich test.clear() ist alles gelöscht.
Überprüfe ich danach die Größe mit .size()
ergibt sich bei
test.size() = 0
bei
test[2].size() = immernoch die alte Größe z.B. 2

btw:

Nussknacker schrieb:

benutze ich test.clear() ist alles gelöscht.
Überprüfe ich danach die Größe mit .size()
ergibt sich bei
test.size() = 0
bei
test[2].size() = immernoch die alte Größe z.B. 2

Das fällt wohl unter "undefined behaviour" - du greifst auf Elemente zu, die nicht (mehr) dem vector gehören.

benutze ich test.clear() ist alles gelöscht.
Überprüfe ich danach die Größe mit .size()
ergibt sich bei
test.size() = 0
bei
test[2].size() = immernoch die alte Größe z.B. 2

Leichenfledderei.

test[1].erase(test[1].begin()+1); funktioniert

hatte es vorher so:
test2[1].erase(test2.begin()+1);

nur test2[1].clear() funktioniert nicht, aber dafür kann ich ja erase() benutzen.

Nochmal danke für eure Hilfe.

nur test2[1].clear() funktioniert nicht, aber dafür kann ich ja erase() benutzen.

Nicht? was liefert denn danach ein test2[1].size() ? Wenns 0 ist, hats funktioniert. Dass du evtl. mit test2[1][4] dann noch Werte bekommst ist dann Pech (weils so aussieht als ob es nicht geklappt haette) oder Glueck (dass dir das programm nicht gleich um die Ohren fliegt), denn der operator[] prueft die indexgrenzen nicht, man kann also durchaus Indizes angeben, die nicht im vector sind (hier die 4). Was dabei rauskommt ist allerdings undefiniert.

Größen vor clear()
test.size() = 10
test[0].size() = 2
test[1].size() = 3
test[2].size() = 4

benutze ich test.clear()
dann sind die Größen:
test.size() = 0
test[0].size() = 2
test[1].size() = 3
test[2].size() = 4

benutze ich test[1].clear()
dann sind die Größen:
test.size() = 10
test[0].size() = 0
test[1].size() = 0
test[2].size() = 0

Ich benutze den MinGW Compiler, evtl. ist es bei anderen Compilern anders.
Am besten ich benutze nur erase()
oder wenn ich alles löschen will eine Schleife welche zuerst test[0] - test[n] löscht
und danach test.clear() dann müsste alles auf NULL sein.

Ich hatte noch die alte Array Version im Programm und die vector<vector<>>
hinten angehängt, hab aber den Namen test2 genannt, von einem struct müsste man
doch mehrere Varianten ableiten können ?
Ich habe schon test2 für meine clear() Versuche verwendet und nicht test

Hier alte Array Version mit drin, so:

struct mytest {
    int irgendwas;
    int sonstwas;
} 

vector <mytest> test[ 10 ];
mytest demo;

vector<vector<mytest> > test2(10);

Aufgefüllt hab ich zuerst die Array Version mit demo und danach die vector<vector<>> Version, auch mit demo, aber demo ist ja nicht mit test oder test2 gekoppelt, oder versteh ich da was falsch ?

warum der Aufruf test[1].clear(); alle Elemente von test löschen sollte, ist mir ein Rätsel.

Tut er nicht. Wenn der vector mit vector<vector<X> > test(10); erstellt wurde, reserviert das dem aeusseren vector speuicher fuer 10 innere vectoren - die werden mit default-ctor initialisiert, also test[i].size() == 0 fuer i = 0..9.
Selbst wenn er wie oben geschrieben einmal test[0].push_back(demo); aufgerufen hat, bleiben die anderen inneren vectoren ja verschont.