empty - swap vector c++

C++ extiende un vector con otro vector (5)

// reserve() is optional - just to improve performance v.reserve(v.size() + distance(v_prime.begin(),v_prime.end())); v.insert(v.end(),v_prime.begin(),v_prime.end());

Soy un programador de C / Python en C ++ trabajando con el STL por primera vez.

En Python, la extensión de una lista con otra lista utiliza el método .extend :

>>> v = [1, 2, 3] >>> v_prime = [4, 5, 6] >>> v.extend(v_prime) >>> print(v) [1, 2, 3, 4, 5, 6]

Actualmente uso este enfoque algorítmico para extender vectores en C ++:

v.resize(v.size() + v_prime.size()); copy(v_prime.begin(), v_prime.end(), v.rbegin());

¿Es esta la manera canónica de extender vectores, o si hay una manera más simple que me falta?

Hay múltiples formas de alcanzar tu objetivo.

std :: vector :: inserción

El vector puede extenderse insertando nuevos elementos antes del elemento en la posición especificada, aumentando efectivamente el tamaño del contenedor por el número de elementos insertados. Puede seguir uno de los siguientes enfoques. La segunda versión usa C ++ 11 y se puede considerar como una respuesta más genérica, ya que b también podría ser una matriz.

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

A veces, en uso, es una buena práctica usar la función de reserva antes de usar std :: vector :: insert. La función std :: vector :: reserve aumenta la capacidad del contenedor a un valor mayor o igual a new_cap. Si new_cap es mayor que la capacidad actual (), se asigna nuevo almacenamiento, de lo contrario, el método no hace nada.

a.reserve(a.size() + distance(b.begin(), b.end()));

El uso de la función de reserva no es obligatorio, pero puede ser aconsejable. Y es mejor utilizar la reserva si está insertando repetidamente en un vector para el que conoce el tamaño final, y ese tamaño es grande. De lo contrario, es mejor dejar que el STL haga crecer su vector según sea necesario.

std :: copy

std :: copy es la segunda opción que puedes considerar para alcanzar tu objetivo. Esta función copia los elementos en el rango (primero, último) en el rango que comienza en el resultado.

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

Sin embargo, el uso de std :: copy es más lento que el uso de std :: vector :: insert (), porque std :: copy () no puede reservar suficiente espacio de antemano (no tiene acceso al vector en sí, solo a un iterador que tiene), mientras que std :: vector :: insert (), siendo una función miembro, puede. Debido a que std :: copy es más lento que usar std :: vector :: insert. La mayoría de las personas sobre el uso estándar copia sin conocer este escenario.

boost :: push_back

La tercera opción que puede considerar es el uso de la función push_back de boost .

boost::push_back(a, b);

Necesitaba dos variantes diferentes de la función extend en C ++ 14, donde se adjuntaba una semántica de movimiento admitida para cada elemento del vector.

vec es tu v , y ext es tu v_prime .

/** * Extend a vector with elements, without destroying source one. */ template<typename T> void vector_extend(std::vector<T> &vec, const std::vector<T> &ext) { vec.reserve(vec.size() + ext.size()); vec.insert(std::end(vec), std::begin(ext), std::end(ext)); } /** * Extend a vector with elements with move semantics. */ template<typename T> void vector_extend(std::vector<T> &vec, std::vector<T> &&ext) { if (vec.empty()) { vec = std::move(ext); } else { vec.reserve(vec.size() + ext.size()); std::move(std::begin(ext), std::end(ext), std::back_inserter(vec)); ext.clear(); } }

Usando std::vector::insert ;

A.reserve(A.size() + B.size()); A.insert(A.end(), B.begin(), B.end());

reserve() es opcional, pero su uso ayuda a mejorar el rendimiento.

Generador de código conveniente para guardar preciosos segundos:

copy(v_prime.begin(), v_prime.end(), back_inserter(v));