KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::vector::swap — twee vectoren omwisselen

Wissel de inhoud en capaciteit van twee vectoren om in constante tijd. Controleer of de allocators compatibel zijn en leer welke iterators geldig blijven.

Versie: 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 is een lidfunctie uit <vector>. De aanroep a.swap(b) wijzigt twee vectoren van hetzelfde type en retourneert void. Hij wisselt hun inhoud en daarmee hun grootte, en ook hun capaciteit, in constante tijd om, zonder afzonderlijke elementen te kopiëren, te verplaatsen of om te wisselen. De niet-lidoverload std::swap(a, b) voor vectoren roept de lidfunctie aan.

Als de allocatoreigenschap propagate_on_container_swap true is, worden de allocators ook omgewisseld. Anders blijven ze bij hun oorspronkelijke vector en moeten ze bij vergelijking gelijk zijn; zo niet, dan is het gedrag ongedefinieerd. In ISO C++23 is de lidfunctie constexpr en gebruikt de noexcept-specificatie de logische OF van propagate_on_container_swap en is_always_equal. Instanties van de standaardallocator std::allocator van hetzelfde type zijn bij vergelijking altijd gelijk; hun vectoren omwisselen is noexcept.

Iterators, pointers en referenties naar elementen blijven geldig: ze verwijzen naar dezelfde elementen, die nu in de andere vector staan. Een bewaarde end()-iterator verwijst niet naar een element en kan ongeldig worden. Vraag na het omwisselen opnieuw end() op bij de vector die de elementen nu bevat.

Bereid een wijziging voor in een aparte vector en controleer die voordat je hem met de actieve vector omwisselt. push_back voegt een element achteraan toe en kan herallocatie veroorzaken; haal de iterator daarom pas na het toevoegen op. std::find_if zoekt vanaf begin() tot aan end(), zonder end() mee te nemen. Is het resultaat gelijk aan end(), dan is niets gevonden. size() geeft het aantal elementen terug, niet de capaciteit.

Mislukt de voorbereiding, dan verandert de actieve vector niet. Na het doorvoeren van de wijziging bevat de werkvector de vorige inhoud van de actieve vector. swap is niet atomair en vervangt geen synchronisatie bij conflicterende toegang vanuit verschillende threads.

Voorbeelden

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

Resultaat

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

`push_back` voegt `7` toe aan `pending`. Na `active.swap(pending)` heeft `active` drie elementen en `pending` twee. `found` verwijst nog steeds naar dezelfde `7`, nu in `active`.

Gerelateerde lessen

  • C++ · Les 15 · Gevorderd · Versie: 3

Bronnen