Namespaces
Variants

std::array<T,N>:: swap

From cppreference.net
C++
Containers library
std::array
void swap ( array & other ) noexcept ( /* siehe unten */ ) ;
(seit C++11)
(constexpr seit C++20)

Tauscht den Inhalt des Containers mit dem von other aus. Veranlasst keine Iteratoren und Referenzen, sich mit dem anderen Container zu assoziieren.

Inhaltsverzeichnis

Parameter

other - Container, mit dem die Inhalte ausgetauscht werden sollen

Rückgabewert

(keine)

Exceptions

noexcept Spezifikation:
noexcept ( noexcept ( swap ( std:: declval < T & > ( ) , std:: declval < T & > ( ) ) ) )

Im obigen Ausdruck wird der Bezeichner swap auf die gleiche Weise gesucht, wie es vom C++17-Merkmal std::is_nothrow_swappable verwendet wird.

(bis C++17)
noexcept Spezifikation:
noexcept ( std:: is_nothrow_swappable_v < T > )
(seit C++17)
For zero-sized arrays,
noexcept Spezifikation:
noexcept

Komplexität

Linear in der Größe des Containers.

Beispiel

Diesen Code ausführen 
#include <array>
#include <iostream>
template<class Os, class V> Os& operator<<(Os& os, const V& v)
{
    os << '{';
    for (auto i : v)
        os << ' ' << i;
    return os << " } ";
}
int main()
{
    std::array<int, 3> a1{1, 2, 3}, a2{4, 5, 6};
    auto it1 = a1.begin();
    auto it2 = a2.begin();
    int& ref1 = a1[1];
    int& ref2 = a2[1];
    std::cout << a1 << a2 << *it1 << ' ' << *it2 << ' ' << ref1 << ' ' << ref2 << '\n';
    a1.swap(a2);
    std::cout << a1 << a2 << *it1 << ' ' << *it2 << ' ' << ref1 << ' ' << ref2 << '\n';
    // Beachten Sie, dass nach dem Swap Iteratoren und Referenzen mit ihrem ursprünglichen
    // Array verbunden bleiben, z.B. zeigt `it1` weiterhin auf Element a1[0], `ref1` bezieht sich weiterhin auf a1[1].
}

Ausgabe: 

{ 1 2 3 } { 4 5 6 } 1 4 2 5
{ 4 5 6 } { 1 2 3 } 4 1 5 2

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 2456 C++11 die noexcept Spezifikation ist fehlerhaft funktionsfähig gemacht

Siehe auch

(C++11)
spezialisiert den std::swap Algorithmus
(Funktionsschablone)