了解重载“ /”运算符中的临时对象

Question

I try to understand how this line of code in blow c++ program, and my questions are

return Rational(_n * rhs._d, _d * rhs._n);

1. how the _n refer to the first object data member?
2. how the temporary object refer get the a._n?

C++ program:

#include <iostream>

class Rational {
    int _n;
    int _d;
public:
    Rational ( int numerator = 0, int denominator = 1 ) : _n(numerator), _d(denominator) {};
    Rational ( const Rational & rhs ) : _n(rhs._n), _d(rhs._d) {};  // copy constructor
    inline int numerator() const { return _n; };
    inline int denominator() const { return _d; };
    Rational operator / ( const Rational & ) const;
};

Rational Rational::operator / ( const Rational & rhs ) const {
    return Rational(_n * rhs._d, _d * rhs._n);
}
// useful for std::cout
std::ostream & operator << (std::ostream & o, const Rational & r) {
    return o << r.numerator() << '/' << r.denominator();
}

int main( int argc, char ** argv ) {
    using namespace std;

    Rational a = 7;     // 7/1
    Rational b(5, 3);   // 5/3
    cout <<"a is : " <<a << endl;
    cout << " b is : "<< b << endl;
    cout << " a/b is:  "<< a / b << endl;

    return 0;
}

which has out put of

a is : 7/1
b is : 5/3
a/b is: 21/5

this program is simple version of this program in github

Answer 1

To put it in a few words, the operator / can be written like this:

class Rational
{
    //...rest of the stuff:

    Rational Divide( const Rational & rhs) const
    {
        return Rational(_n * rhs._d, _d * rhs._n);
    }
};

and instead of the operator / for result = a/b you can write result = a.Divide(b) Basically operator / behaves the same way as Divide method:

Now , let's analyze the divide method:

you have:

result = a.Divide(b); // which is the same as result = a/b in your case

and

Rational Divide( const Rational & rhs) const
{
    return Rational(_n * rhs._d, _d * rhs._n);
}

• rhs is the argument passed to Divide which is the variable b .

• _n and _d are the members of the variable a . You can also write them like this: this->_n and this->_d . Divide is a member function so it can access _n and _d directly.

Now to simplify this even further to understand the way it works, here is another way to write this:

class Radional {/*stuff*/};

Rational Divide( const Rational & a, const Rational & b)
{
    return Rational(a._n * b._d, a._d * b._n);
}

For this example the result = a.Divide(b) transforms into result = Divide(a,b) Notice that now you have a._n and a._d which is the first argument of function Divide

As a conclusion the expression a/b is just a very nice way of writing Divide(a,b) that c++ standard allows.