Question

I’m wondering if you can overload an operator and use it without changing the object’s original values.

Edited code example:

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

I made the accessors const methods, but I’m still getting a privacy error for every tmp.denominator_ / numerator_.

Answer 1

What you’re looking for are the “binary” addition and subtraction operators:

const Rational operator+(const Rational& A, const Rational& B)
{
    Rational result;

    ...

    return result;
}

update (in response to new code and comments):

You are getting that error because your accessor functions are not declared as constant functions, so the compiler has to assume that they might modify the original object. Change your accessors as follows, and you should be good to go:

double numerator() const { return numerator_; }
double denominator() const { return denominator_; }

update

To properly handle privacy issues, you should declare the binary operator+ function as a friend of the Rational class. Here is how it would look:

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
    friend Rational operator+(const Rational& A, const Rational& B);
private:
    double numerator_;
    double denominator_;
};

const Rational operator+(const Rational& a, const Rational& b)
{
    Rational result;

    result.denominator_ = (a.denominator_ * b.denominator_);
    result.numerator_ = (a.numerator_ * b.denominator_);
    result.numerator_ += (b.numerator_ * a.denominator_);

    return result;
}