C++操作符重载2个单独类成员的类对象

假设我有一节课

class Car
{
public:
...
friend operator<(const Car&car1, const Car&car2){
   return car1.getYear() < car2.getYear()
}
private:
   int year;
   double price;
   string brand;
};

如果我想根据价格比较汽车，我怎么能让同一个操作员超载？我必须创建两个Car对象，对于第一个Car对象，我要使用年份进行比较，对于第二个Car对象，我要使用其价格进行比较

---

谢谢

如果类具有price的getter，则不需要编写重载运算符。你可以简单地说：

  Car c1, c2;
  // stuff
  if ( c1.Price() < c2.Price() ) {
       // do something
  }

类似地，你可能不需要在你原来的帖子中写重载；你本可以用一个吸气剂。注意，我并不是说获得者是伟大的想法

如果我想根据价格比较汽车，我怎么能让同一个操作员超载

最好避免这种做法。相反，使用两个不同的函子类。让调用代码选择要使用的函子

struct CompareByYear
{
   bool operator()(Car const& car1, Car const& car2)
   {
      return (car1.getYear() < car2.getYear());
   }
};

struct CompareByPrice
{
   bool operator()(Car const& car1, Car const& car2)
   {
      return (car1.getPrice() < car2.getPrice());
   }
};

---

这种方法一开始可能看起来有些奇怪，但它非常容易遵循和实现，特别是当您有多种方法来比较类的内部数据类型成员时

class Car {
public:
    enum Comparetor {
        BY_YEAR = 0,
        BY_PRICE = 1,
    };

private:    
    int   _year;
    float _price;
    std::string _make;

public:
    Car() :
        _year( 0 ),
        _price( 0 ),
        _make( "" ) 
    {}
    Car( int year, float price, const std::string& make ) :
        _year( year ),
        _price( price ),
        _make( make ) 
    {}

    int yearOf() const {
        return _year;
    }

    float priceOf() const {
        return _price;
    }

    std::string makeOf() const {
        return _make;
    }

    bool compareByLT( Car::Comparetor comp, Car& car2 ) {
        switch ( comp ) {
            case BY_YEAR: {
                return _year < car2._year;
                break;
            }
            case BY_PRICE: {
                return _price < car2._price;
                break;
            }
        }
    }
};   

int main() {    
    Car car1( 2017, 24785.0f, "Ford Mustang" );
    Car car2( 2018, 21579.0f, "Hyundai Elantra" );

    if ( car1.compareByLT( Car::BY_YEAR, car2 ) ) {
        std::cout << car1.makeOf() << " is older than " << car2.makeOf()
            << " by " << car2.yearOf() - car1.yearOf() << " year" << std::endl;
    } else {
        std::cout << car2.makeOf() << " is older than " << car1.makeOf()
            << " by " << car1.yearOf() - car1.yearOf() << " year" << std::endl;
    }

    if ( car1.compareByLT( Car::BY_PRICE, car2 ) ) {
        std::cout << car1.makeOf() << " is cheaper than " << car2.makeOf()
            << " by $" << car2.priceOf() - car1.priceOf() << std::endl;
    } else {
        std::cout << car2.makeOf() << " is cheaper than " << car1.makeOf()
            << " by $" << car1.priceOf() - car2.priceOf() << std::endl;
    }

    _getch(); // #include <conio.h> prevent debugging console on Windows in Visual Studio from closing.
    return 0;
}

这节省了大量不必要的代码输入，最大限度地减少了错误；然而，你的第一个功能必须是100%的错误免费的第二个功能是准确和可靠的

---

现在，如果你尝试这样做：定义操作符，编译器如何知道你的意思，对于两个任意的汽车，c1和c2，如果c1 bool compareByGT( Car::Comparetor comp, Car& car2 ) { return !( compareByLT( comp, car2 ) ); }

{
    // Internal: Belongs to class
    bool operator<( const Car& other ) {
        _year < other._year;
    }

    // Friend of this class
    friend bool operator<( const Car& car1, const Car& car2 );
};

bool operator<( const Car& car1, const Car2& car2 ) {
    return car1._price < car2.price;
}

if ( car1 < car2 ) {
    // Do something...
} else { 
    // Do something else...
}