为什么在unordered_map中使用find（）要比直接读取快得多？

Question

Its hard to describe so I will just show the code:

#include <bits/stdc++.h> 
using namespace std; 

int main() 
{ 
    clock_t start, end; 
    unordered_map<int, int> m;
    long test=0;
    int size = 9999999;
    for (int i=0; i<size/3; i++) {
        m[i] = 1;
    }
    start = clock(); 
    for (int i=0; i<size; i++) {
        //if (m.find(i) != m.end())
            test += m[i];
    }
    end = clock(); 
    double time_taken = double(end - start) / double(CLOCKS_PER_SEC); 
    cout << "Time taken by program is : " << fixed  
         << time_taken << setprecision(5); 
    cout << " sec " << endl; 
    return 0; 
} 

The result(3 times): Without if (m.find(i) != m.end()) :

Time taken by program is : 3.508257 sec 
Time taken by program is : 3.554726 sec 
Time taken by program is : 3.520102 sec 

With if (m.find(i) != m.end()) ：

Time taken by program is : 1.734134 sec 
Time taken by program is : 1.663341 sec 
Time taken by program is : 1.736100 sec 

Can anyone explain why? What really happened inside add m[i] when the key not appeared?

Answer 1

In this line

test += m[i];

the operator[] does two things: First it tries to find the entry for the given key, then if the entry does not exist it creates a new entry.

On the other hand here:

if (m.find(i) != m.end())
        test += m[i];

the operator[] does only one thing: It finds the element with the given key (and because you checked before that it exists, no new entry has to be constructed).

As the map contains only keys up to size/3 your results suggest that creating the element outweights the overhead for first checking if the element does exist.

In the first case there are size elements in the map while in the second there are only size/3 elements in the map. Note that calling operator[] can get more expensive the more elements are in the map. It is Average case: constant, worst case: linear in size. and the same holds for find . However, calling the methods many times, the worst case should amortize and you are left with average constant.

Thanks to Aconcagua, for pointing out that you did not reserve space in the map. In the first case you add many elements that require to allocate space, while in the second, the size of the map stays constant during the part you measure. Try to call reserve before the loop. Naively I would expect that the loops would be very similar in that case.

Answer 2

The difference with and without the if is down to you having only populated the first third of the map.

If you do a find, then the program will go and find the element, and if it exists then it will do the operator[], which finds it again (not terribly efficient), find it exists, and return the value

Without the if, when you do the operator[]. it will try and find the element, fail, and create the element (with the default value for an int, which is 0), and return it

So without the if, you are populating the whole map, which will increase the runtime.

If you wanted to be more efficient, you could use the result of the find to fetch the value

auto iter = m.find(i);
if (iter != m.end()) 
{
    test += iter->second;
}