std::indirectly_readable_traits
| Defined in header <iterator>
|
||
| template< class I > struct indirectly_readable_traits {}; |
(1) | (since C++20) |
| template< class T > struct indirectly_readable_traits<T*> : |
(2) | (since C++20) |
| template< class I > requires std::is_array_v<I> |
(3) | (since C++20) |
| template< class T > struct indirectly_readable_traits<const T> : |
(4) | (since C++20) |
| template< /* has-member-value-type */ T > struct indirectly_readable_traits<T> : |
(5) | (since C++20) |
| template< /* has-member-element-type */ T > struct indirectly_readable_traits<T> : |
(6) | (since C++20) |
| template< /* has-member-value-type */ T > requires /* has-member-element-type */<T> |
(7) | (since C++20) |
| template< /* has-member-value-type */ T > requires /* has-member-element-type */<T> && |
(8) | (since C++20) |
| Helper classes and concepts |
||
| template< class > struct /* cond-value-type */ {}; |
(1) | (exposition only*) |
| template< class T > requires std::is_object_v<T> |
(2) | (exposition only*) |
| template< class T > concept /* has-member-value-type */ = |
(3) | (exposition only*) |
| template< class T > concept /* has-member-element-type */ = |
(4) | (exposition only*) |
Computes the associated value type of the template argument. If the associated value type exists, it is represented by the nested type value_type, otherwise value_type is not defined. A program may specialize indirectly_readable_traits for a program-defined type.
Explanation
The specializations above can be informally described as below.
Given a type T, its associated value type V is determined as follows:
- If
Tis const-qualified,Vis the associated value type of const-unqualifiedT. - Otherwise, if
Tis an array type,Vis the cv-unqualified array element type. - Otherwise, a conditional value type
Cis determined first:
- If
Tis a pointer type,Cis the pointed-to type. - Otherwise, if
Thas nested typesvalue_typeandelement_type:
- If these types are the same (not considering cv-qualification),
Cistypename T::value_type. - Otherwise,
Cis undefined.
- If these types are the same (not considering cv-qualification),
- Otherwise, if
Thas the nested typevalue_typebut notelement_type,Cistypename T::value_type. - Otherwise, if
Thas the nested typeelement_typebut notvalue_type,Cistypename T::element_type. - Otherwise,
Cis undefined.
- If
- Then
Vis determined fromCas follows:- If
Cis undefined, orCis not an object type,Vis undefined. - Otherwise,
Vis cv-unqualifiedC.
- If
Notes
value_type is intended for use with indirectly_readable types such as iterators. It is not intended for use with ranges.
Example
| This section is incomplete Reason: no example |
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| LWG 3446 | C++20 | specializations (5,6) were ambiguous for types having both value_type and element_type nested types
|
added specialization (8) |
| LWG 3541 | C++20 | LWG 3446 introduced hard error for ambiguous cases that value_type and element_type are different
|
added specialization (7) |
See also
| (C++20) |
specifies that a type is indirectly readable by applying operator * (concept) |
| (C++20)(C++20)(C++23)(C++20)(C++20)(C++20) |
computes the associated types of an iterator (alias template) |
| provides uniform interface to the properties of an iterator (class template) |