CKTIS / C++
std::vector::swap — zwei Vektoren vertauschen
Tausche Inhalt und Kapazität zweier Vektoren in konstanter Zeit. Prüfe die Kompatibilität der Allokatoren und lerne, welche Iteratoren danach gültig bleiben.
Version: ISO C++23; implementation support may vary
Syntax
// <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 ist eine Memberfunktion aus <vector>. a.swap(b) verändert zwei Vektoren desselben Typs und gibt void zurück. Der Aufruf tauscht in konstanter Zeit ihre Inhalte und damit ihre Größen sowie ihre Kapazitäten aus, ohne einzelne Elemente zu kopieren, zu verschieben oder zu vertauschen. Die freie Überladung std::swap(a, b) für Vektoren ruft die Memberfunktion auf.
Ist das Allokator-Trait propagate_on_container_swap true, werden die Allokatoren ebenfalls getauscht. Andernfalls bleiben sie bei ihren ursprünglichen Vektoren und müssen beim Vergleich gleich sein; sonst ist das Verhalten undefiniert. In ISO C++23 ist die Memberfunktion constexpr, und ihre noexcept-Spezifikation verknüpft propagate_on_container_swap und is_always_equal mit einem logischen Oder. Instanzen des Standardallokators std::allocator desselben Typs sind beim Vergleich immer gleich; das Tauschen ihrer Vektoren ist noexcept.
Iteratoren, Zeiger und Referenzen auf Elemente bleiben gültig: Sie verweisen auf dieselben Elemente, die nun im jeweils anderen Vektor liegen. Ein gespeicherter end()-Iterator verweist auf kein Element und kann ungültig werden. Rufe nach dem Tausch end() für den Vektor neu ab, der die Elemente jetzt enthält.
Um eine Änderung zu übernehmen, bereite einen separaten Vektor vor und prüfe ihn, bevor du ihn mit dem aktiven tauschst. push_back hängt ein Element an und kann eine Reallokation auslösen; hole den Iterator daher erst danach. std::find_if sucht ab begin() bis ausschließlich end(); ein Ergebnis gleich end() bedeutet, dass nichts gefunden wurde. size() liefert die Anzahl der Elemente, nicht die Kapazität.
Scheitert die Vorbereitung, bleibt der aktive Vektor unverändert. Nach der Übernahme enthält der Arbeitsvektor den vorherigen Inhalt des aktiven Vektors. swap ist nicht atomar und ersetzt keine Synchronisierung bei kollidierenden Zugriffen aus verschiedenen Threads.
Beispiele
#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';
}Ergebnis
active size: 3 pending size: 2 saved element: 7
`push_back` fügt `7` zu `pending` hinzu. Nach `active.swap(pending)` enthält `active` drei Elemente und `pending` zwei. `found` verweist weiterhin auf dieselbe `7`, jetzt in `active`.
Zugehörige Lektionen
- C++ · Lektion 15 · Fortgeschritten · Version: 3
Quellen
- 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]