Get the best out of our app
GeeksforGeeks App
Open App
Browser
Continue

# Inserting elements in std::map (insert, emplace and operator [])

Prerequisite: Map in STL

The map is a container, as the name suggests used to store a key-value pair. The map has an advantage over other containers by the fact that searching in the map, defined by the “key” takes only O(1) time complexity, hence making it useful in various coding fields. The insertion is discussed in this article.

1. Using insert(): Insert function is used to insert the key-value pair in the map. After insertion, the reordering of elements takes place and the map is sorted w.r.t the key.

This function is implemented in 3 ways:

• insert(pair): This function inserts the pair in the map. The insertion only takes place when the key passed is not already inset.
It returns a pointer pair. First element points to the pair already present or newly inserted. The second element returns the boolean status “true” or “false”.
Time complexity: log(n) where n is the size of the map
• insert(hint, pair): In this implementation, the hint pointer is sent with the pair to be inserted. The use of a hint pointer is to help insert() know where the actual insertion has to take place. Hence, trying to reduce the time to allocate the pair.
Hint pointer does not force the insertion at a specific position. This function returns the pointer to the position where the pair is inserted.
Time complexity: log(n) where n is the size of the map if the hint is optimal then O(1)
• insert(beg_ptr, end_ptr): This type of insertion is required to insert the pairs of other containers into the map. The repeated pairs are not inserted if they are present in the destination container.
Time complexity: k*log(n) where n is the size of the map, and k is no. of elements inserted.

## C++

 // C++ code to demonstrate the working of insert()   #include#include // for map operationsusing namespace std;   int main(){    // declaring map    // of char and int    map< char, int > mp;           // declaring iterators    map::iterator it ;    map::iterator it1;    map::iterator it2;           // declaring pair for return value of map containing    // map iterator and bool    pair ::iterator, bool> ptr;           // using insert() to insert single pair    // inserting 'a' with 20    ptr = mp.insert( pair('a', 20) );           // checking if the key was already present or newly inserted    if(ptr.second)        cout << "The key was newly inserted" ;    else        cout << "The key was already present" ;           cout << endl ;           // printing map pairs after insertion    cout << "The map pairs after 1st insertion are : \n";           for (it1 = mp.begin(); it1!=mp.end(); ++it1)        cout << it1->first << "->" << it1->second << endl;           it = mp.begin();           // inserting map pair using hint     mp.insert(it, pair('b', 24) );           cout << endl ;           // printing map pairs after insertion    cout << "The map pairs after 2nd insertion are : \n";           for (it1 = mp.begin(); it1!=mp.end(); ++it1)        cout << it1->first << "->" << it1->second << endl;           // initializing another map     map mp2;           // using insert(beg_iter, end_iter) to copy all elements    mp2.insert(mp.begin(), mp.end());           cout << endl ;           // printing new map pairs after insertion    cout << "The new map pairs after insertion are : \n";           for (it1 = mp2.begin(); it1!=mp2.end(); ++it1)        cout << it1->first << "->" << it1->second << endl;       }

Output

The key was newly inserted
The map pairs after 1st insertion are :
a->20

The map pairs after 2nd insertion are :
a->20
b->24

The new map pairs after insertion are :
a->20
b->24

2. Using emplace: emplace is also used to insert the pairs into the map. This function is similar to “insert()” discussed above, the only difference being that the “in-place” construction of the pair takes place at the position of element insertion contrary to insert() which copies or movies existing objects.

• emplace(): Inserts pairs using an in-place construction strategy. Increases the size of the map by 1. returns a pointer pair. 1st element of which is an iterator pointing to the position of inserted pair. 2nd returns a boolean variable indicating an already present or newly created pair.
Time complexity: log(n) (n is the size of the map)
• emplace_hint(): Takes a “hint_iterator” to get a hint of the position of insertion to possibly reduce the time required to insert the pair inserted. This does not affect the position of insertion. It takes place where it is defined internally.
Time complexity: log(n) (n is the size of the map), if the hint is optimal then O(1)

## C++

 // C++ code to demonstrate the working of emplace()// and emplace_hint()#include#include // for map operationsusing namespace std;   int main(){    // declaring map    map mp;           // declaring iterators    map::iterator it;    map::iterator it1;    map::iterator it2;           // declaring pair for return value of map containing    // map iterator and bool    pair< map::iterator, bool> ptr;           // using emplace() to insert pair element    // inserting 'a' to 24    // no "pair" needed, in-place construction    ptr = mp.emplace('a', 24);           // checking if the pair was already present or newly inserted    // returns true. newly inserted    if (ptr.second)        cout << "The key was newly inserted" ;    else        cout << "The key was already present" ;           cout << endl;           // printing map pairs after insertion    cout << "The map pairs after 1st insertion are : \n";           for (it1 = mp.begin(); it1!=mp.end(); ++it1)        cout << it1->first << "->" << it1->second << endl;           cout << endl ;           // using emplace() to insert single pair    // inserting a to 24 // not inserted this time    ptr = mp.emplace('a', 24);           // checking if the key was already present or newly inserted    // returns false. already inserted    if(ptr.second)        cout << "The key was newly inserted" ;    else        cout << "The key was already present" ;           cout << endl ;           // printing map pairs after insertion    cout << "The map pairs after 2nd insertion are : \n";           for (it1 = mp.begin(); it1!=mp.end(); ++it1)        cout << it1->first << "->" << it1->second << endl;           it = mp.begin();           // inserting map pair using hint    mp.emplace_hint(it, 'b', 20);           cout << endl ;           // printing map pairs after insertion    cout << "The map pairs after 3rd insertion are : \n";           for (it1 = mp.begin(); it1!=mp.end(); ++it1)        cout << it1->first << "->" << it1->second << endl;          }

Output

The key was newly inserted
The map pairs after 1st insertion are :
a->24

The key was already present
The map pairs after 2nd insertion are :
a->24

The map pairs after 3rd insertion are :
a->24
b->20

3. Using operator[]: “[]” can also be used to insert elements in the map. Similar to the above functions and returns the pointer to the newly constructed element. The difference is that this operator always constructs a new element i.e even if a value is not mapped to a key, the default constructor is called and assigns a “null” or “empty” value to the key. The size of the map is always increased by 1
Time complexity: log(n) where n is the size of the map

## C++

 // C++ code to demonstrate the working of operator[] #include#include // for map operationsusing namespace std; int main(){    // declaring map    map mp;         // using [] to assign key to value    mp['a'] = 5;    mp['b'] = 6;    mp['c'] = 2;         // printing values    cout << "The element keys to a is : ";    cout << mp['a'] << endl;         cout << "The element keys to b is : ";    cout << mp['b'] << endl;         cout << "The element keys to c is : ";    cout << mp['c'] << endl;         // default constructor is called    // prints 0    cout << "The element keys to d is : ";    cout << mp['d'] << endl;          }

Output

The element keys to a is : 5
The element keys to b is : 6
The element keys to c is : 2
The element keys to d is : 0

### Note:

Difference between the two ways of inserting(Using operator[] & using insert()):

Both of these two methods work similarly when there is no duplicate key.
The map has the characteristic of removing duplicate keys.
Both methods follow this characteristic of the map and remove the key and it’s a co-responding element if the key is already there in the map.
But in the case of the third method(using operator[]) when a new key is being inserted in the map which is already present in the map then it removes the already present key and its element while in the case of the first method(using insert()) it removes the new key and it’s an element that is being inserted.

Related Article: Searching in Map STL C++

This article is contributed by Manjeet Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.

My Personal Notes arrow_drop_up