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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::unordered_map::find	- std::unordered_map::find

Synopsis
	  iterator find( const Key& key	);			       (1)
	  const_iterator find( const Key& key )	const;		       (2)
	  template<  class  K  >  iterator find( const K& x );		   (3)
       (since C++20)
	  template< class K > const_iterator find( const K&  x	)  const;  (4)
       (since C++20)

	  1,2) Finds an	element	with key equivalent to key.
	  3,4) Finds an	element	with key that compares equivalent to the value
       x. This
	  overload participates	in overload resolution only if Hash::is_trans-
       parent and
	  KeyEqual::is_transparent are valid and each denotes a	type. This as-
       sumes that such
	  Hash	is callable with both K	and Key	type, and that the KeyEqual is
       transparent,
	  which, together, allows calling this function	 without  constructing
       an instance of
	  Key.

Parameters
	  key -	key value of the element to search for
	  x    - a value of any	type that can be transparently compared	with a
       key

Return value
	  Iterator to an element with key equivalent to	key. If	no  such  ele-
       ment is found,
	  past-the-end (see end()) iterator is returned.

Complexity
	  Constant on average, worst case linear in the	size of	the container.

Notes
	  Feature-test	macro:	__cpp_lib_generic_unordered_lookup  (for over-
       loads (3,4))

Example
       // Run this code

	#include <cstddef>
	#include <iostream>
	#include <functional>
	#include <string>
	#include <string_view>
	#include <unordered_map>

	using namespace	std::literals;
	using std::size_t;

	struct string_hash
	{
	    using hash_type = std::hash<std::string_view>;
	    using is_transparent = void;

	    size_t  operator()(const  char*   str)   const	    {	return
       hash_type{}(str); }
	    size_t   operator()(std::string_view   str)	  const	    {	return
       hash_type{}(str); }
	    size_t  operator()(std::string  const&   str)   const   {	return
       hash_type{}(str); }
	};

	int main()
	{
	    // simple comparison demo
	    std::unordered_map<int,char> example = {{1,'a'},{2,'b'}};

	    auto search	= example.find(2);
	    if (search != example.end()) {
		std::cout  << "Found " << search->first	<< " " << search->sec-
       ond << '\n';
	    } else {
		std::cout << "Not found\n";
	    }

	    // C++20  demo:  Heterogeneous  lookup  for	 unordered  containers
       (transparent hashing)
	    std::unordered_map<std::string,	   size_t,	  string_hash,
       std::equal_to<>>	map{ {"one"s, 1} };
	    std::cout << std::boolalpha
		<< (map.find("one")   != map.end()) << '\n'
		<< (map.find("one"s)  != map.end()) << '\n'
		<< (map.find("one"sv) != map.end()) << '\n';
	}

Output:
	Found 2	b
	true
	true
	true

See also
	  count	      returns the number of elements matching specific key
	  (C++11)     (public member function)
	  equal_range returns range of elements	matching a specific key
	  (C++11)     (public member function)

http://cppreference.com		  2022.07.31	   std::unordered_map::find(3)

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

home | help