Namespaces
Variants

std::expected<T,E>:: transform_error

From cppreference.net
C++
Utilities library
std::expected
Primäres Template
template < class F >
constexpr auto transform_error ( F && f ) & ;
(1) (seit C++23)
template < class F >
constexpr auto transform_error ( F && f ) const & ;
(2) (seit C++23)
template < class F >
constexpr auto transform_error ( F && f ) && ;
(3) (seit C++23)
template < class F >
constexpr auto transform_error ( F && f ) const && ;
(4) (seit C++23)
void Partielle Spezialisierung
template < class F >
constexpr auto transform_error ( F && f ) & ;
(5) (seit C++23)
template < class F >
constexpr auto transform_error ( F && f ) const & ;
(6) (seit C++23)
template < class F >
constexpr auto transform_error ( F && f ) && ;
(7) (seit C++23)
template < class F >
constexpr auto transform_error ( F && f ) const && ;
(8) (seit C++23)

Wenn * this einen unerwarteten Wert enthält, ruft es f mit dem unerwarteten Wert von * this als Argument auf und gibt ein std::expected -Objekt zurück, das einen unerwarteten Wert enthält, der mit dem Ergebnis von f initialisiert wird. Andernfalls gibt es ein std::expected -Objekt zurück, das einen erwarteten Wert repräsentiert.

1-4) Der Erwartungswert wird mit dem Erwartungswert val von * this initialisiert.

Gegebener Typ G als:

1,2) std:: remove_cv_t < std:: invoke_result_t < F, decltype ( error ( ) ) >>
3,4) std:: remove_cv_t < std:: invoke_result_t < F, decltype ( std :: move ( error ( ) ) ) >>
5,6) std:: remove_cv_t < std:: invoke_result_t < F, decltype ( error ( ) ) >>
7,8) std:: remove_cv_t < std:: invoke_result_t < F, decltype ( std :: move ( error ( ) ) ) >>

Wenn eine der folgenden Bedingungen erfüllt ist, ist das Programm fehlerhaft:

  • G ist kein gültiges Template-Argument für std::unexpected .
  • Die folgende entsprechende Deklaration ist fehlerhaft:
1,2) G g ( std:: invoke ( std:: forward < F > ( f ) , error ( ) ) ) ;
3,4) G g ( std:: invoke ( std:: forward < F > ( f ) , std :: move ( error ( ) ) ) ;
5,6) G g ( std:: invoke ( std:: forward < F > ( f ) , Fehler ( ) ) ) ;
7,8) G g ( std:: invoke ( std:: forward < F > ( f ) , std :: move ( error ( ) ) ) ;


1,2) Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_constructible_v < T, decltype ( ( val ) ) > true ist.
3,4) Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_constructible_v < T, decltype ( std :: move ( val ) ) > true ist.

Inhaltsverzeichnis

Parameter

f - eine geeignete Funktion oder Callable Objekt, dessen Aufrufsignatur einen Nicht-Referenztyp zurückgibt

Rückgabewert

Gegebener Ausdruck expr als:

1,2) std:: invoke ( std:: forward < F > ( f ) , Fehler ( ) )
3,4) std:: invoke ( std:: forward < F > ( f ) , std :: move ( error ( ) ) )
5,6) std:: invoke ( std:: forward < F > ( f ) , Fehler ( ) )
7,8) std:: invoke ( std:: forward < F > ( f ) , std :: move ( error ( ) ) )

Die Rückgabewerte sind wie folgt definiert:

Überladung Wert von has_value()
true false
( 1,2 ) std:: expected < T, G > ( std:: in_place , val ) std:: expected < T, G >
( std:: unexpect , expr )
( 3,4 ) std:: expected < T, G > ( std:: in_place , std :: move ( val ) )
( 5,6 ) std:: expected < T, G > ( )
( 7,8 )

Beispiel

Dieser Abschnitt ist unvollständig
Grund: Kein Beispiel

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 3938 C++23 der erwartete Wert wurde durch value ( ) [1] erhalten geändert zu ** this
LWG 3973 C++23 der erwartete Wert wurde durch ** this [2] erhalten geändert zu val
  1. ↑ value() erfordert, dass E kopierkonstruierbar ist (siehe LWG-Issue 3843 ), während operator* dies nicht tut.
  2. ↑ ** this kann argumentabhängige Namenssuche auslösen.

Siehe auch

gibt das expected selbst zurück, falls es einen erwarteten Wert enthält; andernfalls gibt es das Ergebnis der gegebenen Funktion für den unerwarteten Wert zurück
(öffentliche Elementfunktion)
gibt ein expected zurück, das den transformierten erwarteten Wert enthält, falls dieser existiert; andernfalls gibt es das expected selbst zurück
(öffentliche Elementfunktion)