如何使类在向量内可搜索？ 我们说有一个C++ 类{STD::string name；STD::String姓/*…其他成员**/}；我们希望它可以在向量中通过2个字符串（姓名、姓氏）进行搜索。怎么做这样的事？我应该实现哪些成员/运算符重载？或者一些散列函数？

如果您使用的是

std:：vector

，最好的方法可能是使用

std:：find_If（）

。这将允许您定义一个自定义谓词，该谓词将应用于每个元素，搜索您需要的任何内容。谓词可以是任何可调用类型；如果您使用的是C++11，那么lambda是理想的

下面是一个使用内联lambda的示例（我假设

Name

类如您在问题中所述）：

std:：向量向量向量机；
//用名称填充向量。。。
自动iter=std:：查找(
vec.begin（），
vec.end（），
[]（const Name&n）{return n.Name==“Random”和&n.Name==“Person”}
);
if（iter！=vec.end（））{
//搜索成功
}

---

您还可以使用存储的lambda或预定义函数/functor作为谓词。

在向量中，使用

std:：find

，您将需要

操作符==

（在逻辑上应该有

运算符！=

；它是 非常糟糕的做法是只提供一个，即使标准 图书馆不需要它）。或者您可以使用

std:：find_if

， 并明确提供比较

如果要对向量进行排序，请使用

std:：lower_bounds

on 或者将对象放入

std:：set

（或者将它们用作

std:：map

），您将需要

操作符=

也是一致的）。再一次， 您可以改为提供显式比较<代码>！（a在这里意味着平等，所以如果您要实现所有 六个运算符，您可能也会明白这意味着什么

对于

std:：unordered_set

（或作为

unordered_map

中的键，您将 还需要一个哈希函数，它必须与

运算符==

；即，如果

a==b

，则

hash（a）==hash（b）

反转显然不能保持，但应该有一个高的 它很可能适用于任意两个

a

和

b

例如，在您的情况下，要按姓名匹配，您 可以定义：

class MatchName
{
    std::string targetName;
    std::string targetSurname;
public:
    MatchName( std::string const& targetName, std::string const& targetSurname )
        : targetName( targetName )
        , targetSurname( targetSurname )
    {
    }
    bool operator()( ClassType const& obj ) const
    {
        return obj.name == targetName
            && obj.surname == targetSurname;
    }
}

或者，如果要保持数据排序：

class OrderByName
{
public:
    bool operator()( ClassType const& lhs, ClassType const& rhs ) const
    {
        return lhs.name < rhs.name
            || (lhs.name == rhs.name && lhs.surname < rhs.surname);
    }
};

类OrderByName
{
公众：
布尔运算符（）（类类型常量和lhs，类类型常量和rhs）常量
{
返回lhs.name

至于未订购的货柜：

template <typename T> struct Hash;
template<>
struct Hash<ClassType>
{
    bool operator()( ClassType const& obj ) const
    {
        return 127 * hash<std::string>( obj.name )
            + hash<std::string( obj.surname );
    }
};

模板结构哈希；
模板
结构散列
{
布尔运算符（）（类类型常量和对象）常量
{
返回127*散列（obj.name）
+Hash对于按键搜索操作，请使用Map或Multimap。您只需要正确的谓词和
std:：find_if
。根据类的语义，预先定义几个有用的谓词可能是有意义的（例如，
MatchName
/
OrderByName
，
MatchSomethingElse
/
OrderBySomethingElse
）或定义
运算符==
和
运算符！=
（可能还有四个不等运算符）。相等/不相等运算符在上下文中可能没有意义，因为该类包含其他数据，这些数据可能独立于名称。或者可能。我们不知道该类的完整语义，因此无法确定。（如果类是可复制的，那么
==
和
！=
的运算符可能是有意义的。尽管可能不符合他想要的查找语义。）
template <typename T> struct Hash;
template<>
struct Hash<ClassType>
{
    bool operator()( ClassType const& obj ) const
    {
        return 127 * hash<std::string>( obj.name )
            + hash<std::string( obj.surname );
    }
};