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) (since C++11)
	  const_iterator find( const Key& key )	const; (2) (since C++11)
	  template< class K >			       (3) (since C++20)
	  iterator find( const K& x );
	  template< class K >			       (4) (since C++20)
	  const_iterator find( const K&	x ) const;

	  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
	  An iterator to the requested element.	If no such element  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	      Value    Std		  Fea-
       ture
							     Heterogeneous
       comparison lookup
	  __cpp_lib_generic_unordered_lookup  201811L (C++20) in unordered as-
       sociative
							     containers; over-
       loads (3,4)

Example
       // Run this code

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

	using namespace	std::literals;

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

	    std::size_t	operator()(const  char*	 str)  const	     {	return
       hash_type{}(str); }
	    std::size_t	 operator()(std::string_view  str)  const    {	return
       hash_type{}(str); }
	    std::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'}};

	    if (auto search = example.find(2); 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
		      (public member function)
	  equal_range returns range of elements	matching a specific key
		      (public member function)

http://cppreference.com		  2024.06.10	   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.1.quarterly>

home | help