Verkettung von zwei std :: -Vektoren

686

Wie verkette ich zwei std::vectors?

Emlai
quelle
5
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;
Spike0xff

Antworten:

726
vector1.insert( vector1.end(), vector2.begin(), vector2.end() );
Robert Gamble
quelle
53
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")
    );

  return 0;
}

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())
    );

  return 0;
}

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.

Alex
quelle
6
Die Methode std :: make_move_iterator () hat mir beim Versuch geholfen, std :: -Vektoren von std :: unique_ptr zu verketten.
Knitschi
Was ist der Unterschied zwischen diesem und std::move(src.begin(), src.end(), back_inserter(dest))?
Kshenoy
77

Oder Sie könnten verwenden:

std::copy(source.begin(), source.end(), std::back_inserter(destination));

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.

Roger Lipscombe
quelle
7
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.
Martin Broadhurst
1
Kopie saugt viel, auch mit Zurückhaltung. vector :: insert vermeidet alle Überprüfungen: quick-bench.com/bLJO4OfkAzMcWia7Pa80ynwmAIA
Denis Yaroshevskiy
63

Mit C ++ 11 würde ich es vorziehen, den Vektor b an a anzuhängen:

std::move(b.begin(), b.end(), std::back_inserter(a));

wann aund bnicht überlappen und bnicht mehr verwendet werden.


Dies ist std::movevon <algorithm>, nicht das übliche std::move von <utility>.

Deqing
quelle
10
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.
YSC
38
std::vector<int> first;
std::vector<int> second;

first.insert(first.end(), second.begin(), second.end());
James Curran
quelle
24

Ich bevorzuge eine, die bereits erwähnt wird:

a.insert(a.end(), b.begin(), b.end());

Wenn Sie jedoch C ++ 11 verwenden, gibt es noch einen allgemeineren Weg:

a.insert(std::end(a), std::begin(b), std::end(b));

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.


Also im Grunde was Sie brauchen:

template <typename T>
void Append(std::vector<T>& a, const std::vector<T>& b)
{
    a.reserve(a.size() + b.size());
    a.insert(a.end(), b.begin(), b.end());
}
ST3
quelle
2
std::wird durch argumentabhängige Suche abgeleitet . end(a)wird genug sein.
Asu
4
@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:

ranges::view::concat(v1, v2)

Demo .

Jarod42
quelle
12

Sie sollten vector :: insert verwenden

v1.insert(v1.end(), v2.begin(), v2.end());
Boris
quelle
2
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.

//vector<int> v1,v2;
if(v1.size()>v2.size()) {
    v1.insert(v1.end(),v2.begin(),v2.end());
} else {
    v2.insert(v2.end(),v1.begin(),v1.end());
}
Vikramjit Roy
quelle
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 .

template <typename T>
std::vector<T>& operator +=(std::vector<T>& vector1, const std::vector<T>& vector2) {
    vector1.insert(vector1.end(), vector2.begin(), vector2.end());
    return vector1;
}

Dann können Sie es so nennen:

vector1 += vector2;
Daniel Giger
quelle
6

Wenn Sie an einer starken Ausnahmegarantie interessiert sind (wenn der Kopierkonstruktor eine Ausnahme auslösen kann):

template<typename T>
inline void append_copy(std::vector<T>& v1, const std::vector<T>& v2)
{
    const auto orig_v1_size = v1.size();
    v1.reserve(orig_v1_size + v2.size());
    try
    {
        v1.insert(v1.end(), v2.begin(), v2.end());
    }
    catch(...)
    {
        v1.erase(v1.begin() + orig_v1_size, v1.end());
        throw;
    }
}

Ähnliches append_movemit starker Garantie kann im Allgemeinen nicht implementiert werden, wenn der Verschiebungskonstruktor des Vektorelements werfen kann (was unwahrscheinlich, aber immer noch ist).

