Printable View
Hey whats up everybody. Im new to the board and Im trying to understand this overloading thing but I dont have a clue. Anyways I have to write a program that adds 2 rational numbers and I have to overload + - * / . I also have to overload the relational and equality operators. Im not sure what that is. Any help will be appreciated
Its basically a easier better way to write statements, heres a quick cheat sheet.
Code:
replace variable = variable + variable;
with variable += variable; //Adds variable to itself
replace variable = variable * variable;
with variable *= variable; // * variable by variable
and so on...
Hope this helps.
Sorry man I dont understand that. I need to do something like this. Im not sure what to put inside the function. How can I add 2 rational numbers if I only pass in one. Im not sure but I think you can only pass in one parameter when you overload something. I also have numerator and denominator in my private section.
Code:Rational Rational::Operator +(Rational &rat)
{
}
That's not operator overloading.Quote:
Originally posted by Ride -or- Die
Its basically a easier better way to write statements, heres a quick cheat sheet.
Anyway operator overloading is just like writing other member functions.
I think you want something like
Rational Rational::operator+(const Rational & rat1 , const Rational & rat2){
//put you code to add here
//and return the result
}
Basic rational numbers class with construction,destruction and operator+ to add 2 rationals together defined.Code:class Rational
{
private:
int _numerator;
int _denominator;
public:
Rational() : _numerator(0),_denominator(1) {}
Rational(int num,int denom) : _numerator(num),_denominator((denom!=0) ? denom:1) {}
Rational(const Rational& rhs) : _denominator(rhs._denominator),_numerator(rhs._numerator){}
virtual ~Rational() {}
Rational operator + (const Rational& rhs)
{
Rational result(*this);
result._denominator+=rhs._denominator;
result._numerator+=rhs._numerator;
return result;
}
};
nm i read it too quickly, sorry dude.
BTW Thats not how rational numbers are added. code is illustration purposes only.You will have to write a correct operator+.
overloading means using the same function name (or operator symbol) and pass it two different sets of paramenters and still get it to work.
Example:
start with the following function:
void add(int, int);
//add takes two ints and does something with them
void add(int, double);
//now add is overloaded to take one int and one double and will do something with them. the function add is overloaded
void add(double, int);
//yes, it is important which sequence you use parameters as this function is different than the one above to the compiler.
void add(double, double);
//another overloaded version of add
void add(double, float);
//yet another overloaded version of add
need I go further? The compiler can determine which version of add to call based on which set of parameters is passed. Note that polymorphism is a related, but different concept, having to do with object methods wherein methods of the same name perform differently based on the type of the object, not the parameters passed to the function/method.
You can do the same thing (overloading) with operators as operators are just shorthand versions of functions.
Ok this is what I have for my addition function. Please tell me whats wrong here I dont have a clue.
Code:#include <iomanip.h>
#include <stdio.h>
//******************************************************************************
class Rational{
friend ostream &operator<<( ostream &, Rational &);
public:
Rational(){ numerator = 0; denominator = 1;}; //constructor function
Rational( int n, int d) {numerator = n; denominator = d (d==0) ? 1:d;}
Rational operator +(Rational);
Rational operator -(Rational);
Rational operator *(Rational);
Rational operator /(Rational);
int gcd (int n, int d);
private:
int numerator;
int denominator;
};
//********************************gcd*******************************************
//function accepts 2 integers through call by value mechanism
//function computes the greatest common divisor and returns the GCD
int Rational :: gcd (int n, int d)
{
if (d == 0)
return n;
else
return (gcd(d, n % d));
}
//******************************************************************************
ostream& operator <<(ostream& out, rational& rat)
{
out << "The Rational value is: " << rat.numerator << " / " << rat.denominator << endl;
return out;
}
//*******************************add********************************************
//function accepts 2 rational types through call by value mechanism
//function adds two rational numbers
Rational Rational::operator +(Rational& rat)
{
Rational value;
value.numerator = rat.numerator * rat.denominator + rat.numerator * rat.denominator;
value.denominator = rat.denominator * rat.denominator;
int i = gcd(numerator, denominator);
if(i != 0 && i != 1){
numerator /= i;
denominator /= i;
}
return value;
}
You will need for many thing for example if you have a class of HugeInteger( a data type that can store very big numbers ), and you want to add two of them, without overloading you'll do:
where add is a member function in class hugeInt.Code:hugeInt h1, h2;
//initialize
h1.add(h2)
but the other way is to overload the addition operator, so you can write:
which makes more sense...Code:hugeInt h2, h2;
//initialize
h1 + h2;
But remember you can only overload existing operators for user defined datatypes, and you cannot overload all operators.
Yeah i know thats for the main function but I wanted to know if my addition function is correct
Wouldn't you want to return a rational reference (&Rational) instead of a Rational?
No. operator + should always return an object and not a reference. Remember this rule. It will serve you well.
Thanks for the help guys but I jsut cant understand it.
heres a link to a simple rational numbers class. Please dont use the code as it is but instead rewrite it yourself. This will just show you how to do the operator overloads and describe some helpful functions such as gcd() and samedenominator() and lcm().
If you are still stuck then post your attempt and ill help.
http://www.gpc.peachnet.edu/~jbenson...ary/Rational.h
http://www.gpc.peachnet.edu/~jbenson...y/Rational.cpp
You're close with your '+' function, but you're adding the fraction to itself. I think:
will work. The left side of the + sign should be able to be represented by the 'private' variables of your class. I did the rational class about two months ago, and the good news is once you get one to work you'll be able to do the rest in no time.Code:value.numerator = (numerator * rat.denominator) + (rat.numerator * denominator);
value.denominator = denominator * rat.denominator;
Im starting to understand this now somewhat. My question is
how do you know where to place the rat.numerator or rat.denominatorCode:value.numerator = (numerator * rat.denominator) + (rat.numerator * denominator);
value.denominator = denominator * rat.denominator;
Yep, you are right. I was thinking of the = operator.Quote:
Originally posted by Stoned_Coder
No. operator + should always return an object and not a reference. Remember this rule. It will serve you well.
The rat.numerator and rat.denominator are on the right side of the operator. So, if you are adding:
solution = 2/3 + 3/4
rat.numerator is 3, and rat.denomator is 4.
or you could try this:
you can do a similar syntax (specify the parameters on the left and right hand side) for +. Of course, you need to determine the lowest common denominator just like you do when doing this by hand before you can add the numerators and denominators.Code:class Rational
{
public:
//do dah
friend Rational & operator * (const Rational & lhs, const Rational & rhs);
//more
};
Rational operator*(const Rational & lhs, const Rational & rhs)
{
Rational result;
result.numerator = lhs. numerator * rhs.numerator;
result.denominator = lhs.denominator * rhs.denominator;
return result;
}
Thanx for your help I appreciate it. I now understand. Im going to take my final in an hour everyone wish me luck hahahahQuote:
Originally posted by Lurker
The rat.numerator and rat.denominator are on the right side of the operator. So, if you are adding:
solution = 2/3 + 3/4
rat.numerator is 3, and rat.denomator is 4.
Most modern compilers support something known as the return value optimisation.
this
is better written as:-Code:Rational operator*(const Rational & lhs, const Rational & rhs)
{
Rational result;
result.numerator = lhs. numerator * rhs.numerator;
result.denominator = lhs.denominator * rhs.denominator;
return result;
}
This eliminates the otherwise needed temporary.Code:Rational operator*(const Rational& lhs,const rational& rhs)
{
return Rational ((lhs.numerator*rhs.numerator),(lhs.denominator*rhs.denominator));
}