CKTIS / C++
std::vector::swap — trocar dois vetores
Troque o conteúdo e a capacidade de dois vetores em tempo constante. Verifique a compatibilidade dos alocadores e saiba que iteradores continuam válidos.
Versão: ISO C++23; implementation support may vary
Sintaxe
// <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 é uma função membro declarada em <vector>. A chamada a.swap(b) modifica dois vetores do mesmo tipo e devolve void. Troca o conteúdo, incluindo o tamanho, e a capacidade dos vetores em tempo constante, sem copiar, mover nem trocar elementos individuais. A sobrecarga não membro std::swap(a, b) para vetores chama a função membro.
Se a característica do alocador propagate_on_container_swap for true, os alocadores também são trocados. Caso contrário, ficam nos vetores originais e têm de ser iguais quando comparados; se não forem, o comportamento é indefinido. Em ISO C++23, a função membro é constexpr e a sua especificação noexcept usa a disjunção lógica de propagate_on_container_swap e is_always_equal. As instâncias do alocador predefinido std::allocator do mesmo tipo comparam sempre como iguais, e a troca dos seus vetores é noexcept.
Os iteradores, ponteiros e referências para elementos continuam válidos: referem-se aos mesmos elementos, agora no outro vetor. Um iterador end() guardado não se refere a um elemento e pode ser invalidado. Após a troca, obtenha novamente end() a partir do vetor que agora contém os elementos.
Para aplicar uma alteração, prepare e valide um vetor separado antes de o trocar com o vetor ativo. push_back acrescenta um elemento no fim e pode provocar uma realocação; obtenha o iterador só depois de acrescentar o elemento. std::find_if procura desde begin() inclusive até end() exclusive; se o resultado for igual a end(), não houve correspondência. size() devolve o número de elementos, não a capacidade.
Se a preparação falhar, o vetor ativo fica inalterado. Após aplicar a alteração, o vetor de trabalho contém o conteúdo anterior do vetor ativo. swap não é uma operação atómica e não substitui a sincronização de acessos em conflito a partir de diferentes threads.
Exemplos
#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` acrescenta `7` a `pending`. Após `active.swap(pending)`, `active` tem três elementos, `pending` tem dois e `found` continua a referir-se ao mesmo `7`, agora em `active`.
Lições relacionadas
- C++ · Lição 15 · Avançado · Versão: 3
Fontes
- 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]