How to overload the operator without changing the initial values?

Question

I am wondering if you can overload the operator and use it without changing the original values ​​of the object.

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 created constors const methods, but I still get a privacy error for every tmp.denominator_ / numerator _.

Answer 1

What you are 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 the new code and comments):

You get this error because your access functions are not declared as constant functions, so the compiler should assume that they can modify the original object. Change your accessors as follows and you should be fine:

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

, operator+ friend Rational. :

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

Answer 2

, - , , ?

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

, : - . , , , :

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

Answer 3

.. + -.. .

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

, .

Answer 4

, , - friend s. operator+ :

const Rational operator+(const Rational& rhs, const Rational& lhs)
{
    double newNumerator = rhs.numerator() * lhs.denominator() +
                          rhs.denominator() * lhs.numerator();
    return Rational(newNumerator, rhs.denominator() * lhs.denominator());
}

:

Item 24 ++ ( ). , , , , non-member non-friend.

, Rational :

Rational::Rational(double numerator = 0, double denominator = 1);

, operator+ -, :

Rational oneHalf(1, 2);
oneHalf + 2;   // works
2 + oneHalf;   // error!

operator+ . , operator+ Rational - , .

Effective ++, Item 23: , -, -.

Answer 5

operator+ operator+=. , . , operator+= -, .

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

    Rational & operator+=(const Rational& b) {
        denominator_ *= b.denominator_);
        numerator_ *= (b.denominator_);
        numerator_ += (b.numerator_ * denominator_);
        return *this;
    }

private:
    double numerator_;
    double denominator_;
};


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

- boost . gotchas ( wintermute 2 + oneHalf.