26 Algorithms library [algorithms]

26.11 Specialized <memory> algorithms [specialized.algorithms]

26.11.2 Special memory concepts [special.mem.concepts]

1
#
Some algorithms in this subclause are constrained with the following exposition-only concepts:
🔗
template<class I> concept nothrow-input-iterator = // exposition only input_iterator<I> && is_lvalue_reference_v<iter_reference_t<I>> && same_as<remove_cvref_t<iter_reference_t<I>>, iter_value_t<I>>;
2
#
A type I models nothrow-input-iterator only if no exceptions are thrown from increment, copy construction, move construction, copy assignment, move assignment, or indirection through valid iterators.
3
#
[Note 1: 
This concept allows some input_iterator ([iterator.concept.input]) operations to throw exceptions.
— end note]
🔗
template<class S, class I> concept nothrow-sentinel-for = sentinel_for<S, I>; // exposition only
4
#
Types S and I model nothrow-sentinel-for only if no exceptions are thrown from copy construction, move construction, copy assignment, move assignment, or comparisons between valid values of type I and S.
5
#
[Note 2: 
This concept allows some sentinel_for ([iterator.concept.sentinel]) operations to throw exceptions.
— end note]
🔗
template<class S, class I> concept nothrow-sized-sentinel-for = // exposition only nothrow-sentinel-for<S, I> && sized_sentinel_for<S, I>;
6
#
Types S and I model nothrow-sized-sentinel-for only if no exceptions are thrown from the - operator for valid values of type I and S.
7
#
[Note 3: 
This concept allows some sized_sentinel_for ([iterator.concept.sizedsentinel]) operations to throw exceptions.
— end note]
🔗
template<class R> concept nothrow-input-range = // exposition only range<R> && nothrow-input-iterator<iterator_t<R>> && nothrow-sentinel-for<sentinel_t<R>, iterator_t<R>>;
8
#
A type R models nothrow-input-range only if no exceptions are thrown from calls to ranges​::​begin and ranges​::​end on an object of type R.
🔗
template<class I> concept nothrow-forward-iterator = // exposition only nothrow-input-iterator<I> && forward_iterator<I> && nothrow-sentinel-for<I, I>;
9
#
[Note 4: 
This concept allows some forward_iterator ([iterator.concept.forward]) operations to throw exceptions.
— end note]
🔗
template<class R> concept nothrow-forward-range = // exposition only nothrow-input-range<R> && nothrow-forward-iterator<iterator_t<R>>;
🔗
template<class I> concept nothrow-bidirectional-iterator = // exposition only nothrow-forward-iterator<I> && bidirectional_iterator<I>;
10
#
A type I models nothrow-bidirectional-iterator only if no exceptions are thrown from decrementing valid iterators.
[Note 5: 
This concept allows some bidirectional_iterator ([iterator.concept.bidir]) operations to throw exceptions.
— end note]
🔗
template<class R> concept nothrow-bidirectional-range = // exposition only nothrow-forward-range<R> && nothrow-bidirectional-iterator<iterator_t<R>>;
11
#
A type I models nothrow-random-access-iterator only if no exceptions are thrown from comparisons of valid iterators, or the -, +, -=, +=, [] operators on valid values of type I and iter_difference_t<I>.
[Note 6: 
This concept allows some random_access_iterator ([iterator.concept.random.access]) operations to throw exceptions.
— end note]
🔗
template<class R> concept nothrow-random-access-range = // exposition only nothrow-bidirectional-range<R> && nothrow-random-access-iterator<iterator_t<R>>; template<class R> concept nothrow-sized-random-access-range = // exposition only nothrow-random-access-range<R> && sized_range<R>;
12
#
A type R models nothrow-sized-random-access-range only if no exceptions are thrown from the call to ranges​::​size on an object of type R.