Namespaces
Variants

std::list<T,Allocator>:: swap

From cppreference.net

C++
Containers library
std::list
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
void swap ( list & other ) ;
(bis C++17)
void swap ( list & other ) noexcept ( /* siehe unten */ ) ;
(seit C++17)
(constexpr seit C++26)

Tauscht den Inhalt des Containers mit dem von other aus. Löst keine Move-, Copy- oder Swap-Operationen für einzelne Elemente aus.

Alle Iteratoren und Referenzen bleiben gültig. Es ist nicht spezifiziert, ob ein Iterator, der den end() Wert in diesem Container hält, nach der Operation auf diesen oder den anderen Container verweist.

Wenn std:: allocator_traits < allocator_type > :: propagate_on_container_swap :: value true ist, dann werden die Allokatoren durch einen unqualifizierten Aufruf von nicht-Member- swap ausgetauscht. Andernfalls werden sie nicht ausgetauscht (und wenn get_allocator ( ) ! = other. get_allocator ( ) , ist das Verhalten undefiniert).

(seit C++11)

Inhaltsverzeichnis

Parameter

other - Container, mit dem die Inhalte ausgetauscht werden sollen

Ausnahmen

(keine)

(bis C++17)
noexcept Spezifikation:
noexcept ( std:: allocator_traits < Allocator > :: is_always_equal :: value )
(seit C++17)

Komplexität

Konstante.

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <list>
template<class Os, class Co>
Os& operator<<(Os& os, const Co& co)
{
    os << '{';
    for (const auto& i : co)
        os << ' ' << i;
    return os << " } ";
}
int main()
{
    std::list<int> a1{1, 2, 3}, a2{4, 5};
    auto it1 = std::next(a1.begin());
    auto it2 = std::next(a2.begin());
    int& ref1 = a1.front();
    int& ref2 = a2.front();
    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 Austausch die Iteratoren und Referenzen mit ihren
    // ursprünglichen Elementen verbunden bleiben, z.B. it1, das auf ein Element in 'a1' mit Wert 2
    // zeigte, zeigt weiterhin auf dasselbe Element, obwohl dieses Element in 'a2' verschoben wurde.
}

Ausgabe: 

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

Siehe auch

spezialisiert den std::swap Algorithmus
(Funktions-Template)