Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

std::vector::swap — výměna dvou vektorů

Vyměňte obsah a kapacitu dvou vektorů v konstantním čase. Ověřte kompatibilitu alokátorů a zjistěte, které iterátory zůstávají po výměně platné.

Verze: ISO C++23; implementation support may vary

Syntaxe

// <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 je členská funkce z hlavičky <vector>. Volání a.swap(b) mění dva vektory stejného typu a vrací void. V konstantním čase vymění jejich obsah, a tedy i velikost, a také kapacitu, aniž by kopírovalo, přesouvalo nebo vyměňovalo jednotlivé prvky. Nečlenské přetížení std::swap(a, b) pro vektory volá členskou funkci.

Pokud má vlastnost alokátoru propagate_on_container_swap hodnotu true, vymění se i alokátory. Jinak zůstanou u původních vektorů a při porovnání si musí být rovny; v opačném případě je chování nedefinované. V ISO C++23 je členská funkce constexpr a její specifikace noexcept používá logický součet vlastností propagate_on_container_swap a is_always_equal. Instance výchozího alokátoru std::allocator stejného typu si jsou při porovnání vždy rovny a výměna jejich vektorů je noexcept.

Iterátory, ukazatele a reference na prvky zůstávají platné: stále označují stejné prvky, nyní v druhém vektoru. Uložený iterátor end() neoznačuje žádný prvek a může být zneplatněn. Po výměně získejte nový end() z vektoru, který nyní prvky obsahuje.

Chcete-li potvrdit změnu, nejprve připravte a ověřte samostatný vektor a pak jej vyměňte s aktivním. push_back přidá prvek na konec a může vyvolat realokaci, proto získejte iterátor až po přidání. std::find_if prohledává rozsah od begin() včetně do end() bez této koncové pozice; výsledek rovný end() znamená, že se žádný prvek nenašel. size() vrací počet prvků, nikoli kapacitu.

Pokud příprava selže, aktivní vektor se nezmění. Po potvrzení změny obsahuje pracovní vektor původní obsah aktivního vektoru. swap není atomická operace a nenahrazuje synchronizaci konfliktních přístupů z různých vláken.

Příklady

#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';
}

Výsledek

active size: 3
pending size: 2
saved element: 7

`push_back` přidá `7` do `pending`. Po `active.swap(pending)` má `active` tři prvky, `pending` dva a `found` stále označuje tutéž `7`, nyní v `active`.

Související lekce

  • C++ · Lekce 15 · Pokročilá · Verze: 3

Zdroje