Реализовать поиск по заданному полю в массиве объектов пользовательского типа (структуры)

#include <iostream>
#include <string>
 
class Furniture
{
protected:
    std::string name;
    double price;
    unsigned total;
    std::string vendor_code;
    std::string color;
    std::string date;
public:
    Furniture(void) : name("none"), price(0.0), total(0U), vendor_code("none"), color("none"), date("01.01.1970") {};
    Furniture(std::string _n, double _p, unsigned _t, std::string _v, std::string _c, std::string _d)
        : name(_n), price(_p), total(_t), vendor_code(_v), color(_c), date(_d) {};
    Furniture(const Furniture&) = default;
    Furniture& operator = (const Furniture&) = default;
    ~Furniture(void) = default;
    
    void SetName(const std::string &_n) { this->name = _n; }
    void SetPrice(double _p) { this->price = _p; }
    void SetTotal(unsigned _t) { this->total = _t; }
    void SetVendorCode(const std::string &_v) { this->vendor_code = _v; }
    void SetColor(const std::string &_c) { this->color = _c; }
    void SetDate(const std::string &_d) { this->date = _d; }
    
    std::string GetName(void) const { return this->name; }
    double GetPrice(void) const { return this->price; }
    unsigned GetTotal(void) const { return this->total; }
    std::string GetVendorCode(void) const { return this->vendor_code; }
    std::string GetColor(void) const { return this->color; }
    std::string GetDate(void) const { return this->date; }
    
    friend std::ostream& operator << (std::ostream &os, const Furniture &rhs)
    {
        return os << "Name: " << rhs.name << std::endl
            << "Price: " << rhs.price << std::endl
            << "Total: $" << rhs.total << std::endl
            << "Vendor Code: " << rhs.vendor_code << std::endl
            << "Color: " << rhs.color << std::endl
            << "Date: " << rhs.date << std::endl
            << std::endl;
    }
    friend bool operator == (const Furniture &lhs, const Furniture &rhs)
    {
        return lhs.GetVendorCode() == rhs.GetVendorCode();
    }
    friend bool operator != (const Furniture &lhs, const Furniture &rhs)
    {
        return !(lhs == rhs);
    }
    friend bool operator < (const Furniture &lhs, const Furniture &rhs)
    {
        return lhs.GetVendorCode() < rhs.GetVendorCode();
    }
    friend bool operator > (const Furniture &lhs, const Furniture &rhs)
    {
        return lhs.GetVendorCode() > rhs.GetVendorCode();
    }
};
///================================
static const unsigned SIZE_FURS(5);
static Furniture furs[SIZE_FURS];
///================================
inline void Delimiter(void);
void ShakerSort(void);
Furniture* SearchByVendorCode(const std::string &element);
unsigned NumberOfCopies(const std::string &date);
void Print(void);
///================================
int main()
{
    furs[0].SetVendorCode("C");
    furs[1].SetVendorCode("C++");
    furs[2].SetVendorCode("Python");
    furs[3].SetVendorCode("Cyberforum");
    furs[4].SetVendorCode("Go");
    furs[4].SetTotal(10);
    furs[1].SetTotal(50);
    furs[2].SetTotal(20);
    furs[3].SetTotal(0);
    furs[4].SetTotal(55);
    
    ShakerSort();
    Print();
    Furniture *found = SearchByVendorCode("Python");
    std::cout << *found << std::endl;
    std::cout << "NumberOfCopies: " << NumberOfCopies("01.01.1970") << std::endl;
}
///================================
inline void Delimiter(void)
{
    std::cout << "--------------------" << std::endl;
}
 
void ShakerSort(void)
{
    for (unsigned i(0U), n(SIZE_FURS - 1U); i < n; i++, n--)
    {
        for (unsigned j(i); j < n; j++)
            if (furs[j] > furs[j + 1U])
            {
                std::swap(furs[j], furs[j + 1U]);
            }
        for (unsigned j(n - 1U); j > i; j--)
            if (furs[j] < furs[j - 1])
            {
                std::swap(furs[j], furs[j - 1U]);
            }
    }
}
 
Furniture* SearchByVendorCode(const std::string &element)
{
    Furniture *endIt = furs + SIZE_FURS;
 
    Furniture *left = furs;
    Furniture *right = endIt;
 
    if (furs[0].GetVendorCode() > element
        || furs[SIZE_FURS - 1U].GetVendorCode() < element)
        return endIt;
    while ((right -  left) > 0) {
        Furniture *mid = left + (right - left) / 2;
        if (element <= mid->GetVendorCode())
            right = mid;
        else
            left = mid + 1;
    }
    if (right->GetVendorCode() == element)
        return right;
    return endIt;
}
 
unsigned NumberOfCopies(const std::string &date)
{
    unsigned total(0U);
    for (unsigned i(0U); i < SIZE_FURS; i++)
        if (furs[i].GetDate() == date)
            total += furs[i].GetTotal();
    return total;
}
 
void Print(void)
{
    Delimiter();
    std::cout << "Print: " << std::endl
        << std::endl;
    for (unsigned i(0U), count(0U); i < SIZE_FURS; ++i)
    {
        std::cout << "Furniture #" << ++count << std::endl
            << furs[i] << std::endl;
    }
    Delimiter();
}