C++ 如何在std:：binary\u搜索中设置针类型

我有以下简单的程序，可以搜索一个项目：

#include <vector>
#include <algorithm>
#include <string>
#include <iostream>

class Record
{
public:
    Record() = default;
    Record(std::string name, int data) : mName(name), mData(data) { }
    std::string mName;
    int mData = 0;
};

int main(int, char**)
{
    std::vector<Record> recs;

    recs.emplace_back(Record("1", 1));
    recs.emplace_back(Record("55555", 2));
    recs.emplace_back(Record("333", 3));
    recs.emplace_back(Record("qwertyuiop", 4));
    recs.emplace_back(Record("22", 5));
    recs.emplace_back(Record("4444", 6));

    std::cout << "Unsorted:" << std::endl;
    for (auto& rec : recs)
    {
        std::cout << "Name: "  << rec.mName << " Data: " << rec.mData << std::endl;
    }
    std::cout << std::endl;

    std::stable_sort(recs.begin(), recs.end(), [](const Record& lhs, const Record& rhs) -> bool
    {
        return lhs.mName.length() < rhs.mName.length();
    });

    std::cout << "Sorted:" << std::endl;
    for (auto& rec : recs)
    {
        std::cout << "Name: " << rec.mName << " Data: " << rec.mData << std::endl;
    }
    std::cout << std::endl;

    if (std::binary_search(
        recs.begin(), 
        recs.end(),
        Record("qwertyuiop", 4),
        [](const Record& lhs, const Record& rhs) -> bool 
    {
        return lhs.mName < rhs.mName;
    }))
    {
        std::cout << "Found" << std::endl;
    }
    else
    {
        std::cout << "Not found" << std::endl;
    }


    return 0;
}

#包括
#包括
#包括
#包括
课堂记录
{
公众：
记录（）=默认值；
记录（std:：string name，int data）：mName（name），mData（data）{}
std：：字符串mName；
int-mData=0；
};
int main（int，char**）
{
std：：矢量记录；
记录安放（记录（“1”，1））；
记录安置（记录（“55555”，2））；
记录安置（记录（“333”，3））；
记录安置（记录（“qwertyuiop”，4））；
记录安置（记录（“22”，5））；
记录安放（记录（“4444”，6））；
std:：cout您可以通过添加一个
隐式
构造函数将
std:：string
转换为
Record
，并添加一个操作符将
Record
转换为
std:：string

operator std::string() const {
    return mName;
}

Record(std::string name) : mName(name), mData(int()) {}

或者，您可以将现有构造函数转换为

Record(std::string name, int data = int()) : mName(name), mData(data) {}

但无论如何，您需要创建一个
std:：string
对象来进行搜索

/// create std::string object from "qwertyuiop"
if (std::binary_search(recs.begin(), recs.end(), std::string("qwertyuiop"), 
    [](const Record & lhs, const std::string & rhs) -> bool 
        {
            return lhs.mName < rhs;    /// rhs is a std::string type
        })) {
    std::cout << "Found" << std::endl;
}
else {
    std::cout << "Not found" << std::endl;
}

///从“qwertyuiop”创建std:：string对象
如果（std:：binary_search（recs.begin（）、recs.end（）、std:：string（“qwertyuiop”），
[]（常量记录和lhs，常量标准：：字符串和rhs）->bool
{
返回lhs.mNamestd:：cout您可以创建处理异构比较的函数对象类型：

struct comp_t
{
    bool operator()(Record const& lhs, std::string const& rhs) const {
        return lhs.mName < rhs;
    }

    bool operator()(std::string const& lhs, Record const& rhs) const {
        return lhs < rhs.mName;
    }
};

我想不出用标准库实现这一点的方法，我会自己实现二进制搜索——大约10行代码
struct comp_t
{
    bool operator()(Record const& lhs, std::string const& rhs) const {
        return lhs.mName < rhs;
    }

    bool operator()(std::string const& lhs, Record const& rhs) const {
        return lhs < rhs.mName;
    }
};

std::binary_search(recs.begin(), recs.end(),
                   std::string("qwertyuiop"),
                   comp_t{})