std::incrementable_traits

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Iterator library

Iterator primitives
iterator_traits
input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tag
iterator
Iterator adaptors
reverse_iterator move_iterator (C++11) back_insert_iterator front_insert_iterator insert_iterator	make_reverse_iterator (C++14) make_move_iterator (C++11) back_inserter front_inserter inserter
Stream iterators
istream_iterator
ostream_iterator
istreambuf_iterator
ostreambuf_iterator
Iterator operations
advance
distance
prev (C++11)
next (C++11)
Range access
begincbegin (C++11)(C++14)
endcend (C++11)(C++14)
rbegincrbegin (C++14)(C++14)
rendcrend (C++14)(C++14)
Container access
sizessize (C++17)(C++20)
empty (C++17)
data (C++17)

 

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 } -> 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.

2) Specialization for pointers. Provides a member type difference_type equal to 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 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.

Implicit expression variations

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.

See also

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