Namespaces
Variants

    std::tuple<Types...>::swap

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Libre et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support du langage
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostics
    Bibliothèque de gestion de la 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 de 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
     
    Bibliothèque d'utilitaires
    Support du langage
    Support des types (types de base, RTTI)
    Macros de test de fonctionnalités de la bibliothèque (C++20)
    Utilitaires de programme
    Fonctions variadiques
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Support des coroutines (C++20)
    Support des contrats (C++26)
    Comparaison à trois voies
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilitaires généraux
    Opérateurs relationnels (obsolète en C++20)
     
    std::tuple
     
    Défini dans l'en-tête <tuple> 
    void swap( tuple& other ) noexcept(/* see below */);
    		(1) (depuis C++11)
    (constexpr depuis C++20) 
    constexpr void swap( const tuple& other ) noexcept(/* see below */) const;
    		(2) (depuis C++23)

    Appelle swap (qui peut être std::swap, ou peut être trouvée via ADL) pour chaque élément dans *this et son élément correspondant dans other.

    Si un appel de fonction swap sélectionné est mal formé, ou n'échange pas les éléments correspondants des deux tuples, le comportement est indéfini.

    		(jusqu'à C++23)

    Si un appel de fonction swap sélectionné n'échange pas les éléments correspondants des deux tuples, le comportement est indéfini.

    1) Le programme est mal formé si (std::is_swappable_v<Types> && ...) n'est pas true.
    2) Le programme est mal formé si (std::is_swappable_v<const Types> && ...) n'est pas true.
    		(depuis C++23)

    Paramètres

    autre - tuple de valeurs à échanger

    Valeur de retour

    (aucun)

    Exceptions

    noexcept spécification :
    noexcept (

    noexcept ( swap ( std:: declval < T0 & >> ( ) , std:: declval < T0 & > ( ) ) ) &&
    noexcept ( swap ( std:: declval < T1 & >> ( ) , std:: declval < T1 & > ( ) ) ) &&
    noexcept ( swap ( std:: declval < T2 & >> ( ) , std:: declval < T2 & > ( ) ) ) &&
    ...

    )

    Dans l'expression ci-dessus, l'identifiant swap est recherché de la même manière que celle utilisée par le trait C++17 std::is_nothrow_swappable .

    		(jusqu'en C++17)
    1)
    noexcept spécification :
    noexcept ( ( std:: is_nothrow_swappable_v < Types > && ... ) )
    2)
    noexcept spécification :
    noexcept ( ( std:: is_nothrow_swappable_v < const Types > && ... ) )
    		(depuis C++17)

    Exemple

    Exécuter ce code 
    #include <iostream>
#include <string>
#include <tuple>
int main()
{
    std::tuple<int, std::string, float> p1{42, "ABCD", 2.71}, p2;
    p2 = std::make_tuple(10, "1234", 3.14);
    auto print_p1_p2 = [&](auto rem)
    {
        std::cout << rem
                  << "p1 = {" << std::get<0>(p1)
                  << ", "     << std::get<1>(p1)
                  << ", "     << std::get<2>(p1) << "}, "
                  << "p2 = {" << std::get<0>(p2)
                  << ", "     << std::get<1>(p2)
                  << ", "     << std::get<2>(p2) << "}\n";
    };
    print_p1_p2("Before p1.swap(p2): ");
    p1.swap(p2);
    print_p1_p2("After  p1.swap(p2): ");
    swap(p1, p2);
    print_p1_p2("After swap(p1, p2): ");
}

    Sortie : 

    Before p1.swap(p2): p1 = {42, ABCD, 2.71}, p2 = {10, 1234, 3.14}
After  p1.swap(p2): p1 = {10, 1234, 3.14}, p2 = {42, ABCD, 2.71}
After swap(p1, p2): p1 = {42, ABCD, 2.71}, p2 = {10, 1234, 3.14}

    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 publié Comportement corrigé
    LWG 2456 C++11 la spécification noexcept est mal formée rendue fonctionnelle

    Voir aussi

    (C++11)
    		spécialise l'algorithme std::swap
    (modèle de fonction)
    (C++11)
    		échange le contenu
    (fonction membre publique de std::pair<T1,T2> )