• Status: Solved
• Priority: Medium
• Security: Public
• Views: 570

# class rational

Can you comment on the effectiveness of this code?  I tried to create a class for rational numbers with overloaded operators which apply to my rational type class?  This is a homework assignment, but I wanted to make sure it looked ok.

class Rational {
public:
Rational(int t = 0, int n = 1);

friend Rational operator+ (const Rational& lVal, const Rational& rVal);
friend Rational operator- (const Rational& lVal, const Rational& rVal);
friend Rational operator* (const Rational& lVal, const Rational& rVal);
friend Rational operator/ (const Rational& lVal, const Rational& rVal);

Rational& operator+= (const Rational& rVal);
Rational& operator-= (const Rational& rVal);
Rational& operator*= (const Rational& rVal);
Rational& operator/= (const Rational& rVal);

friend int operator<  (const Rational& lVal, const Rational& rVal);
friend int operator<= (const Rational& lVal, const Rational& rVal);
friend int operator== (const Rational& lVal, const Rational& rVal);
friend int operator!= (const Rational& lVal, const Rational& rVal);
friend int operator>= (const Rational& lVal, const Rational& rVal);
friend int operator>  (const Rational& lVal, const Rational& rVal);

friend ostream& operator<< (ostream& os, const Rational& rat);
friend istream& operator>> (istream& is, Rational& rat);

private:
int teller, number;

void reduce();
int  number(int, int);
};

//Constructors

Rational::Rational(int t, int n): teller(t), number(n) {
reduce();
}

Rational Rational::operator -() const {
return Rational(-teller, number);
}

Rational operator+ (const Rational& lVal, const Rational& rVal) {
Rational result;

result.teller = lVal.teller * rVal.number + lVal.number * rVal.teller;
result.number = lVal.number * rVal.number;

result.reduce();
return result;
}

Rational operator- (const Rational& lVal, const Rational& rVal) {
Rational result;
result = lVal + -rVal;

result.reduce();
return result;
}

Rational operator* (const Rational& lVal, const Rational& rVal) {
Rational result;
result.teller = lVal.teller * rVal.teller;
result.number = lVal.number * rVal.number;

result.reduce();
return result;
}

Rational operator/ (const Rational& lVal, const Rational& rVal) {
Rational result;
result.teller = lVal.teller * rVal.number;
result.number = lVal.number * rVal.teller;
result.reduce();
return result;
}

Rational& Rational::operator+= (const Rational& rVal) {
teller = teller * rVal.number + number * rVal.teller;
number = number * rVal.number;

reduce();
return *this;
}

Rational& Rational::operator-= (const Rational& rVal) {
this->operator+=(-rVal);
reduce();
return *this;
}

Rational& Rational::operator*= (const Rational& rVal) {
teller = teller * rVal.teller;
number = number * rVal.number;

reduce();
return *this;
}

Rational& Rational::operator/= (const Rational& rVal) {
teller = teller * rVal.number;
number = number * rVal.teller;

reduce();
return *this;
}

int operator<  (const Rational& lVal, const Rational& rVal) {
return(lVal.toDouble() < rVal.toDouble());
}

int operator<= (const Rational& lVal, const Rational& rVal) {
return(lVal < rVal || lVal == rVal);
}

int operator== (const Rational& lVal, const Rational& rVal) {
return lVal.teller * rVal.number == lVal.number * rVal.teller;
}

int operator!= (const Rational& lVal, const Rational& rVal) {
return !(lVal == rVal);
}

int operator>= (const Rational& lVal, const Rational& rVal) {
return(lVal > rVal || lVal == rVal);
}

int operator>  (const Rational& lVal, const Rational& rVal) {
return(lVal.toDouble() > rVal.toDouble());
}

istream& operator>> (istream& is, Rational& rat) {
int t, n;
char deel;
is >> t >> deel >> n;
rat = Rational(t,n);
return is;
}

int main() {
clrscr();
Rational b1;
Rational b2;

cout << "Input the number in the form (a/b): ";
cin >> b1 >> b2;

// Test for +, -, *, /
cout << b1 << " + " << b2 << " = " << b1 + b2 << endl;
cout << b1 << " - " << b2 << " = " << b1 - b2 << endl;
cout << b1 << " * " << b2 << " = " << b1 * b2 << endl;
cout << b1 << " / " << b2 << " = " << b1 / b2 << endl;

// test program for overloaded operators
cout << b1 << " <  " << b2;
(b1 <  b2) ? cout << " [X]" << endl : cout << " [ ]" << endl;

cout << b1 << " <= " << b2;
(b1 <= b2) ? cout << " [X]" << endl << endl : cout << " [ ]" << endl << endl;

cout << b1 << " == " << b2;
(b1 == b2) ? cout << " [X]" << endl : cout << " [ ]" << endl;

cout << b1 << " != " << b2;
(b1 != b2) ? cout << " [X]" << endl << endl : cout << " [ ]" << endl << endl;

cout << b1 << " >= " << b2;
(b1 >= b2) ? cout << " [X]" << endl : cout << " [ ]" << endl;

cout << b1 << " >  " << b2;
(b1 >  b2) ? cout << " [X]" << endl : cout << " [ ]" << endl << endl;

getch();
return 0;
}
0
rumi54
• 2
• 2
1 Solution

Software ArchitectCommented:
Everything seems to be ok, although I don't find Rational::reduce() implementation.
0

Author Commented:
The GCF function...
0

Software ArchitectCommented:
LOL. Yes I know what means but maybe you can optimize something there.
Your comparison (<, >, ==, etc.) operators could be "inline" to enhance performance.
Your division operators have not "divide by zero" exception management.
0

Author Commented:
I figured you know what it means.  :)  I thought I left it out completely.  Thanks.
0
Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

Have a better answer? Share it in a comment.