std:: swap

From cppreference.net

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 seulement si std:: is_move_constructible_v < T > && std:: is_move_assignable_v < T > est 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 seulement si std:: is_swappable_v < T2 > est true .

(depuis C++17)

Table des matières

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

(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)

`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 de point de personnalisation)
iter_swap	échange les éléments pointés par deux itérateurs (modèle de fonction)
swap_ranges	échange deux plages d'éléments (modèle de fonction)
exchange (C++14)	remplace l'argument par une nouvelle valeur et retourne sa valeur précédente (modèle de fonction)

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants