Який найкращий спосіб об'єднати два вектори?

Я використовую багатопотокове запитання і хочу об'єднати результати. Наприклад:

std::vector<int> A;
std::vector<int> B;
std::vector<int> AB;

Я хочу, щоб AB містив вміст A і вміст B у такому порядку. Який найефективніший спосіб зробити щось подібне?

AB.reserve( A.size() + B.size() ); // preallocate memory
AB.insert( AB.end(), A.begin(), A.end() );
AB.insert( AB.end(), B.begin(), B.end() );

Це саме те , що функція член std::vector::insertдля

std::vector<int> AB = A;
AB.insert(AB.end(), B.begin(), B.end());

Залежить від того, чи дійсно вам потрібно фізично об'єднати два вектори або ви хочете надати вигляд конкатенації заради ітерації. Функція boost :: join

http://www.boost.org/doc/libs/1_43_0/libs/range/doc/html/range/reference/utilities/join.html

дасть вам це.

std::vector<int> v0;
v0.push_back(1);
v0.push_back(2);
v0.push_back(3);

std::vector<int> v1;
v1.push_back(4);
v1.push_back(5);
v1.push_back(6);
...

BOOST_FOREACH(const int & i, boost::join(v0, v1)){
    cout << i << endl;
}

повинен вам дати

1
2
3
4
5
6

Примітка boost :: join не копіює два вектори в новий контейнер, але генерує пару ітераторів (діапазон), які охоплюють проміжок обох контейнерів. Буде деяка продуктивність, але, можливо, менше, ніж спочатку скопіювати всі дані в новий контейнер.

На основі відповіді Кирила В. Лядвінського я склав нову версію. Цей фрагмент використання шаблону та перевантаження. З ним можна писати vector3 = vector1 + vector2і vector4 += vector3. Сподіваюся, це може допомогти.

template <typename T>
std::vector<T> operator+(const std::vector<T> &A, const std::vector<T> &B)
{
    std::vector<T> AB;
    AB.reserve(A.size() + B.size());                // preallocate memory
    AB.insert(AB.end(), A.begin(), A.end());        // add A;
    AB.insert(AB.end(), B.begin(), B.end());        // add B;
    return AB;
}

template <typename T>
std::vector<T> &operator+=(std::vector<T> &A, const std::vector<T> &B)
{
    A.reserve(A.size() + B.size());                // preallocate memory without erase original data
    A.insert(A.end(), B.begin(), B.end());         // add B;
    return A;                                        // here A could be named AB
}

У напрямку відповіді Бредгонесурфінга багато разів не потрібно поєднувати два вектори (O (n)), а натомість просто працювати з ними так, ніби вони з'єднані (O (1)) . Якщо це ваш випадок, це можна зробити без необхідності збільшення бібліотек.

Трюк полягає у створенні векторного проксі: класу обгортки, який маніпулює посиланнями на обидва вектори, зовні розглядається як єдиний, суміжний.

ВИКОРИСТАННЯ

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

VecProxy<int> AB(A, B);  // ----> O(1). No copies performed.

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

ВПРОВАДЖЕННЯ

template <class T>
class VecProxy {
private:
    std::vector<T>& v1, v2;
public:
    VecProxy(std::vector<T>& ref1, std::vector<T>& ref2) : v1(ref1), v2(ref2) {}
    const T& operator[](const size_t& i) const;
    const size_t size() const;
};

template <class T>
const T& VecProxy<T>::operator[](const size_t& i) const{
    return (i < v1.size()) ? v1[i] : v2[i - v1.size()];
};

template <class T>
const size_t VecProxy<T>::size() const { return v1.size() + v2.size(); };

ОСНОВНА ПЕРЕВАГА

Це O (1) (постійний час) для його створення та з мінімальним додатковим розподілом пам'яті.

ДЕЯКІ ПЛАТИ, ЩО ВІДМОВИТИ

• Вам слід зайнятися цим, лише якщо ви дійсно знаєте, чим займаєтесь, коли маєте справу з посиланнями . Це рішення призначене для конкретної мети поставленого питання, для якого воно працює досить добре . Використовувати його в будь-якому іншому контексті може призвести до несподіваної поведінки, якщо ви не впевнені в тому, як працюють посилання.
• У цьому прикладі AB не забезпечує оператора доступу без дозволу ([]). Не соромтеся включати його, але пам’ятайте: оскільки АВ містить посилання, присвоєння ним значень також вплине на оригінальні елементи в межах А та / або В. Чи це бажана особливість, чи ні, це питання, яке стосується додатків, слід уважно розглянути.
• Будь-які зміни, безпосередньо внесені до A або B (наприклад, присвоєння значень, сортування тощо), також "модифікують" AB. Це не обов'язково погано (насправді це може бути дуже зручно: AB ніколи не потрібно чітко оновлювати, щоб він був синхронізований як до А, так і до В), але це, безумовно, поведінка, якої слід знати. Важливий виняток: зміни розміру A і / або B на sth більше може призвести до їх перерозподілу в пам'яті (для необхідності суміжного простору), а це, в свою чергу, призведе до недійсності AB.
• Оскільки кожному доступу до елемента передує тест (а саме "i <v1.size ()"), час доступу до VecProxy, хоча і постійний, також трохи повільніше, ніж у векторів.
• Цей підхід можна узагальнити до n векторів. Я не пробував, але це не повинно бути великою справою.

Ще один простий варіант, про який ще не говорилося:

copy(A.begin(),A.end(),std::back_inserter(AB));
copy(B.begin(),B.end(),std::back_inserter(AB));

І за допомогою алгоритму злиття:

#include <algorithm>
#include <vector>
#include <iterator>
#include <iostream>
#include <sstream>
#include <string>

template<template<typename, typename...> class Container, class T>
std::string toString(const Container<T>& v)
{
    std::stringstream ss;
    std::copy(v.begin(), v.end(), std::ostream_iterator<T>(ss, ""));
    return ss.str();
};


int main()
{
    std::vector<int> A(10);
    std::vector<int> B(5);  //zero filled
    std::vector<int> AB(15);

    std::for_each(A.begin(), A.end(),
            [](int& f)->void
            {
                f = rand() % 100;
            });

    std::cout << "before merge: " << toString(A) << "\n";
    std::cout << "before merge: " << toString(B) << "\n";
    merge(B.begin(),B.end(), begin(A), end(A), AB.begin(), [](int&,int&)->bool {});
    std::cout << "after merge:  " << toString(AB) << "\n";

    return 1;
}

Якщо ваші вектори відсортовані *, перевірте set_union з <алгоритму>.

set_union(A.begin(), A.end(), B.begin(), B.end(), AB.begin());

Є більш ретельний приклад за посиланням

* спасибі rlbond

Усі рішення правильні, але мені було легше просто написати функцію, щоб реалізувати це. подобається це:

template <class T1, class T2>
void ContainerInsert(T1 t1, T2 t2)
{
    t1->insert(t1->end(), t2->begin(), t2->end());
}

Таким чином ви можете уникнути тимчасового розміщення, як це:

ContainerInsert(vec, GetSomeVector());