Namespaces
Variants

std:: iter_value_t, std:: iter_reference_t, std:: iter_const_reference_t, std:: iter_difference_t, std:: iter_rvalue_reference_t, std:: iter_common_reference_t

From cppreference.net
C++
Iterator library
Iterator concepts
Iterator primitives
iter_value_t iter_difference_t iter_reference_t iter_const_reference_t iter_rvalue_reference_t iter_common_reference_t
(C++20) (C++20) (C++20) (C++23) (C++20) (C++20)
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
(C++20)
Iterator adaptors
Range access
(C++11) (C++14)
(C++14) (C++14)
(C++11) (C++14)
(C++14) (C++14)
(C++17) (C++20)
(C++17)
(C++17)
Definiert im Header <iterator>
template < class T >
using iter_value_t = /* siehe unten */ ;
(1) (seit C++20)
template < /*dereferenzierbar*/ T >
using iter_reference_t = decltype ( * std:: declval < T & > ( ) ) ;
(2) (seit C++20)
template < std:: indirectly_readable T >

using iter_const_reference_t =
std:: common_reference_t < const std :: iter_value_t < T > && ,

std :: iter_reference_t < T >> ;
(3) (seit C++23)
template < class T >
using iter_difference_t = /* siehe unten */ ;
(4) (seit C++20)
template < /*dereferenceable*/ T >

requires /* siehe unten */
using iter_rvalue_reference_t =

decltype ( ranges:: iter_move ( std:: declval < T & > ( ) ) ) ;
(5) (seit C++20)
template < std:: indirectly_readable T >

using iter_common_reference_t =
std:: common_reference_t < std :: iter_reference_t < T > ,

/*indirect-value-t*/ < T >> ;
(6) (seit C++20)
Hilfsvorlagen
template < class T >
concept /*dereferenceable*/ = /* siehe unten */ ;
(7) ( Nur zur Darstellung* )
template < std:: indirectly_readable T >
using /*indirect-value-t*/ = /* siehe unten */ ;
(8) ( Nur zur Darstellung* )

Berechne die zugehörigen Typen eines Iterators.

1) Berechnet den Werttyp von T .
2) Berechnet den reference type von T .
3) Berechnet den const reference type von T .
4) Berechnet den Differenztyp von T .
5) Berechnet den rvalue reference type von T . Die Bedingung für dieses Alias-Template ist genau dann erfüllt, wenn der Ausdruck ranges:: iter_move ( std:: declval < T & > ( ) ) gültig ist und einen referenzierbaren Typ hat.
6) Berechnet den common reference type von T . Dies ist der gemeinsame Referenztyp zwischen seinem Referenztyp und einem Lvalue-Referenz auf seinen Werttyp.
7) Das ausschließlich für die Darstellung verwendete Konzept dereferenceable ist genau dann erfüllt, wenn der Ausdruck * std:: declval < T & > ( ) gültig ist und einen referenzierbaren Typ hat.
8) Die ausschließlich für die Darstellung verwendete Alias-Vorlage indirect-value-t bezeichnet Folgendes:
  • std:: invoke_result_t < Proj & , /*indirect-value-t*/ < I >> falls T identisch ist mit std :: projected < I, Proj > für bestimmte Typen I und Proj .
  • Andernfalls, std :: iter_value_t < T > & .

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
P2609R3 C++20 std::iter_common_reference_t wurde definiert in Bezug
auf std :: iter_value_t < T > & was fälschlicherweise behandelte
std::projected Typen, die in Rvalue-Referenztypen projizieren 		definiert in Bezug auf
/*indirect-value-t*/ < T >
um solche Fälle zu behandeln

Siehe auch

(C++20)
spezifiziert, dass ein Typ indirekt lesbar ist durch Anwendung des Operators *
(Konzept)
(C++20)
spezifiziert, dass ein semiregular Typ mit Prä- und Post-Inkrementoperatoren inkrementiert werden kann
(Konzept)
(C++20)
berechnet den Werttyp eines indirectly_readable Typs
(Klassentemplate)
(C++20)
berechnet den Differenztyp eines weakly_incrementable Typs
(Klassentemplate)
bietet eine einheitliche Schnittstelle zu den Eigenschaften eines Iterators
(Klassentemplate)
(C++20) (C++23) (C++20) (C++23)
ermittelt Iterator- und Sentinel-Typen eines Ranges
(Alias-Template)
(C++20) (C++23) (C++20) (C++20)
ermittelt Referenztypen eines Ranges
(Alias-Template)
(C++20) (C++20) (C++20)
ermittelt Größen-, Differenz- und Werttypen eines Ranges
(Alias-Template)