初始化二维 map c++

Question

I have been thinking lately about 2d structures (of integers) in which their sizes can grow dynamically. I came across 'map' which I think that it meets my following need: Essentially, what I want is to check whether a random entry has been initialized or not (do something if it has not been initialized yet).

int main(){ 
   int int1, int2;
   std::map<int,std::map<int,int>> my_map;
   cout << "Enter two integers separated by space: ";
   cin >> int1 >> int2;
   if(has my_map[int1][int2] not been initialized){
      do something
   }
}

I am hoping that such functionality is available with C++.

Answer 1

If what you mean by checking whether an entry "has been initialized" is checking that a pair of keys has a value assigned to them -- one key for the outer map and one for the inner map -- you can test contents of a map of maps as below:

bool contains_keys(const std::map<int, std::map<int, int>>& map_of_maps, int key1, int key2) {
    auto iter = map_of_maps.find(key1);
    if (iter == map_of_maps.end()) {
        return false;
    }
    return iter->second.find(key2) != iter->second.end();
}

However, I question whether a map of maps is really what you want. If what you want is just a mapping from two keys to a single value, a more direct and space efficient implementation is to use an std::map with an std::tuple or std::pair as the key type.

Tuples version below.

#include <map>
#include <tuple>
#include <iostream>

int main()
{
    std::map<std::tuple<int, int>, int> map_of_pairs;
    map_of_pairs[{42, 17}] = 3;

    bool contains_42_17 = (map_of_pairs.find({ 42, 17 }) != map_of_pairs.end());
    bool contains_67_23 = (map_of_pairs.find({ 67, 23 }) != map_of_pairs.end());

    std::cout << ((contains_42_17) ? "yes\n" : "no\n");
    std::cout << ((contains_67_23) ? "yes\n" : "no\n");
}

Also unless you actually need the above to be ordered, consider an unordered_map.

Answer 2

You could write a function that first checks the outer map for key1 , then if an inner map exists with that key, check the inner map for key2 .

bool nested_contains(std::map<int,std::map<int,int>> const& my_map, int key1, int key2)
{
    auto itOuter = my_map.find(key1);
    if (itOuter == my_map.end())
        return false;
        
    return itOuter->second.contains(key2);
}

Then use it like

int main()
{ 
   int int1, int2;
   std::map<int,std::map<int,int>> my_map;
   std::cout << "Enter two integers separated by space: ";
   std::cin >> int1 >> int2;
   if(nested_contains(my_map, int1, int2)){
      // do something
   }
}

Answer 3

You can quickly do it creating a custom function using the find method. In that case the algorithm is suitable for being generic.

template<typename T>
bool contains_keys_cpp_20(std::map<T, std::map<T, T>> const& nested_map, T key1, T key2)
{
    auto pair = nested_map.find(key1);
    return (pair != nested_map.end()) && (pair->second.contains(key2));
}

template<typename T>
bool contains_keys_cpp_17(std::map<T, std::map<T, T>> const& nested_map, T key1, T key2)
{
    auto pair = nested_map.find(key1);
    return (pair != nested_map.end()) && (pair->second.find(key2) != pair->second.end());
}

int main()
{
    {
        std::map<int, std::map<int, int>> my_map;
        my_map[1] = { { 2, 1} };
        bool result = contains_keys_cpp_17(my_map, 3, 2);
        // false
    }

    {
        std::map<int, std::map<int, int>> my_map;
        my_map[3] = { { 2, 1} };
        bool result = contains_keys_cpp_17(my_map, 3, 2);
        // true
    }

    {
        std::map<char, std::map<char, char>> my_map;
        my_map['3'] = { { '2', '1'} };
        bool result = contains_keys_cpp_17(my_map, '3', '2');
        // true
    }

    return 0;
}