RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://cplusplus.com/reference/unordered_set/unordered_set/operator=/ below:

public member function

<unordered_set>

std::unordered_set::operator= copy (1)

unordered_set& operator= ( const unordered_set& ust );

move (2)

unordered_set& operator= ( unordered_set&& ust );

initializer list (3)

unordered_set& operator= ( intitializer_list<value_type> il );

Assign content

Assigns ust (or il) as the new content for the container.

The elements contained in the object before the call are destroyed, and replaced by those in unordered_set ust or initializer list il, if any.

The first version (1) performs a copy assignment, which copies all the elements of ust into the container object (with ust preserving its contents).

The second version (2) performs a move assignment, which transfer ownership of the contents of ust to the object. No copies occur: the content is lost by ust.

The third version (3) assigns the contents of the initializer list il as the elements of the container object.

Parameters

ust: An unordered_set object of the same type (i.e., with the same template parameters).
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 in the container, defined in unordered_set as an alias of its first template parameter (Key).

Return value*this
Example

// unordered_set::operator=
#include <iostream>
#include <string>
#include <unordered_set>

template<class T>
T cmerge (T a, T b) {
  T t(a); t.insert(b.begin(),b.end()); return t;
}

int main ()
{
  std::unordered_set<std::string> first, second, third;
  first = {"red","green","blue"};      // init list
  second = {"orange","pink","yellow"}; // init list
  third = cmerge (first, second);      // move
  first = third;                       // copy

  std::cout << "first contains:";
  for (const std::string& x: first) std::cout << " " << x;
  std::cout << std::endl;

  return 0;
}

Possible output:

first contains: orange blue red pink yellow green

Complexity For the copy assignment (1): Linear in sizes (destructions, copies).
For the move assignment (2): Linear in current container size (destructions).*
For the initializer list assignment (3): On average, linear in sizes (destructions, move-assignments) -- worst case: quadratic.
* Additional complexity for assignments if allocators do not propagate.

Iterator validity All iterators, references and pointers to elements that were in the container before the call are invalidated.

See also

unordered_set::unordered_set: Construct unordered_set (public member function)

unordered_set::emplace: Construct and insert element (public member function)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4