std::unordered_set::insert

Parameters

val

Object to be copied to (or moved as) the value of the new element.
Versions (1) and (3) copy the element (i.e., val preserves its contents, the container keeps a copy).
Versions (2) and (4) move the element (i.e., val loses its content, which is acquired by the new element in the container).
Member type value_type is the type of the elements in the container, defined in unordered_set as an alias of the first template parameter (Key).

hint

Iterator to a position suggested as a hint on where to start the search for the proper insertion point. This value may or may not be used by the container to optimize the operation. The element will be stored in its corresponding bucket, no matter what is passed as hint.
Member type const_iterator is a forward iterator type.

first, last

Iterators specifying a range of elements. Copies of the elements in the range [first,last) are inserted in the unordered_set container.
Notice that the range includes all the elements between first and last, including the element pointed by first but not the one pointed by last.
Neither first nor last shall be iterators in the destination container.
The template type can be any type of input iterator.

il

An initializer_list object. The compiler will automatically construct such objects from initializer list declarators.
Member type value_type is the type of the elements contained in the container, defined in unordered_set as an alias of the first template parameter (Key).

Return value

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// unordered_set::insert
#include <iostream>
#include <string>
#include <array>
#include <unordered_set>
int main ()
{
  std::unordered_set<std::string> myset = {"yellow","green","blue"};
  std::array<std::string,2> myarray = {"black","white"};
  std::string mystring = "red";
  myset.insert (mystring);                        // copy insertion
  myset.insert (mystring+"dish");                 // move insertion
  myset.insert (myarray.begin(), myarray.end());  // range insertion
  myset.insert ( {"purple","orange"} );           // initializer list insertion
  std::cout << "myset contains:";
  for (const std::string& x: myset) std::cout << " " << x;
  std::cout <<  std::endl;
  return 0;
}

myset contains: green blue reddish white yellow black red orange purple

Complexity

Single element insertions:

Average case: constant.
Worst case: linear in container size.

Multiple elements insertion:

Average case: linear in the number of elements inserted.
Worst case: N*(size+1): number of elements inserted times the container size plus one.

Iterator validity

See also

unordered_set::emplace

Construct and insert element (public member function)

unordered_set::emplace_hint

Construct and insert element with hint (public member function)

unordered_set::operator=

Assign content (public member function)

unordered_set::erase

Erase elements (public member function)