std::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

 

Algorithmenbibliothek

Beschränkte Algorithmen und Algorithmen für Bereiche (C++20)
Beschränkte Algorithmen, z.B. ranges::copy, ranges::sort, ...
Ausführungsrichtlinien (C++17)
is_execution_policy (C++17)   execution::seqexecution::parexecution::par_unseqexecution::unseq (C++17)    (C++17)(C++17)(C++20)	execution::sequenced_policyexecution::parallel_policyexecution::parallel_unsequenced_policyexecution::parallel_unsequenced (C++17)(C++17)(C++17)(C++20)
Nicht-modifizierende Sequenzoperationen Stapeloperationen for_each for_each_n (C++17) Suchoperationen all_ofany_ofnone_of (C++11)                (C++11)(C++11) countcount_if mismatch equal findfind_iffind_if_not (C++11) find_end find_first_of adjacent_find search search_n Modifizierende Sequenzoperationen Kopieroperationen copycopy_if (C++11) copy_backward copy_n (C++11) move (C++11) move_backward (C++11) Tauschoperationen swap iter_swap swap_ranges Transformationsoperationen replacereplace_if transform replace_copyreplace_copy_if Generierungsoperationen fill fill_n generate generate_n Entfernungsoperationen removeremove_if unique remove_copyremove_copy_if unique_copy Ordnungsändernde Operationen reverse reverse_copy rotate rotate_copy random_shuffleshuffle (bis C++17)(C++11) shift_leftshift_right (C++20)(C++20) Stichprobenoperationen sample (C++17)	Sortier- und verwandte Operationen Partitionierungsoperationen partition partition_copy (C++11)   stable_partition is_partitioned (C++11) partition_point (C++11) Sortieroperationen sort stable_sort partial_sort partial_sort_copy is_sorted (C++11) is_sorted_until (C++11) nth_element Binäre Suchoperationen (auf partitionierten Bereichen) lower_bound upper_bound equal_range binary_search Mengenoperationen (auf sortierten Bereichen) includes set_union set_intersection set_difference set_symmetric_difference Zusammenführungsoperationen (auf sortierten Bereichen) merge inplace_merge Heapoperationen push_heap pop_heap make_heap sort_heap is_heap (C++11) is_heap_until (C++11) Minimum/Maximum-Operationen max min minmax (C++11) clamp (C++17) max_element min_element minmax_element (C++11) Lexikographische Vergleichsoperationen lexicographical_compare lexicographical_compare_three_way (C++20) Permutationsoperationen next_permutation prev_permutation is_permutation (C++11) C-Bibliothek qsort bsearch
Numerische Operationen
iota (C++11) inner_product adjacent_difference    accumulate reduce (C++17) transform_reduce (C++17)	partial_sum inclusive_scan (C++17)    exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)
Operationen auf uninitialisiertem Speicher
uninitialized_copy uninitialized_move (C++17)    uninitialized_fill uninitialized_copy_n (C++11) uninitialized_move_n (C++17) uninitialized_fill_n	destroy (C++17) destroy_n (C++17) destroy_at (C++17) construct_at (C++20)       uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17)

 

Definiert in Header <algorithm>		(bis C++11)
Definiert in der Header-Datei <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 gegebenen Werte.

1) Tauscht die Werte a und b.

Diese Überladung nimmt nur an der Auflösung von Überladungen 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 Auflösung von Überladungen teil, wenn std::is_swappable_v<T2> true ist.

(seit C++17)

Parameter

a, b	-	die zu tauschenden 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 dem Bezeichner swap in der Ausnahme-Spezifikation findet diese Funktionsvorlage zusätzlich zu allem, was durch die üblichen Suchregeln gefunden wird, wodurch die Ausnahme-Spezifikation äquivalent zu C++17 std::is_nothrow_swappable wird.	(seit C++11) (bis C++17)
noexcept-Spezifikation:   noexcept(std::is_nothrow_swappable_v<T2>)	(seit C++17)

Komplexität

1) Konstant.

2) Linear in N.

Spezialisierungen

std::swap kann für von Programmen definierte Typen im Namespace std spezialisiert werden, aber solche Spezialisierungen werden von ADL nicht gefunden (der Namespace std ist nicht der assoziierte Namespace für den von Programmen definierten Typ).

(bis C++20)

Der erwartete Weg, einen von Programmen definierten Typ tauschbar zu machen, ist die Bereitstellung einer nicht-Member-Funktion swap im selben Namespace wie der Typ: siehe Swappable für Details.

Die folgenden Überladungen werden bereits von der Standardbibliothek bereitgestellt

