Namespaces
Variants

std:: swap

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Definiert in Header <algorithm>
(bis C++11)
Definiert in Header <utility>
(seit C++11)
Definiert in Header <string_view>
template < class T >
void swap ( T & a, T & b ) ;
(1) (bedingt noexcept seit C++11)
(constexpr seit C++20)
template < class T2, std:: size_t N >
void swap ( T2 ( & a ) [ N ] , T2 ( & b ) [ N ] ) ;
(2) (bedingt noexcept seit C++11)
(constexpr seit C++20)

Tauscht die angegebenen Werte aus.

1) Tauscht die Werte a und b .

Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_move_constructible_v < T > && std:: is_move_assignable_v < T > true ist.

(seit C++17)
2) Tauscht die Arrays a und b . Entspricht std:: swap_ranges ( a, a + N, b ) .

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std:: is_swappable_v < T2 > true ist.

(seit C++17)

Inhaltsverzeichnis

Parameter

a, b - die zu vertauschenden Werte
Typanforderungen
-
T muss die Anforderungen von CopyConstructible und CopyAssignable (bis C++11) MoveConstructible und MoveAssignable (seit C++11) erfüllen.
-
T2 muss die Anforderungen von Swappable erfüllen.

Rückgabewert

(keine)

Ausnahmen

1)

(keine)

(bis C++11)
noexcept Spezifikation:
noexcept (

std:: is_nothrow_move_constructible < T > :: value &&
std:: is_nothrow_move_assignable < T > :: value

)
(seit C++11)
2)
noexcept Spezifikation:
noexcept ( noexcept ( swap ( * a, * b ) ) )
Die Suche nach der Bezeichnung swap in der Ausnahmespezifikation findet diese Funktionsvorlage zusätzlich zu allem, was durch die üblichen Suchregeln gefunden wird, wodurch die Ausnahmespezifikation äquivalent zu C++17 std::is_nothrow_swappable ist. 		(seit C++11)
(bis C++17)
noexcept Spezifikation:
noexcept ( std:: is_nothrow_swappable_v < T2 > )
(seit C++17)

Komplexität

1) Konstante.
2) Linear in N .

Spezialisierungen

std::swap kann für programmdefinierte Typen in namespace std spezialisiert werden , aber solche Spezialisierungen werden nicht durch ADL gefunden (der namespace std ist nicht der assoziierte Namespace für den programmdefinierten Typ).

(bis C++20)

Die erwartete Methode, um einen program-defined type swappable zu machen, ist das Bereitstellen einer Nicht-Member-Funktion swap im selben Namespace wie der Typ: siehe Swappable für Details.

Die folgenden Überladungen sind bereits durch die Standardbibliothek bereitgestellt:

(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktionsschablone)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktionsschablone)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktionsschablone)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktionsschablone)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktionsschablone)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktionsschablone)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++20)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++23)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++23)
spezialisiert den std::swap Algorithmus
(Funktionsschablone)
(C++23)
spezialisiert den std::swap Algorithmus
(Funktionsschablone)
(C++23)
spezialisiert den std::swap Algorithmus
(Funktionstemplate)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktionsschablone)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktion)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++14)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++17)
spezialisiert den std::swap Algorithmus
(Funktionsschablone)
(C++17)
spezialisiert den std::swap Algorithmus
(Funktion)
(C++17)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++23)
spezialisiert den std::swap Algorithmus
(Funktionsschablone)
(C++17)
spezialisiert den std::swap Algorithmus
(Funktion)
(C++23)
spezialisiert den std::swap Algorithmus
(Funktion)
(C++20)
spezialisiert den std::swap Algorithmus
(Funktion)
(C++23)
spezialisiert den std::swap Algorithmus
(Funktion)
(C++20)
spezialisiert den std::swap Algorithmus
(Funktion)
(C++20)
spezialisiert den std::swap Algorithmus
(Funktion)

Beispiel

Diesen Code ausführen 
#include <algorithm>
#include <iostream>
namespace Ns
{
    class A
    {
        int id {};
        friend void swap(A& lhs, A& rhs)
        {
            std::cout << "swap(" << lhs << ", " << rhs << ")\n";
            std::swap(lhs.id, rhs.id);
        }
        friend std::ostream& operator<<(std::ostream& os, A const& a)
        {
            return os << "A::id=" << a.id;
        }
    public:
        A(int i) : id {i} {}
        A(A const&) = delete;
        A& operator = (A const&) = delete;
    };
}
int main()
{
    int a = 5, b = 3;
    std::cout << a << ' ' << b << '\n';
    std::swap(a, b);
    std::cout << a << ' ' << b << '\n';
    Ns::A p {6}, q {9};
    std::cout << p << ' ' << q << '\n';
//  std::swap(p, q); // Fehler, Typanforderungen nicht erfüllt
    swap(p, q);      // OK, ADL findet die passende friend `swap`
    std::cout << p << ' ' << q << '\n';
}

Ausgabe: 

5 3
3 5
A::id=6 A::id=9
swap(A::id=6, A::id=9)
A::id=9 A::id=6

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 227 C++98 T war nicht erforderlich CopyConstructible oder DefaultConstructible zu sein
(ein temporäres Objekt vom Typ T könnte möglicherweise nicht konstruiert werden) 		T muss ebenfalls
CopyConstructible sein
LWG 809 C++98 Arrays konnten nicht getauscht werden Überladung (2) hinzugefügt
LWG 2554 C++11 Tauschen mehrdimensionaler Arrays kann niemals
noexcept sein aufgrund von Namensauflösungsproblemen 		funktionsfähig gemacht

Siehe auch

(C++20)
tauscht die Werte zweier Objekte
(Anpassungspunktobjekt)
tauscht die von zwei Iteratoren referenzierten Elemente
(Funktionstemplate)
tauscht zwei Elementbereiche
(Funktionstemplate)
(C++14)
ersetzt das Argument durch einen neuen Wert und gibt seinen vorherigen Wert zurück
(Funktionstemplate)