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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::multimap - std::multimap

Synopsis
	  Defined in header <map>
	  template<

	  class	Key,
	  class	T,							(1)
	  class	Compare	= std::less<Key>,
	  class	Allocator = std::allocator<std::pair<const Key,	T> >

	  > class multimap;
	  namespace pmr	{

	  template <class Key, class T,	class Compare =	std::less<Key>>
	  using	 multimap  =  std::multimap<Key, T, Compare,		   (2)
       (since C++17)
	  std::pmr::polymorphic_allocator<std::pair<const Key,T>>>;

	  }

	  Multimap is an associative container that contains a sorted list  of
       key-value pairs,
	  while	permitting multiple entries with the same key. Sorting is done
       according to
	  the comparison function Compare, applied to the keys.	Search,	inser-
       tion, and removal
	  operations have logarithmic complexity.

	  The  order  of  the key-value	pairs whose keys compare equivalent is
       the order of
	  insertion and	does not change. (since	C++11)

	  Everywhere the  standard  library  uses  the	Compare	 requirements,
       equivalence is
	  determined  by  using	 the equivalence relation as described on Com-
       pare. In	imprecise
	  terms, two objects a and b are considered equivalent if neither com-
       pares less than
	  the other: !comp(a, b) && !comp(b, a).

	  std::multimap	meets the requirements of  Container,  AllocatorAware-
       Container,
	  AssociativeContainer and ReversibleContainer.

Member types
	  Member type		  Definition
	  key_type		  Key
	  mapped_type		  T
	  value_type		  std::pair<const Key, T>
	  size_type		  Unsigned integer type	(usually std::size_t)
	  difference_type	  Signed integer type (usually std::ptrdiff_t)
	  key_compare		  Compare
	  allocator_type	  Allocator
	  reference		  value_type&
	  const_reference	  const	value_type&
	  pointer					    Allocator::pointer
       (until C++11)
				  std::allocator_traits<Allocator>::pointer
       (since C++11)
				  Allocator::const_pointer
       (until
	  const_pointer
       C++11)
				  std::allocator_traits<Alloca-
       tor>::const_pointer (since
										  C++11)
	  iterator		  LegacyBidirectionalIterator to value_type
	  const_iterator	    LegacyBidirectionalIterator	   to	 const
       value_type
	  reverse_iterator	  std::reverse_iterator<iterator>
	  const_reverse_iterator  std::reverse_iterator<const_iterator>
	  node_type (since C++17) a specialization of node handle representing
       a container
				  node

Member classes
	  value_compare	compares objects of type value_type
			(class)

Member functions
	  constructor	constructs the multimap
			(public	member function)
	  destructor	destructs the multimap
			(public	member function)
	  operator=	assigns	values to the container
			(public	member function)
	  get_allocator	returns	the associated allocator
			(public	member function)

Iterators
	  begin		returns	an iterator to the beginning
	  cbegin	(public	member function)
	  (C++11)
	  end		returns	an iterator to the end
	  cend		(public	member function)
	  (C++11)
	  rbegin	returns	a reverse iterator to the beginning
	  crbegin	(public	member function)
	  (C++11)
	  rend		returns	a reverse iterator to the end
	  crend		(public	member function)
	  (C++11)

Capacity
	  empty		checks whether the container is	empty
			(public	member function)
	  size		returns	the number of elements
			(public	member function)
	  max_size	returns	the maximum possible number of elements
			(public	member function)

Modifiers
	  clear		clears the contents
			(public	member function)
			inserts	elements
	  insert	or nodes
			(since C++17)
			(public	member function)
	  emplace	constructs element in-place
	  (C++11)	(public	member function)
	  emplace_hint	constructs elements in-place using a hint
	  (C++11)	(public	member function)
	  erase		erases elements
			(public	member function)
	  swap		swaps the contents
			(public	member function)
	  extract	extracts nodes from the	container
	  (C++17)	(public	member function)
	  merge		splices	nodes from another container
	  (C++17)	(public	member function)

Lookup
	  count		returns	the number of elements matching	specific key
			(public	member function)
	  find		finds element with specific key
			(public	member function)
	  contains	checks if the container	contains element with specific
       key
	  (C++20)	(public	member function)
	  equal_range	returns	range of elements matching a specific key
			(public	member function)
	  lower_bound	returns	an iterator to the first element not less than
       the given key
			(public	member function)
	  upper_bound	 returns an iterator to	the first element greater than
       the given key
			(public	member function)

Observers
	  key_comp	returns	the function that compares keys
			(public	member function)
	  value_comp	returns	the function that compares keys	in objects  of
       type value_type
			(public	member function)

Non-member functions
	  operator==
	  operator!=
	  operator<
	  operator<=
	  operator>
	  operator>=		    lexicographically  compares	 the values in
       the multimap
	  operator<=>		   (function template)
	  (removed in C++20)
	  (removed in C++20)
	  (removed in C++20)
	  (removed in C++20)
	  (removed in C++20)
	  (C++20)
	  std::swap(std::multimap) specializes the std::swap algorithm
				   (function template)
	  erase_if(std::multimap)  Erases  all	elements  satisfying  specific
       criteria
	  (C++20)		   (function template)

	 Deduction guides(since	C++17)

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

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

home | help