std::swap(std::pair) (C++11)	spezialisiert den std::swap Algorithmus (Funktionsvorlage)
std::swap(std::tuple) (C++11)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::shared_ptr) (C++11)	spezialisiert den std::swap Algorithmus (Funktionsschablone)
std::swap(std::weak_ptr) (C++11)	spezialisiert den std::swap Algorithmus (Funktionsschablone)
std::swap(std::unique_ptr) (C++11)	spezialisiert den std::swap Algorithmus (Funktionsschablone)
std::swap(std::function) (C++11)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::basic_string)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::array) (C++11)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::deque)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::forward_list) (C++11)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::list)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::vector)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::map)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::multimap)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::set)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::multiset)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::unordered_map) (C++11)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::unordered_multimap) (C++11)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::unordered_set) (C++11)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::unordered_multiset) (C++11)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::queue) (C++11)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::priority_queue) (C++11)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::stack) (C++11)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::valarray) (C++11)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::basic_stringbuf) (C++11)	spezialisiert den std::swap Algorithmus (Funktionsvorlage)
std::swap(std::basic_istringstream) (C++11)	spezialisiert den std::swap Algorithmus (Funktionsvorlage)
std::swap(std::basic_ostringstream) (C++11)	spezialisiert den std::swap Algorithmus (Funktionsvorlage)
std::swap(std::basic_stringstream) (C++11)	spezialisiert den std::swap Algorithmus (Funktionsvorlage)
std::swap(std::basic_filebuf) (C++11)	spezialisiert den std::swap Algorithmus (Funktionsvorlage)
std::swap(std::basic_ifstream) (C++11)	spezialisiert den std::swap Algorithmus (Funktionsvorlage)
std::swap(std::basic_ofstream) (C++11)	spezialisiert den std::swap Algorithmus (Funktionsvorlage)
std::swap(std::basic_fstream) (C++11)	spezialisiert den std::swap Algorithmus (Funktionsvorlage)
std::swap(std::basic_syncbuf) (C++20)	spezialisiert den std::swap Algorithmus (Funktionsschablone)
std::swap(std::basic_spanbuf) (C++23)	spezialisiert den std::swap Algorithmus (Funktionsvorlage)
std::swap(std::basic_ispanstream) (C++23)	spezialisiert den std::swap Algorithmus (Funktionsvorlage)
std::swap(std::basic_ospanstream) (C++23)	spezialisiert den std::swap Algorithmus (Funktionsvorlage)
std::swap(std::basic_spanstream) (C++23)	spezialisiert den std::swap Algorithmus (Funktionsvorlage)
std::swap(std::basic_regex) (C++11)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::match_results) (C++11)	spezialisiert den std::swap Algorithmus (Funktionstemplate)
std::swap(std::thread) (C++11)	spezialisiert den std::swap Algorithmus (Funktion)
std::swap(std::unique_lock) (C++11)	spezialisiert den std::swap Algorithmus (Funktionsvorlage)
std::swap(std::shared_lock) (C++14)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::promise) (C++11)	spezialisiert den std::swap Algorithmus (Funktionstemplates)
std::swap(std::packaged_task) (C++11)	spezialisiert den std::swap Algorithmus (Funktionstemplates)
std::swap(std::optional) (C++17)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::any) (C++17)	spezialisiert den std::swap Algorithmus (function)
std::swap(std::variant) (C++17)	spezialisiert den std::swap Algorithmus (function template)
std::swap(std::basic_stacktrace) (C++23)	spezialisiert den std::swap Algorithmus (function template)
swap(std::filesystem::path) (C++17)	spezialisiert den std::swap Algorithmus (Funktion)
swap(std::expected) (C++23)	spezialisiert den std::swap Algorithmus (Funktion)
swap(std::jthread) (C++20)	spezialisiert den std::swap Algorithmus (Funktion)
swap(std::move_only_function) (C++23)	spezialisiert den std::swap Algorithmus (Funktion)
swap(std::stop_source) (C++20)	spezialisiert den std::swap Algorithmus (Funktion)
swap(std::stop_token) (C++20)	spezialisiert den std::swap Algorithmus (Funktion)

Beispiel

Führen Sie diesen Code aus

#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); // error, type requirements are not satisfied
    swap(p, q);      // OK, ADL finds the appropriate 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	Korrigiertes Verhalten
LWG 227	C++98	T musste nicht CopyConstructible oder DefaultConstructible sein (ein temporäres Objekt vom Typ T konnte möglicherweise nicht konstruiert werden)	T muss auch CopyConstructible sein
LWG 809	C++98	Arrays konnten nicht getauscht werden	Überladung (2) hinzugefügt
LWG 2554	C++11	mehrdimensionale Arrays zu tauschen kann niemals sein noexcept aufgrund von Namensauflösungsproblemen	wurde behoben

Siehe auch

ranges::swap (C++20)	tauscht die Werte von zwei Objekten (Customization Point Objekt)
iter_swap	Tauscht die Elemente, auf die zwei Iteratoren zeigen (Funktionstempelat)
swap_ranges	Tauscht zwei Elementbereiche (Funktionstempelat)
exchange (C++14)	ersetzt das Argument durch einen neuen Wert und gibt seinen vorherigen Wert zurück (Funktionsvorlage)