Schöne Möglichkeit, einen Vektor an sich selbst anzuhängen

Ich möchte den Inhalt des Vektors duplizieren und am Ende des ursprünglichen Vektors anhängen, dh v[i]=v[i+n] for i=0,2,...,n-1

Ich suche nach einer netten Möglichkeit, dies zu tun, nicht mit einer Schleife. ich sah std::vector::insert aber die iterative Version verbietet es einem Iterator *this(dh Verhalten ist undefiniert).

Ich habe es auch versucht std::copy wie folgt (aber es führte zu einem Segmentierungsfehler):

copy( xx.begin(), xx.end(), xx.end());

Beeindruckend. So viele Antworten, die nahe beieinander liegen, keine mit den richtigen Teilen. Sie brauchen beides resize (oder reserve) und copy_nzusammen mit der Erinnerung an die Originalgröße.

auto old_count = xx.size();
xx.resize(2 * old_count);
std::copy_n(xx.begin(), old_count, xx.begin() + old_count);

oder

auto old_count = xx.size();
xx.reserve(2 * old_count);
std::copy_n(xx.begin(), old_count, std::back_inserter(xx));

Beim Benutzen reserve, copy_n ist erforderlich, weil die end() iterator zeigt ein Element nach dem Ende … was bedeutet, dass es auch nicht “vor dem Einfügepunkt” des ersten Einfügens liegt und ungültig wird.

23.3.6.5 [vector.modifiers] verspricht das für insert und push_back:

Bemerkungen: Verursacht eine Neuzuweisung, wenn die neue Größe größer als die alte Kapazität ist. Wenn keine Neuzuweisung erfolgt, bleiben alle Iteratoren und Referenzen vor dem Einfügepunkt gültig. Wenn eine Ausnahme ausgelöst wird, außer durch den Kopierkonstruktor, den Verschiebekonstruktor, den Zuweisungsoperator oder den Verschiebezuweisungsoperator von T oder durch eine InputIterator-Operation, gibt es keine Auswirkungen. Wenn eine Ausnahme vom Move-Konstruktor eines Nicht-CopyInsertable-T ausgelöst wird, sind die Auswirkungen nicht angegeben.

Ich würde es so machen:

#include <algorithm>
#include <vector>
#include <utility>

int main(int argc, char* argv[])
{
    std::vector<int> v1 = { 1, 2, 3, 4, 5 };

    {
        std::vector<int> v2(v1.begin(), v1.end());
        std::copy(v1.begin(), v1.end(), std::back_inserter(v2));
        std::swap(v1, v2);
    }

    return 0;
}

EDIT: Ich habe eine etwas effizientere Version hinzugefügt.

#include <algorithm>
#include <vector>
#include <utility>

int main(int argc, char* argv[])
{
    std::vector<int> v1 = { 1, 2, 3, 4, 5 };

    {
        typedef std::move_iterator<decltype(v1)::iterator> VecMoveIter;
        std::vector<int> v2(v1);
        std::copy(VecMoveIter(v1.begin()), VecMoveIter(v1.end()), std::back_inserter(v2));
        v1 = std::move(v2);
    }

    return 0;
}

Zum Anhängen von mehr als einem Slot mit Duplikaten.

    int main() {
        std::vector<int> V;
        V.push_back(1);
        V.push_back(2);

        int oldSize = V.size();
        int newSize = oldSize;
        int nDupSlot = 4;

        V.resize(nDupSlot * oldSize);
        for(int i=0; i<(nDupSlot-1); ++i) {
            std::copy_n(V.begin(), oldSize, V.begin() + newSize);       
            newSize = newSize + oldSize;
         }

        for(int i =0; i<V.size(); ++i) {
            std::cout<<V[i];
            }

        return 0;
    }

Ausgabe:

12121212

Es ist vielleicht nicht der effektivste Weg, aber es ist sicher einfach:

std::vector<int> toAppend(xx);
xx.insert(xx.end(), toAppend.begin(), toAppend.end();