Größenbeschränkung für std::vector



  • Angenommen ich habe in einer Klasse eine member-Variable
    std::vector<string> member_vector;

    und innerhalb einer Funktion der Klasse einen temporären vector
    std::vector<string> tmp_vector;

    Gibt es für diese beiden eigentlich irgendwelche Größenbeschränkungen (z.B. stack-Größe)?
    Bzw. ist folgende Aktion OK / problemlos?

    member_funktion:

    std::vector<string> tmp_vector;
    for( std::vector<string>::iterator it = member_vector.begin(); it != member_vector.end(); ++it )
    	tmp_vector.push_back( *it );
    member_vector.swap( tmp_vector );
    


  • EOP schrieb:

    Angenommen ich habe in einer Klasse eine member-Variable
    std::vector<string> member_vector;

    und innerhalb einer Funktion der Klasse einen temporären vector
    std::vector<string> tmp_vector;

    Gibt es für diese beiden eigentlich irgendwelche Größenbeschränkungen (z.B. stack-Größe)?
    Bzw. ist folgende Aktion OK / problemlos?

    member_funktion:

    std::vector<string> tmp_vector;
    for( std::vector<string>::iterator it = member_vector.begin(); it != member_vector.end(); ++it )
    	tmp_vector.push_back( *it );
    member_vector.swap( tmp_vector );
    

    Größenbeschränkungen gibt es theoretisch (bzw. laut Standard) nicht, praktisch ist der freie Speicher der limitierende Faktor (die Container fordern den Speicher dynamisch an, also nicht auf dem Stack).

    Die Aktion ist Ok, problemlos und vor allem weitgehend sinnlos. Du erstellst einen neuen vector, kopierst die inhalte des alten 1 zu 1 dort hinein und vertauscht sie dann. Der Efeekt ist gleich null, wenn nicht gerade der alte vector viel mehr Speicher angefordert hatte als zu dem zeitpunkt benötigt. Sprich, du reduzierst höchstens die capacity. Das geht allerdings auch deutlich schneller mit dem copy-Ctor:

    member_vector.swap(std::vector<string>(member_vector));
    

    Für deine push_back-sequenz muss nach und nach immer neuer Speicher angefordert werden und dabei jedesmal der Inhalt des vectors in den neu angeforderten Speicher umkopiert werden - der copy-ctor fordert einmalig genügend speicher an und macht genau eine kopie pro element.



  • Größenbeschränkungen gibt es theoretisch (bzw. laut Standard) nicht, praktisch ist der freie Speicher der limitierende Faktor (die Container fordern den Speicher dynamisch an, also nicht auf dem Stack).

    Dankeschön, das wollte ich wissen.

    Der Rest war nur ein theoretisches Beispiel.
    In Wirklichkeit verwaltet der member_vector eine virtuelle CListCtrl und der tmp_vector wird für Aktionen wie z.B. Löschen aus der Liste benutzt:

    if( !delete_flag ) tmp_vector.push_back( *it ); ...swap
    

    Die Methode hat sich als die schnellste rausgestellt (bei mehreren Hunderttausend Zeilen).



  • Benutz remove_if()

    Deine Variante ist ja eine elegant wie eine handbremse 😉



  • EOP schrieb:

    Gibt es für diese beiden eigentlich irgendwelche Größenbeschränkungen (z.B. stack-Größe)?

    Nur als Ergänzung:
    Ein vector belegt nur mit seinen, ich sage mal Basisdaten, den Stack. Ich glaube ohne Ausnahme verwenden alle STL-Container [wie ist das beim std::tr1::array?] den Heap für die Daten. Du siehst davon nur nichts, da du als Anwender dieses Wissen eigentlich für die Verwendung nicht benötigst (IMHO ein Beispiel für eine gute Schnittstelle).



  • Shade Of Mine schrieb:

    Benutz remove_if()

    Deine Variante ist ja eine elegant wie eine handbremse 😉

    Schluck, das tat weh.

    Ich versprech' (wieder mal) mich zu bessern. 😉


  • Mod

    pumuckl schrieb:

    member_vector.swap(std::vector<string>(member_vector));
    

    Die Reihenfolge der Argumente beachten...

    std::vector<string>(member_vector).swap(member_vector);
    

Anmelden zum Antworten