std::ranges:: swap

Échange les valeurs référencées par t et u .

ranges:: swap ( t, u ) est équivalent-expression à :

1. ( void ) swap ( t, u ) , si t ou u a un type classe ou énumération, et que cette expression est valide, où la résolution de surcharge est effectuée dans l'espace de noms std::ranges avec le candidat supplémentaire template < class T > void swap ( T & , T & ) = delete ; .
   • Si la fonction sélectionnée par la résolution de surcharge n'échange pas les valeurs référencées par t et u , le programme est mal formé ; aucun diagnostic requis.
2. Sinon, ( void ) ranges:: swap_ranges ( t, u ) , si t et u sont des tableaux lvalue de même étendue (mais potentiellement de types d'éléments différents) et que ranges:: swap ( * t, * u ) est une expression valide, sauf que noexcept ( ( void ) ranges:: swap_ranges ( t, u ) ) est égal à noexcept ( ranges:: swap ( * t, * u ) ) .
3. Sinon, une expression qui échange les valeurs référencées de t et u , si elles sont toutes deux des lvalues de même type V qui modélise std:: move_constructible < V > et std:: assignable_from < V & , V > .
   • Le résultat de l'application de l'opérateur noexcept à cette expression est égal à std:: is_nothrow_move_constructible_v < V > && std:: is_nothrow_move_assignable_v < V > .
   • Cette expression est une expression constante si
     • V est un LiteralType ,
     • à la fois t = std :: move ( u ) ) et u = std :: move ( t ) sont des sous-expressions constantes , et
     • les expressions complètes des initialiseurs dans les déclarations suivantes sont des sous-expressions constantes :
       • V v1 ( std :: move ( t ) ) ;
       • V v2 ( std :: move ( u ) ) ;
4. Sinon, ranges:: swap ( t, u ) est mal formé, ce qui peut entraîner un échec de substitution lorsque ranges:: swap ( t, u ) apparaît dans le contexte immédiat d'une instanciation de template.

Objets de point de personnalisation

Le nom ranges::swap désigne un objet de point de personnalisation , qui est un objet fonction const d'un type de classe littéral semiregular . Voir CustomizationPointObject pour plus de détails.

Exemple

#include <array>
#include <concepts>
#include <iostream>
#include <ranges>
#include <string_view>
#include <vector>
void print(std::string_view name, 
           std::ranges::common_range auto const& p, 
           std::ranges::common_range auto const& q)
{
    std::cout << name << "1{ ";
    for (auto const& i : p)
        std::cout << i << ' ';
    std::cout << "}, " << name << "2{ ";
    for (auto const& i : q)
        std::cout << i << ' ';
    std::cout << "}\n";
}
void print(std::string_view name, int p, int q)
{
    std::cout << name << "1 = " << p << ", " << name << "2 = " << q << '\n';
}
struct IntLike
{
    int v;
};
void swap(IntLike& lhs, int& rhs)
{
    std::swap(lhs.v, rhs);
}
void swap(int& lhs, IntLike& rhs)
{
    std::swap(lhs, rhs.v);
}
std::ostream& operator<<(std::ostream& out, IntLike i)
{
    return out << i.v;
}
int main()
{
    std::vector a1{10, 11, 12}, a2{13, 14};
    std::ranges::swap(a1, a2);
    print("a", a1, a2);
    std::array b1{15, 16, 17}, b2{18, 19, 20};
    std::ranges::swap(b1, b2);
    print("b", b1, b2);
    // std::array c1{1, 2, 3}; std::array c2{4, 5};
    // std::ranges::swap(c1, c2); // erreur : aucun swap trouvé par ADL
    int d1[]{21, 22, 23}, d2[]{24, 25, 26};
    std::ranges::swap(d1, d2);
    print("d", d1, d2);
    // int e1[]{1, 2, 3}, e2[]{4, 5};
    // std::ranges::swap(e1, e2); // erreur : dimensions incompatibles
    // char f1[]{1, 2, 3};
    // int  f2[]{4, 5, 6};
    // std::ranges::swap(f1, f2); // erreur : aucun swap(*f1, *f2) trouvé par ADL
    IntLike g1[]{1, 2, 3};
    int     g2[]{4, 5, 6};
    std::ranges::swap(g1, g2); // échange hétérogène pris en charge
    print("g", g1, g2);
    int h1{27}, h2{28};
    std::ranges::swap(h1, h2);
    print("h", h1, h2);
}

a1{ 13 14 }, a2{ 10 11 12 }
b1{ 18 19 20 }, b2{ 15 16 17 }
d1{ 24 25 26 }, d2{ 21 22 23 }
g1{ 4 5 6 }, g2{ 1 2 3 }
h1 = 28, h2 = 27

Voir aussi