¿Cuál es la mejor manera de concatenar dos vectores?

Estoy usando multihilo y quiero fusionar los resultados. Por ejemplo:

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

Quiero que AB tenga los contenidos de A y los contenidos de B en ese orden. ¿Cuál es la forma más eficiente de hacer algo como esto?

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

Esto es precisamente lo que la función miembro std::vector::insertes para

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

Depende de si realmente necesita concatenar físicamente los dos vectores o si desea dar la apariencia de concatenación en aras de la iteración. La función boost :: join

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

te dará esto

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

debería darte

1
2
3
4
5
6

Tenga en cuenta boost :: join no copia los dos vectores en un nuevo contenedor, sino que genera un par de iteradores (rango) que cubren el lapso de ambos contenedores. Habrá algo de sobrecarga de rendimiento, pero tal vez menos que copiar todos los datos a un nuevo contenedor primero.

Basado en la respuesta de Kiril V. Lyadvinsky , hice una nueva versión. Este fragmento utiliza la plantilla y la sobrecarga. Con ella, puedes escribir vector3 = vector1 + vector2y vector4 += vector3. Espero que pueda ayudar.

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
}

En la dirección de la respuesta de Bradgonesurfing, muchas veces uno realmente no necesita concatenar dos vectores (O (n)), sino que simplemente trabaja con ellos como si estuvieran concatenados (O (1)) . Si este es su caso, se puede hacer sin la necesidad de bibliotecas Boost.

El truco es crear un proxy vectorial: una clase de contenedor que manipula referencias a ambos vectores, vistos externamente como uno único y contiguo.

USO

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

IMPLEMENTACIÓN

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

PRINCIPALES BENEFICIOS

Es O (1) (tiempo constante) para crearlo, y con una asignación mínima de memoria adicional.

ALGUNAS COSAS A CONSIDERAR

• Solo debe hacerlo si realmente sabe lo que está haciendo cuando se trata de referencias . Esta solución está diseñada para el propósito específico de la pregunta formulada, para lo cual funciona bastante bien . Emplearlo en cualquier otro contexto puede conducir a un comportamiento inesperado si no está seguro de cómo funcionan las referencias.
• En este ejemplo, AB no proporciona un operador de acceso no constante ([]). Siéntase libre de incluirlo, pero tenga en cuenta: dado que AB contiene referencias, asignarle valores también afectará los elementos originales dentro de A y / o B. Si esta es una característica deseable o no, es una pregunta específica de la aplicación que uno debe Considere cuidadosamente.
• Cualquier cambio realizado directamente en A o B (como asignar valores, ordenar, etc.) también "modificará" AB. Esto no es necesariamente malo (en realidad, puede ser muy útil: AB nunca necesita actualizarse explícitamente para mantenerse sincronizado tanto con A como con B), pero ciertamente es un comportamiento que uno debe tener en cuenta. Excepción importante: cambiar el tamaño de A y / o B a algo más grande puede hacer que estos se reasignen en la memoria (por la necesidad de un espacio contiguo), y esto a su vez invalidaría AB.
• Como cada acceso a un elemento está precedido por una prueba (es decir, "i <v1.size ()"), el tiempo de acceso VecProxy, aunque constante, también es un poco más lento que el de los vectores.
• Este enfoque se puede generalizar a n vectores. No lo he intentado, pero no debería ser un gran problema.

Una variante más simple que aún no se mencionó:

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

Y usando el algoritmo de fusión:

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

Si sus vectores están ordenados *, consulte set_union de <algorithm>.

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

Hay un ejemplo más completo en el enlace.

* gracias rlbond

Todas las soluciones son correctas, pero me resultó más fácil escribir una función para implementar esto. Me gusta esto:

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

De esa manera puede evitar la colocación temporal de esta manera:

ContainerInsert(vec, GetSomeVector());