AlexT
quelle
Kann man nicht auch v1.erase(...werfen?
Klasse Skelett
insertkümmert sich schon darum. Außerdem entspricht dieser Aufruf erasevon a resize.
Potatoswatter
Ich mag das - danke!
Natersoz
5

Fügen Sie dieses Ihrer Header-Datei hinzu:

template <typename T> vector<T> concat(vector<T> &a, vector<T> &b) {
    vector<T> ret = vector<T>();
    copy(a.begin(), a.end(), back_inserter(ret));
    copy(b.begin(), b.end(), back_inserter(ret));
    return ret;
}

und benutze es so:

vector<int> a = vector<int>();
vector<int> b = vector<int>();

a.push_back(1);
a.push_back(2);
b.push_back(62);

vector<int> r = concat(a, b);

r enthält [1,2,62]

Stepan Yakovenko
quelle
Ich weiß nicht, warum dies abgelehnt wurde. Dies ist möglicherweise nicht der effizienteste Weg, aber es ist nicht falsch und effektiv.
leeor_net
4

Hier ist eine Allzwecklösung mit C ++ 11-Verschiebungssemantik:

template <typename T>
std::vector<T> concat(const std::vector<T>& lhs, const std::vector<T>& rhs)
{
    if (lhs.empty()) return rhs;
    if (rhs.empty()) return lhs;
    std::vector<T> result {};
    result.reserve(lhs.size() + rhs.size());
    result.insert(result.cend(), lhs.cbegin(), lhs.cend());
    result.insert(result.cend(), rhs.cbegin(), rhs.cend());
    return result;
}

template <typename T>
std::vector<T> concat(std::vector<T>&& lhs, const std::vector<T>& rhs)
{
    lhs.insert(lhs.cend(), rhs.cbegin(), rhs.cend());
    return std::move(lhs);
}

template <typename T>
std::vector<T> concat(const std::vector<T>& lhs, std::vector<T>&& rhs)
{
    rhs.insert(rhs.cbegin(), lhs.cbegin(), lhs.cend());
    return std::move(rhs);
}

template <typename T>
std::vector<T> concat(std::vector<T>&& lhs, std::vector<T>&& rhs)
{
    if (lhs.empty()) return std::move(rhs);
    lhs.insert(lhs.cend(), std::make_move_iterator(rhs.begin()), std::make_move_iterator(rhs.end()));
    return std::move(lhs);
}

Beachten Sie, wie sich dies von appending zu a unterscheidet vector.

Daniel
quelle
4

Sie können Ihre eigene Vorlage für den Operator + vorbereiten:

template <typename T> 
inline T operator+(const T & a, const T & b)
{
    T res = a;
    res.insert(res.end(), b.begin(), b.end());
    return res;
}

Als nächstes - benutze einfach +:

vector<int> a{1, 2, 3, 4};
vector<int> b{5, 6, 7, 8};
for (auto x: a + b)
    cout << x << " ";
cout << endl;

Dieses Beispiel gibt folgende Ausgabe:

1 2 3 4 5 6 7 8
Vladimir U.
quelle
2
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.

Unten ist das Beispiel:

#include <iostream>
#include <vector>
#include <algorithm>

int main()
{
    //DATA
    std::vector<int> v1{2,4,6,8};
    std::vector<int> v2{12,14,16,18};

    //MERGE
    std::vector<int> dst;
    std::merge(v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(dst));

    //PRINT
    for(auto item:dst)
        std::cout<<item<<" ";

    return 0;
}
Pavan Chandaka
quelle
2
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.

std::vector<int> A{ 1, 2, 3, 4, 5};
std::vector<int> B{ 10, 20, 30 };

VecProxy<int> AB(A, B);  // ----> O(1)!

for (size_t i = 0; i < AB.size(); i++)
    std::cout << AB[i] << " ";  // ----> 1 2 3 4 5 10 20 30

Siehe https://stackoverflow.com/a/55838758/2379625 für weitere Informationen, einschließlich der ‚VecProxy‘ Implementierung sowie Vor - und Nachteile.

Ronald Souza
quelle
3
vector<int> v1 = {1, 2, 3, 4, 5};
vector<int> v2 = {11, 12, 13, 14, 15};
copy(v2.begin(), v2.end(), back_inserter(v1));
Beispiel
quelle
6
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

namespace internal {

// Implementation detail of Concatenate, appends to a pre-reserved vector, copying or moving if
// appropriate
template<typename Target, typename Head, typename... Tail>
void AppendNoReserve(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");
    if constexpr (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));
    }
    if constexpr (sizeof...(Tail) > 0) {
        AppendNoReserve(target, std::forward<Tail>(tail)...);
    }
}

template<typename Head, typename... Tail>
size_t TotalSize(const Head& head, const Tail&... tail) {
    if constexpr (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<typename Head, typename... Tail>
auto Concatenate(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;
}
Drew
quelle
1

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:

  1. Ihr vectorenthält Grundelemente
  2. Ihre enthaltenen Grundelemente haben eine Größe von 32 Bit oder weniger
  3. 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:

static_assert(sizeof(char32_t) == sizeof(int));

Wenn dies gilt, können Sie einfach Folgendes tun:

const u32string concatenation = u32string(first.cbegin(), first.cend()) + u32string(second.cbegin(), second.cend());

Weitere Informationen zu den Unterschieden zwischen stringund finden vectorSie hier: https://stackoverflow.com/a/35558008/2642059

Ein Live-Beispiel für diesen Code finden Sie hier: http://ideone.com/7Iww3I

Jonathan Mee
quelle
0

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 iterator
    for (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.

Aleph0
quelle
0

Sie können dies mit vorimplementierten STL-Algorithmen tun, indem Sie eine Vorlage für eine polymorphe Verwendung verwenden.

#include <iostream>
#include <vector>
#include <algorithm>

template<typename T>

void concat(std::vector<T>& valuesa, std::vector<T>& valuesb){

     for_each(valuesb.begin(), valuesb.end(), [&](int value){ valuesa.push_back(value);});
}

int main()
{
    std::vector<int> values_p={1,2,3,4,5};
    std::vector<int> values_s={6,7};

   concat(values_p, values_s);

    for(auto& it : values_p){

        std::cout<<it<<std::endl;
    }

    return 0;
}

Sie können den zweiten Vektor löschen, wenn Sie ihn nicht weiter verwenden möchten ( clear()Methode).

rekkalmd
quelle
-3

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());
nvnhcmus
quelle
4
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 ).
tmlen
Was ist setcapacity? Was ist function: ?
LF
@LF Ich denke, er spricht über die resizeMethode.
Matthieu H