Namespaces
Variants

    std::expected<T,E>::operator->, std::expected<T,E>::operator*

    Von de.cppreference.net
     
    C++
     
    Hilfsbibliothek
    Sprachunterstützung
    Typunterstützung (grundlegende Typen, RTTI)
    Feature-Test-Makros der Bibliothek (C++20)
    Programmhilfsmittel
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinenunterstützung (C++20)
    Vertragsunterstützung (C++26)
    Dreivektorenvergleich
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Allgemeine Hilfsmittel
    Relationsoperatoren (veraltet in C++20)
    Ganzzahlvergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabular-Typen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    std::expected
     
    Primäre Vorlage
    		 
    constexpr const T* operator->() const noexcept;
    		(1) (seit C++23) 
    constexpr T* operator->() noexcept;
    		(2) (seit C++23) 
    constexpr const T& operator*() const& noexcept;
    		(3) (seit C++23) 
    constexpr T& operator*() & noexcept;
    		(4) (seit C++23) 
    constexpr const T&& operator*() const&& noexcept;
    		(5) (seit C++23) 
    constexpr T&& operator*() && noexcept;
    		(6) (seit C++23)
    void partielle Spezialisierung
    		 
    constexpr void operator*() const noexcept;
    		(7) (seit C++23)

    Greift auf den erwarteten Wert zu, der in *this enthalten ist.

    1,2) Gibt einen Zeiger auf den erwarteten Wert zurück.
    3-6) Gibt einen Verweis auf den erwarteten Wert zurück.
    7) Gibt nichts zurück.

    Falls has_value() false ist, ist das Verhalten undefiniert.

    		(bis C++26)

    Falls has_value() false ist:

    • Wenn die Implementierung gehärtet ist, tritt eine Vertragsverletzung auf.
    • Wenn die Implementierung nicht gehärtet ist, ist das Verhalten undefiniert.
    		 (seit C++26)

    Rückgabewert

    1,2) std:: addressof ( val  )
    3,4) val
    5,6) std :: move ( val  )

    Hinweise

    Diese Operatoren prüfen nicht, ob der Optional einen erwarteten Wert repräsentiert. Benutzer können dies manuell durch Verwendung von has_value() oder operator bool() tun. Alternativ, falls geprüfter Zugriff benötigt wird, können value() oder value_or() verwendet werden.

    Beispiel

    Diesen Code ausführen 
    #include <cassert>
#include <expected>
#include <iomanip>
#include <iostream>
#include <string>
int main()
{
    using namespace std::string_literals;
    std::expected<int, std::string> ex1 = 6;
    assert(*ex1 == 6);
    *ex1 = 9;
    assert(*ex1 == 9);
    // *ex1 = "error"s; // Fehler, ex1 enthält einen erwarteten Wert vom Typ int
    ex1 = std::unexpected("error"s);
    // *ex1 = 13; // UB, ex1 enthält einen unerwarteten Wert
    assert(ex1.value_or(42) == 42);
    std::expected<std::string, bool> ex2 = "Moon"s;
    std::cout << "ex2: " << std::quoted(*ex2) << ", size: " << ex2->size() << '\n';
    // Sie können den erwarteten Wert "entnehmen", indem Sie operator* auf einen std::expected-Rvalue aufrufen
    auto taken = *std::move(ex2);
    std::cout << "taken " << std::quoted(taken) << "\n"
                 "ex2: " << std::quoted(*ex2) << ", size: " << ex2->size() << '\n';
}

    Mögliche Ausgabe: 

    ex2: "Moon", size: 4
taken "Moon"
ex2: "", size: 0

    Siehe auch

    		gibt den erwarteten Wert zurück
    (öffentliche Elementfunktion)
    		gibt den erwarteten Wert zurück falls vorhanden, andernfalls einen anderen Wert
    (öffentliche Elementfunktion)
    		prüft, ob das Objekt einen erwarteten Wert enthält
    (öffentliche Elementfunktion)
    		gibt den unerwarteten Wert zurück
    (öffentliche Elementfunktion)