C++ 如何使用二进制搜索STL函数在嵌套类中搜索整数？

如何使用

binary\u search

STL函数在嵌套类中搜索整数？是否可以对向量

vITems

进行二进制搜索以搜索产品类别ID？目前，我必须在

Order

类中填充

std:：vector vProd

数组，以使用

binary\u search

函数

我在这个问题上做了很多研究，但没能解决这个问题

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

    class Product {
    public:

        int Id;
        std::string Name;

        Product(int idProd, const std::string &nameProd) : Id(idProd), Name(nameProd) {}
        Product(int idProd) : Id(idProd)  {} // Required for lambda function to work on binary_search function
    };

    class Item {
    public:

        Product Prod;
        int Number;

        Item(Product &prod, int numProd) : Prod(prod), Number(numProd) {}
    };

    class Order{
    private:
        std::vector<Item> vItems;

    public:

        bool consultProd(int idProd) const {
            std::vector<Product> vProd;
            size_t total = vItems.size();

            for(size_t i = 0; i < total; i++)
                vProd.push_back(vItems[i].Prod);


            bool yesId = binary_search( vProd.begin(), vProd.end(), idProd,
                                   []( const Product &p1, const Product &p2)
                                    {
                                        return p1.Id < p2.Id;
                                    } );

            return yesId;
        }


        void setItem(Item &it){
            vItems.push_back(it);
        }

    };


    int main()
    {
        //----------------------------------------------------------------
        Product p1(1, "aaa"), p2(2, "bbb"), p3(3, "ccc"), p4(4, "ddd");

        Item it1(p1, 1), it2(p2, 3), it3(p3, 3), it4(p4, 7);

        Order ord;

        ord.setItem(it1);
        ord.setItem(it2);
        ord.setItem(it3);
        ord.setItem(it4);
        //----------------------------------------------------------------

        if( !ord.consultProd(2) )
            ord.setItem(it2);
        else
          std::cout << "Warning: Product already included in the order.\n";

        system("pause");


        return 0;
}

#包括
#包括
#包括
类产品{
公众：
int-Id；
std：：字符串名；
Product（intidprod，conststd:：string&nameProd）：Id（idProd），Name（nameProd）{}
Product（int idProd）：lambda函数使用二进制搜索函数所需的Id（idProd）{}//
};
类项目{
公众：
产品生产；
整数；
项目（产品和产品，国际numProd）：产品（prod），编号（numProd）{}
};
阶级秩序{
私人：
std：：向量vItems；
公众：
bool CONSONTPROD（int idProd）常数{
std：：矢量vProd；
size_t total=vItems.size（）；
对于（大小i=0；i
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

模板结构重载：Ts..{using Ts:：operator（）…；}；
模板重载（Ts…）->重载；

您可以使用自定义比较器：

bool consultProd(int idProd) const {
    return binary_search(
        vItems.begin(),
        vItems.end(),
        idProd,
        overloaded{[](int id, const Item& item) { return id < item.Prod.Id; },
                   [](const Item& item, int id) { return item.Prod.Id < id; }
                  });
}

bool consultProd（int idProd）const{
返回二进制搜索(
vItems.begin（），
vItems.end（），
idProd，
重载{[]（int-id，const-Item&Item）{return-id

有助手时：

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

模板结构重载：Ts..{using Ts:：operator（）…；}；
模板重载（Ts…）->重载；

您可以使用自定义比较器：

bool consultProd(int idProd) const {
    return binary_search(
        vItems.begin(),
        vItems.end(),
        idProd,
        overloaded{[](int id, const Item& item) { return id < item.Prod.Id; },
                   [](const Item& item, int id) { return item.Prod.Id < id; }
                  });
}

bool consultProd（int idProd）const{
返回二进制搜索(
vItems.begin（），
vItems.end（），
idProd，
重载{[]（int-id，const-Item&Item）{return-id

您可以使用：

在每次二进制搜索之前进行排序没有意义：二进制搜索需要
O（logn）
时间，但排序需要
O（nlogn）
时间。这比
std:：find\u提供的线性时间复杂度
O（n）
更糟糕，如果
您可以使用：

在每次二进制搜索之前进行排序没有意义：二进制搜索需要
O（logn）
时间，但排序需要
O（nlogn）
时间。这比线性时间复杂度
O（n）更糟糕
由
std:：find_if
提供，不清楚问题出在哪里。您已经在使用二进制搜索。您提供的代码可以工作。您可以从整数隐式生成
产品
。@eerorika是的，但我需要填写产品向量以获取产品ID。是否可以从项目向量？不清楚你想要什么…摆脱
产品（int-idProd）
？@Jarod42不必创建乘积向量来进行搜索。我想知道是否可以在ITEMs向量中搜索产品ID。不清楚问题出在哪里。您已经在使用二进制搜索。您提供的代码可以工作。但是您隐式地从整数构建了一个
产品
。@eerorika是的，但我需要填写一个p要获取产品ID，请使用Product vector。是否可以从Items vector获取此产品ID？不清楚您想要什么…删除
产品（int idProd）
？@Jarod42不必创建产品向量来进行搜索。我想知道是否可以在ITEMs向量中搜索产品ID。极好的解决方案。非常感谢，朋友。进行排序的正确方法是什么？尝试如下，但无效。[code]排序（vItems.begin（），vItems.end（），[]（const-Item&it1，const-Item&it2）{返回it1.Prod.Idstd:：lower_bound
和
std:：upper_bound
来实现这一点。这样做，您就不用每次调用
std:：sort
。精彩的解释。它确实让我确信，在这种情况下，线性排序是正确的。现在，把性能问题从上下文中去掉，我如何在我的代码上下文中进行适当的二进制排序？我尝试创建一个构造函数[code]项（Product&prod）：prod（prod）{}[\code]，并使用函数[code]sort（vItems.begin（），vItems.end（），[]（const-Item&it1，const-Item&it2）{return it1.Prod.Id@Evg非常感谢你，朋友。我从你们身上学到了很多东西。非常好的解决方案。非常感谢你，朋友。t是什么