std:: sized_sentinel_for, std:: disable_sized_sentinel_for

From cppreference.com

indirectly_readable (C++20)
indirectly_writable (C++20)
weakly_incrementable (C++20)
incrementable (C++20)
is-integer-like is-signed-integer-like (C++20) (C++20)

sentinel_for (C++20)
sized_sentinel_for (C++20)
input_iterator (C++20)
output_iterator (C++20)
input_or_output_iterator (C++20)

forward_iterator (C++20)
bidirectional_iterator (C++20)
random_access_iterator (C++20)
contiguous_iterator (C++20)

Iterator primitives

input_iterator_tag output_iterator_tag forward_iterator_tag bidirectional_iterator_tag random_access_iterator_tag contiguous_iterator_tag

(C++20)

iter_value_t iter_difference_t iter_reference_t iter_const_reference_t iter_rvalue_reference_t iter_common_reference_t

(C++20) (C++20) (C++20) (C++23) (C++20) (C++20)

iterator (deprecated in C++17)
iterator_traits
incrementable_traits (C++20)
indirectly_readable_traits (C++20)

Algorithm concepts and utilities

Indirect callable concepts

indirectly_unary_invocable indirectly_regular_unary_invocable

(C++20) (C++20)

indirect_unary_predicate (C++20)
indirect_binary_predicate (C++20)

indirect_equivalence_relation (C++20)
indirect_strict_weak_order (C++20)

Common algorithm requirements

indirectly_movable (C++20)
indirectly_movable_storable (C++20)
indirectly_copyable (C++20)

indirectly_copyable_storable (C++20)
indirectly_swappable (C++20)
indirectly_comparable (C++20)

permutable (C++20)
mergeable (C++20)
sortable (C++20)

Utilities

indirect_result_t

(C++20)

projected

(C++20)

projected_value_t

(C++26)

Iterator adaptors

reverse_iterator
make_reverse_iterator (C++14)
move_iterator (C++11)
make_move_iterator (C++11)
default_sentinel_t default_sentinel (C++20) (C++20)
unreachable_sentinel_t unreachable_sentinel (C++20) (C++20)

front_insert_iterator
back_insert_iterator
inserter
insert_iterator
front_inserter
back_inserter
move_sentinel (C++20)

common_iterator (C++20)
counted_iterator (C++20)
basic_const_iterator (C++23)
const_iterator (C++23)
const_sentinel (C++23)
make_const_iterator (C++23)
make_const_sentinel (C++23)

Stream iterators

istream_iterator
ostream_iterator

istreambuf_iterator
ostreambuf_iterator

Iterator customization points
ranges::iter_move (C++20)
ranges::iter_swap (C++20)

Iterator operations

advance
distance
prev (C++11)
next (C++11)

ranges::advance (C++20)
ranges::distance (C++20)
ranges::prev (C++20)
ranges::next (C++20)

Range access

begin cbegin (C++11) (C++14)
rbegin crbegin (C++14) (C++14)

end cend (C++11) (C++14)
rend crend (C++14) (C++14)

size ssize (C++17) (C++20)
empty (C++17)
data (C++17)

Defined in header `<iterator>`
template < class S, class I > concept sized_sentinel_for = std:: sentinel_for < S, I > && ! std :: disable_sized_sentinel_for < std:: remove_cv_t < S > , std:: remove_cv_t < I >> && requires ( const I & i, const S & s ) { { s - i } - > std:: same_as < std:: iter_difference_t < I >> ; { i - s } - > std:: same_as < std:: iter_difference_t < I >> ; } ;	(1)	(since C++20)
template < class S, class I > inline constexpr bool disable_sized_sentinel_for = false ;	(2)	(since C++20)

1) The


        sized_sentinel_for

concept specifies that an object of the iterator type

and an object of the sentinel type

can be subtracted to compute the distance between them in constant time.

2) The


        disable_sized_sentinel_for

variable template can be used to prevent iterators and sentinels that can be subtracted but do not actually model


        sized_sentinel_for

from satisfying the concept.

A program may specialize


        disable_sized_sentinel_for

for cv-unqualified non-array object type

and

, as long as at least one of which is a program-defined type . Such specializations are usable in constant expressions and have type const bool .

Semantic requirements

Let i be an iterator of type I , and s a sentinel of type S such that [ i , s ) denotes a range. Let n be the smallest number of applications of ++ i necessary to make bool ( i == s ) be true . I and S model sized_sentinel_for<S, I> only if all following conditions are satisfied:

If n is representable by std:: iter_difference_t < I > , then s - i is well-defined and equals n .
If - n is representable by std:: iter_difference_t < I > , then i - s is well-defined and equals - n .

Equality preservation

Expressions declared in requires expressions of the standard library concepts are required to be equality-preserving (except where stated otherwise).

Implicit expression variations

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

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

ranges::sized_range (C++20)	specifies that a range knows its size in constant time (concept)
ranges::size (C++20)	returns an integer equal to the size of a range (customization point object)

std:: sized_sentinel_for, std:: disable_sized_sentinel_for

Semantic requirements

Equality preservation

Implicit expression variations

See also

Navigation