Defined in header
Call signature
template<std::input_iteratorI1,std::sentinel_for<I1>S1,std::input_iteratorI2,std::sentinel_for<I2>S2,classProj1=std::identity,classProj2=std::identity,std::indirect_strict_weak_order<std::projected<I1,Proj1>,std::projected<I2,Proj2>>Comp=ranges::less>constexprboolincludes(I1first1,S1last1,I2first2,S2last2,Compcomp={},Proj1proj1={},Proj2proj2={}) (1) (since C++20)template<ranges::input_rangeR1,ranges::input_rangeR2,classProj1=std::identity,classProj2=std::identity,std::indirect_strict_weak_order<std::projected<ranges::iterator_t<R1>,Proj1>,std::projected<ranges::iterator_t<R2>,Proj2>>Comp=ranges::less>constexprboolincludes(R1&&r1,R2&&r2,Compcomp={},Proj1proj1={},Proj2proj2={}) (2) (since C++20)template</*execution-policy*/Ep,std::random_access_iteratorI1,std::sized_sentinel_for<I1>S1,std::random_access_iteratorI2,std::sized_sentinel_for<I2>S2,classProj1=std::identity,classProj2=std::identity,std::indirect_strict_weak_order<std::projected<I1,Proj1>,std::projected<I2,Proj2>>Comp=ranges::less>boolincludes(Ep&&policy,I1first1,S1last1,I2first2,S2last2,Compcomp={},Proj1proj1={},Proj2proj2={}); (3) (since C++26)template</*execution-policy*/Ep,/*sized-random-access-range*/R1,/*sized-random-access-range*/R2,classProj1=std::identity,classProj2=std::identity,std::indirect_strict_weak_order<std::projected<ranges::iterator_t<R1>,Proj1>,std::projected<ranges::iterator_t<R2>,Proj2>>Comp=ranges::less>boolincludes(Ep&&policy,R1&&r1,R2&&r2,Compcomp={},Proj1proj1={},Proj2proj2={}); (4) (since C++26)For the definition of /*execution-policy*/, see
; for the definition of /*sized-random-access-range*/, see
.
1,2) Checks if the sorted target range [first2, last2) or r2 is a subsequence of the sorted source range [first1, last1) or r1.
A sequence S is a subsequence of another sequence T if S can be obtained from T by removing any number of T’s elements and keeping the remaining elements in the same order.
3,4) Same as (1,2), but executed according to policy.
If any of the following conditions is satisfied, the behavior is undefined:
The source range is not
with respect to the comparator comp and projection proj1.
The target range is not sorted with respect to the comparator comp and projection proj2.
The function-like entities described on this page are
(informally known as niebloids), that is:
Explicit template argument lists cannot be specified when calling any of them.
None of them are visible to
.
When any of them are found by
as the name to the left of the function-call operator,
is inhibited.
Parameters
first1, last1 - the pair of iterators defining the source
r1 - the source range first2, last2 - the pair of iterators defining the target
r2 - the target range comp - the comparator to be applied to the (projected) elements proj1 - the projection to be applied to the elements in the source range proj2 - the projection to be applied to the elements in the target range policy - the
to use Return value
true if the target range is a subsequence of the source range; otherwise false.
Complexity
Given
N1 as ranges::distance(first1,last1) or ranges::distance(r1),
N2 as ranges::distance(first2,last2) or ranges::distance(r2):
1,2) At most 2⋅(N1+N2)-1 applications of comp, proj1 and proj2.
3,4)𝓞(N1+N2) applications of comp, proj1 and proj2.
Exceptions
3,4) During the execution process:
If the temporary memory resources required for parallelization are not available,
is thrown.
If an uncaught exception is thrown while accessing objects via an algorithm argument, the behavior is determined by the execution policy (for
,
is invoked).
Possible implementation
structincludes_fn{template<std::input_iteratorI1,std::sentinel_for<I1>S1,std::input_iteratorI2,std::sentinel_for<I2>S2,classProj1=std::identity,classProj2=std::identity,std::indirect_strict_weak_order<std::projected<I1,Proj1>,std::projected<I2,Proj2>>Comp=ranges::less>constexprbooloperator()(I1first1,S1last1,I2first2,S2last2,Compcomp={},Proj1proj1={},Proj2proj2={})const{for(;first2!=last2;++first1){if(first1==last1||comp(*first2,*first1))returnfalse;if(!comp(*first1,*first2))++first2;}returntrue;}template<ranges::input_rangeR>autoget_end(R&&r){returnranges::end(r);}template<ranges::forward_rangeR>autoget_end(R&&r){returnranges::next(ranges::begin(r),ranges::end(r));}template<ranges::input_rangeR1,ranges::input_rangeR2,classProj1=std::identity,classProj2=std::identity,std::indirect_strict_weak_order<std::projected<ranges::iterator_t<R1>,Proj1>,std::projected<ranges::iterator_t<R2>,Proj2>>Comp=ranges::less>constexprbooloperator()(R1&&r1,R2&&r2,Compcomp={},Proj1proj1={},Proj2proj2={})const{return(*this)(ranges::begin(r1),get_end(r1),ranges::begin(r2),get_end(r2),std::ref(comp),std::ref(proj1),std::ref(proj2));}};inlineconstexprautoincludes=includes_fn{};Example
Run this code
#include<algorithm>#include<cctype>#include<initializer_list>#include<iomanip>#include<iostream>#include<locale>#include<string>template<classT>std::ostream&operator<<(std::ostream&os,conststd::initializer_list<T>&list){for(os<<"{ ";constauto&elem:list)os<<elem<<' ';returnos<<"} ";}structtrue_false:std::numpunct<char>{std::stringdo_truename()const{return"? Yes\n";}std::stringdo_falsename()const{return"? No\n";}};intmain(){std::cout.imbue(std::locale(std::cout.getloc(),newtrue_false));autoignore_case=[](chara,charb){returnstd::tolower(a)<std::tolower(b);};constautoa={'a','b','c'},b={'a','c'},c={'a','a','b'},d={'g'},e={'a','c','g'},f={'A','B','C'},z={'a','b','c','f','h','x'};std::cout<<z<<"includes\n"<<std::boolalpha<<a<<std::ranges::includes(z.begin(),z.end(),a.begin(),a.end())<<b<<std::ranges::includes(z,b)<<c<<std::ranges::includes(z,c)<<d<<std::ranges::includes(z,d)<<e<<std::ranges::includes(z,e)<<f<<std::ranges::includes(z,f,ignore_case);}Output:
{ a b c f h x } includes { a b c } ? Yes { a c } ? Yes { a a b } ? No { g } ? No { a c g } ? No { A B C } ? Yes See also