View source for cpp/iterator/incrementable traits

{{cpp/title|incrementable_traits}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header|iterator}}
{{dcl|num=1|since=c++20|
template< class I >
struct incrementable_traits {};
}}
{{dcl|num=2|since=c++20|
template< class T >
    requires std::is_object_v<T>
struct incrementable_traits<T*>;
}}
{{dcl|num=3|since=c++20|
template< class T >
struct incrementable_traits<const T>
    : incrementable_traits<T> {};
}}
{{dcl|num=4|since=c++20|
template< class T >
    requires requires { typename T::difference_type; }
struct incrementable_traits<T>;
}}
{{dcl|num=5|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>;
}}
{{dcl end}}

Computes the associated difference type of the type {{tt|I}}, if any. A program may specialize {{tt|incrementable_traits}} for a {{lsd|cpp/language/type#Program-defined type}}.

@1@ Primary template is an empty struct.

@2@ Specialization for pointers.
@@ Provides a member type {{tt|difference_type}} same as {{lc|std::ptrdiff_t}}.

@3@ Specialization for const-qualified types.

@4@ Specialization for types that define a public and accessible member type {{tt|difference_type}}.
@@ Provides a member type {{tt|difference_type}} same as {{tt|T::difference_type}}.

@5@ Specialization for types that do not define a public and accessible member type {{tt|difference_type}} but do support subtraction.
@@ Provides a member type {{tt|difference_type}} same as {{c/core|std::make_signed_t<decltype(std::declval<T>() - std::declval<T>())>}}. The implicit expression variations rule (see below) applies to the expression {{c|a - b}}.

{{cpp/concepts/implicit expression variations}}

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc|cpp/iterator/dsc weakly_incrementable}}
{{dsc inc|cpp/iterator/dsc iter_t}}
{{dsc inc|cpp/iterator/dsc iterator_traits}}
{{dsc end}}

{{langlinks|de|es|ja|ru|zh}}