初始化二维地图 C++

Question

我最近一直在考虑二维结构（整数），在这些结构中，它们的大小可以动态增长。我遇到了 'map'，我认为它满足了我的以下需求：本质上，我想要的是检查是否 random 条目是否已经初始化（如果还没有初始化就做点什么）。

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

但是，我怀疑地图中的地图是否真的是你想要的。如果您想要的只是从两个键到单个值的映射，更直接且 space 有效的实现是使用 std::map 和 std::tuple 或 std::pair 作为密钥类型。

下面的元组版本。

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

初始化二维地图 C++

Initialising a 2d map c++

c++

dictionary

initialization

multidimensional-array

is-empty