Question

让我说我有一个班级

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

如果我想根据价格比较汽车，如何重载同一个运营商？我必须创建两个Car对象，并且我想要使用年份来比较第一个汽车对象，我想用它的价格比较第二个汽车对象。

谢谢！

Answer 1

如果你的班级有价格的吸气剂，那么你不需要写一个重载的运算符。你可以简单地说：

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

同样，您可能不需要在原始帖子中写入重载;你可以用一个吸气剂。注意我并不是说吸气剂是好主意。

Answer 2

如果我想根据价格比较汽车，我如何重载同一个运营商？

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

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());
   }
};

Answer 3

这种方法起初可能看起来很奇怪但是很容易遵循＆amp;特别是如果您有多种方法来比较类的内部数据类型成员。

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;
}

您尝试做的方法因为含糊不清而无法工作。意味着如果您尝试定义2个不同的运算符，使用相同的2个相同对象意味着它们的声明/定义/签名完全相同，编译器如何解析要使用哪个overload。它不知道如何区分你的意思。我应该按price还是year进行比较......？并且操作员不能接受另一个参数来知道哪一个。

如果由于某种原因，您需要的代码库要求您必须定义运算符，因为某种继承或数据结构机制......然后您可以仅为其中一个值（成员类型）重载运算符。你必须选择最有意义的使用哪一个。然后，对于其他数据，您必须编写函数或方法来执行此操作。我在这里简单介绍的是，您可以将类的内部数据的所有比较总结为一个函数，调用者必须通过它来传递要比较的枚举类型。

或正如其他人所说;如果您有访问方法来检索私有成员，那么只要它们是按类型构建的，或者是已经为它们定义了运算符的类型，就可以简单地进行比较。

对上面当前类的跟进：好的，所以我们现在有一个比较函数，比较小于，我们现在想要做大于。而不是像我们之前那样完全写出大于版本，你可以像这样简化第二种方法：

 bool compareByGT( Car::Comparetor comp, Car& car2 ) {
     return !( compareByLT( comp, car2 ) );
 }

这节省了大量不必要的代码输入，最大限度地减少了错误;但是你的第一个功能必须100％无错误才能使第二个功能准确可靠。

现在，如果您尝试这样做：为类本身定义operator<()并在类之外定义朋友版本，如下所示：

{
    // 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;
}

您认为会发生什么？

当你使用compare运算符时，这很简单：

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

它将决定使用属于该类的那个。

现在，如果你注释掉属于该类的那个保持代码中其他地方的if语句，代码将不会中断，当你编译，构建并通过调试器再次运行它时它应该执行而没有问题但是在这个时候它将通过朋友版进行比较。

C ++运算符为2个独立的类成员重载类对象

3 个答案: