CKTIS / C++
std::vector::swap — intercambiar dos vectores
Intercambia el contenido y la capacidad de dos vectores en tiempo constante. Comprueba la compatibilidad de los asignadores y qué iteradores siguen siendo válidos.
Versión: ISO C++23; implementation support may vary
Sintaxis
// <vector>, ISO C++23; member declaration inside std::vector<T, Allocator>
constexpr void swap(vector& other) noexcept(
std::allocator_traits<Allocator>::propagate_on_container_swap::value ||
std::allocator_traits<Allocator>::is_always_equal::value);
// Call with two mutable lvalues of the same vector type:
a.swap(b);
// The non-member overload for vectors delegates to the member:
std::swap(a, b);std::vector::swap es una función miembro de <vector>. La llamada a.swap(b) modifica dos vectores del mismo tipo y devuelve void. Intercambia su contenido, incluidos sus tamaños, y sus capacidades en tiempo constante, sin copiar, mover ni intercambiar elementos individuales. La sobrecarga no miembro std::swap(a, b) para vectores llama a la función miembro.
Si el rasgo del asignador propagate_on_container_swap vale true, también se intercambian los asignadores. Si no, permanecen en sus vectores originales y deben resultar iguales al compararlos; de lo contrario, el comportamiento es indefinido. En ISO C++23, la función miembro es constexpr y su especificación noexcept usa la disyunción lógica de propagate_on_container_swap e is_always_equal. Las instancias del asignador predeterminado std::allocator del mismo tipo siempre resultan iguales al compararlas, y el intercambio de sus vectores es noexcept.
Los iteradores, punteros y referencias a elementos siguen siendo válidos: designan los mismos elementos, ahora en el otro vector. Un iterador end() guardado no designa un elemento y puede quedar invalidado. Tras el intercambio, vuelve a obtener end() del vector que ahora contiene los elementos.
Para aplicar un cambio, prepara y valida un vector separado antes de intercambiarlo con el activo. push_back añade un elemento al final y puede reasignar el almacenamiento, así que obtén el iterador después de añadirlo. std::find_if busca desde begin() inclusive hasta end() exclusive; un resultado igual a end() indica que no hubo coincidencias. size() devuelve el número de elementos, no la capacidad.
Si falla la preparación, el vector activo queda intacto. Tras aplicar el cambio, el vector de trabajo conserva el contenido anterior del activo. swap no es una operación atómica ni sustituye la sincronización de accesos en conflicto desde distintos hilos.
Ejemplos
#include <algorithm>
#include <iostream>
#include <vector>
int main() {
std::vector<int> active{1, 2};
auto pending = active;
pending.push_back(7);
auto found = std::find_if(pending.begin(), pending.end(),
[](int value) { return value == 7; });
if (found == pending.end()) {
return 1;
}
active.swap(pending);
std::cout << "active size: " << active.size() << '\n';
std::cout << "pending size: " << pending.size() << '\n';
std::cout << "saved element: " << *found << '\n';
}Resultado
active size: 3 pending size: 2 saved element: 7
`push_back` añade `7` a `pending`. Tras `active.swap(pending)`, `active` tiene tres elementos, `pending` tiene dos y `found` sigue apuntando al mismo `7`, ahora en `active`.
Lecciones relacionadas
- C++ · Lección 15 · Avanzado · Versión: 3
Fuentes
- C++23 working draft N4950 — Programming Language C++
- C++ working draft — [vector.capacity]
- C++ working draft — [container.requirements]
- C++ working draft — [vector.syn]
- C++ working draft — [default.allocator]
- C++ working draft — [vector.modifiers]
- C++ working draft — [alg.find]
- C++ working draft — [intro.races]