初始化2d地图c++

Question

我最近一直在考虑2d结构(整数)，它们的大小可以动态增长。我遇到了“map”，我认为它满足了以下需求:本质上，我想要的是检查一个随机条目是否已经初始化(如果它还没有初始化的话，就做一些事情)。

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
   }
}

我希望这种功能可以在C++中使用。

Answer 1

如果检查条目“已初始化”的意思是检查一对键是否有分配给它们的值--一个键用于外部映射，一个用于内部地图--您可以测试地图的内容，如下所示：

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();
}

然而，我怀疑地图是否真的是你想要的。如果您想要的只是从两个键到单个值的映射，那么更直接和空间效率更高的实现是使用std::map和std::tuple或std：：结对作为键类型。

元组版本如下。

#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");
}

另外，除非您确实需要对上面的内容进行排序，否则请考虑使用unordered_map。

Answer 2

您可以编写一个函数，该函数首先检查key1的外部映射，然后如果有该键的内部映射存在，则检查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);
}

然后用它就像

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

您可以使用find方法快速创建自定义函数。在这种情况下，该算法适用于泛型。

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;
}