Skip to content

Search topics & cppreference

Search all study topics, concept maps, and 6,587 C++ and C reference pages.

std::incrementable_traits

Computes the associated difference type of the type I, if any. A program may specialize incrementable_traits for a program-defined type.

Iterator
  • C++20
  • C++23
1 min readView on cppreference
NotebookLM
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. A program may specialize incrementable_traits for a program-defined type.

1) Primary template is an empty struct.
2) Specialization for pointers.
Provides a member type difference_type same as std::ptrdiff_t.
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 same as 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 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.

Implicit expression variations

A requires expression that uses an expression that is non-modifying for some constant lvalue operand also requires implicit expression variations.

Example

This section is incomplete
Reason: no example

See also

specifies that a semiregular type can be incremented with pre- and post-increment operators
(concept)
computes the associated types of an iterator
(alias template)
provides uniform interface to the properties of an iterator
(class template)

Content from this page on cppreference.com, licensed under CC-BY-SA 3.0 and GFDL. Modified: restyled, site navigation removed, code windows added. Offline snapshot of 9 February 2025.