Namespaces
Variants

std:: incrementable_traits

From cppreference.net
C++
Iterator library
Iterator concepts
Iterator primitives
(deprecated in C++17)
incrementable_traits
(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)
Défini dans l'en-tête <iterator>
template < class I >
struct incrementable_traits { } ;
(1) (depuis C++20)
template < class T >

requires std:: is_object_v < T >

struct incrementable_traits < T * > ;
(2) (depuis C++20)
template < class T >

struct incrementable_traits < const T >

: incrementable_traits < T > { } ;
(3) (depuis C++20)
template < class T >

requires requires { typename T :: difference_type ; }

struct incrementable_traits < T > ;
(4) (depuis C++20)
template < class T >

requires ( ! requires { typename T :: difference_type ; } ) &&
requires ( const T & a, const T & b ) { { a - b } - > std:: integral ; }

struct incrementable_traits < T > ;
(5) (depuis C++20)

Calcule le type de différence associé du type I , le cas échéant. Un programme peut spécialiser incrementable_traits pour un type défini par le programme .

1) Le gabarit principal est une structure vide.
2) Spécialisation pour les pointeurs.
Fournit un type membre difference_type identique à std::ptrdiff_t .
3) Spécialisation pour les types qualifiés const.
4) Spécialisation pour les types qui définissent un type membre public et accessible difference_type .
Fournit un type membre difference_type identique à T::difference_type .
5) Spécialisation pour les types qui ne définissent pas un type membre public et accessible difference_type mais qui prennent en charge la soustraction.
Fournit un type membre difference_type identique à std:: make_signed_t < decltype ( std:: declval < T > ( ) - std:: declval < T > ( ) ) > . La règle des variations d'expressions implicites (voir ci-dessous) s'applique à l'expression a - b .

Variations d'expressions implicites

Une requires expression qui utilise une expression non modifiante pour un opérande constant lvalue requiert également les variations d'expression implicites .

Exemple

Cette section est incomplète
Raison : aucun exemple

Voir aussi

(C++20)
spécifie qu'un type semiregular peut être incrémenté avec les opérateurs de pré-incrémentation et post-incrémentation
(concept)
(C++20) (C++20) (C++23) (C++20) (C++20) (C++20)
calcule les types associés d'un itérateur
(alias de modèle)
fournit une interface uniforme pour les propriétés d'un itérateur
(modèle de classe)