Namensräume
Varianten

    std::ranges::swap

    Aus cppreference.com
     
    C++
     
    Utilities-Bibliothek
     
    <tbody> </tbody>
    definiert in Header <concepts>
    inline namespace /* unspecified */ { inline constexpr /* unspecified */ swap = /* unspecified */; }
    		 (Anpassungspunkt)
    Aufrufsignatur
    template< class T, class U > requires /* see below */ constexpr void swap(T&& t, U&& u) noexcept(/* see below */);

    Es tauscht die beiden Werte, die durch t und u refrenziert werden, aus.

    Ein Aufruf von ranges::swap

    1. ist ausdrucksäquivalent zu (void)swap(std::forward<T>(t), std::forward<U>(u)), falls dieser Ausdruck gültig ist, wo Überladungsauflösung mit den folgenden Kandidaten erfolgt:
      • template<class T> void swap(T&, T&) = delete;
      • template<class T, std::size_t N> void swap(T(&)[N], T(&)[N]) = delete;
      • jede Deklaration von swap, die durch argumentabhängige Suche, gefunden wird.
      Falls die Funktion, die durch die Überladungsauflösung aufgewählt worden ist, die Werte, die durch t und u referenziert werden, nicht austauscht, so ist das Program fehlerhaft (Es ist keine Fehlermeldung erforderlich).
    2. anderenfalls ist er ausdrucksäquivalent zu (void)ranges::swap_ranges(t, u) mit der Ausnahme, daß noexcept(ranges::swap(t, u)) und noexcept(ranges::swap(*t, *u)) gleich sind, falls T und U lokalisierbare Referenzen zu Arraytypen mit gleichem Umfang (aber möglicherweise unterschiedlichen Elementtypen) und ranges::swap(*t, *u) ein gültiger Ausdruck ist;
    3. anderenfalls werden die referenzierten Wert ausgetauscht mittels V v(std::move(t)); t = std::move(u); u = std::move(v);, falls T und U beide lokalisierbare Referenzen auf einen Typ V, der die Bedingungen std::move_constructible<V> und std::assignable_from<V&, V> erfüllt.
      • Ob der Aufruf möglicherweise Ausnahmen wirft, ist durch die obigen Operationen spezifiert.
      • Der Aufruf ist ein konstanter Unterausdruck, falls beide obigen Operationen und der Austausch von u and v während konstanter Evaluation benutzt werden kann.
      Falls eins der Konzepte nicht modelliert ist, ist das Pogramm fehlerhaft (Es ist keine Fehlermeldung erforderlich).
    4. In allen anderen Fällen ist ein Aufruf von ranges::swap fehlerhaft, welches in einen Substitutionsfehler führen kann, falls ranges::swap(t, u) im unmittelbaren Kontekt einer Templateinstanzierung auftritt.

    ausdrucksäquivalent

    Der Ausdruck e ist ausdrucksäquivalent zum Ausdruck f, falls e und f die gleiche Wirkung haben, entweder beide Ausnahmen werfen können oder beide keine Ausnahmen werfen (d.h. noexcept(e) == noexcept(f)) und entweder beide konstante Unterausdrücke oder beide nicht-konstante Unterausdrücke.

    Anpassungspunkte

    Der Name ranges::swap bezeichnet einen Anpassungspunkt, der ein konstantes Funktionsobjekt eines literalen semiregulären Klassentyp ist. Zu Darstellungszwecken wird die cv-unqualifizierte Version des Typs mit __swap_fn bezeichnet.

    Alle Instanzen von __swap_fn sind gleich. Die Wirkung des Aufrufens von verschiedenen Instanzen vom Typ __swap_fn auf den selben Argumenten ist äquivalent, unabhängig davon ob der Ausdruck, der die Instanz bezeichnet, ein lokalisierbarer oder lesbarer Wert ist und ob er eine const-Qualifikation hat oder nicht. A volatile-qualifizierte Instance muß nicht aufrufbar sein.) . Dadurch kann ranges::swap frei kopiert werden und die Kopien können beliebig ausgetauscht werden.

    Bei einer gegebenen Menge von Typen Args... bildet __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...> ab, falls std::declval<Args>()... die obigen Anforderungen an Argumente von ranges::swap. Anderenfalls kein Funktionsaufrufoperator von __swap_fn nimmt an der Auflösung der Überladungen teil.

    Beispiele

    #include <array>
#include <concepts>
#include <iostream>
#include <ranges>
#include <string_view>
#include <vector>

void print(std::string_view const 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 const name, int p, int q)
{
    std::cout << name << "1 = " << p << ", " << name << "2 = " << q << '\n';
}

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: types mismatch

    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: types mismatch

    // char f1[]{1,2,3};
    // int  f2[]{4,5,6};
    // std::ranges::swap(f1, f2); // error: types mismatch

    int g1{27}, g2{28};
    std::ranges::swap(g1, g2);
    print("g", g1, g2);
}

    Output: 

    a1{ 13 14 }, a2{ 10 11 12 }
b1{ 18 19 20 }, b2{ 15 16 17 }
d1{ 24 25 26 }, d2{ 21 22 23 }
g1 = 28, g2 = 27

    Referenzen

    (C++20)
    		 spezifiert, daß Werte eines Typs oder Werte zweier verschiedener Typen miteinander austauschbar sind.
    (Konzept) [edit]
    tauscht die Werte von zwei Objekten
    Original:
    swaps the values of two objects
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (Funktions-Template) [edit]