Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::find_end

      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 ForwardIt1,class ForwardIt2>

      ForwardIt1 find_end( ForwardIt1 first, ForwardIt1 last,

                           ForwardIt2 s_first, ForwardIt2 s_last);
      (1)(constexpr since C++20)
      template<class ExecutionPolicy,class ForwardIt1,class ForwardIt2>

      ForwardIt1 find_end( ExecutionPolicy&& policy,
                           ForwardIt1 first, ForwardIt1 last,

                           ForwardIt2 s_first, ForwardIt2 s_last);
      (2)(since C++17)
      template<class ForwardIt1,class ForwardIt2,class BinaryPred>

      ForwardIt1 find_end( ForwardIt1 first, ForwardIt1 last,
                           ForwardIt2 s_first, ForwardIt2 s_last,

                           BinaryPred p);
      (3)(constexpr since C++20)
      template<class ExecutionPolicy,

               class ForwardIt1,class ForwardIt2,class BinaryPred>
      ForwardIt1 find_end( ExecutionPolicy&& policy,
                           ForwardIt1 first, ForwardIt1 last,
                           ForwardIt2 s_first, ForwardIt2 s_last,

                           BinaryPred p);
      (4)(since C++17)

      Searches for the last occurrence of the sequence[s_firsts_last) in the range[firstlast).

      1) Elements are compared usingoperator==.
      3) Elements are compared using the given binary predicatep.
      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

      first, last - the pair of iterators defining therange of elements to examine
      s_first, s_last - the pair of iterators defining therange of elements to search for
      policy - theexecution policy to use
      p - binary predicate which returns ​true if the elements should be treated as equal.

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

       bool pred(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 objects of typesForwardIt1 andForwardIt2 can be dereferenced and then implicitly converted toType1 andType2 respectively.​

      Type requirements
      -
      ForwardIt1 must meet the requirements ofLegacyForwardIterator.
      -
      ForwardIt2 must meet the requirements ofLegacyForwardIterator.

      [edit]Return value

      Iterator to the beginning of last occurrence of the sequence[s_firsts_last) in range[firstlast).

      If[s_firsts_last) is empty or if no such sequence is found,last is returned.

      [edit]Complexity

      Given\(\scriptsize N\)N asstd::distance(first, last) and\(\scriptsize S\)S asstd::distance(s_first, s_last):

      1,2) At most\(\scriptsize S\cdot(N-S+1)\)S·(N-S+1) comparisons usingoperator==.
      3,4) At most\(\scriptsize S\cdot(N-S+1)\)S·(N-S+1) applications of the predicatep.

      [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

      find_end (1)
      template<class ForwardIt1,class ForwardIt2>constexpr//< since C++20ForwardIt1 find_end(ForwardIt1 first, ForwardIt1 last,                    ForwardIt2 s_first, ForwardIt2 s_last){if(s_first== s_last)return last;     ForwardIt1 result= last;while(true){        ForwardIt1 new_result=std::search(first, last, s_first, s_last);if(new_result== last)break;else{            result= new_result;            first= result;++first;}}return result;}
      find_end (3)
      template<class ForwardIt1,class ForwardIt2,class BinaryPred>constexpr//< since C++20ForwardIt1 find_end(ForwardIt1 first, ForwardIt1 last,                    ForwardIt2 s_first, ForwardIt2 s_last,                    BinaryPred p){if(s_first== s_last)return last;     ForwardIt1 result= last;while(true){        ForwardIt1 new_result=std::search(first, last, s_first, s_last, p);if(new_result== last)break;else{            result= new_result;            first= result;++first;}}return result;}

      [edit]Example

      Run this code
      #include <algorithm>#include <array>#include <cmath>#include <iostream> auto print_result=[](auto result,constauto& v){    result== v.end()?std::cout<<"Sequence not found\n":std::cout<<"Last occurrence is at: "<<std::distance(v.begin(), result)<<'\n';}; int main(){constauto v={1,2,3,4,1,2,3,4,1,2,3,4}; for(autoconst& x:{std::array{1,2,3},{4,5,6}}){auto iter= std::find_end(v.begin(), v.end(), x.begin(), x.end());// overload (1)        print_result(iter, v);} for(autoconst& x:{std::array{-1,-2,-3},{-4,-5,-6}}){auto iter= std::find_end(v.begin(), v.end(), x.begin(), x.end(),// overload (3)[](int x,int y){return std::abs(x)== std::abs(y);});        print_result(iter, v);}}

      Output:

      Last occurrence is at: 8Sequence not foundLast occurrence is at: 8Sequence not found

      [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[s_firsts_last) is emptyreturnslast in this case
      LWG 2150C++98the condition of “sequence occurence” was incorrectcorrected

      [edit]See also

      searches for the first occurrence of a range of elements
      (function template)[edit]
      returnstrue if one sequence is a subsequence of another
      (function template)[edit]
      finds the first two adjacent items that are equal (or satisfy a given predicate)
      (function template)[edit]
      finds the first element satisfying specific criteria
      (function template)[edit]
      searches for any one of a set of elements
      (function template)[edit]
      searches for the first occurrence of a number consecutive copies of an element in a range
      (function template)[edit]
      finds the last sequence of elements in a certain range
      (algorithm function object)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/find_end&oldid=180334"

      [8]ページ先頭

      ©2009-2025 Movatter.jp