Defined in header `<iterator>` | ||
---|---|---|

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. Users may specialize `incrementable_traits`

for a program-defined type.

1) Primary template is an empty struct.

3) Specialization for const-qualified types.

4) Specialization for types that define a public and accessible member type

`difference_type`

. Provides a member type `difference_type`

equal to `T::difference_type`

.
5) Specialization for types that do not define a public and accessible member type

`difference_type`

but do support subtraction. Provides a member type `difference_type`

equal to `std::make_signed_t<decltype(std::declval<T>() - std::declval<T>())>`

. The implicit expression variations rule (see below) applies to the expression `a - b`

.A *requires-expression* that uses an expression that is non-modifying for some constant lvalue operand also implicitly requires additional variations of that expression that accept a non-constant lvalue or (possibly constant) rvalue for the given operand unless such an expression variation is explicitly required with differing semantics. These *implicit expression variations* must meet the same semantic requirements of the declared expression. The extent to which an implementation validates the syntax of the variations is unspecified.

(C++20) | specifies that a `semiregular` type can be incremented with pre- and post-increment operators (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) |

© cppreference.com

Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.

https://en.cppreference.com/w/cpp/iterator/incrementable_traits