std::swap

Défini dans l'en-tête `<algorithm>`		(jusqu'à C++11)
Défini dans l'en-tête `<utility>`		(depuis C++11)
Défini dans l'en-tête `<string_view>`
template< class T > void swap( T& a, T& b );	(1)	(conditionnellement noexcept depuis C++11) (constexpr depuis C++20)
template< class T2, std::size_t N > void swap( T2 (&a)[N], T2 (&b)[N] );	(2)	(conditionnellement noexcept depuis C++11) (constexpr depuis C++20)

Échange les valeurs données.

1) Échange les valeurs a et b.

Cette surcharge participe à la résolution de surcharge uniquement si std::is_move_constructible_v<T> && std::is_move_assignable_v<T> satisfait true.

(depuis C++17)

2) Échange les tableaux a et b. Équivalent à std::swap_ranges(a, a + N, b).

Cette surcharge participe à la résolution de surcharge uniquement si std::is_swappable_v<T2> satisfait true.

(depuis C++17)

Paramètres

a, b	-	les valeurs à échanger
Exigences de type
- `T` doit satisfaire aux exigences de CopyConstructible et CopyAssignable (jusqu'à C++11) MoveConstructible et MoveAssignable (depuis C++11) .
- `T2` doit satisfaire aux exigences de Swappable .

Valeur de retour

(aucun)

Exceptions

1)

(aucun)	(jusqu'à C++11)
`noexcept` spécification : noexcept ( std:: is_nothrow_move_constructible < T > :: value && std:: is_nothrow_move_assignable < T > :: value )	(depuis C++11)

2)

`noexcept` spécification : noexcept ( noexcept ( swap ( * a, * b ) ) ) La recherche de l'identifiant `swap` dans la spécification d'exception trouve ce modèle de fonction en plus de tout ce qui est trouvé par les règles de recherche habituelles, rendant la spécification d'exception équivalente à C++17 std::is_nothrow_swappable .	(depuis C++11) (jusqu'à C++17)
`noexcept` spécification : noexcept ( std:: is_nothrow_swappable_v < T2 > )	(depuis C++17)

Complexité

1) Constante.

2) Linéaire en N .

Spécialisations

std::swap peut être spécialisé dans l'espace de noms std pour les types définis par le programme, mais ces spécialisations ne sont pas trouvées par ADL (l'espace de noms std n'est pas l'espace de noms associé pour le type défini par le programme).

(jusqu'à C++20)

La manière attendue de rendre un type défini par le programme interchangeable est de fournir une fonction non-membre swap dans le même espace de noms que le type : voir Swappable pour plus de détails.

Les surcharges suivantes sont déjà fournies par la bibliothèque standard :

std::swap (std::pair) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::tuple) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::shared_ptr) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::weak_ptr) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::unique_ptr) (C++11)	spécialise l'algorithme std::swap (fonction template)
std::swap (std::function) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::basic_string)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::array) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::deque)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::forward_list) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::list)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::vector)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::map)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::multimap)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::set)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::multiset)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::unordered_map) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::unordered_multimap) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::unordered_set) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::unordered_multiset) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::queue) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::priority_queue) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::stack) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::valarray) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::basic_stringbuf) (C++11)	spécialise l'algorithme std::swap (fonction template)
std::swap (std::basic_istringstream) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::basic_ostringstream) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::basic_stringstream) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::basic_filebuf) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::basic_ifstream) (C++11)	spécialise l'algorithme std::swap (fonction template)
std::swap (std::basic_ofstream) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::basic_fstream) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::basic_syncbuf) (C++20)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::basic_spanbuf) (C++23)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::basic_ispanstream) (C++23)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::basic_ospanstream) (C++23)	spécialise l'algorithme std::swap (fonction template)
std::swap (std::basic_spanstream) (C++23)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::basic_regex) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::match_results) (C++11)	spécialise l'algorithme `std::swap` (modèle de fonction)
std::swap (std::thread) (C++11)	spécialise l'algorithme std::swap (fonction)
std::swap (std::unique_lock) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::shared_lock) (C++14)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::promise) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::packaged_task) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::optional) (C++17)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::any) (C++17)	spécialise l'algorithme std::swap (fonction)
std::swap (std::variant) (C++17)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::basic_stacktrace) (C++23)	spécialise l'algorithme std::swap (modèle de fonction)
swap (std::filesystem::path) (C++17)	spécialise l'algorithme std::swap (fonction)
swap (std::expected) (C++23)	spécialise l'algorithme std::swap (fonction)
swap (std::jthread) (C++20)	spécialise l'algorithme std::swap (fonction)
swap (std::move_only_function) (C++23)	spécialise l'algorithme std::swap (fonction)
swap (std::stop_source) (C++20)	spécialise l'algorithme std::swap (fonction)
swap (std::stop_token) (C++20)	spécialise l'algorithme std::swap (fonction)

Exemple

Exécuter ce code

#include <algorithm>
#include <iostream>
namespace Ns
{
    class A
    {
        int id {};
        friend void swap(A& lhs, A& rhs)
        {
            std::cout << "swap(" << lhs << ", " << rhs << ")\n";
            std::swap(lhs.id, rhs.id);
        }
        friend std::ostream& operator<<(std::ostream& os, A const& a)
        {
            return os << "A::id=" << a.id;
        }
    public:
        A(int i) : id {i} {}
        A(A const&) = delete;
        A& operator = (A const&) = delete;
    };
}
int main()
{
    int a = 5, b = 3;
    std::cout << a << ' ' << b << '\n';
    std::swap(a, b);
    std::cout << a << ' ' << b << '\n';
    Ns::A p {6}, q {9};
    std::cout << p << ' ' << q << '\n';
//  std::swap(p, q); // erreur, les exigences de type ne sont pas satisfaites
    swap(p, q);      // OK, ADL trouve la fonction `swap` amie appropriée
    std::cout << p << ' ' << q << '\n';
}

Sortie :

5 3
3 5
A::id=6 A::id=9
swap(A::id=6, A::id=9)
A::id=9 A::id=6

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	Appliqué à	Comportement tel que publié	Comportement correct
LWG 227	C++98	`T` n'était pas requis d'être CopyConstructible ou DefaultConstructible (un objet temporaire de type `T` pourrait ne pas pouvoir être construit)	`T` est également requis d' être CopyConstructible
LWG 809	C++98	les tableaux ne pouvaient pas être échangés	surcharge ajoutée (2)
LWG 2554	C++11	l'échange de tableaux multidimensionnels ne peut jamais être noexcept en raison de problèmes de recherche de nom	rendu fonctionnel

Voir aussi

ranges::swap (C++20)	échange les valeurs de deux objets (objet point de personnalisation)
iter_swap	échange les éléments pointés par deux itérateurs (modèle de fonction)
swap_ranges	échange deux intervalles d'éléments (modèle de fonction & objet fonction d'algorithme)
ranges::swap_ranges (C++20)
exchange (C++14)	remplace l'argument par une nouvelle valeur et retourne sa valeur précédente (modèle de fonction)

Support du compilateur
Indépendant et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test des fonctionnalités (C++20)
Bibliothèque de support du langage
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque du système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants