C++ std::unordered_map 比 std::map 慢？

Question

In the example below I was expecting unordered_map to be faster than map , but it's not the case. Why is it so? Is unordered_map designed for another purpose than being faster than the regular map?

#include <iostream>
#include <chrono>
#include <unordered_map>
#include <map>


int main()
{
    std::unordered_map<int, double> grid_unmap_int;
    std::map<int, double> grid_map_int;
    
    size_t map_size = 1e7;

    auto t1 = clock();
    for (size_t i = 0; i < map_size; ++i) {
        grid_unmap_int[i] = 1.0;
    }
    auto t2 = clock();


    for (size_t k = 0; k < map_size; ++k) {
        grid_map_int[k] = 1.0;
    }
    auto t3 = clock();

    std::cout << "Insertion \n";
    std::cout << "Filling unordered map int key: " << (t2 - t1) / static_cast<double>(CLOCKS_PER_SEC) << " seconds.\n";
    std::cout << "Filling map int key: " << (t3 - t2) / static_cast<double>(CLOCKS_PER_SEC) << " seconds.\n";
    std::cout << std::endl;

    t1 = clock();
    for (size_t i = 0; i < map_size; ++i) {
        double b = grid_unmap_int[i] ;
    }
    t2 = clock();


    for (size_t k = 0; k < map_size; ++k) {
        double b = grid_map_int[k];
    }
    t3 = clock();

    std::cout << "Retrieve \n";
    std::cout << "Filling unordered map int key: " << (t2 - t1) / static_cast<double>(CLOCKS_PER_SEC) << " seconds.\n";
    std::cout << "Filling map int key: " << (t3 - t2) / static_cast<double>(CLOCKS_PER_SEC) << " seconds.\n";


    return 0;
}

EDIT: the results: enter image description here

Answer 1

In the example below I was expecting unordered_map to be faster than map , but it's not the case. Why is it so?

That can be the case, as std::map promises logarithmic lookup time , while std::ordered_map promises constant lookup time on average, worst case linear in the size of the container .

Which is a fancy way of saying "It could be better, and it could be worse. Profile it for your specific scenario".

Is unordered_map designed for another purpose than being faster than the regular map ?

Yes.

std::map can only use keys that are ordered . There must be an established way to sort the type, like the int in your example. And in return, iterating the std::map gives you that ordering.

std::unordered_map can only use keys for which std::hash<Key> is defined. The keys do not need to have an established ordering (They could be images, for example. Or colors. Or sounds.) But there must exist some way to convert the values to hashes.