在C ++中嵌套的unordered_map / hash_map更新

Question

I'm new in C++ and have the following problems about unordered_map (or hash_map):

#include <unordered_map>
#include <iostream>
using namespace std;

int main()
{
    unordered_map<int,int> h1;
    int temp1=0;
    h1.insert(pair<int,int>(0,temp1));
    unordered_map<int, unordered_map<int,int>> h2;
    h2.insert(pair<int, unordered_map<int,int>>(1,h1));
    unordered_map<int, unordered_map<int,int>>::iterator h2_itor=h2.find(1);
    h2_itor->second.find(0)->second++;

    unordered_map<int, unordered_map<int,int>> h3;
    for(int i=0;i<100;i++)
    {
        int first=rand()%10;
        int second=rand()%10;

        unordered_map<int, unordered_map<int,int>>::iterator h3_itor=h3.find(first);
        if(h3_itor!=h3.end())
        {
            unordered_map<int,int> submap=h3_itor->second;
            unordered_map<int,int>::iterator submap_itor=submap.find(second);
            if(submap_itor!=submap.end())
                submap_itor->second++;
            else
                submap.insert(pair<int,int>(second, 1));
        }
        else
        {
            unordered_map<int,int> submap;
            submap.insert(pair<int,int>(second,1));
            h3.insert(pair<int, unordered_map<int,int>>(first,submap));
        }
    }

    return 0;
}

The output is quite odd. For h1 and h2 it seems work, which means the value in h1 with key 0 is updated (incremented by 1). Though this looks trivial, for h3, which I randomly insert some "pairs" (first, second) and counting with hash map, the count seems can not be updated. For example, it may be like this:

insert 1 -> 7 -> 1 
 ... 
now update 1 -> 7 -> 1 to 1 -> 7 -> 2 using my code
fetch: h3.find(1)->second.find(7)->second : it's still 1 but not 2!

which shows the update of value is unsuccessful. I know in Java this never happens. So where does this problem lies?

Answer 1

The problem is here:

unordered_map<int,int> submap = h3_itor->second;

This results in the whole submap being copied into you new local submap objects. All the modifications you do to it are lost when it gets destroyed upon leaving the scope.

Instead you can use the reference to the actual hashmap element you want to modify:

unordered_map<int,int> &submap = h3_itor->second;

This one & should fix everything.

Answer 2

Here's a refactored version (i think) of the second part of the code. I am also generating a consistent test data set so we can reproduce behaviour on each run (randomness is an anathema to testing).

Here's the code. What's the question?

#include <unordered_map>
#include <iostream>

using i2i = std::unordered_map<int, int>;
using map_i_to_i2i = std::unordered_map<int, i2i>;

void test_insert(map_i_to_i2i& outer, int v1, int v2)
{
    auto iouter = outer.find(v1);
    if (iouter == outer.end()) {
        std::cout << "case c) [" << v1 << "] = [" << v2 << "] = 1\n";
        outer[v1][v2] = 1;
    }
    else {
        auto& inner = iouter->second;
        auto iinner = inner.find(v2);
        if (iinner == inner.end())
        {
            std::cout << "case b) [" << v1 << "][" << v2 << "] = 1\n";
            inner.emplace_hint(iinner, v2, 1);
        }
        else {
            std::cout << "case c) [" << v1 << "][" << v2 << "] += 1\n";
            iinner->second += 1;
        }
    }
}

int main()
{
    map_i_to_i2i h3;
    for (int passes = 0 ; passes < 3 ; ++passes)
    {
        for (int x = 0 ; x < 2 ; ++x) {
            for (int y = 0 ; y < 2 ; ++y) {
                test_insert(h3, x, y);
            }
        }
    }
    return 0;
}

Answer 3

Not really an answer, just an FYI: if this is more than an exercise in using iterators, there is a much easier way to do this:

unordered_map<int, unordered_map<int,int>> h3
h3[0][0] = 1;

for (int i=0; i<100; i++ ) {
    int first=rand()%10;
    int second=rand()%10;
    h3[first][second]++;
}

This works because, if a value is missing, unordered_map::operator[] will default construct and insert it. For a map, that is an empty map, and for an int, that's zero.

If you wanted another default, you could use unordered_map::emplace , eg:

unordered_map<int, unordered_map<int,int>> h3
h3[0][0] = 2;

for (int i=0; i<100; i++ ) {
    int x=rand()%10;
    int y=rand()%10;
    int& val = h3[x].emplace(y, 1).first->second;
    val *= 2;
}

Yes, thats slightly more confusing: emplace inserts the specified value if the key is missing (no overwriting if it already exists), and returns std::pair<iterator, bool> .

Here, the bool tells you if your value was inserted or not, and iterator itself is a wrapper around std::pair<key,val>* , hence the .first->second to get the value out.

Besides being shorter/more readable, both of these are also more efficient. In your code, you do a lookup twice if the value isn't present, but both of the above only do one lookup.