Verkettung von zwei std::Vektoren

Question

Wie verkette ich zwei std::vector s?

Answer 1

Diese Lösung mag etwas kompliziert sein, aber boost-range hat auch einige andere schöne 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 ist es die Absicht, die Vektor a y b einfach eine Operation darüber laufen lassen. In diesem Fall gibt es die lächerlich einfache join Funktion.

#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;
}

Bei großen Vektoren kann dies ein Vorteil sein, da kein Kopieren stattfindet. Es kann auch zum Kopieren verwendet werden und lässt sich leicht auf mehr als einen Container verallgemeinern.

Aus irgendeinem Grund gibt es nichts wie boost::join(a,b,c) was vernünftig sein könnte.

Answer 2

Wenn Sie nach einer Möglichkeit suchen, einen Vektor nach der Erstellung an einen anderen anzuhängen, vector::insert ist die beste Lösung, wie zum Beispiel schon mehrfach geantwortet wurde:

vector<int> first = {13};
const vector<int> second = {42};

first.insert(first.end(), second.cbegin(), second.cend());

Leider gibt es keine Möglichkeit, eine const vector<int> müssen Sie, wie oben beschrieben, konstruieren und dann insert .

---

Wenn Sie tatsächlich nach einem Container suchen, der die Verkettung dieser beiden vector<int> s, kann es etwas Besseres für Sie geben, wenn:

1. Ihr vector enthält Primitive
2. Die enthaltenen Primitive haben eine Größe von 32 Bit oder weniger
3. Sie wollen eine const Container

Wenn alle oben genannten Punkte zutreffen, würde ich vorschlagen, die basic_string der char_type entspricht der Größe des Primitivs, das in Ihrer vector . Sie sollten eine static_assert in Ihrem Code, um sicherzustellen, dass diese Größen konsistent bleiben:

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

Wenn dies der Fall ist, können Sie einfach tun:

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

Für weitere Informationen über die Unterschiede zwischen string y vector können Sie hier nachsehen: https://stackoverflow.com/a/35558008/2642059

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

Answer 3

Sie können dies mit vorimplementierten STL-Algorithmen tun, indem Sie eine Vorlage für einen polymorphen Typ 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 wollen ( clear() Methode).

Answer 4

Verketten Sie zwei std::vector-s con for Schleife in einer std::vector .

    std::vector <int> v1 {1, 2, 3}; //declare vector1
    std::vector <int> v2 {4, 5}; //declare vector2
    std::vector <int> suma; //declare vector suma

    for(int i = 0; i < v1.size(); i++) //for loop 1
    {
         suma.push_back(v1[i]);
    }

    for(int i = 0; i< v2.size(); i++) //for loop 2
    {
         suma.push_back(v2[i]);
    }

    for(int i = 0; i < suma.size(); i++) //for loop 3-output
    {
         std::cout << suma[i];
    }

Answer 5

Um ehrlich zu sein, könnten Sie zwei Vektoren schnell verketten, indem Sie Elemente aus zwei Vektoren in den anderen kopieren oder nur einen der beiden Vektoren anhängen! Das hängt von deinem Ziel ab.

Methode 1: Weisen Sie dem neuen Vektor eine Größe zu, die der Summe der Größe der beiden ursprünglichen Vektoren entspricht.

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: Anhängen von Vektor A durch Hinzufügen/Einfügen von Elementen des Vektors B.

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