overloading operators and friend functions

Question

I am having trouble implementing friend functions with overloading operators. I do not have a solid understanding of what I need to use these functions for. If anyone can give me some guidance on how to proceed. Please and thank you in advance. Instructions :

This class implements rational number of the type 2/3.

class Rational;

private data: int n, (fraction numerator)
int d (fraction denominator).

//   make sure that d is always positive.

//  optional:   always simplify the number so that n and d don't have a common factor


public interface:
constructors:
two int args, to allow setting rational to any legal value
default numerator to be 0, default denominator to be 1

friend istream& operator >>(istream& in_str, Rational& right)

friend ostream& operator <<(ostream& out_str, cnst Rational& right)



overload + - * / <  <=  > >=   ==

friend Rational operator+(const Rational&, const Rational&);
....


*/ 
/*
A possible test and output is given below.

int main()
{
cout << "Testing declarations" << endl;
cout << "Rational x, y(2), z(-5,-6), w(1,-3);" << endl;
Rational x, y(2), z(-5, -6), w(1, -3);
cout << "x = " << x << ", y = " << y << ",  z = " << z
<< ", w = " << w << endl << endl;



cout << "Testing the constructor and normalization routines: " << endl;
y = Rational(-1, -4);
cout << "y =Rational(-1, -4) outputs as " << y << endl;
y = Rational(-1, 4);
cout << "y =Rational(-1, 4)outputs as " << y << endl;
y = Rational(1, -4);
cout << "y = Rational(128, -48) outputs as " << y << endl;
Rational a(1, 1);
cout << "Rational a(1,1); a outputs as: " << a << endl;
Rational ww = y*a;
cout << y << " * " << a << " = " << ww << endl << endl;

cout << "Testing >> overloading: \nEnter "
<< "a fraction in the format "
<< "integer_numerator/integer_denominator"
<< endl;
cin >> x;
cout << "You entered the equivalent of: " << x << endl;
cout << z << " -  (" << w << ") = " << z - w << endl << endl;



w = Rational(-7, 3);
z = Rational(-3, 5);
cout << "Testing arithmetic and relational "
<< " operator overloading" << endl << endl;
cout << w << " * " << z << " = " << w * z << endl;
cout << w << " + " << z << " = " << w + z << endl;
cout << w << " - " << z << " = " << w - z << endl;
cout << w << " / " << z << " = " << w / z << endl;

cout << w << " <  " << z << " : " << (w < z) << endl;

cout << w << " <= " << z << " : " << (w <= z) << endl;
cout << w << " <= " << w << " : " << (w <= w) << endl;

cout << w << " >  " << z << " : " << (w > z) << endl;
cout << w << " > " << w << " : " << (w > w) << endl;
cout << w << " >= " << z << " : " << (w >= z) << endl;

return 0;
}

== == == == == == == == ==

TestingTesting declarations
Rational x, y(2), z(-5, -6), w(1, -3);
x = 0 / 1, y = 2 / 1, z = 5 / 6, w = -1 / 3

Testing the constructor and normalization routines :
y = Rational(-1, -4) outputs as 1 / 4
y = Rational(-1, 4)outputs as - 1 / 4
y = Rational(128, -48) outputs as - 1 / 4
Rational a(1, 1); a outputs as : 1 / 1
- 1 / 4 * 1 / 1 = -1 / 4

Testing >> overloading :
    Enter a fraction in the format integer_numerator / integer_denominator
    2 / -3
    You entered the equivalent of : -2 / 3
    5 / 6 - (-1 / 3) = 21 / 18

    Testing arithmetic and relational  operator overloading

    - 7 / 3 * -3 / 5 = 21 / 15
    - 7 / 3 + -3 / 5 = -44 / 15
    - 7 / 3 - -3 / 5 = -26 / 15
    - 7 / 3 / -3 / 5 = 35 / 9
    - 7 / 3 <  -3 / 5 : 1
    - 7 / 3 <= -3 / 5 : 1
    - 7 / 3 <= -7 / 3 : 1
    - 7 / 3 >  -3 / 5 : 0
    - 7 / 3 > -7 / 3 : 0
    - 7 / 3 >= -3 / 5 : 0

*/

My Code:

#include <iostream>
using namespace std;

class Rational {
    private:
        int n; // (fraction numerator)
        int d; // (fraction denominator).

    public:
        Rational() {
            n = 0;
            d = 1;
        }
        Rational(int num, int denom) {
            n = num;
            d = denom;
        }

        friend istream& operator >> (istream& in_str, Rational& right);
        friend ostream& operator << (ostream& out_str, const Rational& right);
        friend Rational operator+ (const Rational&, const Rational&);

        //friend istream& operator >> (istream& in_str, Rational& right);
        //friend ostream& operator <<(ostream& out_str, const Rational& right);
        //friend Rational operator+(const Rational&, const Rational&);


};




int main()
{
    cout << "Testing declarations" << endl;
    cout << "Rational x, y(2), z(-5,-6), w(1,-3);" << endl;
    return 0;
}

istream& operator >> (istream& in_str, Rational& right) {
    cin >> n.right;
}
ostream& operator << (ostream& out_str, const Rational& right); {
    cout << out_str;
}
Rational operator+(const Rational&, const Rational&); {
    cout << Rational;
}

Answer 1

Think of it this way....In your example you aren't really overloading a method in your class, but rather you are overloading the operator >> for streams. You have to make it a friend so that the implementation of

istream& operator >> (istream& in_str, Rational& right)

and the other stream operators can see the member data of your class. They aren't methods of your class, but rather are defined as global functions. If they were not friend functions they could not see the private data they need to work with.

See https://isocpp.org/wiki/faq/friends and https://isocpp.org/wiki/faq/operator-overloading

This is one of the very few times it would be close to acceptable to use keyword "friend". "friend" is generally frowned upon in all cases but this one and when implementing the factory pattern.

For some contrast, google "C++ overloading operator =" which is a class method, and therefore does not need to be a friend.