std::ranges::swap

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Definiert in der Header-Datei <concepts>
namespace ranges {     inline namespace /* nicht spezifiziert */ {         inline constexpr /* nicht spezifiziert */ swap = /* nicht spezifiziert */;     } }		(seit C++20) (Customization-Point-Objekt)
Aufruf-Signatur
template< class T, class U > constexpr void ranges::swap( T&& t, U&& u ) noexcept(/* siehe unten */);		(seit C++20)

Tauscht die Werte, auf die durch t und u verwiesen wird.

ranges::swap(t, u) ist ausdrucksäquivalent zu

1. (void)swap(t, u), wenn t oder u einen Klassen- oder Aufzählungstyp haben, und dieser Ausdruck gültig ist, wobei die Überladungsauswahl im Namespace std::ranges mit dem zusätzlichen Kandidaten template<class T> void swap(T&, T&) = delete; durchgeführt wird.
   • Wenn die durch die Überladungsauswahl ausgewählte Funktion die Werte, auf die durch t und u verwiesen wird, nicht vertauscht, ist das Programm schlecht geformt; keine Diagnose erforderlich.
2. Andernfalls (void)ranges::swap_ranges(t, u), wenn t und u L-Wert-Arrays gleicher Ausdehnung (aber möglicherweise unterschiedlicher Elementtypen) sind und ranges::swap(*t, *u) ein gültiger Ausdruck ist, wobei noexcept((void)ranges::swap_ranges(t, u)) gleich noexcept(ranges::swap(*t, *u)) ist.
3. Andernfalls ein Ausdruck, der die referenzierten Werte von t und u vertauscht, wenn beide L-Werte des gleichen Typs V sind, der std::move_constructible<V> und std::assignable_from<V&, V> modelliert.
   • Das Ergebnis der Anwendung des noexcept-Operators auf diesen Ausdruck ist gleich std::is_nothrow_move_constructible_v<V> && std::is_nothrow_move_assignable_v<V>.
   • Dieser Ausdruck ist ein Konstantausdruck, wenn
     • V ein LiteralType ist,
     • beide t = std::move(u)) und u = std::move(t) Konstante Unterausdrücke sind, und
     • die vollständigen Ausdrücke der Initialisierer in den folgenden Deklarationen Konstante Unterausdrücke sind
       • V v1(std::move(t));
       • V v2(std::move(u));
4. Andernfalls ist ranges::swap(t, u) schlecht geformt, was zu einem Substitutionsfehler führen kann, wenn ranges::swap(t, u) im unmittelbaren Kontext einer Template-Instanziierung auftritt.

Customization Point Objects

Der Name ranges::swap bezeichnet ein Customization Point Object, das ein const Funktionsobjekt eines literalen semiregular-Klassentyps ist. Zu Auslegungszwecken wird die cv-unqualifizierte Version seines Typs als __swap_fn bezeichnet.

Alle Instanzen von __swap_fn sind gleich. Die Auswirkungen des Aufrufs unterschiedlicher Instanzen vom Typ __swap_fn mit denselben Argumenten sind äquivalent, unabhängig davon, ob der Ausdruck, der die Instanz bezeichnet, ein lvalue oder rvalue ist, und ob er const-qualifiziert ist oder nicht (jedoch ist keine volatile-qualifizierte Instanz aufrufbar).

Gegeben sei eine Menge von Typen Args.... Wenn std::declval<Args>()... die Anforderungen für Argumente an ranges::swap oben erfüllt, modelliert __swap_fn

• std::invocable<__swap_fn, Args...>,
• std::invocable<const __swap_fn, Args...>,
• std::invocable<__swap_fn&, Args...>, und
• std::invocable<const __swap_fn&, Args...>.
  

Andernfalls nimmt kein Funktionsaufrufoperator von __swap_fn an der Überladungsauswahl teil.

Beispiel

Führen Sie diesen Code aus

#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); // error: no swap found by 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); // error: extents mismatch
 
    // char f1[]{1, 2, 3};
    // int  f2[]{4, 5, 6};
    // std::ranges::swap(f1, f2); // error: no swap(*f1, *f2) found by ADL
 
    IntLike g1[]{1, 2, 3};
    int     g2[]{4, 5, 6};
    std::ranges::swap(g1, g2); // heterogeneous swap supported
    print("g", g1, g2);
 
    int h1{27}, h2{28};
    std::ranges::swap(h1, h2);
    print("h", h1, h2);
}

Ausgabe

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

Siehe auch

swappableswappable_with (C++20)	gibt an, dass ein Typ vertauscht werden kann oder dass zwei Typen miteinander vertauscht werden können (Konzept)
swap	tauscht die Werte von zwei Objekten (Funktionsvorlage)