Initialising a 2d map c++ - 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;
}