Die gegebenen Antworten verketten sich nicht wirklich. Sie fügen eine Kopie hinzu. Es kann eine Verwendung (aus Sicht der Effizienz) geben, um eine std :: vector-Verkettungsmethode zu erstellen. Dies würde jedoch eine ausgefeilte gemeinsame Nutzung der Verwaltung der Knoten erfordern, und dies wurde wahrscheinlich auch nicht getan.
FauChristian
8
@FauChristian: Nein, aus Sicht der Effizienz kann es keine Verwendung geben. Der Vektorspeicher muss kontinuierlich sein, daher ist es unmöglich, was Ihnen vorgeschlagen wird. Wenn Sie "eine ausgefeilte gemeinsame Nutzung der Verwaltung der Knoten" wünschen und die Vektorklasse so ändern würden, würden Sie eine Deque erhalten. Selbst dann ist es sehr schwierig, den Speicher auf die vorgeschlagene Weise wiederzuverwenden, obwohl dies etwas praktikabler wäre. Ich denke nicht, dass es derzeit implementiert ist. Die Hauptsache ist, dass bei einer solchen gemeinsamen Nutzung von Verwaltungsknoten (einer Deque) der Endknoten teilweise leer sein kann.
Cookie
4
@lecaruyer Sie erkennen, dass Sie gerade eine Frage markiert haben, die zwei Jahre zuvor als Duplikat gestellt wurde
eshirima
9
Bin ich der einzige, der sich fragt, warum dies nicht als a + boder a.concat(b)in der Standardbibliothek implementiert ist ? Vielleicht wäre die Standardimplementierung suboptimal, aber jede Array-Verkettung muss nicht mikrooptimiert werden
oseiskar
9
Jahre der Evolution, die fortschrittlichste Überladung von Operatoren aller gängigen Sprachen, ein Template-System, das die Komplexität der Sprache verdoppelt, und dennoch lautet die Antwort nicht v = v1 + v2;
Ich würde nur Code hinzufügen, um zuerst die Anzahl der Elemente zu ermitteln, die jeder Vektor enthält, und Vektor1 als das Element mit dem größten Wert festlegen. Wenn Sie etwas anderes tun, kopieren Sie viel unnötig.
Joe Pineda
34
Ich habe eine Frage. Funktioniert dies, wenn Vektor1 und Vektor2 dieselben Vektoren sind?
Alexander Rafferty
6
Wenn Sie mehrere Vektoren zu einem verketten, ist es hilfreich, reservezuerst den Zielvektor aufzurufen ?
Faheem Mitha
33
@ AlexanderRafferty: Nur wenn vector1.capacity() >= 2 * vector1.size(). Was untypisch ist, wenn Sie nicht angerufen haben std::vector::reserve(). Andernfalls wird der Vektor neu zugewiesen, wodurch die als Parameter 2 und 3 übergebenen Iteratoren ungültig werden.
Drew Dormann
28
Es ist schade, dass es in der Standardbibliothek keinen prägnanteren Ausdruck gibt. .concatoder +=oder so
nmr
193
Wenn Sie C ++ 11 verwenden und die Elemente verschieben möchten, anstatt sie nur zu kopieren, können Sie sie std::move_iteratorzusammen mit Einfügen (oder Kopieren) verwenden:
#include<vector>#include<iostream>#include<iterator>int main(int argc,char** argv){
std::vector<int> dest{1,2,3,4,5};
std::vector<int> src{6,7,8,9,10};// Move elements from src to dest.// src is left in undefined but safe-to-destruct state.
dest.insert(
dest.end(),
std::make_move_iterator(src.begin()),
std::make_move_iterator(src.end()));// Print out concatenated vector.
std::copy(
dest.begin(),
dest.end(),
std::ostream_iterator<int>(std::cout,"\n"));return0;}
Dies ist für das Beispiel mit Ints nicht effizienter, da das Verschieben nicht effizienter ist als das Kopieren. Bei einer Datenstruktur mit optimierten Verschiebungen kann jedoch das Kopieren unnötiger Zustände vermieden werden:
#include<vector>#include<iostream>#include<iterator>int main(int argc,char** argv){
std::vector<std::vector<int>> dest{{1,2,3,4,5},{3,4}};
std::vector<std::vector<int>> src{{6,7,8,9,10}};// Move elements from src to dest.// src is left in undefined but safe-to-destruct state.
dest.insert(
dest.end(),
std::make_move_iterator(src.begin()),
std::make_move_iterator(src.end()));return0;}
Nach dem Verschieben bleibt das Element von src in einem undefinierten, aber zerstörungssicheren Zustand, und seine früheren Elemente wurden am Ende direkt auf das neue Element von dest übertragen.
Dieses Muster ist nützlich, wenn die beiden Vektoren nicht genau den gleichen Typ enthalten, da Sie anstelle von std :: back_inserter etwas verwenden können, um von einem Typ in den anderen zu konvertieren.
Die Kopiermethode ist nicht so gut. Push_back wird mehrmals aufgerufen, was bedeutet, dass wenn viele Elemente eingefügt werden müssen, dies mehrere Neuzuweisungen bedeuten kann. Es ist besser, Insert zu verwenden, da die Vektorimplementierung einige Optimierungen vornehmen kann, um Neuzuweisungen zu vermeiden. es könnte Speicher reservieren, bevor mit dem Kopieren begonnen wird
Yogesh Arora
7
@Yogesh: Zugegeben, aber nichts hindert Sie daran, reservezuerst anzurufen . Der Grund std::copyist manchmal nützlich, wenn Sie etwas anderes als verwenden möchten back_inserter.
Roger Lipscombe
Wenn Sie "Mehrfachzuweisungen" sagen, ist dies richtig - aber die Anzahl der Zuweisungen ist im schlechtesten Protokoll (Anzahl der hinzugefügten Einträge) -, was bedeutet, dass die Kosten für das Hinzufügen eines Eintrags in der Anzahl der hinzugefügten Einträge konstant sind. (Machen Sie sich im Grunde keine Sorgen, es sei denn, die Profilerstellung zeigt, dass Sie eine Reserve benötigen).
Martin Bonner unterstützt Monica
Möglicherweise möchten Sie stattdessen std :: transform verwenden.
Undefiniertes Verhalten, wenn a tatsächlich b ist (was in Ordnung ist, wenn Sie wissen, dass dies niemals passieren kann - aber es lohnt sich, sich des allgemeinen Codes bewusst zu sein).
Martin Bonner unterstützt Monica
1
@ MartinBonner Danke, dass du das erwähnt hast. Wahrscheinlich sollte ich mich wieder dem alten insertWeg zuwenden, der sicherer ist.
Deqing
15
Ah, der ANDERE std :: move. Ziemlich verwirrend, wenn Sie es zum ersten Mal sehen.
Xaxxon
1
Ist das anders als insert()bei move_iterators? Wenn das so ist, wie?
GPhilo
1
Ich habe eine Notiz darüber hinzugefügt, wovon std::movewir hier sprechen, da die meisten Leute diese Überlastung nicht kennen. Hoffe es ist eine Verbesserung.
Auch nicht Teil einer Frage, aber es ist ratsam, reservevor dem Anhängen zu verwenden , um eine bessere Leistung zu erzielen. Und wenn Sie den Vektor mit sich selbst verketten, ohne ihn zu reservieren, schlägt dies fehl, also sollten Sie es immer tun reserve.
@Asu ADL fügt nur hinzu, std::wenn der Typ von astammt std, wodurch der generische Aspekt zunichte gemacht wird .
Potatoswatter
guter Punkt. In diesem Fall ist es ein Vektor, also würde es sowieso funktionieren, aber ja, das ist eine bessere Lösung.
Asu
std :: begin () / end () wurden für Sammlungen (wie Arrays) hinzugefügt, die sie nicht als Mitgliedsfunktionen haben. Arrays haben aber auch keine insert () -Mitgliedsfunktion und rufen die Frage auf: "Gibt es eine Sammlung mit insert (), aber ohne begin () (was mit std :: begin () funktioniert)?"
James Curran
15
Mit Range v3 kann es zu einer verzögerten Verkettung kommen:
Ist das nicht dasselbe mit der Antwort von Tom Ritter und Robert Gamble im Jahr 2008?
IgNite
9
Eine allgemeine Leistungssteigerung für die Verkettung besteht darin, die Größe der Vektoren zu überprüfen. Und füge den kleineren mit dem größeren zusammen.
So einfach, aber ich habe nie so darüber nachgedacht!
Zimano
2
Der Beispielcode ist falsch. v1.insert(v2.end()...verwendet einen Iterator in v2, um die Position in anzugeben v1.
David Stone
Sie können auch einen schnellen Tausch verwenden. @ DavidStone Ich habe es so bearbeitet, dass die Concat-Reihenfolge geändert werden kann. Ist es möglich, am Anfang eines Vektors zu addieren?
qwr
Sie können in den Anfang einfügen, aber das wird langsamer. Um wirklich zu "verketten", spielt die Reihenfolge jedoch normalerweise eine Rolle, und genau das müssen Sie tun.
David Stone
7
Wenn Sie Vektoren präzise verketten möchten, können Sie den +=Operator überladen .
Ähnliches append_movemit starker Garantie kann im Allgemeinen nicht implementiert werden, wenn der Verschiebungskonstruktor des Vektorelements werfen kann (was unwahrscheinlich, aber immer noch ist).
Verwenden T operator+(const T & a, const T & b)ist gefährlich, es ist besser zu verwenden vector<T> operator+(const vector<T> & a, const vector<T> & b).
Matthieu H
4
Es gibt einen Algorithmus std::mergeaus C ++ 17 , der sehr einfach zu bedienen ist.
Ich denke nicht, dass es einfacher zu verwenden ist als std::vector::insert, aber es hat etwas anderes zu tun : zwei Bereiche zu einem neuen Bereich zusammenzuführen, anstatt einen Vektor am Ende eines anderen einzufügen. Erwähnenswert in der Antwort?
jb
4
Wenn Sie lediglich den Wertebereich für schreibgeschützte Zwecke durchlaufen möchten, besteht eine Alternative darin, beide Vektoren um einen Proxy (O (1)) zu wickeln, anstatt sie zu kopieren (O (n)), damit sie sofort angezeigt werden als eine einzige, zusammenhängende.
Dieses Code-Snippet kann das Problem zwar lösen, erklärt jedoch nicht, warum oder wie es die Frage beantwortet. Bitte geben Sie eine Erklärung für Ihren Code an , da dies wirklich zur Verbesserung der Qualität Ihres Beitrags beiträgt. Flagger / Rezensenten: Für Nur-Code-Antworten wie diese, Downvote, nicht löschen! (Hinweis: Diese Antwort kann tatsächlich einfach genug sein, um eine Erklärung und damit Abstimmungen unnötig zu machen. Möglicherweise möchten Sie noch eine Erklärung hinzufügen, um weitere NAA / VLQ-Flags zu verhindern.)
Scott Weldon
2
Ich habe diese Funktion implementiert, die eine beliebige Anzahl von Containern verkettet, von rvalue-Referenzen abweicht und auf andere Weise kopiert
namespaceinternal{// Implementation detail of Concatenate, appends to a pre-reserved vector, copying or moving if// appropriatetemplate<typenameTarget,typenameHead,typename...Tail>voidAppendNoReserve(Target* target,Head&& head,Tail&&... tail){// Currently, require each homogenous inputs. If there is demand, we could probably implement a// version that outputs a vector whose value_type is the common_type of all the containers// passed to it, and call it ConvertingConcatenate.static_assert(
std::is_same_v<typename std::decay_t<Target>::value_type,typename std::decay_t<Head>::value_type>,"Concatenate requires each container passed to it to have the same value_type");ifconstexpr(std::is_lvalue_reference_v<Head>){
std::copy(head.begin(), head.end(), std::back_inserter(*target));}else{
std::move(head.begin(), head.end(), std::back_inserter(*target));}ifconstexpr(sizeof...(Tail)>0){AppendNoReserve(target, std::forward<Tail>(tail)...);}}template<typenameHead,typename...Tail>size_tTotalSize(constHead& head,constTail&... tail){ifconstexpr(sizeof...(Tail)>0){return head.size()+TotalSize(tail...);}else{return head.size();}}}// namespace internal/// Concatenate the provided containers into a single vector. Moves from rvalue references, copies/// otherwise.template<typenameHead,typename...Tail>autoConcatenate(Head&& head,Tail&&... tail){size_t totalSize =internal::TotalSize(head, tail...);
std::vector<typename std::decay_t<Head>::value_type> result;
result.reserve(totalSize);internal::AppendNoReserve(&result, std::forward<Head>(head), std::forward<Tail>(tail)...);return result;}
Wenn Sie nach einer Möglichkeit suchen, einen Vektor nach der Erstellung an einen anderen anzuhängen, vector::insertist dies die beste Wahl, wie bereits mehrfach beantwortet wurde, zum Beispiel:
vector<int> first ={13};const vector<int> second ={42};
first.insert(first.end(), second.cbegin(), second.cend());
Leider gibt es keine Möglichkeit, eine zu konstruieren const vector<int>, wie oben müssen Sie dann konstruieren insert.
Wenn Sie tatsächlich nach einem Container suchen, der die Verkettung dieser beiden vector<int>s enthält, steht Ihnen möglicherweise etwas Besseres zur Verfügung, wenn:
Ihr vectorenthält Grundelemente
Ihre enthaltenen Grundelemente haben eine Größe von 32 Bit oder weniger
Du willst einen constContainer
Wenn alles oben Genannte zutrifft, würde ich vorschlagen, die basic_stringWho's zu char_typeverwenden, die der Größe des in Ihrem enthaltenen Primitivs entsprechen vector. Sie sollten ein static_assertin Ihren Code aufnehmen, um zu überprüfen, ob diese Größen konsistent bleiben:
Diese Lösung mag etwas kompliziert sein, hat aber boost-rangeauch einige andere nette Dinge zu bieten.
#include<iostream>#include<vector>#include<boost/range/algorithm/copy.hpp>int main(int,char**){
std::vector<int> a ={1,2,3};
std::vector<int> b ={4,5,6};
boost::copy(b, std::back_inserter(a));for(auto& iter : a){
std::cout << iter <<" ";}return EXIT_SUCCESS;}
Oft besteht die Absicht darin, den Vektor zu kombinieren aund bihn bei einer Operation einfach zu durchlaufen. In diesem Fall gibt es die lächerliche einfache joinFunktion.
#include<iostream>#include<vector>#include<boost/range/join.hpp>#include<boost/range/algorithm/copy.hpp>int main(int,char**){
std::vector<int> a ={1,2,3};
std::vector<int> b ={4,5,6};
std::vector<int> c ={7,8,9};// Just creates an iteratorfor(auto& iter : boost::join(a, boost::join(b, c))){
std::cout << iter <<" ";}
std::cout <<"\n";// Can also be used to create a copy
std::vector<int> d;
boost::copy(boost::join(a, boost::join(b, c)), std::back_inserter(d));for(auto& iter : d){
std::cout << iter <<" ";}return EXIT_SUCCESS;}
Für große Vektoren kann dies ein Vorteil sein, da nicht kopiert wird. Es kann auch zum Kopieren und Verallgemeinern in mehrere Container verwendet werden.
Aus irgendeinem Grund gibt es nichts Vergleichbares boost::join(a,b,c), was vernünftig sein könnte.
Um ehrlich zu sein, können Sie zwei Vektoren schnell verketten, indem Sie Elemente von zwei Vektoren in den anderen kopieren oder nur einen von zwei Vektoren anhängen!. Es hängt von Ihrem Ziel ab.
Methode 1: Zuweisen eines neuen Vektors mit seiner Größe ist die Summe der Größe zweier ursprünglicher Vektoren.
vector<int> concat_vector = vector<int>();
concat_vector.setcapacity(vector_A.size()+ vector_B.size());// Loop for copy elements in two vectors into concat_vector
Methode 2: Fügen Sie Vektor A hinzu, indem Sie Elemente von Vektor B hinzufügen / einfügen.
// Loop for insert elements of vector_B into vector_A with insert() function: vector_A.insert(vector_A .end(), vector_B.cbegin(), vector_B.cend());
Was fügt Ihre Antwort hinzu, das in anderen Antworten noch nicht angegeben wurde?
Mat
13
@Mat: Fettgedruckte Zeichen.
Marcv81
Wenn die ursprünglichen Vektoren danach nicht mehr benötigt werden, ist es möglicherweise besser, sie std::move_iteratorso zu verwenden , dass Elemente verschoben anstatt kopiert werden. (Siehe en.cppreference.com/w/cpp/iterator/move_iterator ).
a + b
odera.concat(b)
in der Standardbibliothek implementiert ist ? Vielleicht wäre die Standardimplementierung suboptimal, aber jede Array-Verkettung muss nicht mikrooptimiert werdenAntworten:
quelle
reserve
zuerst den Zielvektor aufzurufen ?vector1.capacity() >= 2 * vector1.size()
. Was untypisch ist, wenn Sie nicht angerufen habenstd::vector::reserve()
. Andernfalls wird der Vektor neu zugewiesen, wodurch die als Parameter 2 und 3 übergebenen Iteratoren ungültig werden..concat
oder+=
oder soWenn Sie C ++ 11 verwenden und die Elemente verschieben möchten, anstatt sie nur zu kopieren, können Sie sie
std::move_iterator
zusammen mit Einfügen (oder Kopieren) verwenden:Dies ist für das Beispiel mit Ints nicht effizienter, da das Verschieben nicht effizienter ist als das Kopieren. Bei einer Datenstruktur mit optimierten Verschiebungen kann jedoch das Kopieren unnötiger Zustände vermieden werden:
Nach dem Verschieben bleibt das Element von src in einem undefinierten, aber zerstörungssicheren Zustand, und seine früheren Elemente wurden am Ende direkt auf das neue Element von dest übertragen.
quelle
std::move(src.begin(), src.end(), back_inserter(dest))
?Ich würde die Einfügefunktion verwenden , so etwas wie:
quelle
Oder Sie könnten verwenden:
Dieses Muster ist nützlich, wenn die beiden Vektoren nicht genau den gleichen Typ enthalten, da Sie anstelle von std :: back_inserter etwas verwenden können, um von einem Typ in den anderen zu konvertieren.
quelle
reserve
zuerst anzurufen . Der Grundstd::copy
ist manchmal nützlich, wenn Sie etwas anderes als verwenden möchtenback_inserter
.Mit C ++ 11 würde ich es vorziehen, den Vektor b an a anzuhängen:
wann
a
undb
nicht überlappen undb
nicht mehr verwendet werden.Dies ist
std::move
von<algorithm>
, nicht das üblichestd::move
von<utility>
.quelle
insert
Weg zuwenden, der sicherer ist.insert()
beimove_iterator
s? Wenn das so ist, wie?std::move
wir hier sprechen, da die meisten Leute diese Überlastung nicht kennen. Hoffe es ist eine Verbesserung.quelle
Ich bevorzuge eine, die bereits erwähnt wird:
Wenn Sie jedoch C ++ 11 verwenden, gibt es noch einen allgemeineren Weg:
Auch nicht Teil einer Frage, aber es ist ratsam,
reserve
vor dem Anhängen zu verwenden , um eine bessere Leistung zu erzielen. Und wenn Sie den Vektor mit sich selbst verketten, ohne ihn zu reservieren, schlägt dies fehl, also sollten Sie es immer tunreserve
.Also im Grunde was Sie brauchen:
quelle
std::
wird durch argumentabhängige Suche abgeleitet .end(a)
wird genug sein.std::
wenn der Typ vona
stammtstd
, wodurch der generische Aspekt zunichte gemacht wird .Mit Range v3 kann es zu einer verzögerten Verkettung kommen:
Demo .
quelle
Sie sollten vector :: insert verwenden
quelle
Eine allgemeine Leistungssteigerung für die Verkettung besteht darin, die Größe der Vektoren zu überprüfen. Und füge den kleineren mit dem größeren zusammen.
quelle
v1.insert(v2.end()...
verwendet einen Iterator inv2
, um die Position in anzugebenv1
.Wenn Sie Vektoren präzise verketten möchten, können Sie den
+=
Operator überladen .Dann können Sie es so nennen:
quelle
Wenn Sie an einer starken Ausnahmegarantie interessiert sind (wenn der Kopierkonstruktor eine Ausnahme auslösen kann):
Ähnliches
append_move
mit starker Garantie kann im Allgemeinen nicht implementiert werden, wenn der Verschiebungskonstruktor des Vektorelements werfen kann (was unwahrscheinlich, aber immer noch ist).quelle
v1.erase(...
werfen?insert
kümmert sich schon darum. Außerdem entspricht dieser Aufruferase
von aresize
.Fügen Sie dieses Ihrer Header-Datei hinzu:
und benutze es so:
r enthält [1,2,62]
quelle
Hier ist eine Allzwecklösung mit C ++ 11-Verschiebungssemantik:
Beachten Sie, wie sich dies von
append
ing zu a unterscheidetvector
.quelle
Sie können Ihre eigene Vorlage für den Operator + vorbereiten:
Als nächstes - benutze einfach +:
Dieses Beispiel gibt folgende Ausgabe:
quelle
T operator+(const T & a, const T & b)
ist gefährlich, es ist besser zu verwendenvector<T> operator+(const vector<T> & a, const vector<T> & b)
.Es gibt einen Algorithmus
std::merge
aus C ++ 17 , der sehr einfach zu bedienen ist.Unten ist das Beispiel:
quelle
std::vector::insert
, aber es hat etwas anderes zu tun : zwei Bereiche zu einem neuen Bereich zusammenzuführen, anstatt einen Vektor am Ende eines anderen einzufügen. Erwähnenswert in der Antwort?Wenn Sie lediglich den Wertebereich für schreibgeschützte Zwecke durchlaufen möchten, besteht eine Alternative darin, beide Vektoren um einen Proxy (O (1)) zu wickeln, anstatt sie zu kopieren (O (n)), damit sie sofort angezeigt werden als eine einzige, zusammenhängende.
Siehe https://stackoverflow.com/a/55838758/2379625 für weitere Informationen, einschließlich der ‚VecProxy‘ Implementierung sowie Vor - und Nachteile.
quelle
quelle
Ich habe diese Funktion implementiert, die eine beliebige Anzahl von Containern verkettet, von rvalue-Referenzen abweicht und auf andere Weise kopiert
quelle
Wenn Sie nach einer Möglichkeit suchen, einen Vektor nach der Erstellung an einen anderen anzuhängen,
vector::insert
ist dies die beste Wahl, wie bereits mehrfach beantwortet wurde, zum Beispiel:Leider gibt es keine Möglichkeit, eine zu konstruieren
const vector<int>
, wie oben müssen Sie dann konstruiereninsert
.Wenn Sie tatsächlich nach einem Container suchen, der die Verkettung dieser beiden
vector<int>
s enthält, steht Ihnen möglicherweise etwas Besseres zur Verfügung, wenn:vector
enthält Grundelementeconst
ContainerWenn alles oben Genannte zutrifft, würde ich vorschlagen, die
basic_string
Who's zuchar_type
verwenden, die der Größe des in Ihrem enthaltenen Primitivs entsprechenvector
. Sie sollten einstatic_assert
in Ihren Code aufnehmen, um zu überprüfen, ob diese Größen konsistent bleiben:Wenn dies gilt, können Sie einfach Folgendes tun:
Weitere Informationen zu den Unterschieden zwischen
string
und findenvector
Sie hier: https://stackoverflow.com/a/35558008/2642059Ein Live-Beispiel für diesen Code finden Sie hier: http://ideone.com/7Iww3I
quelle
Diese Lösung mag etwas kompliziert sein, hat aber
boost-range
auch einige andere nette Dinge zu bieten.Oft besteht die Absicht darin, den Vektor zu kombinieren
a
undb
ihn bei einer Operation einfach zu durchlaufen. In diesem Fall gibt es die lächerliche einfachejoin
Funktion.Für große Vektoren kann dies ein Vorteil sein, da nicht kopiert wird. Es kann auch zum Kopieren und Verallgemeinern in mehrere Container verwendet werden.
Aus irgendeinem Grund gibt es nichts Vergleichbares
boost::join(a,b,c)
, was vernünftig sein könnte.quelle
Sie können dies mit vorimplementierten STL-Algorithmen tun, indem Sie eine Vorlage für eine polymorphe Verwendung verwenden.
Sie können den zweiten Vektor löschen, wenn Sie ihn nicht weiter verwenden möchten (
clear()
Methode).quelle
Um ehrlich zu sein, können Sie zwei Vektoren schnell verketten, indem Sie Elemente von zwei Vektoren in den anderen kopieren oder nur einen von zwei Vektoren anhängen!. Es hängt von Ihrem Ziel ab.
Methode 1: Zuweisen eines neuen Vektors mit seiner Größe ist die Summe der Größe zweier ursprünglicher Vektoren.
Methode 2: Fügen Sie Vektor A hinzu, indem Sie Elemente von Vektor B hinzufügen / einfügen.
quelle
std::move_iterator
so zu verwenden , dass Elemente verschoben anstatt kopiert werden. (Siehe en.cppreference.com/w/cpp/iterator/move_iterator ).setcapacity
? Was istfunction:
?resize
Methode.