Two ranges are considered equal if they have the same number of elements and every pair of corresponding projected elements satisfiespred. That is,std::invoke(pred,std::invoke(proj1,*first1),std::invoke(proj2,*first2)) returnstrue for all pairs of corresponding elements in both ranges.

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

If the length of the range[first1, last1) does not equal the length of the range[first2, last2), returnsfalse.

If the elements in the two ranges are equal after projection, returnstrue.

Otherwise returnsfalse.

[edit]Notes

ranges::equal should not be used to compare the ranges formed by the iterators fromstd::unordered_set,std::unordered_multiset,std::unordered_map, orstd::unordered_multimap because the order in which the elements are stored in those containers may be different even if the two containers store the same elements.

When comparing entire containers or string views for equality,operator== for the corresponding type are usually preferred.

ranges::equal is not guaranteed to be short-circuit. E.g. if the first pair elements of both ranges do not compare equal, the rest of elements may also be compared. Non-short-circuit comparison may happen when the ranges are compared withstd::memcmp or implementation-specific vectorized algorithms.

[edit]Complexity

At mostmin(last1- first1, last2- first2) applications of the predicate and corresponding projections.

However, ifS1 andS2 both modelstd::sized_sentinel_for their respective iterators, andlast1- first1!= last2- first2 then no applications of the predicate are made (size mismatch is detected without looking at any elements).

[edit]Possible implementation

struct equal_fn{template<std::input_iterator I1,std::sentinel_for<I1> S1,std::input_iterator I2,std::sentinel_for<I2> S2,class Pred=ranges::equal_to,class Proj1=std::identity,class Proj2=std::identity>  requiresstd::indirectly_comparable<I1, I2, Pred, Proj1, Proj2>constexprbool      operator()(I1 first1, S1 last1, I2 first2, S2 last2,                 Pred pred={}, Proj1 proj1={}, Proj2 proj2={})const{ifconstexpr(std::sized_sentinel_for<S1, I1> andstd::sized_sentinel_for<S2, I2>)if(std::ranges::distance(first1, last1)!= std::ranges::distance(first2, last2))returnfalse; for(; first1!= last1;++first1,(void)++first2)if(!std::invoke(pred,std::invoke(proj1,*first1),std::invoke(proj2,*first2)))returnfalse;returntrue;} template<ranges::input_range R1,ranges::input_range R2,class Pred=ranges::equal_to,class Proj1=std::identity,class Proj2=std::identity>  requiresstd::indirectly_comparable<ranges::iterator_t<R1>,ranges::iterator_t<R2>,                                      Pred, Proj1, Proj2>constexprbool      operator()(R1&& r1, R2&& r2, Pred pred={}, Proj1 proj1={}, Proj2 proj2={})const{return(*this)(ranges::begin(r1),ranges::end(r1),ranges::begin(r2),ranges::end(r2),std::ref(pred),std::ref(proj1),std::ref(proj2));}}; inlineconstexpr equal_fn equal;

[edit]Example

#include <algorithm>#include <iomanip>#include <iostream>#include <ranges>#include <string_view> constexprbool is_palindrome(conststd::string_view s){namespace views= std::views;auto forward= s|views::take(s.size()/2);auto backward= s|views::reverse|views::take(s.size()/2);return std::ranges::equal(forward, backward);} void test(conststd::string_view s){std::cout<<std::quoted(s)<<" is "<<(is_palindrome(s)?"":"not ")<<"a palindrome\n";} int main(){    test("radar");    test("hello");    static_assert(is_palindrome("ABBA") and not is_palindrome("AC/DC"));}

"radar" is a palindrome"hello" is not a palindrome

[edit]See also

• In other languages

• Español
• 日本語
• Русский
• 中文