Namespaces
Variants

std::pair<T1,T2>:: swap

From cppreference.net
C++
Utilities library
std::pair
(1)
void swap ( pair & other ) noexcept ( /* voir ci-dessous */ ) ;
(depuis C++11)
(jusqu'à C++20)
constexpr void swap ( pair & other ) noexcept ( /* voir ci-dessous */ ) ;
(depuis C++20)
constexpr void swap ( const pair & other ) const noexcept ( /* voir ci-dessous */ ) ;
(2) (depuis C++23)

Échange first avec other.first et second avec other.second , comme par using std:: swap ; swap ( first, other. first ) ; swap ( second, other. second ) ; .

Si l'appel de la fonction swap sélectionnée est mal formé ou n'échange pas la valeur du membre, le comportement est indéfini.

(jusqu'à C++23)
1) Le programme est mal formé si std:: is_swappable_v < T1 > ou std:: is_swappable_v < T2 > n'est pas true .
2) Le programme est mal formé si std:: is_swappable_v < const T1 > ou std:: is_swappable_v < const T2 > n'est pas true .

Si l'appel de la fonction swap sélectionnée n'échange pas la valeur du membre, le comportement est indéfini.

(depuis C++23)

Table des matières

Paramètres

autre - paire de valeurs à échanger

Valeur de retour

(aucun)

Exceptions

noexcept spécification :
noexcept (

noexcept ( swap ( first, other. first ) ) &&
noexcept ( swap ( second, other. second ) )

)

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'à C++17)
1)
noexcept spécification :
noexcept (

std:: is_nothrow_swappable_v < first_type > &&
std:: is_nothrow_swappable_v < second_type >

)
2)
noexcept spécification :
noexcept (

std:: is_nothrow_swappable_v < const first_type > &&
std:: is_nothrow_swappable_v < const second_type >

)
(depuis C++17)

Exemple

Exécuter ce code 
#include <iostream>
#include <utility>
#include <string>
int main()
{
    std::pair<int, std::string> p1(10, "test"), p2;
    p2.swap(p1);
    std::cout << "(" << p2.first << ", " << p2.second << ")\n";
#if __cpp_lib_ranges_zip >= 202110L
    // Utilisation de la surcharge swap qualifiée const de C++23
    // (swap ne propage plus la constance de pair)
    int i1 = 10, i2{};
    std::string s1("test"), s2;
    const std::pair<int&, std::string&> r1(i1, s1), r2(i2, s2);
    r2.swap(r1);
    std::cout << "(" << i2 << ", " << s2 << ")\n";
#endif
}

Sortie possible : 

(10, test)
(10, test)

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

échange les valeurs de deux objets
(fonction template)
échange le contenu de deux tuple s
(fonction membre publique de std::tuple<Types...> )