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,
       (2) (since C++17)
		  class	Compare	= std::less<Key>
	      >	using multimap = std::multimap<Key, T, Compare,
		  std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;

	  }

	  std::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,
	  insertion, and removal operations have logarithmic complexity.

	  Iterators of std::multimap iterate in	non-descending order of	 keys,
       where
	  non-descending  is  defined by the comparison	that was used for con-
       struction. That is,
	  given

	    * m, a std::multimap
	    * it_l and it_r, dereferenceable iterators to m, with it_l < it_r.

	  m.value_comp()(*it_r,	*it_l) == false	(least to  greatest  if	 using
       the default
	  comparison).

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

	  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.

Template parameters
	   This	section	is incomplete
	   Reason: Add descriptions of the template parameters.

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&
				  Allocator::pointer
       (until C++11)
	  pointer		     std::allocator_traits<Allocator>::pointer
       (since C++11)

				  Allocator::const_pointer
       (until
										  C++11)
	  const_pointer				 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)
	  insert_range	inserts	a range	of elements
	  (C++23)	(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  of
       two multimaps
	  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)

Notes
	      Feature-test macro       Value	Std		      Feature
	  __cpp_lib_containers_ranges 202202L (C++23) Ranges construction  and
       insertion for
						      containers

Example
	   This	section	is incomplete
	   Reason: no example

	  Defect reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	    DR	  Applied to	       Behavior	as published		  Cor-
       rect behavior
			     Key was not required to be
	  LWG  230 C++98      CopyConstructible				Key is
       also required to
			     (a	key of type Key	might  not  be	able  to    be
       CopyConstructible
			     be	constructed)

Categories:
	    * Todo with	reason
	    * Todo no example

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

home | help