如何使用binary_search STL函数在嵌套类中搜索整数？

Question

如何使用binary_searc STL函数在嵌套类中搜索整数？

是否有可能对向量向量进行二进制搜索以搜索产品类别ID？

当前，我需要在Order类中填充vProd数组以使用binary_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;
}

Answer 1

使用助手：

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<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; }
                  });
}

Demo

Answer 2

您可以使用std::lower_bound：

std::lower_bound

请注意，

const auto item_it = std::lower_bound(vItems.begin(), vItems.end(), idProd,
    [](const Item& item, int id) { return item.Prod.Id < id; });

const bool yesId = (item_it != vItems.end() && item_it->Prod.Id == idProd);
return yesId;

应该表示按[vItems.begin(), vItems.end())排序或至少相对于Prod.Id分区的项的有效范围。如果不满足此条件，则Prod.Id < idProd的行为未定义。