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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::set::insert	- std::set::insert

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

	  Inserts element(s) into the container, if the	container doesn't  al-
       ready contain an
	  element with an equivalent key.

	  1-2) inserts value.
	  3-4)	inserts	 value	in  the	 position  as  close as	possible, just
       prior(since C++11), to
	  hint.
	  5) Inserts elements from range [first, last).	If  multiple  elements
       in the range have
	  keys that compare equivalent,	it is unspecified which	element	is in-
       serted (pending
	  LWG2844).
	  6)  Inserts  elements	 from initializer list ilist. If multiple ele-
       ments in	the range
	  have keys that compare equivalent, it	is unspecified	which  element
       is inserted
	  (pending LWG2844).
	  7)  If  nh is	an empty node handle, does nothing. Otherwise, inserts
       the element owned
	  by nh	into the container , if	the container doesn't already  contain
       an element with
	  a key	equivalent to nh.key().	The behavior is	undefined if nh	is not
       empty and
	  get_allocator() != nh.get_allocator().
	  8)  If  nh is	an empty node handle, does nothing and returns the end
       iterator.
	  Otherwise, inserts the element owned by nh into  the	container,  if
       the container
	  doesn't  already  contain  an	 element  with	a  key	equivalent  to
       nh.key(), and returns
	  the iterator pointing	to the element with key	equivalent to nh.key()
       (regardless of
	  whether the insert succeeded or failed). If the insertion  succeeds,
       nh is moved
	  from,	 otherwise it retains ownership	of the element.	The element is
       inserted	as
	  close	as possible to the position just prior to hint.	 The  behavior
       is undefined if
	  nh is	not empty and get_allocator() != nh.get_allocator().

	  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
			iterator,  used	 as  a suggestion as to	where to start
       the  (until C++11)
	  hint	      -	search
			iterator to the	position before	which the new  element
       (since C++11)
			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-2)	Returns	 a pair	consisting of an iterator to the inserted ele-
       ment (or	to the
	  element that prevented the insertion)	and a bool value set  to  true
       if the insertion
	  took place.
	  3-4)	Returns	an iterator to the inserted element, or	to the element
       that prevented
	  the insertion.
	  5-6) (none)
	  7) Returns an	insert_return_type with	 the  members  initialized  as
       follows:

	    *  If  nh is empty,	inserted is false, position is end(), and node
       is empty.
	    * Otherwise	if the insertion took place, inserted is  true,	 posi-
       tion points to the
	      inserted element,	and node is empty.
	    *  If the insertion	failed,	inserted is false, node	has the	previ-
       ous value of nh,
	      and position points to an	 element  with	a  key	equivalent  to
       nh.key().

	  8)  End  iterator if nh was empty, iterator pointing to the inserted
       element if
	  insertion took place,	and iterator pointing to an element with a key
       equivalent to
	  nh.key() if it failed.

Exceptions
	  1-4) If an exception is thrown by any	operation, the	insertion  has
       no effect.

	   This	section	is incomplete
	   Reason: cases 5-8

Complexity
	  1-2) Logarithmic in the size of the container, O(log(size())).

	  3-4)	Amortized  constant  if	 the insertion happens in the position
       just  (until C++11)
	  after	the hint, logarithmic in the size of the container otherwise.
	  3-4) Amortized constant if the insertion  happens  in	 the  position
       just  (since C++11)
	  before the hint, logarithmic in the size of the container otherwise.

	  5-6)	O(N*log(size() + N)), where N is the number of elements	to in-
       sert.
	  7) Logarithmic in the	size of	the container, O(log(size())).
	  8) Amortized constant	if the insertion happens in the	position  just
       before the hint,
	  logarithmic in the size of the container otherwise.

Notes
	  The hinted insert (3,4) does not return a boolean in order to	be
	  signature-compatible	with  positional insert	on sequential contain-
       ers, such as
	  std::vector::insert. This makes it possible to  create  generic  in-
       serters such as
	  std::inserter.  One  way  to	check success of a hinted insert is to
       compare size()
	  before and after.

	  The overloads	(5,6) are often	implemented as a loop that  calls  the
       overload	(3) with
	  end()	 as  the  hint;	 they are optimized for	appending a sorted se-
       quence (such as
	  another set) whose smallest element is greater than the last element
       in *this

Example
       // Run this code

	#include <set>
	#include <cassert>
	#include <iostream>

	int main()
	{
	  std::set<int>	set;

	  auto result_1	= set.insert(3);
	  assert(result_1.first	!= set.end()); // it's a valid iterator
	  assert(*result_1.first == 3);
	  if (result_1.second)
	    std::cout << "insert done\n";

	  auto result_2	= set.insert(3);
	  assert(result_2.first	== result_1.first); // same iterator
	  assert(*result_2.first == 3);
	  if (!result_2.second)
	    std::cout << "no insertion\n";
	}

Output:
	insert done
	no insertion

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		  2022.07.31		   std::set::insert(3)

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

home | help