Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
std::find_first_of(3)	      C++ Standard Libary	 std::find_first_of(3)

NAME
       std::find_first_of - std::find_first_of

Synopsis
	  Defined in header <algorithm>
	  template< class ForwardIt1, class ForwardIt2 >

	  ForwardIt1   find_first_of(  ForwardIt1  first,		(until
       C++11)
	  ForwardIt1 last,

	  ForwardIt2 s_first, ForwardIt2 s_last	);
	  template< class InputIt, class ForwardIt >

	  InputIt  find_first_of(  InputIt  first,  InputIt		(since
       C++11)
	  last,								(until
       C++20)

	  ForwardIt s_first, ForwardIt s_last );
	  template< class InputIt, class ForwardIt >

	  constexpr  InputIt  find_first_of(  InputIt  first,		(since
       C++20)
	  InputIt last,

	  ForwardIt s_first, ForwardIt s_last );
	  template< class ExecutionPolicy, class
	  ForwardIt1, class ForwardIt2 >

	  ForwardIt1   find_first_of(  ExecutionPolicy&&	   (2)	(since
       C++17)
	  policy, ForwardIt1 first, ForwardIt1 last,

	  ForwardIt2 s_first, ForwardIt2 s_last	);
	  template< class ForwardIt1, class ForwardIt2,
	  class	BinaryPredicate	>

	  ForwardIt1	 find_first_of(	    ForwardIt1	   first,	   (1)
       (until C++11)
	  ForwardIt1 last,

	  ForwardIt2 s_first, ForwardIt2 s_last,
	  BinaryPredicate p );
	  template< class InputIt, class ForwardIt, class
	  BinaryPredicate >

	  InputIt	find_first_of(	     InputIt	   first,      InputIt
       (since C++11)
	  last,
       (until C++20)

	  ForwardIt s_first, ForwardIt s_last,
	  BinaryPredicate p );
	  template< class InputIt, class ForwardIt, class      (3)
	  BinaryPredicate >

	  constexpr	 InputIt      find_first_of(	  InputIt	first,
       (since C++20)
	  InputIt last,

	  ForwardIt s_first, ForwardIt s_last,
	  BinaryPredicate p );
	  template< class ExecutionPolicy, class
	  ForwardIt1, class ForwardIt2,	class
	  BinaryPredicate >

	  ForwardIt1	find_first_of(	  ExecutionPolicy&&		   (4)
       (since C++17)
	  policy, ForwardIt1 first, ForwardIt last,

	  ForwardIt2 s_first, ForwardIt2 s_last,
	  BinaryPredicate p );

	  Searches the range [first, last) for any  of	the  elements  in  the
       range [s_first,
	  s_last).

	  1) Elements are compared using operator==.
	  3) Elements are compared using the given binary predicate p.
	  2,4)	Same  as  (1,3), but executed according	to policy. These over-
       loads do	not
	  participate in overload resolution unless
	  std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>
	  (until C++20)
	  std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>
	  (since C++20)	is true.

Parameters
	  first, last	  - the	range of elements to examine
	  s_first, s_last - the	range of elements to search for
	  policy	  - the	execution policy to use. See execution	policy
       for details.
			    binary  predicate  which  returns true if the ele-
       ments 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);

	  p		  - While the signature	does not need to have const &,
       the function
			    must  not modify the objects passed	to it and must
       be able to
			    accept all values of type (possibly	 const)	 Type1
       and Type2
			    regardless of value	category (thus,	Type1 &	is not
       allowed
			    ,  nor is Type1 unless for Type1 a move is equiva-
       lent to a copy
			    (since C++11)).
			    The	types Type1 and	Type2 must be  such  that  ob-
       jects of	types
			    ForwardIt1	and ForwardIt2 can be dereferenced and
       then implicitly
			    converted to Type1 and Type2 respectively.

