Question

我在重载比较运算符>和<时遇到问题。我尝试了两种不同的方式，但我仍然遇到麻烦。

bool Car::operator ==(const Car &car)
{
    return mLNumber == car.GetNum();
}

bool Car::operator <(const Car &carB)
{
    return mLNumber < carB.GetNum(); 
}
bool Car::operator >(const Car &carB)
{
    return mLNumber > carB.GetNum(); 
}
int Car::GetNum()
{
    return mLNumber;
}

我的==运算符运行正常。我得到这些运营商不存在的错误。这是我的第二次尝试。

bool Car::operator <(const Car &carA, const Car &carB)
{
    return carA.GetNum() < carB.GetNum(); 
}
bool Car::operator >(const Car &carB)
{
    return carA.GetNum() > carB.GetNum(); 
}

我得到的错误是参数太多了。我也明白了：

'Car::GetNum' : cannot convert 'this' pointer from 'const Car' to 'Car &'

Answer 1

尝试制作运营商const：

bool Car::operator <(const Car &carB) const {
    return mLNumber < carB.GetNum(); 
}
bool Car::operator >(const Car &carB) const {
    return mLNumber > carB.GetNum(); 
}

修改在这种情况下，您应该将GetNum()函数设为const，因为您在const Car&个对象上调用它。

你也不需要GetNum()，你可以写

bool Car::operator <(const Car &carB) const {
    return mLNumber < carB.mLNumber; 
}

Answer 2

代码中存在两个问题 - 第一，逻辑上，您的运算符在类型上不可变 - 它们不会更改对象，它们只分析它们，并且你应该能够在不可变（const）对象上调用它们。因此，正如alestanis指出的那样，使它们成为const （所有运算符和getter方法）。

第二个，< ==和>是二元运算符。实现它们有两种选择：作为自由运算符或作为成员。你和成员一起去了，没关系，但是：

bool Car::operator <(const Car &carA, const Car &carB)

不声明二元运算符。当您将运算符实现为成员时，第一个参数隐式地是当前对象（*this），因此它应该是

bool Car::operator <(const Car &carB) const

免费运算符如下：

bool operator < (const Car& carA, const Car& carB);

请注意，此const没有意义，因为它不是成员。但请注意，第一个参数（carA）标记为const，它对应于应用于成员版本中方法的const（在引擎盖下，标记this为const）。

Answer 3

有助于了解您将这些运营商称为何处。

你的第二个版本有两个Car参数应该是全局运算符。因此，如果您使用它们，请从定义中删除Car ::。将声明移出Car类的主体。

由于您在const Car对象上调用GetNum，因此Car :: GetNum函数也需要为const。更脏的方法是抛弃常数，但这是不赞成的。

Answer 4

在第一种情况下：

您的运算符不会更改操作数的数据，那么它应该是const：

bool Car::operator <(const Car &carB) const {
                                    //^^^^^
    return mLNumber < carB.GetNum(); 
}
bool Car::operator >(const Car &carB) const {
                                   // ^^^^^
    return mLNumber > carB.GetNum(); 
}

int Car::GetNum() const
                //^^^^^
{
    return mLNumber;
}

在第二种情况下，当运算符接受2个参数时，它们应该被实现为自由函数：

bool operator <(const Car &carA, const Car &carB)
{
    return carA.GetNum() < carB.GetNum(); 
}
bool operator >(const Car &carA, const Car &carB)
{
    return carA.GetNum() > carB.GetNum(); 
}

Answer 5

您的错误是当您想要比较一个const对象而您的运算符未标记为const时，作为一般规则，您应始终标记不会将对象更改为对象的函数和运算符const这会让生活变得更轻松。例如：

bool Car::operator ==(const Car &car) const // <-- This function is const
{
    return mLNumber == car.GetNum();
}

Answer 6

问题是car::GetNum()未声明为const，因此您无法在const car个实例上调用它。运算符以const Car &carB为参数，因此您无法在GetNum()上调用carB，因为carB是const个对象，但GetNum() }尚未声明const。

你应养成将所有不修改对象的函数声明为const的习惯。要将函数声明为const，只需在右括号后附加const即可。两者都在声明中，以及定义。例如：

class car {
    // ...
    void car::foo() const;
    // ...
};

void car::foo() const
{ /* ... */ }

或者，如果您在类声明中内联定义它：

class car {
    // ...
    void car::foo() const
    { /* ... */ }
    // ...
};

虽然在这种特殊情况下并不是绝对必要的（这意味着这不是代码无法编译的原因），但出于同样的原因，运算符本身也应该被声明const（这样你也可以使用它们）在const个对象上。）

重载比较运算符

6 个答案: