Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::tuple
Défini dans l'en-tête <tuple>
void swap ( tuple & other ) noexcept ( /* voir ci-dessous */ ) ;
(1) (depuis C++11)
(constexpr depuis C++20)
constexpr void swap ( const tuple & other ) noexcept ( /* voir ci-dessous */ ) const ;
(2) (depuis C++23)

Appelle swap (qui pourrait être std::swap , ou pourrait être trouvé 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'en 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)

Table des matières

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