当两个 std::map 对象相同时

Question

I have two std::map objects that I populate with the same data but the order is different:

using TMap = std::map<int, std::wstring>;
using TSourceData = std::vector< std::pair<int, std::wstring> >;

TSourceData gen_source_data(int size)
{
    TSourceData result;
    result.reserve(size);

    for(int i = 0; i < size; ++i)
    {
        result.push_back( std::make_pair(i, std::to_wstring(i)) );
    }

    return result;
}

TMap fill_map(const TSourceData& source)
{
    TMap result;

    auto randomized = source;
    std::random_shuffle(randomized.begin(), randomized.end());

    for(const auto &e : randomized)
    {
        result[e.first] = e.second;
    }

    return result;
}

int main()
{
    auto source = gen_source_data(1000);

    auto m1 = fill_map(source);
    auto m2 = fill_map(source);

    std::wcout << (m1 == m2) << std::endl;
}

In VS2017 it seems to always print 1 so the two maps are equal no matter in what order they were filled. But is it guaranteed to be so? And if so, could you explain why?

Answer 1

... so the two maps are equal no matter in what order they were filled. But is it guaranteed to be so?

Yes, because std::map is a sorted associative container (usually implemented as a binary tree) its elements are guaranteed to be sorted (regardless of its implementation).

Answer 2

std::map is an associative container. The difference between a sequential container and an associative container is that:

• a sequential container lets you decide the position of the element
• an associative container itself determines the position of the element

Also since std::map is a sorted container, there can be only one possible order for all the keys, so in the absence of duplicates, insertion order for std::map doesn't matter. Similarly, the ordering inside std::unordered_map is determined by the hash of each key, and is again not dependent on the insertion order.

Notice that you shuffle a vector (a sequential container), then you copy the values into a map . It's impossible to "shuffle" a map , since you do not control the position of the elements there.