Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::expected
Modèle primaire
constexpr const T * operator - > ( ) const noexcept ;
(1) (depuis C++23)
constexpr T * operator - > ( ) noexcept ;
(2) (depuis C++23)
constexpr const T & operator * ( ) const & noexcept ;
(3) (depuis C++23)
constexpr T & operator * ( ) & noexcept ;
(4) (depuis C++23)
constexpr const T && operator * ( ) const && noexcept ;
(5) (depuis C++23)
constexpr T && operator * ( ) && noexcept ;
(6) (depuis C++23)
void Spécialisation partielle
constexpr void operator * ( ) const noexcept ;
(7) (depuis C++23)

Accède à la valeur attendue contenue dans * this .

1,2) Retourne un pointeur vers la valeur attendue.
3-6) Retourne une référence à la valeur attendue.
7) Ne retourne rien.

Si has_value() est false , le comportement est indéfini.

(jusqu'à C++26)

Si has_value() est false :

  • Si l'implémentation est renforcée , une violation de contrat se produit. De plus, si le gestionnaire de violation de contrat retourne sous la sémantique d'évaluation "observer", le comportement est indéfini.
  • Si l'implémentation n'est pas renforcée, le comportement est indéfini.
(depuis C++26)

Table des matières

Valeur de retour

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

Notes

Ces opérateurs ne vérifient pas si l'optional représente une valeur attendue, les utilisateurs peuvent le faire manuellement en utilisant has_value() ou operator bool() . Alternativement, si un accès vérifié est nécessaire, value() ou value_or() peuvent être utilisés.

Exemple

Exécuter ce code 
#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; // erreur, ex1 contient une valeur attendue de type int
    ex1 = std::unexpected("error"s);
    // *ex1 = 13; // comportement indéfini, ex1 contient une valeur inattendue
    assert(ex1.value_or(42) == 42);
    std::expected<std::string, bool> ex2 = "Moon"s;
    std::cout << "ex2: " << std::quoted(*ex2) << ", taille: " << ex2->size() << '\n';
    // Vous pouvez "prendre" la valeur attendue en appelant operator* sur une rvalue std::expected
    auto taken = *std::move(ex2);
    std::cout << "taken " << std::quoted(taken) << "\n"
                 "ex2: " << std::quoted(*ex2) << ", taille: " << ex2->size() << '\n';
}

Sortie possible : 

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

Voir aussi

retourne la valeur attendue
(fonction membre publique)
retourne la valeur attendue si présente, une autre valeur sinon
(fonction membre publique)
vérifie si l'objet contient une valeur attendue
(fonction membre publique)
retourne la valeur inattendue
(fonction membre publique)