c++ - 在不改变原始值的情况下重载运算符的方法？

Question

我想知道是否可以重载运算符并在不更改对象原始值的情况下使用它。

编辑后的代码示例:

class Rational{
public:
   Rational(double n, double d):numerator_(n), denominator_(d){};
   Rational(){}; // default constructor
   double numerator() const { return numerator_; } // accessor
   double denominator() const { return denominator_; } // accessor
private:
    double numerator_;
    double denominator_;
};

const Rational operator+(const Rational& a, const Rational& b)
{
      Rational tmp;
      tmp.denominator_ = (a.denominator() * b.denominator());
      tmp.numerator_ = (a.numerator() * b.denominator());
      tmp.numerator_ += (b.numerator() * a.denominator());
      return tmp;
}

我将访问器设为常量方法，但我仍然收到每个 tmp.denominator_/numerator_ 的隐私错误。

Answer 1

也许我遗漏了什么，但你为什么不把修改参数的代码拿出来呢？

const Rational Rational::operator+(Rational& num)
{
      Rational tmp;
      tmp.denominator_ = (denominator_*num.denominator_);
      //numerator_*=num.denominator_;
      //num.numerator_*=denominator_;
      tmp.numerator_ = (numerator_+num.numerator_);
      return tmp;
}

这会被 const-correct 更早地捕获.

这意味着你的函数签名应该是这样的:

Rational Rational::operator+(const Rational& num) const

然后你会得到错误，因为你正在修改 const 对象。现在您的运算符的编写方式通常被认为是不正确的。

当您添加 2 + 3 时，2 和 3 都不会改变:它们是常量。

编辑

抱歉，我错过了真正的数学部分。这里有一些事情:

作为一个成员函数(我上面有的)，这样做:

// Note that I use lhs and rhs to refer to the left-hand
// and right-hand sides of an operation. As a member function
// my left-hand side is implicitly `this`.
Rational Rational::operator+(const Rational& rhs) const
{
    Rational temp;

    temp.denominator_ = (denominator() * rhs.denominator());
    temp.numerator_ = (numerator() * rhs.denominator());
    temp.numerator_ += (denominator() * rhs.numerator());
    return temp;
}

作为一个全局函数，这样做:

Rational operator+(const Rational& lhs, const Rational& rhs)
{
    Rational temp;

    temp.denominator_ = (lhs.denominator() * rhs.denominator());
    temp.numerator_ = (lhs.numerator() * rhs.denominator());
    temp.numerator_ += (lhs.denominator() * rhs.numerator());

    return temp;
}

这里的问题是您会遇到访问冲突:您的成员变量对类来说是私有(private)的。您需要让编译器知道如果此函数通过使该函数成为类的友元来处理类的私有(private)变量是可以的:

class Rational
{
public:
    friend Rational operator+(const Rational& lhs, const Rational& rhs);
}