Namensräume
Varianten
Aktionen

std::experimental::ranges::swap

Von cppreference.com
< cpp‎ | experimental‎ | ranges
 
 
 
 
Allgemeine Dienstprogramme-Bibliothek
Hilfskomponenten
swap
Funktionsobjekte
Metaprogrammierung und Typ-Traits
Getaggte Paare und Tupel
                          
Tag-Spezifizierer
                                      
                          
 
Definiert in Header <experimental/ranges/utility>
namespace {

    constexpr /* nicht spezifiziert */ swap = /* nicht spezifiziert */;

}
(Ranges TS)
(Customization-Point-Objekt)
Aufruf-Signatur
template< class T, class U >

    requires /* siehe unten */

void swap( T&& t, U&& u ) noexcept(/* siehe unten */);

Vertauscht die Werte, auf die von t und u verwiesen wird.

Ein Aufruf von ranges::swap ist äquivalent zu

1) (void)swap(std::forward<T>(t), std::forward<U>(u)), wenn dieser Ausdruck gültig ist, wobei die Überladungsauflösung mit den folgenden Kandidaten durchgeführt wird
  • template<class T> void swap(T&, T&) = delete;
  • template<class T, std::size_t N> void swap(T(&)[N], T(&)[N]) = delete;
  • beliebige Deklarationen von swap, die durch Argumentabhängige Suche (ADL) gefunden werden.
Wenn die durch Überladungsauflösung ausgewählte Funktion die Werte, auf die von t und u verwiesen wird, nicht vertauscht, ist das Programm schlecht geformt; keine Diagnose erforderlich.
2) Andernfalls (void)ranges::swap_ranges(t, u), wenn T und U lvalue-Referenzen auf Array-Typen gleicher Ausdehnung sind (aber möglicherweise unterschiedliche Elementtypen haben) und ranges::swap(*t, *u) ein gültiger Ausdruck ist.
3) Andernfalls, wenn T und U beide V& für einen Typ V sind, der die syntaktischen Anforderungen von MoveConstructible<V> und Assignable<V&, V> erfüllt, werden die referenzierten Werte vertauscht, als ob durch V v{std::move(t)}; t = std::move(u); u = std::move(v);. Wenn die semantischen Anforderungen eines der Konzepte nicht erfüllt sind, ist das Programm schlecht geformt; keine Diagnose erforderlich.
4) In allen anderen Fällen ist ein Aufruf von ranges::swap schlecht geformt.

ranges::swap kann in einem konstanten Ausdruck verwendet werden, wenn jede Funktion, die er aufruft (wie oben beschrieben), so verwendet werden kann.

Inhalt

[bearbeiten] Customization Point Objects

Der Name ranges::swap bezeichnet ein Customization Point Object, das ein Funktionsobjekt eines literalen Semiregular-Klassentyps ist (der zur besseren Übersichtlichkeit als SwapT bezeichnet wird). Alle Instanzen von SwapT sind gleich. Daher kann ranges::swap frei kopiert werden und seine Kopien können austauschbar verwendet werden.

Gegeben eine Menge von Typen Args..., wenn std::declval<Args>()... die Anforderungen für Argumente an ranges::swap wie oben erfüllt, erfüllt SwapT ranges::Invocable<const SwapT, Args...>. Andernfalls nimmt kein Funktionsaufrufoperator von SwapT an der Überladungsauflösung teil.

In jeder Translation Unit, in der ranges::swap definiert ist, bezieht es sich auf dieselbe Instanz des Customization Point Objects. (Dies bedeutet, dass es frei in Dingen wie Inline-Funktionen und Funktionsvorlagen verwendet werden kann, ohne die Ein-Definitionen-Regel zu verletzen.)

[bearbeiten] Exceptions

1)
noexcept-Spezifikation:  
noexcept(noexcept((void)swap(std::forward<T>(t), std::forward<T>(u))))
, wobei swap wie oben beschrieben gefunden wird.
2)
noexcept-Spezifikation:  
noexcept(noexcept(ranges::swap(*t, *u)))
3)
noexcept-Spezifikation:  
noexcept(std::is_nothrow_move_constructible<V>::value &&
         std::is_nothrow_move_assignable<V>::value)

[bearbeiten] Beispiel

[bearbeiten] Siehe auch

tauscht die Werte von zwei Objekten
(Funktionsvorlage) [edit]