std::incrementable_traits - cppreference.com (original) (raw)
| Defined in header | ||
|---|---|---|
| template< class I > struct incrementable_traits {}; | (1) | (since C++20) |
| template< class T > requires std::is_object_v<T> struct incrementable_traits<T*>; | (2) | (since C++20) |
| template< class T > struct incrementable_traits<const T> : incrementable_traits<T> {}; | (3) | (since C++20) |
| template< class T > requires requires { typename T::difference_type; } struct incrementable_traits<T>; | (4) | (since 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) | (since C++20) |
Computes the associated difference type of the type I, if any. A program may specialize incrementable_traits for a program-defined type.
Primary template is an empty struct.
Specialization for pointers.
Provides a member type difference_type same as std::ptrdiff_t.
Specialization for const-qualified types.
Specialization for types that define a public and accessible member type
difference_type.
Provides a member type difference_type same as T::difference_type.
- Specialization for types that do not define a public and accessible member type
difference_typebut do support subtraction.
Provides a member type difference_type same as std::make_signed_t<decltype(std::declval<T>() - std::declval<T>())>. The implicit expression variations rule (see below) applies to the expression a - b.
[edit] Implicit expression variations
A requires expression that uses an expression that is non-modifying for some constant lvalue operand also requires implicit expression variations.