swap(std::expected)

 

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

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::expected

Memberfunktionen

expected::expected

expected::~expected

expected::operator=

Observer

expected::operator->expected::operator*

expected::operator boolexpected::has_value

expected::value

expected::error

expected::value_or

expected::error_or

Monadische Operationen

expected::and_then

expected::or_else

expected::transform

expected::transform_error

Modifizierer

expected::emplace

expected::swap

Nicht-Member-Funktionen

operator==(std::expected)

swap(std::expected)

Hilfsklassen

unexpected

bad_expected_access

unexpect_tunexpect

 

friend constexpr void swap( expected& lhs, expected& rhs ) noexcept(/*siehe unten*/);		(seit C++23)

Überlädt den std::swap Algorithmus für std::expected. Vertauscht den Zustand von lhs mit dem von rhs. Ruft effektiv lhs.swap(rhs) auf.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn lhs.swap(rhs) gültig ist.

Diese Funktion ist für die gewöhnliche unqualifizierte oder qualifizierte Suche nicht sichtbar und kann nur durch argumentabhängige Suche gefunden werden, wenn std::expected<T, E> eine assoziierte Klasse der Argumente ist.

Parameter

lhs, rhs

-

expected Objekte, deren Zustände vertauscht werden sollen

Rückgabewert

(keine)

Ausnahmen

noexcept-Spezifikation:  

noexcept(noexcept(lhs.swap(rhs)))

Beispiel

Führen Sie diesen Code aus

#include <expected>
#include <iostream>
#include <string>
 
using Ex = std::expected<std::string, int>;
 
void show(const Ex& ex1, const Ex& ex2)
{
    for (int i{}; i < 2; ++i)
    {
        std::cout << (i ? "ex2" : "ex1");
        if (const Ex& ex = (i ? ex2 : ex1); ex.has_value())
            std::cout << ".has_value() = " << *ex << '\n';
        else
            std::cout << ".error() = " << ex.error() << '\n';
    }
}
 
int main()
{
    Ex ex1("\N{DOG FACE}");
    Ex ex2{"\N{BONE}"};
    show(ex1, ex2);
    swap(ex1, ex2);
    std::cout << "swap(ex1, ex2);\n";
    show(ex1, ex2);
    std::cout << '\n';
 
    ex2 = std::unexpected(13);
    show(ex1, ex2);
    swap(ex1, ex2);
    std::cout << "swap(ex1, ex2);\n";
    show(ex1, ex2);
    std::cout << '\n';
 
    ex2 = std::unexpected(19937);
    show(ex1, ex2);
    swap(ex1, ex2);
    std::cout << "swap(ex1, ex2);\n";
    show(ex1, ex2);
    std::cout << '\n';
}

Ausgabe

ex1.has_value() = 🐶
ex2.has_value() = 🦴
swap(ex1, ex2);
ex1.has_value() = 🦴
ex2.has_value() = 🐶
 
ex1.has_value() = 🦴
ex2.error() = 13
swap(ex1, ex2);
ex1.error() = 13
ex2.has_value() = 🦴
 
ex1.error() = 13
ex2.error() = 19937
swap(ex1, ex2);
ex1.error() = 19937
ex2.error() = 13

Siehe auch

swap	tauscht die Inhalte (member function)