C++ 如何按值而不是键查找容器中的对象

我有一张带有

我想在

映射中搜索特定值（非键）并检索指向正确
int*
（映射值）的迭代器

我可以使用std:：find_if（）

吗

其中比较应类似于：

bool compare(int* v1, int* v2)
{
 return (v1==v2);
}

---

完成此任务的最佳方法是什么？您可以这样做：

#include <string>                                                                                                                                                                                                                           
#include <iostream>
#include <algorithm>
#include <map>

int main()
{
    std::map<int, std::string> m = {{1, "a"}, {2, "b"}};
    std::string value_to_find = "b";
    auto it = std::find_if(m.begin(), m.end(), [&](decltype(m)::value_type &v) {
        return v.second == value_to_find;
    });

    if (it != m.end()) {
        std::cout << it->first << std::endl;
    }
    return 0;
}

---

您可以这样做：

#include <string>                                                                                                                                                                                                                           
#include <iostream>
#include <algorithm>
#include <map>

int main()
{
    std::map<int, std::string> m = {{1, "a"}, {2, "b"}};
    std::string value_to_find = "b";
    auto it = std::find_if(m.begin(), m.end(), [&](decltype(m)::value_type &v) {
        return v.second == value_to_find;
    });

    if (it != m.end()) {
        std::cout << it->first << std::endl;
    }
    return 0;
}

---

std:：find_if

将为任何“类映射”类型执行任务，例如

std:：map

或

std:：unordered_map

。注意：集合不需要订购；任何定义

inputierator

（即“iterable”）的操作都可以

这是一个适用于任何“类映射”（但不适用于“类多映射”）的函数

模板
typename映射类型：：常量迭代器查找值（常量映射类型和映射，常量typename映射类型：：映射类型和值）
{
返回std:：find_if（std:：cbegin（map），std:：cend（map），[&value]（const auto&p）{return p.second==value；}）；
}
int main（int argc，常量字符**argv）
{
无序映射{{0，'A'}，{1，'B'}，{2，'C'}；
char val{'B'}；
自动it=查找_值（map，val）；
if（it！=std:：cend（map））std:：cout first
std:：find_if
将为任何“类映射”类型执行任务，例如
std:：map
或
std:：unordered_map
。请注意，集合不需要排序；任何定义
InputIterator
（即可“iterable”）的操作都可以

这是一个适用于任何“类映射”（但不适用于“类多映射”）的函数

模板
typename映射类型：：常量迭代器查找值（常量映射类型和映射，常量typename映射类型：：映射类型和值）
{
返回std:：find_if（std:：cbegin（map），std:：cend（map），[&value]（const auto&p）{return p.second==value；}）；
}
int main（int argc，常量字符**argv）
{
无序映射{{0，'A'}，{1，'B'}，{2，'C'}；
char val{'B'}；
自动it=查找_值（map，val）；
如果（it！=std:：cend（map））Std:Cuth>代码> STD:：FiffyIf < /C> >：如果你这样做有任何规律性，我会强烈考虑采用LeFlou的建议而不是当前的答案。<代码> STD:：FordION < < /C> >：如果你这样做有任何规律性，我会强烈考虑接受“LeFlou的建议”而不是当前的答案。ith C++14，
[&]（auto&v）{…}
@Creris是的，但问题被标记为
c++11
。我真的很欣赏
c++14
的自动类型推断。@丹尼尔是的，可能被什么东西弄糊涂了。我只是想说，处理无序的容器效率很低。@VictorPolevoy解决方案的时间复杂度仍然与
std:：find_if
一样线性>基本上是一个线性时间算法。如果您想达到次线性时间复杂度，您需要使用一个期望有序范围的算法。@VictorPolevoy不认为使用有序容器更有效；有序容器按键排序，而不是按值排序。或者使用C++14，
[&]（auto&v）{…}
@Creris是的，但问题被标记为
c++11
。我真的很欣赏
c++14
的自动类型推断。@丹尼尔是的，可能被什么东西弄糊涂了。我只是想说，处理无序的容器效率很低。@VictorPolevoy解决方案的时间复杂度仍然与
std:：find_if
一样线性>基本上是一个线性时间算法。如果您想达到次线性时间复杂度，您需要使用一个期望有序范围的算法。@VictorPolevoy不认为使用有序容器更有效；有序容器在键上排序，而不是在值上排序。在这个问题是关于
c++11
。你在lamba的参数列表中使用
auto
，而这个问题是关于
c++11
。
[&](std::map<int, std::string>::value_type &v)

template <typename MapType>
typename MapType::const_iterator find_value(const MapType& map, const typename MapType::mapped_type& value)
{
    return std::find_if(std::cbegin(map), std::cend(map), [&value] (const auto& p) { return p.second == value; });
}

int main(int argc, const char **argv)
{
    std::unordered_map<int, char> map {{0, 'A'}, {1, 'B'}, {2, 'C'}};
    char val {'B'};
    auto it = find_value(map, val);
    if (it != std::cend(map)) std::cout << it->first << std::endl;
    return 0;
}