CKTIS / C++
std::vector::swap — scambiare due vettori
Scambia il contenuto e la capacità di due vettori in tempo costante. Verifica la compatibilità degli allocatori e quali iteratori restano validi dopo lo scambio.
Versione: ISO C++23; implementation support may vary
Sintassi
// <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 è una funzione membro dichiarata in <vector>. La chiamata a.swap(b) modifica due vettori dello stesso tipo e restituisce void. Scambia il loro contenuto, e quindi le loro dimensioni, e le loro capacità in tempo costante, senza copiare, spostare o scambiare i singoli elementi. L’overload non membro std::swap(a, b) per i vettori chiama la funzione membro.
Se il tratto dell’allocatore propagate_on_container_swap vale true, vengono scambiati anche gli allocatori. Altrimenti restano associati ai vettori originali e devono risultare uguali al confronto; in caso contrario, il comportamento è indefinito. In ISO C++23 la funzione membro è constexpr e la sua specifica noexcept usa l’OR logico dei tratti propagate_on_container_swap e is_always_equal. Le istanze dell’allocatore predefinito std::allocator dello stesso tipo risultano sempre uguali al confronto e lo scambio dei loro vettori è noexcept.
Iteratori, puntatori e riferimenti agli elementi rimangono validi: indicano gli stessi elementi, che ora appartengono all’altro vettore. Un iteratore end() salvato non indica un elemento e può essere invalidato. Dopo lo scambio, ottieni di nuovo end() dal vettore che ora contiene gli elementi.
Per applicare una modifica, prepara e convalida un vettore separato prima di scambiarlo con quello attivo. push_back aggiunge un elemento in coda e può provocare una riallocazione, quindi ottieni l’iteratore dopo l’aggiunta. std::find_if cerca da begin() incluso a end() escluso; un risultato uguale a end() indica che non ci sono corrispondenze. size() restituisce il numero di elementi, non la capacità.
Se la preparazione fallisce, il vettore attivo rimane invariato. Dopo aver applicato la modifica, il vettore di lavoro contiene il contenuto precedente di quello attivo. swap non è atomico e non sostituisce la sincronizzazione tra accessi in conflitto da thread diversi.
Esempi
#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';
}Risultato
active size: 3 pending size: 2 saved element: 7
`push_back` aggiunge `7` a `pending`. Dopo `active.swap(pending)`, `active` ha tre elementi, `pending` ne ha due e `found` indica ancora lo stesso `7`, ora in `active`.
Lezioni correlate
- C++ · Lezione 15 · Avanzato · Versione: 3
Fonti
- 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]