{"id":26162,"date":"2021-03-26T11:14:00","date_gmt":"2021-03-26T05:44:00","guid":{"rendered":"https:\/\/www.mygreatlearning.com\/blog\/unordered_map-in-cpp\/"},"modified":"2024-09-03T11:08:55","modified_gmt":"2024-09-03T05:38:55","slug":"unordered_map-in-cpp","status":"publish","type":"post","link":"https:\/\/www.mygreatlearning.com\/blog\/unordered_map-in-cpp\/","title":{"rendered":"unordered_map in C++"},"content":{"rendered":"\n

unordered_map C++<\/strong><\/h2>\n\n\n\n

The unordered_map in C++ is like a data structure of dictionary type that store element. It has a sequence of (key, value) pair, which allows fast retrieval of an individual element based on their unique key.<\/p>\n\n\n\n

The function of each unique key is to hold only a single value associated with it, and key-value is generally used to identify the element uniquely. It is often referred to as an associative array. In (key, value) pair, the mapped value is an object with content associated with each unique key. For each pair type of key and mapped value may differ.<\/p>\n\n\n\n

In an unordered map, the element does not get sorted in any particular order with respect to either their key-value or mapped value. Instead, it organises values into bucket depending on their hash values that allow fast access to the individual element directly by their key values.<\/p>\n\n\n\n

Note:<\/strong> unordered_map container performs faster than map when they have to access an individual element by their key. Generally, they get less efficient when it comes to range iteration through a subset of their elements.<\/p>\n\n\n\n

Unordered_map in C++ implements the direct access operator (subscript operator []), allowing direct access of mapped value using its key value as the argument.<\/p>\n\n\n\n

Example<\/strong><\/h4>\n\n\n\n

Here is example of std:: unordered_map from <unordered_map> header file<\/p>\n\n\n

\ntemplate &lt; class Key,\n           class T,\n           class Hash = hash&lt;Key>,\n           class Pred = equal_to&lt;Key>,\n           class Alloc = allocator&lt; pair&lt;const Key,T> >\n           > class unordered_map;\n\n<\/pre><\/div>\n\n\n
Unordered_map-class template<\/strong><\/h2>\n\n\n\n
The unordered_map class template is defined in the Standard Template Library (STL) <\/strong>of C++; it is a set of a Class template to use in common programming task such as in data structure and function such as in a list, stack, array etc. Usually, it is a library of container classes, algorithm, and iterators. It is a generalised library, and so, its components are parameterised.<\/p>\n\n\n\n
Template Parameters <\/strong><\/h3>\n\n\n\n
Parameter  <\/strong><\/td>Description<\/strong><\/td><\/tr>
Key<\/strong><\/td>It has a type of key values as each element in an unordered map is uniquely identified by its key value.  <\/strong><\/td><\/tr>
T<\/strong><\/td>Type of mapped value as each element in an unordered map is used to store some data as its mapped value.<\/td><\/tr>
Hash<\/strong><\/td>A unary function object type that takes an object of type key type as an argument and returns a unique value of the type size_t based on it. This can be either a class implementing a function call operator or a pointer to function. This defaults to hash<key>, which return a hash value with a Probability of the collision approaching 1.0\/std :: numeric_limits <size_t> :: max().The unordered map object uses the hash values returned by this function to organise its elements internally, speeding up the process of locating individual elements.<\/td><\/tr>
Pred<\/strong><\/td>A binary predicate that takes up two arguments of the key type and returns a bool. The expression pred(a,b), where 'pred' is an object of this type, and a and b are key values, shall return true if a is to be considered equivalent to b. This can be either a class implementing a function call operator or a pointer to a function (see the constructor for an example). This defaults to the equal_to<Key>, which returns the same as applying the equal-to operator (a==b). The unordered_map object uses this expression to determine whether two-element keys are equivalent. No two elements in an unordered_map container can have keys that yield true using this predicate.<\/td><\/tr>
Alloc<\/strong><\/td>It is a type of allocator object used to define the storage allocation model. The allocator class template is used by default, which defines the simplest memory allocation model and is value-independent.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
In the reference for the unordered_map member functions, these same names (Key, T, Hash, Pred and Alloc) are assumed for the template parameters.<\/p>\n\n\n\n
The elements are organised into buckets. Keys with a similar hash code are stored in the same bucket.<\/p>\n\n\n\n
The number of buckets is automatically increased by a call to insert or as the result of calling rehash.<\/p>\n\n\n\n
Unordered_map public types<\/strong><\/h2>\n\n\n\n
1. typedef <\/strong>implementation-defined size_type;<\/p>\n\n\n\n
An unsigned integral type.<\/p>\n\n\n\n
'size_type' can represent any non-negative value of difference_type.<\/p>\n\n\n\n
2. typedef <\/strong>implementation-defined difference_type;<\/p>\n\n\n\n
A signed integral type which is identical to the difference type of iterator and 'const_iterator'.<\/p>\n\n\n\n
3. typedef <\/strong>implementation-defined iterator;<\/p>\n\n\n\n
An iterator whose value type is the value_type.<\/p>\n\n\n\n
Any iterator category except output iterator.<\/p>\n\n\n\n
Convertible to const_iterator.<\/p>\n\n\n\n
4. typedef <\/strong>implementation-defined const_iterator;<\/p>\n\n\n\n
A constant iterator whose value type is the value_type.<\/p>\n\n\n\n
Any iterator category except output iterator.<\/p>\n\n\n\n
5. typedef<\/strong> implementation-defined local_iterator;<\/p>\n\n\n\n
An iterator with the same value type, difference type and pointer and reference type as an iterator.<\/p>\n\n\n\n
A local_iterator object could be used to iterate through a single bucket.<\/p>\n\n\n\n
6. typedef<\/strong> implementation-defined const_local_iterator;<\/p>\n\n\n\n
A constant iterator with a similar value type, difference type and pointer and reference type as the const_iterator.<\/p>\n\n\n\n
A const_local_iterator object could be used to iterate through a single bucket.<\/p>\n\n\n\n
Unordered_map iterators<\/strong><\/h2>\n\n\n\n
Iterators to elements of unordered_map containers access to both the key and the mapped value. For this, the class defines what is called its value_type, which is a pair class with its first value corresponding to the const version of the key type (template parameter Key) and its second value corresponding to the mapped value (template parameter T):<\/p>\n\n\n\n
 <\/td>typedef pair<const Key, T> value_type;<\/td><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
  1. iterator begin();
    const_iterator begin() const;<\/li><\/ol>\n\n\n\n
    Returns:<\/td>An iterator that refers to the first element of the container or, if the box is empty, the past-the-end value for the container.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
    1. iterator end();
      const_iterator end() const;<\/li><\/ol>\n\n\n\n
      Returns:<\/td>An iterator referring to the past-the-end value for the container.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
      1. const_iterator cbegin() const;<\/li><\/ol>\n\n\n\n
        Returns:<\/td>A constant iterator that refers to the first element of the container, or if the container is empty, the past-the-end value for the container.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
        1. const_iterator cend() const;<\/li><\/ol>\n\n\n\n
          Returns:<\/td>A constant iterator referring to the past-the-end value for the container.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
          Iterators of a unordered_map container point to elements of this value_type. Thus, for an iterator called it that point to an element of a map, its key and mapped value can be accessed respectively with:<\/p>\n\n\n\n
          <\/p>\n\n\n\n
          Member types<\/strong><\/h2>\n\n\n\n
          The following aliases are member types of unordered_map. They are widely used as parameter and return types by member functions:<\/p>\n\n\n\n
          member type<\/strong><\/td>definition<\/strong><\/td>notes<\/strong><\/td><\/tr>
          key_type<\/td>the first template parameter (Key)<\/td><\/td><\/tr>
          mapped_type<\/td>the second template parameter (T)<\/td><\/td><\/tr>
          value_type<\/td>pair<const key_type,mapped_type><\/td><\/td><\/tr>
          hasher<\/td>the third template parameter (Hash)<\/td>defaults to: hash<key_type><\/td><\/tr>
          key_equal<\/td>the fourth template parameter (Pred)<\/td>defaults to: equal_to<key_type><\/td><\/tr>
          allocator_type<\/td>the fifth template parameter (Alloc)<\/td>defaults to: allocator<value_type><\/td><\/tr>
          reference<\/td>value_type&<\/td><\/td><\/tr>
          const_reference<\/td>const value_type&<\/td><\/td><\/tr>
          pointer<\/td>allocator_traits<Alloc>::pointer<\/td>for the default allocator: value_type*<\/td><\/tr>
          const_pointer<\/td>allocator_traits<Alloc>::const_pointer<\/td>for the default allocator: const value_type*<\/td><\/tr>
          iterator<\/td>a forward iterator to value_type<\/td><\/td><\/tr>
          const_iterator<\/td>a forward iterator to const value_type<\/td><\/td><\/tr>
          local_iterator<\/td>a forward iterator to value_type<\/td><\/td><\/tr>
          const_local_iterator<\/td>a forward iterator to const value_type<\/td><\/td><\/tr>
          size_type<\/td>an unsigned integral type<\/td>usually the same as size_t<\/td><\/tr>
          difference_type<\/td>a signed integral type<\/td>usually the same as ptrdiff_t<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
          Container Properties of unordered_map:<\/strong><\/h2>\n\n\n\n
          Here are the container properties of unordered_map:<\/p>\n\n\n\n