The range[first, last) must be at least partially ordered with respect tovalue, i.e. it must satisfy all of the following requirements:

• partitioned with respect toelement< value orcomp(element, value) (that is, all elements for which the expression istrue precedes all elements for which the expression isfalse).
• partitioned with respect to!(value< element) or!comp(value, element).
• for all elements, ifelement< value orcomp(element, value) istrue then!(value< element) or!comp(value, element) is alsotrue.

A fully-sorted range meets these criteria.

The returned view is constructed from two iterators, one pointing to the first element that isnot less thanvalue and another pointing to the first elementgreater thanvalue. The first iterator may be alternatively obtained withstd::ranges::lower_bound(), the second - withstd::ranges::upper_bound().

The function-like entities described on this page arealgorithm function objects (informally known asniebloids), that is:

• Explicit template argument lists cannot be specified when calling any of them.
• None of them are visible toargument-dependent lookup.
• When any of them are found bynormal unqualified lookup as the name to the left of the function-call operator,argument-dependent lookup is inhibited.

[edit]Parameters

[edit]Return value

std::ranges::subrange containing a pair of iterators defining the wanted range, the first pointing to the first element that isnot less thanvalue and the second pointing to the first elementgreater thanvalue.

If there are no elementsnot less thanvalue, the last iterator (iterator that is equal tolast orranges::end(r)) is returned as the first element. Similarly if there are no elementsgreater thanvalue, the last iterator is returned as the second element.

[edit]Complexity

The number of comparisons performed is logarithmic in the distance betweenfirst andlast (at most2 * log2(last - first) + O(1) comparisons). However, for an iterator that does not modelrandom_access_iterator, the number of iterator increments is linear.

[edit]Possible implementation

struct equal_range_fn{template<std::forward_iterator I,std::sentinel_for<I> S,class Proj=std::identity,class T= std::projected_value_t<I, Proj>,std::indirect_strict_weak_order<const T*, std::projected<I, Proj>> Comp=ranges::less>constexprranges::subrange<I>        operator()(I first, S last,const T& value, Comp comp={}, Proj proj={})const{returnranges::subrange(ranges::lower_bound(first, last, value,std::ref(comp),std::ref(proj)),ranges::upper_bound(first, last, value,std::ref(comp),std::ref(proj)));} template<ranges::forward_range R,class Proj=std::identity,class T= std::projected_value_t<ranges::iterator_t<R>, Proj>,std::indirect_strict_weak_order<const T*, std::projected<ranges::iterator_t<R>,                                           Proj>> Comp=ranges::less>constexprranges::borrowed_subrange_t<R>        operator()(R&& r,const T& value, Comp comp={}, Proj proj={})const{return(*this)(ranges::begin(r),ranges::end(r), value,std::ref(comp),std::ref(proj));}}; inlineconstexpr equal_range_fn equal_range;

[edit]Notes

[edit]Example

#include <algorithm>#include <compare>#include <complex>#include <iostream>#include <vector> struct S{int number{};char name{};// note: name is ignored by these comparison operatorsfriendbool operator==(const S s1,const S s2){return s1.number== s2.number;}friendauto operator<=>(const S s1,const S s2){return s1.number<=> s2.number;}friendstd::ostream& operator<<(std::ostream& os, S o){return os<<'{'<< o.number<<", '"<< o.name<<"'}";}}; void println(auto rem,constauto& v){for(std::cout<< rem;constauto& e: v)std::cout<< e<<' ';std::cout<<'\n';} int main(){// note: not ordered, only partitioned w.r.t. S defined belowstd::vector<S> vec{{1,'A'},{2,'B'},{2,'C'},{2,'D'},{4,'D'},{4,'G'},{3,'F'}}; const S value{2,'?'}; namespace ranges= std::ranges; auto a= ranges::equal_range(vec, value);    println("1. ", a); auto b= ranges::equal_range(vec.begin(), vec.end(), value);    println("2. ", b); auto c= ranges::equal_range(vec,'D',ranges::less{},&S::name);    println("3. ", c); auto d= ranges::equal_range(vec.begin(), vec.end(),'D',ranges::less{},&S::name);    println("4. ", d); using CD=std::complex<double>;std::vector<CD> nums{{1,0},{2,2},{2,1},{3,0},{3,1}};auto cmpz=[](CD x, CD y){return x.real()< y.real();};#ifdef __cpp_lib_algorithm_default_value_typeauto p3= ranges::equal_range(nums,{2,0}, cmpz);#elseauto p3= ranges::equal_range(nums, CD{2,0}, cmpz);#endif    println("5. ", p3);}

1. {2, 'B'} {2, 'C'} {2, 'D'}2. {2, 'B'} {2, 'C'} {2, 'D'}3. {2, 'D'} {4, 'D'}4. {2, 'D'} {4, 'D'}5. (2,2) (2,1)

[edit]See also

• In other languages

• Español
• 日本語
• 中文