Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::vector::swap — échanger deux vecteurs

Échangez le contenu et la capacité de deux vecteurs en temps constant. Vérifiez la compatibilité des allocateurs et sachez quels itérateurs restent utilisables.

Version : 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 est une fonction membre déclarée dans <vector>. L’appel a.swap(b) modifie deux vecteurs de même type et renvoie void. Il échange leur contenu, donc aussi leur taille, ainsi que leur capacité en temps constant, sans copier, déplacer ni permuter les éléments un à un. La surcharge non membre std::swap(a, b) pour les vecteurs appelle la fonction membre.

Si le trait d’allocateur propagate_on_container_swap vaut true, les allocateurs sont également échangés. Sinon, chacun reste associé à son vecteur d’origine et ils doivent être égaux lors de la comparaison ; dans le cas contraire, le comportement est indéfini. En ISO C++23, la fonction membre est constexpr et sa spécification noexcept repose sur le OU logique des traits propagate_on_container_swap et is_always_equal. Les instances de l’allocateur par défaut std::allocator de même type sont toujours égales à la comparaison, et l’échange de leurs vecteurs est noexcept.

Les itérateurs, pointeurs et références vers des éléments restent valides : ils désignent les mêmes éléments, désormais dans l’autre vecteur. Un itérateur end() mémorisé ne désigne aucun élément et peut être invalidé. Après l’échange, récupérez de nouveau end() auprès du vecteur qui contient maintenant les éléments.

Pour appliquer une modification, préparez et validez un vecteur séparé avant de l’échanger avec le vecteur actif. push_back ajoute un élément à la fin et peut provoquer une réallocation ; obtenez donc l’itérateur après cet ajout. std::find_if cherche de begin() inclus à end() exclu ; un résultat égal à end() signifie qu’aucun élément ne convient. size() renvoie le nombre d’éléments, pas la capacité.

Si la préparation échoue, le vecteur actif reste inchangé. Une fois la modification appliquée, le vecteur de travail contient l’ancien contenu du vecteur actif. swap n’est pas atomique et ne remplace pas la synchronisation des accès conflictuels provenant de différents threads.

Exemples

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

Résultat

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

`push_back` ajoute `7` à `pending`. Après `active.swap(pending)`, `active` contient trois éléments, `pending` en contient deux et `found` désigne toujours le même `7`, désormais dans `active`.

Leçons associées

  • C++ · Leçon 15 · Avancé · Version : 3

Sources