C++ 检查'；最深的'；地图中的元素

我有一张

地图

第一个键代表节点，第二个键代表属性，“deep”元素代表特定值

我需要检查该元素，但执行以下操作会将不必要的键添加到地图中：

map<int, map<int, int>> test;
if (test[4][3] > 5)
{
    //do something
}

map测试；
如果（测试[4][3]>5）
{
//做点什么
}

我认为这是另一种选择

map<int, map<int, int>> test;
if (test.find(4) != test.end())
{
    if (test[4].find(3) != test[4].end())
    {
        if (test[4][3] > 5)
        {
            //do something
        }
    }
}

map测试；
if（test.find（4）！=test.end（））
{
if（测试[4]。查找（3）！=测试[4]。结束（）
{
如果（测试[4][3]>5）
{
//做点什么
}
}
}

---

有更好的方法吗？我不知道地图中是否存在键

[4][3]

，我不想不必要地添加它。谢谢

这应该有效-首先在第一个映射中搜索并保存返回的迭代器，然后如果该迭代器有效，则搜索他指向的映射并将结果保存在另一个迭代器中，如果他有效，则表示您搜索的对象存在，您只需检查它的值：

map<int, map<int, int>> test;
map<int, map<int, int>>::iterator it1;
map<int, int>::iterator it2;
if ((it1 = test.find(4)) != test.end())
{
    if ((it2 = it1->second.find(3)) != it1->second.end())
    {
        if (it2->second > 5)
        {
            //do something
        }
    }
}
return 0;

map测试；
迭代器it1；
迭代器it2；
if（（it1=test.find（4））！=test.end（）
{
如果（（it2=it1->second.find（3））！=it1->second.end（））
{
如果（it2->秒>5）
{
//做点什么
}
}
}
返回0；

这应该有效-首先在第一个映射中搜索并保存返回的迭代器，然后如果该迭代器有效，则搜索他指向的映射并将结果保存在另一个迭代器中，如果他有效，则意味着您搜索的对象存在，您只需检查它的值：

map<int, map<int, int>> test;
map<int, map<int, int>>::iterator it1;
map<int, int>::iterator it2;
if ((it1 = test.find(4)) != test.end())
{
    if ((it2 = it1->second.find(3)) != it1->second.end())
    {
        if (it2->second > 5)
        {
            //do something
        }
    }
}
return 0;

map测试；
迭代器it1；
迭代器it2；
if（（it1=test.find（4））！=test.end（）
{
如果（（it2=it1->second.find（3））！=it1->second.end（））
{
如果（it2->秒>5）
{
//做点什么
}
}
}
返回0；

我认为这可能会让我们更容易了解发生了什么：

map<int, map<int, int>> test; 
map<int, map<int, int>>::iterator outer = test.find(4);
if (outer != test.end())
{
    map<int, int>::iterator inner = outer->second.find(3);
    if (inner != outer->second.end())
    {
        if (inner->second > 5)
        {
            //do something
        }
    }
}
return 0;

map测试；
迭代器外部=test.find（4）；
if（外部！=test.end（））
{
map:：iterator internal=outer->second.find（3）；
如果（内部！=外部->第二个.end（））
{
如果（内部->秒>5）
{
//做点什么
}
}
}
返回0；

我认为这可能会让我们更容易了解发生了什么：

map<int, map<int, int>> test; 
map<int, map<int, int>>::iterator outer = test.find(4);
if (outer != test.end())
{
    map<int, int>::iterator inner = outer->second.find(3);
    if (inner != outer->second.end())
    {
        if (inner->second > 5)
        {
            //do something
        }
    }
}
return 0;

map测试；
迭代器外部=test.find（4）；
if（外部！=test.end（））
{
map:：iterator internal=outer->second.find（3）；
如果（内部！=外部->第二个.end（））
{
如果（内部->秒>5）
{
//做点什么
}
}
}
返回0；

与Tomer Arazy的建议没有本质区别，但使用C++11的

decltype

来消除重复的类型声明（修改映射的数据类型时可能会很麻烦）：

---

然后可能会在某个地方捕捉到

std:：out_of_range

异常。

与Tomer Arazy的建议没有根本区别，但使用C++11的

decltype

来消除重复的类型声明（修改映射的数据类型时可能会很麻烦）：

---

然后可能会在某个地方捕捉到

std:：out\u of_range

异常。

谢谢-但是它与我的第二个实现有什么不同？如果您在一个步骤中声明并初始化迭代器，然后在另一个步骤中对照end（）进行检查，可能会更清楚。@sccs:yours必须执行两次搜索。一次在find（）中，一次在索引[]中。这一个保存每个查找的结果，并直接对其进行操作。执行此操作时：

test.find（3）

在节点映射中搜索，而不是在属性映射中搜索。2.您的在最后一步中进行了2次额外（不必要）搜索，而我的则使用iterator@sccs-虽然做测试[4]看起来像是直接访问，但事实并非如此！它实际上是在树中执行搜索（log（n）），您需要将结果保存到其他地方以避免这种情况（编辑：或Matthew说的；））谢谢-但是它与我的第二个实现有何不同？如果您在一个步骤中声明并初始化迭代器，然后对照end（）进行检查，可能会更清楚在另一种情况下。@sccs:yours必须执行两次搜索。一次在find（）中，一次在索引[]中。这一个保存每个查找的结果，并直接对其进行操作。执行此操作时：

test.find（3）

在节点映射中搜索，而不是在属性映射中搜索。2.您的在最后一步中进行了2次额外（不必要）搜索，而我的则使用iterator@sccs-虽然做测试[4]看起来像是直接访问，但事实并非如此！它实际上是在树中执行搜索（log（n）），您需要将结果保存到其他地方以避免（编辑：或Matthew说的；））在我的部件上键入错误-现在编辑“有更好的方法吗？”-至少不要使用

查找（4）

，然后立即使用

测试[4]

，因为这将搜索两次值，在您的情况下搜索四次（您认为

find

返回什么？）。请始终记住，

[]

对地图的访问不像对数组或向量的访问那样自由，它是O（logn）。在我的部分键入错误-现在编辑“有更好的方法吗？”-至少不要使用

查找（4）

，然后在之后立即使用

测试[4]

，因为这样会搜索两次值，在您的案例中，有四次（您认为

find

返回什么？）。请始终记住，

[]

对地图的访问不像对数组或向量的访问那样自由，它是O（logn）。这很好-使用C++11的另一种方法是使用

自动
@TomerArazy，因为您无法将赋值放入if，因此整个操作都使用单个if，与Mathew的代码类似，只是使用了适当的
auto
s。这取决于你更看重什么