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

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

我创建了访问器const方法,但是我仍然为每个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都不会改变:它们是const.

编辑

对不起,我错过了实际的数学部分.以下是一些事项:

作为成员函数(我上面提到的),执行以下操作:

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

这里的问题是您将获得访问冲突:您的成员变量是该类的私有变量.你需要让编译器知道如果这个函数通过使函数成为类的朋友来处理你的类的私有变量是可以的:

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