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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::multimap::insert - std::multimap::insert

Synopsis
	  iterator insert( const value_type& value );	       (1)
	  iterator  insert(  value_type&&  value  );		    (2)	(since
       C++17)
	  template<  class  P  >				   (3)	(since
       C++11)
	  iterator insert( P&& value );
	  iterator     insert(	   iterator	pos,	 const	   value_type&
       (until C++11)
	  value	);
	  iterator	 insert(       const_iterator	     pos,	 const
       (since C++11)
	  value_type& value );
	  iterator   insert(   const_iterator	pos,  value_type&&	   (5)
       (since C++17)
	  value	);
	  template<   class   P	  >					   (6)
       (since C++11)
	  iterator insert( const_iterator pos, P&& value );    (4)
	  template< class InputIt >				   (7)
	  void insert( InputIt first, InputIt last );
	  void	 insert(   std::initializer_list<value_type>   ilist	   (8)
       (since C++11)
	  );
	  iterator  insert(  node_type&&   nh	);			   (9)
       (since C++17)
	  iterator   insert(  const_iterator  pos,  node_type&&	 nh	  (10)
       (since C++17)
	  );

	  Inserts element(s) into the container.

	  1-3) Inserts value. If the container has  elements  with  equivalent
       key, inserts at
	  the upper bound of that range.
	  Overload  (3)	 is  equivalent	to emplace(std::forward<P>(value)) and
       only participates
	  in   overload	  resolution   if    std::is_constructible<value_type,
       P&&>::value == true.
	  4-6) Inserts value in	the position as	close as possible to the posi-
       tion just prior
	  to pos.
	  Overload   (6)   is	equivalent   to	 emplace_hint(hint,  std::for-
       ward<P>(value)) and only
	  participates	  in	overload    resolution	   if	  std::is_con-
       structible<value_type, P&&>::value
	  == true.
	  7) Inserts elements from range [first, last).
	  8) Inserts elements from initializer list ilist.
	  9)  If  nh is	an empty node handle, does nothing. Otherwise, inserts
       the element owned
	  by nh	into the container and returns an iterator pointing at the in-
       serted element.
	  If a range containing	elements with keys equivalent to nh.key()  ex-
       ists in the
	  container, the element is inserted at	the end	of that	range. The be-
       havior is
	  undefined  if	 nh is not empty and get_allocator() !=	nh.get_alloca-
       tor().
	  10) If nh is an empty	node handle, does nothing and returns the  end
       iterator.
	  Otherwise,  inserts  the element owned by nh into the	container, and
       returns the
	  iterator pointing to the element with	key  equivalent	 to  nh.key().
       The element is
	  inserted as close as possible	to the position	just prior to pos. The
       behavior	is
	  undefined  if	 nh is not empty and get_allocator() !=	nh.get_alloca-
       tor().

	  No iterators or references are invalidated.
	  If the insertion is successful, pointers and references to the  ele-
       ment obtained
	  while	 it  is	 held in the node handle are invalidated, and pointers
       and references
	  obtained to that element before it was extracted become valid.
	  (since C++17)

Parameters
	  pos	      -	iterator to the	position before	which the new  element
       will be inserted
	  value	      -	element	value to insert
	  first, last -	range of elements to insert
	  ilist	      -	initializer list to insert the values from
	  nh	      -	a compatible node handle

Type requirements
	  -
	  InputIt must meet the	requirements of	LegacyInputIterator.

Return value
	  1-6) An iterator to the inserted element.
	  7,8) (none)
	  9,10)	 End  iterator	if  nh was empty, iterator pointing to the in-
       serted element
	  otherwise.

Exceptions
	  1-6) If an exception is thrown by any	operation, the	insertion  has
       no effect.
	  7,8) No exception safety guarantee.
	  9,10)	 If an exception is thrown by any operation, the insertion has
       no effect.

Complexity
	  1-3) O(log(size()))
	  4-6) Amortized constant if the insertion  happens  in	 the  position
       just before pos,
	  O(log(size())) otherwise.
	  7,8)	O(Nlog(size()  + N)), where N is the number of elements	to in-
       sert.
	  9) O(log(size()))
	  10) Amortized	constant if the	insertion happens in the position just
       before pos,
	  O(log(size())) otherwise.

Example
       // Run this code

	#include <functional>
	#include <iostream>
	#include <map>
	#include <string>
	#include <string_view>
	#include <utility>

	template<class M>
	void print(const std::string_view rem, const M&	mmap)
	{
	    std::cout << rem <<	' ';
	    for	(const auto& e : mmap)
		std::cout << '{' << e.first << ',' << e.second << "} ";
	    std::cout << '\n';
	}

	int main()
	{
	    // list-initialize
	    std::multimap<int, std::string, std::greater<int>> mmap
		{{2, "foo"}, {2, "bar"}, {3, "baz"}, {1, "abc"}, {5, "def"}};
	    print("#1",	mmap);

	    // insert using value_type
	    mmap.insert(decltype(mmap)::value_type(5, "pqr"));
	    print("#2",	mmap);

	    // insert using pair
	    mmap.insert(std::pair{6, "uvw"});
	    print("#3",	mmap);

	    mmap.insert({7, "xyz"});
	    print("#4",	mmap);

	    // insert using initializer_list
	    mmap.insert({{5, "one"}, {5, "two"}});
	    print("#5",	mmap);

	    // insert using a pair of iterators
	    mmap.clear();
	    const auto il = {std::pair{1, ""}, {2, ""},	{2, ""}, {3, ""}};
	    mmap.insert(il.begin(), il.end());
	    print("#6",	mmap);
	}

Output:
	#1 {5,def} {3,baz} {2,foo} {2,bar} {1,abc}
	#2 {5,def} {5,pqr} {3,baz} {2,foo} {2,bar} {1,abc}
	#3 {6,uvw} {5,def} {5,pqr} {3,baz} {2,foo} {2,bar} {1,abc}
	#4 {7,xyz} {6,uvw} {5,def} {5,pqr} {3,baz} {2,foo} {2,bar} {1,abc}
	#5 {7,xyz} {6,uvw} {5,def} {5,pqr}  {5,one}  {5,two}  {3,baz}  {2,foo}
       {2,bar} {1,abc}
	#6 {3,}	{2,} {2,} {1,}

	  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
								    the	inser-
       tion is required
			      pos was just a hint, it could be	    to
	  LWG 233   C++98	totally	 ignored			be  as
       close as	possible to
								    the
								    position
       just prior to pos
			      the  complexity  of  overload (5)	was    removed
       the linear
	  LWG 264  C++98      required to be linear  if		      require-
       ment
			      the  range  [first,  last) is sorted     in this
       special case
			      according	to Compare
	  LWG 371  C++98      the order	of equivalent  elements	      required
       to be preserved
			      was not guaranteed to be preserved
	  LWG  2005  C++11	overloads (3,6)	were poorly described improved
       the description

See also
	  emplace      constructs element in-place
	  (C++11)      (public member function)
	  emplace_hint constructs elements in-place using a hint
	  (C++11)      (public member function)
	  inserter     creates a std::insert_iterator of  type	inferred  from
       the argument
		       (function template)

http://cppreference.com		  2024.06.10	      std::multimap::insert(3)

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

home | help