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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::unordered_set::find	- std::unordered_set::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 <source_location>
	#include <string>
	#include <string_view>
	#include <unordered_set>

	using namespace	std::literals;

	namespace logger { bool	enabled{false};	}

	inline void who(const std::source_location  sloc  =  std::source_loca-
       tion::current())
	{
	    if (logger::enabled)
		std::cout << sloc.function_name() << '\n';
	}

	struct string_hash // C++20's transparent hashing
	{
	    using hash_type = std::hash<std::string_view>;
	    using is_transparent = void;

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

	int main()
	{
	    std::unordered_set<int> example{1, 2, -10};

	    std::cout << "Simple comparison demo:\n" <<	std::boolalpha;
	    if (auto search = example.find(2); search != example.end())
		std::cout << "Found " << *search << '\n';
	    else
		std::cout << "Not found\n";

	    std::unordered_set<std::string,    string_hash,   std::equal_to<>>
       set{"one"s, "two"s};

	    logger::enabled = true;
	    std::cout  <<  "Heterogeneous  lookup  for	unordered   containers
       (transparent hashing):\n"
		      << (set.find("one")   != set.end()) << '\n'
		      << (set.find("one"s)  != set.end()) << '\n'
		      << (set.find("one"sv) != set.end()) << '\n';
	}

Possible output:
	Simple comparison demo:
	Found 2
	Heterogeneous lookup for unordered containers (transparent hashing):
	std::size_t string_hash::operator()(const char*) const
	true
	std::size_t string_hash::operator()(const std::string&)	const
	true
	std::size_t string_hash::operator()(std::string_view) const
	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_set::find(3)

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

home | help