Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::ranges::find,std::ranges::find_if,std::ranges::find_if_not

      From cppreference.com
      <cpp‎ |algorithm‎ |ranges
       
       
      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
       
      Constrained algorithms
      All names in this menu belong to namespacestd::ranges
      Non-modifying sequence operations
      Modifying sequence operations
      Partitioning operations
      Sorting operations
      Binary search operations (on sorted ranges)
             
             
      Set operations (on sorted ranges)
      Heap operations
      Minimum/maximum operations
      Permutation operations
      Fold operations
      Operations on uninitialized storage
      Return types
       
      Defined in header<algorithm>
      Call signature
      (1)
      template<std::input_iterator I,std::sentinel_for<I> S,

               class T,class Proj=std::identity>
      requiresstd::indirect_binary_predicate
                   <ranges::equal_to, std::projected<I, Proj>,const T*>

      constexpr I find( I first, S last,const T& value, Proj proj={});
      (since C++20)
      (until C++26)
      template<std::input_iterator I,std::sentinel_for<I> S,

               class Proj=std::identity,
               class T= std::projected_value_t<I, Proj>>
      requiresstd::indirect_binary_predicate
                   <ranges::equal_to, std::projected<I, Proj>,const T*>

      constexpr I find( I first, S last,const T& value, Proj proj={});
      (since C++26)
      (2)
      template<ranges::input_range R,class T,class Proj=std::identity>

      requiresstd::indirect_binary_predicate
                   <ranges::equal_to,
                    std::projected<ranges::iterator_t<R>, Proj>,const T*>
      constexprranges::borrowed_iterator_t<R>

          find( R&& r,const T& value, Proj proj={});
      (since C++20)
      (until C++26)
      template<ranges::input_range R,class Proj=std::identity,

               class T= std::projected_value_t<ranges::iterator_t<R>, Proj>>
      requiresstd::indirect_binary_predicate
                   <ranges::equal_to,
                    std::projected<ranges::iterator_t<R>, Proj>,const T*>
      constexprranges::borrowed_iterator_t<R>

          find( R&& r,const T& value, Proj proj={});
      (since C++26)
      template<std::input_iterator I,std::sentinel_for<I> S,

               class Proj=std::identity,
               std::indirect_unary_predicate<std::projected<I, Proj>> Pred>

      constexpr I find_if( I first, S last, Pred pred, Proj proj={});
      (3)(since C++20)
      template<ranges::input_range R,class Proj=std::identity,

               std::indirect_unary_predicate
                   <std::projected<ranges::iterator_t<R>, Proj>> Pred>
      constexprranges::borrowed_iterator_t<R>

          find_if( R&& r, Pred pred, Proj proj={});
      (4)(since C++20)
      template<std::input_iterator I,std::sentinel_for<I> S,

               class Proj=std::identity,
               std::indirect_unary_predicate<std::projected<I, Proj>> Pred>

      constexpr I find_if_not( I first, S last, Pred pred, Proj proj={});
      (5)(since C++20)
      template<ranges::input_range R,class Proj=std::identity,

               std::indirect_unary_predicate
                   <std::projected<ranges::iterator_t<R>, Proj>> Pred>
      constexprranges::borrowed_iterator_t<R>

          find_if_not( R&& r, Pred pred, Proj proj={});
      (6)(since C++20)

      Returns the first element in the range[firstlast) that satisfies specific criteria:

      1)find searches for an element equal tovalue.
      3)find_if searches for an element for which predicatepred returnstrue.
      5)find_if_not searches for an element for which predicatepred returnsfalse.
      2,4,6) Same as(1,3,5), but usesr as the source range, as if usingranges::begin(r) asfirst andranges::end(r) aslast.

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

      Contents

      [edit]Parameters

      first, last - the iterator-sentinel pair defining therange of elements to examine
      r - the range of the elements to examine
      value - value to compare the elements to
      pred - predicate to apply to the projected elements
      proj - projection to apply to the elements

      [edit]Return value

      Iterator to the first element satisfying the condition or iterator equal tolast if no such element is found.

      [edit]Complexity

      At mostlast- first applications of the predicate and projection.

      [edit]Possible implementation

      find (1)
      struct find_fn{template<std::input_iterator I,std::sentinel_for<I> S,class Proj=std::identity,class T= std::projected_value_t<I, Proj>>    requiresstd::indirect_binary_predicate<ranges::equal_to, std::projected<I, Proj>,const T*>constexpr I operator()(I first, S last,const T& value, Proj proj={})const{for(; first!= last;++first)if(std::invoke(proj,*first)== value)return first;return first;} template<ranges::input_range R,class T,class Proj=std::identity>    requiresstd::indirect_binary_predicate<ranges::equal_to,                 std::projected<ranges::iterator_t<R>, Proj>,const T*>constexprranges::borrowed_iterator_t<R>        operator()(R&& r,const T& value, Proj proj={})const{return(*this)(ranges::begin(r),ranges::end(r), value,std::ref(proj));}}; inlineconstexpr find_fn find;
      find_if (3)
      struct find_if_fn{template<std::input_iterator I,std::sentinel_for<I> S,class Proj=std::identity,std::indirect_unary_predicate<std::projected<I, Proj>> Pred>constexpr I operator()(I first, S last, Pred pred, Proj proj={})const{for(; first!= last;++first)if(std::invoke(pred,std::invoke(proj,*first)))return first;return first;} template<ranges::input_range R,class Proj=std::identity,std::indirect_unary_predicate<std::projected<ranges::iterator_t<R>, Proj>> Pred>constexprranges::borrowed_iterator_t<R>        operator()(R&& r, Pred pred, Proj proj={})const{return(*this)(ranges::begin(r),ranges::end(r),std::ref(pred),std::ref(proj));}}; inlineconstexpr find_if_fn find_if;
      find_if_not (5)
      struct find_if_not_fn{template<std::input_iterator I,std::sentinel_for<I> S,class Proj=std::identity,std::indirect_unary_predicate<std::projected<I, Proj>> Pred>constexpr I operator()(I first, S last, Pred pred, Proj proj={})const{for(; first!= last;++first)if(!std::invoke(pred,std::invoke(proj,*first)))return first;return first;} template<ranges::input_range R,class Proj=std::identity,std::indirect_unary_predicate<std::projected<ranges::iterator_t<R>, Proj>> Pred>constexprranges::borrowed_iterator_t<R>        operator()(R&& r, Pred pred, Proj proj={})const{return(*this)(ranges::begin(r),ranges::end(r),std::ref(pred),std::ref(proj));}}; inlineconstexpr find_if_not_fn find_if_not;

      [edit]Notes

      Feature-test macroValueStdFeature
      __cpp_lib_algorithm_default_value_type202403(C++26)List-initialization for algorithms(1,2)

      [edit]Example

      Run this code
      #include <algorithm>#include <cassert>#include <complex>#include <format>#include <iostream>#include <iterator>#include <string>#include <vector> void projector_example(){struct folk_info{unsigned uid;std::string name, position;}; std::vector<folk_info> folks{{0,"Ana","dev"},{1,"Bob","devops"},{2,"Eve","ops"}}; constauto who{"Eve"};if(auto it= std::ranges::find(folks, who,&folk_info::name); it!= folks.end())std::cout<<std::format("Profile:\n""    UID: {}\n""    Name: {}\n""    Position: {}\n\n",                                 it->uid, it->name, it->position);} int main(){namespace ranges= std::ranges;     projector_example(); constint n1=3;constint n2=5;constauto v={4,1,3,2}; if(ranges::find(v, n1)!= v.end())std::cout<<"v contains: "<< n1<<'\n';elsestd::cout<<"v does not contain: "<< n1<<'\n'; if(ranges::find(v.begin(), v.end(), n2)!= v.end())std::cout<<"v contains: "<< n2<<'\n';elsestd::cout<<"v does not contain: "<< n2<<'\n'; auto is_even=[](int x){return x%2==0;}; if(auto result= ranges::find_if(v.begin(), v.end(), is_even); result!= v.end())std::cout<<"First even element in v: "<<*result<<'\n';elsestd::cout<<"No even elements in v\n"; if(auto result= ranges::find_if_not(v, is_even); result!= v.end())std::cout<<"First odd element in v: "<<*result<<'\n';elsestd::cout<<"No odd elements in v\n"; auto divides_13=[](int x){return x%13==0;}; if(auto result= ranges::find_if(v, divides_13); result!= v.end())std::cout<<"First element divisible by 13 in v: "<<*result<<'\n';elsestd::cout<<"No elements in v are divisible by 13\n"; if(auto result= ranges::find_if_not(v.begin(), v.end(), divides_13);        result!= v.end())std::cout<<"First element indivisible by 13 in v: "<<*result<<'\n';elsestd::cout<<"All elements in v are divisible by 13\n"; std::vector<std::complex<double>> nums{{4,2}};#ifdef __cpp_lib_algorithm_default_value_type// T gets deduced in (2) making list-initialization possibleconstauto it= ranges::find(nums,{4,2});#elseconstauto it= ranges::find(nums,std::complex<double>{4,2});#endifassert(it== nums.begin());}

      Output:

      Profile:    UID: 2    Name: Eve    Position: ops v contains: 3v does not contain: 5First even element in v: 4First odd element in v: 1No elements in v are divisible by 13First element indivisible by 13 in v: 4

      [edit]See also

      finds the first two adjacent items that are equal (or satisfy a given predicate)
      (algorithm function object)[edit]
      finds the last sequence of elements in a certain range
      (algorithm function object)[edit]
      searches for any one of a set of elements
      (algorithm function object)[edit]
      finds the first position where two ranges differ
      (algorithm function object)[edit]
      searches for the first occurrence of a range of elements
      (algorithm function object)[edit]
      finds the first element satisfying specific criteria
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/ranges/find&oldid=180614"

      [8]ページ先頭

      ©2009-2025 Movatter.jp