Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      std::includes

      From cppreference.com
      <cpp‎ |algorithm
       
       
      Algorithm library
      Constrained algorithms and algorithms on ranges(C++20)
      Constrained algorithms, e.g.ranges::copy,ranges::sort, ...
      Execution policies(C++17)
      Sorting and related operations
      Partitioning operations
      Sorting operations
      Binary search operations
      (on partitioned ranges)
      Set operations (on sorted ranges)
      Merge operations (on sorted ranges)
      Heap operations
      Minimum/maximum operations
      (C++11)
      (C++17)
      Lexicographical comparison operations
      Permutation operations
      C library
      Numeric operations
      Operations on uninitialized memory
       
      Defined in header<algorithm>
      template<class InputIt1,class InputIt2>

      bool includes( InputIt1 first1, InputIt1 last1,

                     InputIt2 first2, InputIt2 last2);
      		 (1)(constexpr since C++20)
      template<class ExecutionPolicy,

               class ForwardIt1,class ForwardIt2>
      bool includes( ExecutionPolicy&& policy,
                     ForwardIt1 first1, ForwardIt1 last1,

                     ForwardIt2 first2, ForwardIt2 last2);
      		 (2)(since C++17)
      template<class InputIt1,class InputIt2,class Compare>

      bool includes( InputIt1 first1, InputIt1 last1,

                     InputIt2 first2, InputIt2 last2, Compare comp);
      		 (3)(constexpr since C++20)
      template<class ExecutionPolicy,

               class ForwardIt1,class ForwardIt2,class Compare>
      bool includes( ExecutionPolicy&& policy,
                     ForwardIt1 first1, ForwardIt1 last1,

                     ForwardIt2 first2, ForwardIt2 last2, Compare comp);
      		 (4)(since C++17)

      Returnstrue if the sorted range[first2, last2) is asubsequence of the sorted range[first1, last1) (a subsequence need not be contiguous).

      1) If[first1, last1) or[first2, last2) is notsorted with respect tooperator<(until C++20)std::less{}(since C++20), the behavior is undefined.
      3) If[first1, last1) or[first2, last2) is not sorted with respect tocomp, the behavior is undefined.
      2,4) Same as(1,3), but executed according topolicy.
      These overloads participate in overload resolution only if all following conditions are satisfied:

      std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> istrue.

      		(until C++20)

      std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> istrue.

      		(since C++20)

      Contents

      [edit]Parameters

      first1, last1 - the pair of iterators defining the sortedrange of elements to examine
      first2, last2 - the pair of iterators defining the sortedrange of elements to search for
      policy - theexecution policy to use
      comp - comparison function object (i.e. an object that satisfies the requirements ofCompare) which returns ​true if the first argument isless than (i.e. is orderedbefore) the second.

      The signature of the comparison function should be equivalent to the following:

      bool cmp(const Type1& a,const Type2& b);

      While the signature does not need to haveconst&, the function must not modify the objects passed to it and must be able to accept all values of type (possibly const)Type1 andType2 regardless ofvalue category (thus,Type1& is not allowed, nor isType1 unless forType1 a move is equivalent to a copy(since C++11)).
      The typesType1 andType2 must be such that an object of typeInputIt can be dereferenced and then implicitly converted to both of them.​

      Type requirements
      -
      InputIt1, InputIt2 must meet the requirements ofLegacyInputIterator.
      -
      ForwardIt1, ForwardIt2 must meet the requirements ofLegacyForwardIterator.
      -
      Compare must meet the requirements ofCompare.

      [edit]Return value

      true if[first2, last2) is a subsequence of[first1, last1); otherwisefalse.

      An empty sequence is a subsequence of any sequence, sotrue is returned if[first2, last2) is empty.

      [edit]Complexity

      Given\(\scriptsize N_1\)N1 asstd::distance(first1, last1) and\(\scriptsize N_2\)N2 asstd::distance(first2, last2):

      1,2) At most\(\scriptsize 2 \cdot (N_1+N_2)-1\)2⋅(N1+N2)-1 comparisons usingoperator<(until C++20)std::less{}(since C++20).
      3,4) At most\(\scriptsize 2 \cdot (N_1+N_2)-1\)2⋅(N1+N2)-1 applications of the comparison functioncomp.

      [edit]Exceptions

      The overloads with a template parameter namedExecutionPolicy report errors as follows:

      • If execution of a function invoked as part of the algorithm throws an exception andExecutionPolicy is one of thestandard policies,std::terminate is called. For any otherExecutionPolicy, the behavior is implementation-defined.
      • If the algorithm fails to allocate memory,std::bad_alloc is thrown.

      [edit]Possible implementation

      include (1)
      template<class InputIt1,class InputIt2>bool includes(InputIt1 first1, InputIt1 last1,              InputIt2 first2, InputIt2 last2){for(; first2!= last2;++first1){if(first1== last1||*first2<*first1)returnfalse;if(!(*first1<*first2))++first2;}returntrue;}
      include (3)
      template<class InputIt1,class InputIt2,class Compare>bool includes(InputIt1 first1, InputIt1 last1,              InputIt2 first2, InputIt2 last2, Compare comp){for(; first2!= last2;++first1){if(first1== last1|| comp(*first2,*first1))returnfalse;if(!comp(*first1,*first2))++first2;}returntrue;}

      [edit]Example

      Run this code
      #include <algorithm>#include <cctype>#include <iostream> template<class Os,class Co>Os& operator<<(Os& os,const Co& v){for(constauto& i: v)        os<< i<<' ';return os<<'\t';} int main(){constauto        v1={'a','b','c','f','h','x'},        v2={'a','b','c'},        v3={'a','c'},        v4={'a','a','b'},        v5={'g'},        v6={'a','c','g'},        v7={'A','B','C'}; auto no_case=[](char a,char b){returnstd::tolower(a)<std::tolower(b);}; std::cout<< v1<<"\nincludes:\n"<<std::boolalpha<< v2<<": "<< std::includes(v1.begin(), v1.end(), v2.begin(), v2.end())<<'\n'<< v3<<": "<< std::includes(v1.begin(), v1.end(), v3.begin(), v3.end())<<'\n'<< v4<<": "<< std::includes(v1.begin(), v1.end(), v4.begin(), v4.end())<<'\n'<< v5<<": "<< std::includes(v1.begin(), v1.end(), v5.begin(), v5.end())<<'\n'<< v6<<": "<< std::includes(v1.begin(), v1.end(), v6.begin(), v6.end())<<'\n'<< v7<<": "<< std::includes(v1.begin(), v1.end(), v7.begin(), v7.end(), no_case)<<" (case-insensitive)\n";}

      Output:

      a b c f h xincludes:a b c   : truea c     : truea a b   : falseg       : falsea c g   : falseA B C   : true (case-insensitive)

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      LWG 1205C++98the return value was unclear if[first2, last2) is emptyreturnstrue in this case

      [edit]See also

      computes the difference between two sets
      (function template)[edit]
      searches for the first occurrence of a range of elements
      (function template)[edit]
      returnstrue if one sequence is a subsequence of another
      (algorithm function object)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/includes&oldid=180577"
      [8]ページ先頭
      ©2009-2025 Movatter.jp