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

Showing content from https://cplusplus.com/unordered_set::unordered_set below:

public member function

<unordered_set>

explicit unordered_set ( size_type n = /* see below */,                         const hasher& hf = hasher(),                         const key_equal& eql = key_equal(),                         const allocator_type& alloc = allocator_type() );explicit unordered_set ( const allocator_type& alloc );

template <class InputIterator>         unordered_set ( InputIterator first, InputIterator last,                         size_type n = /* see below */,                         const hasher& hf = hasher(),                         const key_equal& eql = key_equal(),                         const allocator_type& alloc = allocator_type() );

unordered_set ( const unordered_set& ust );unordered_set ( const unordered_set& ust, const allocator_type& alloc );

unordered_set ( unordered_set&& ust );unordered_set ( unordered_set&& ust, const allocator_type& alloc );

unordered_set ( initializer_list<value_type> il,                size_type n = /* see below */,                const hasher& hf = hasher(),                const key_equal& eql = key_equal(),                const allocator_type& alloc = allocator_type() );

unordered_set();explicit unordered_set ( size_type n,                         const hasher& hf = hasher(),                         const key_equal& eql = key_equal(),                         const allocator_type& alloc = allocator_type() );explicit unordered_set ( const allocator_type& alloc );         unordered_set ( size_type n, const allocator_type& alloc );         unordered_set ( size_type n, const hasher& hf, const allocator_type& alloc );

template <class InputIterator>  unordered_set ( InputIterator first, InputIterator last,                  size_type n = /* see below */,                  const hasher& hf = hasher(),                  const key_equal& eql = key_equal(),                  const allocator_type& alloc = allocator_type() );template <class InputIterator>  unordered_set ( InputIterator first, InputIterator last, size_type n,                  const allocator_type& alloc );template <class InputIterator>  unordered_set ( InputIterator first, InputIterator last, size_type n,                  const hasher& hf, const allocator_type& alloc );

unordered_set ( const unordered_set& ust );unordered_set ( const unordered_set& ust, const allocator_type& alloc );

unordered_set ( unordered_set&& ust );unordered_set ( unordered_set&& ust, const allocator_type& alloc );

unordered_set ( initializer_list<value_type> il,                size_type n = /* see below */,                const hasher& hf = hasher(),                const key_equal& eql = key_equal(),                const allocator_type& alloc = allocator_type() );unordered_set ( initializer_list<value_type> il, size_type n,                const allocator_type& alloc );unordered_set ( initializer_list<value_type> il, size_type n,                const hasher& hf, const allocator_type& alloc );

Construct unordered_set

(1) empty container constructor (default constructor)

Constructs an empty unordered_set object, containing no elements and with a size of zero.
It can construct the container with specific hasher, key_equal and allocator objects, along with a minimum number of hash buckets.

(2) range constructor

Constructs an unordered_set object containing copies of each of the elements in the range [first,last).

(3) copy constructor (and copying with allocator)

The object is initialized to have the same contents and properties as the ust unordered_set object.

(4) move constructor (and moving with allocator)

The object acquires the contents of the rvalue ust.

(5) initializer list

Initializes the container with the contents of the list.

n

Minimum number of initial buckets.
This is not the number of elements in the container, but the minimum number of slots desired for the internal hash table on construction.
If this argument is not specified, the constructor determines this automatically (in a way that depends on the particular library implementation).
Member type size_type is an unsigned integral type.

hf

Hasher function object. A hasher is a function that returns an integral value based on the container object key passed to it as argument.
Member type hasher is defined in unordered_set as an alias of its second template parameter (Hash).

eql

Comparison function object, that returns true if the two container object keys passed as arguments are to be considered equal.
Member type key_equal is defined in unordered_set as an alias of its third template parameter (Pred).

alloc

Allocator object to be used instead of constructing a new one.
For class instantiations using their version of the default allocator class template, this parameter is not relevant.
Member type allocator_type is defined in unordered_set as an alias of its fourth template parameter (Alloc).

first, last

Input iterators to the initial and final positions in a range. The range used is [first,last), which includes all the elements between first and last, including the element pointed by first but not the element pointed by last.
The function template type can be any type of input iterator.

ust

Another unordered_set object of the same type (with the same class template arguments), whose contents are either copied or moved.

il

An initializer_list object.
These objects are automatically constructed 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 the first template parameter (Key).

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

// constructing unordered_sets
#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;                                // empty
  std::unordered_set<std::string> second ( {"red","green","blue"} );    // init list
  std::unordered_set<std::string> third ( {"orange","pink","yellow"} ); // init list
  std::unordered_set<std::string> fourth ( second );                    // copy
  std::unordered_set<std::string> fifth ( cmerge(third,fourth) );       // move
  std::unordered_set<std::string> sixth ( fifth.begin(), fifth.end() ); // range

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

  return 0;
}

sixth contains: pink yellow red green orange blue

unordered_set::operator=

Assign content (public member function)

unordered_set::insert

Insert elements (public member function)

unordered_set::reserve

Request a capacity change (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