Type requirements
	  -
	  InputIt must meet the	requirements of	LegacyInputIterator.
	  -
	  ForwardIt1 must meet the requirements	of LegacyForwardIterator.
	  -
	  ForwardIt2 must meet the requirements	of LegacyForwardIterator.

Return value
	  Iterator to the first	element	in the range  [first,  last)  that  is
       equal to	an element
	  from	the range [s_first, s_last). If	no such	element	is found, last
       is returned.

Complexity
	  Does at most (S*N)  comparisons  where  S  =	std::distance(s_first,
       s_last) and N =
	  std::distance(first, last).

Exceptions
	  The overloads	with a template	parameter named	ExecutionPolicy	report
       errors as
	  follows:

	    *  If  execution  of  a  function invoked as part of the algorithm
       throws an exception
	      and ExecutionPolicy is one of the	standard policies, std::termi-
       nate is called.
	      For any other ExecutionPolicy, the behavior  is  implementation-
       defined.
	    *  If  the	algorithm  fails to allocate memory, std::bad_alloc is
       thrown.

Possible implementation
First version
	  template<class InputIt, class	ForwardIt>
	  InputIt find_first_of(InputIt	first, InputIt last,
				ForwardIt s_first, ForwardIt s_last)
	  {
	      for (; first != last; ++first) {
		  for (ForwardIt it = s_first; it != s_last; ++it) {
		      if (*first == *it) {
			  return first;
		      }
		  }
	      }
	      return last;
	  }

Second version
	  template<class InputIt, class	ForwardIt, class BinaryPredicate>
	  InputIt find_first_of(InputIt	first, InputIt last,
				ForwardIt s_first, ForwardIt s_last,
				BinaryPredicate	p)
	  {
	      for (; first != last; ++first) {
		  for (ForwardIt it = s_first; it != s_last; ++it) {
		      if (p(*first, *it)) {
			  return first;
		      }
		  }
	      }
	      return last;
	  }

Example
	  The following	code searches for any of specified integers in a  vec-
       tor of integers:

       // Run this code

	#include <algorithm>
	#include <iostream>
	#include <vector>

	auto print_sequence = [](auto const id,	auto const& seq, int pos = -1)
       {
	    std::cout << id << "{ ";
	    for	(int i{}; auto const& e	: seq) {
		const bool mark	{i == pos};
		std::cout << (i++ ? ", " : "");
		std::cout << (mark ? ">> " : "") << e << (mark ? " <<" : "");
	    }
	    std::cout << " }\n";
	};

	int main()
	{
	    const std::vector<int> v{0,	2, 3, 25, 5};
	    const auto t1 = {19, 10, 3,	4};
	    const auto t2 = {1,	6, 7, 9};

	    auto find_any_of = [](const	auto& v, const auto& t)	{
		const auto result = std::find_first_of(v.begin(), v.end(),
						       t.begin(), t.end());
		if (result == v.end()) {
		    std::cout << "No elements of v are equal to	any element of
       ";
		    print_sequence("t =	", t);
		    print_sequence("v =	", v);
		} else {
		    const auto pos = std::distance(v.begin(), result);
		    std::cout  <<  "Found a match (" <<	*result	<< ") at posi-
       tion " << pos;
		    print_sequence(", where t =	", t);
		    print_sequence("v =	", v, pos);
		}
	    };

	    find_any_of(v, t1);
	    find_any_of(v, t2);
	}

Output:
	Found a	match (3) at position 2, where t = { 19, 10, 3,	4 }
	v = { 0, 2, >> 3 <<, 25, 5 }
	No elements of v are equal to any element of t = { 1, 6, 7, 9 }
	v = { 0, 2, 3, 25, 5 }

See also
	  find
	  find_if		finds the first	 element  satisfying  specific
       criteria
	  find_if_not		(function template)
	  (C++11)
	  ranges::find_first_of	searches for any one of	a set of elements
	  (C++20)		(niebloid)

http://cppreference.com		  2022.07.31		 std::find_first_of(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::find_first_of&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help