Namespaces
Variants
Views
Actions

std::incrementable_traits

From cppreference.com
< cpp‎ | iterator
 
 
Iterator library
Iterator concepts
Iterator primitives
(deprecated in C++17)
incrementable_traits
(C++20)


Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
(C++20)

Iterator adaptors
Iterator customization points
Iterator operations
(C++11)    
(C++11)
Range access
(C++11)(C++14)
(C++14)(C++14)    
(C++11)(C++14)
(C++14)(C++14)    
(C++17)(C++20)
(C++17)
(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 } -> 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.

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

[edit] Example

[edit] See also

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