Operator Overloading (I think...?) - Overclock.net

stn0092 · 10-12-09

My assignment is to use the provided private data and member functions and implement them and then test them in some main. Honestly, my understanding of using classes isn't all that great anyway.

I was lost form the very start.

Code:

//Rational.h

#ifndef RATIONAL_H_DEF
#define RATIONAL_H_DEF

#include <iostream>
using namespace std;

class Rational
{
	long _p;
	long _q;

	public:

		Rational ( ); //default constructor 
		Rational ( long, long = 1 ); //constructor
		Rational ( const Rational& ); //copy constructor
		Rational& operator= ( const Rational& );
		Rational& operator+= ( const Rational& );
		Rational& operator-= ( const Rational& );
		Rational& operator*= ( const Rational& );
		Rational& operator/= ( const Rational& );
};
#endif

Code:

//Rational.cpp

#include <iostream>
#include "Rational.h"

Rational::Rational ()
{
     _p = 1;
     _q = 1;
}

Rational& operator+= (const Rational& R)
{
     _p = (_p * R._q) + (R._p * _q);
     _q *= R._q;

    //pasted from a previous assignment; not quite sure it works
}

When I try to compile this (g++ pendantic), I get an error about operator+= requiring exactly two arguments.

dharmaBum · 10-12-09

You have:

Quote:

Rational& operator+= (const Rational& R)

Should be:

Quote:

Rational& Rational:: operator+=(const Rational& R)

Also, you need to return something. Because you want the same "Rational" object back:

Quote:

return *this;

"this" is a keyword to the C++ compiler uses to refer to the current object. So, using the statement

Quote:

x+=y;

"this" will refer to x.

The "*" in the return statement is a consequence of "this" actually being a pointer, which for this discussion we need not jump into those dark waters.

This setup with operators allows you to chain them together, like so:

Quote:

x+=y+=z+=a;

Which might seem unwieldy and confusing, but consider another operator chain:

Quote:

cout<<"Hello"<<endl<<"World"<<sizeof(a)<<"and then some!"<<endl;

"<<" here is actually an operator that returns the "stream" (where you write/read things to/from) back, so you can keep using the "<<" operator to mean "output". Similar for cin and ">>".

The equivalent, non-operator, non-object statement would be:

Quote:

printf("Hello\nWorld%dand then some!\n",sizeof(a));

Which is a pain to read and write (especially when all the special codes for numbers and formatting need to be recalled).

Edit: for clarity

stn0092 · 10-12-09

Thanks.

My assignment has me implementing the member functions in a separate .cpp, but, out of curiosity, can I do it right where I define my class?

Code:

//Rational.h

#ifndef RATIONAL_H_DEF
#define RATIONAL_H_DEF

#include <iostream>
using namespace std;

class Rational
{
	long _p;
	long _q;

	public:

		Rational ( ); //default constructor 
		Rational ( long, long = 1 ); //constructor
		Rational ( const Rational& ); //copy constructor
		Rational& operator= ( const Rational& );
		Rational& operator+= ( const Rational& );
		const{
			_p = (_p * R._q) + (R._p * _q);
			_q *= R._q;
			return *this;
		}
		Rational& operator-= ( const Rational& );
		Rational& operator*= ( const Rational& );
		Rational& operator/= ( const Rational& );
		friend ostream& operator<< ( ostream&, const Rational&);
		friend istream& operator>> ( istream&, Rational&);
};
#endif

I won't be doing it that way, but I'm just wondering.

dharmaBum · 10-13-09

Quote:

Originally Posted by stn0092

Thanks.

My assignment has me implementing the member functions in a separate .cpp, but, out of curiosity, can I do it right where I define my class?

I won't be doing it that way, but I'm just wondering.

Yes, that is fine, but your syntax will throw compile errors here.

You have:

Code:

		Rational& operator+= ( const Rational& );
		const{
			_p = (_p * R._q) + (R._p * _q);
			_q *= R._q;
			return *this;
		}

which is wrong.

Instead, what you can do is simply use the normal syntax of function definitions:

Code:

class Rational{
...
public:
...
		Rational& operator+= ( const Rational& ){
			_p = (_p * R._q) + (R._p * _q);
			_q *= R._q;
			return *this;
		}
...
};

Best coding practice would be to put them in separate files (or, at least, declare before you define). But this is for the sake of the programmer; the compiler doesn't really care.

stn0092 · 10-14-09

I need some more help.

I'm trying to implement operator+ using operator+=.

Code:

//Rational.h

#ifndef RATIONAL_H_DEF
#define RATIONAL_H_DEF

#include <iostream>
using namespace std;

class Rational
{
	long _p;
	long _q;

	public:

		Rational ( ); //default constructor 
		Rational ( long, long = 1 ); //constructor
		Rational ( const Rational& ); //copy constructor
		Rational& operator= ( const Rational& );
		Rational& operator+= ( const Rational& );
		friend ostream& operator<< ( ostream&, const Rational&);
		friend istream& operator>> ( istream&, Rational&);
		Rational operator+ (const Rational& ) const;
		Rational operator+ (long) const; 
		friend Rational operator+ (long, const Rational&);
};
#endif

Code:

//Rational.cpp

#include <iostream>
#include "Rational.h"
using namespace std;

Rational::Rational()
{
	_p = 1;
	_q = 1;
}

Rational::Rational ( long P, long Q )
{
     _p = P;
     _q = (Q == 0)? 1:Q;
}

Rational& Rational::operator= ( const Rational& R)
{
	_p = R._p;
	_q = R._q;
	return *this;
}

Rational& Rational::operator+= ( const Rational& R)
{
	_p = (_p * R._q) + (R._p * _q);
	_q *= R._q;
	return *this;
}

ostream& operator<< ( ostream& os, const Rational& R)
{
	os << R._p << "/" << R._q;
	return os;
}


istream& operator>> ( istream& is, Rational& R)
{
	char c;
	is >> R._p >> c >> R._q;
	return is;
}

Rational operator+ (long L, const Rational& R)
{
	Rational temp(L);
	return temp+=R;
}

Code:

Compile errors

Rational.o: In function `operator+(long, Rational const&)':
Rational.cpp:(.text+0x274): undefined reference to `Rational::Rational(Rational const&)'
Main.o: In function `main':
Main.cpp:(.text+0x345): undefined reference to `Rational::operator+(Rational const&) const'
collect2: ld returned 1 exit status
make: *** [Main] Error 1

I've tried it a few different ways, but I get compile errors each time. The member functions are given by my teacher and we're not allowed to change those.

I was thinking I could just do return += R, but that didn't work (error: expected primary-expression before â+=â token).

EDIT: I think I made some progress. In Rational.cpp, operator+ is now:

Code:

Rational operator+ (long L, const Rational& R)
{
	Rational temp(L);
	Rational x;
	x._p = temp._p += R._p;
	x._q = temp._q += R._q;
	return x;
}

But now I'm getting an error in my main.

Code:

#include <iostream>
#include "Rational.h"
using namespace std;

int main()
{
	Rational rat1(1, 2);
	Rational rat2(-20, 4);
           Rational x;

	//+
	cout << rat1 << " + " << rat2 << " = ";
	x = rat1+rat2;
	cout << x << endl;

	return 0;
}


COMPILE ERRORS

Main.cpp:(.text+0x345): undefined reference to `Rational::operator+(Rational const&) const'
collect2: ld returned 1 exit status
make: *** [Main] Error 1

:/ I was hoping to get this and add on the unary operators to finish this up tonight, but I've been stuck for a couple hours now.

Spotswood · 10-14-09

You need to implement the copy constructor.

stn0092 · 10-14-09

Code:

#include <iostream>
#include "Rational.h"
using namespace std;

Rational::Rational()
{
	_p = 1;
	_q = 1;
}

Rational::Rational ( long P, long Q )
{
     _p = P;
     _q = (Q == 0)? 1:Q;
}

Rational& Rational::operator= ( const Rational& R)
{
	_p = R._p;
	_q = R._q;
	return *this;
}

Rational& Rational::operator+= ( const Rational& R)
{
	_p = (_p * R._q) + (R._p * _q);
	_q *= R._q;
	return *this;

}

ostream& operator<< ( ostream& os, const Rational& R)
{
	os << R._p << "/" << R._q;
	return os;
}


istream& operator>> ( istream& is, Rational& R)
{
	char c;
	is >> R._p >> c >> R._q;
	return is;
}

Rational& Rational::operator+ (const Rational& R) const
{
	_p = 1;
	_q = 1;
	return *this;
}

Rational& Rational::operator+ (long R) const
{	
	_p = 1;
	_q = 1;
	return *this;
}

Rational operator+ (long L, const Rational& R)
{
	Rational x(L);
	return x += R;
}

Quote:

Rational.o: In function `operator+(long, Rational const&)':
Rational.cpp:(.text+0x274): undefined reference to `Rational::Rational(Rational const&)'
Rational.o: In function `Rational::operator+(long) const':
Rational.cpp:(.text+0x29d): undefined reference to `Rational::Rational(Rational const&)'
Rational.o: In function `Rational::operator+(Rational const&) const':
Rational.cpp:(.text+0x2c5): undefined reference to `Rational::Rational(Rational const&)'
collect2: ld returned 1 exit status
make: *** [Main] Error 1

Where did I go wrong did now? :(

Spotswood · 10-14-09

Quote:

Originally Posted by stn0092

Where did I go wrong did now?

You didn't implement the copy constructor:

Code:

Rational::Rational ( const Rational& o)
: _p(o._p), _q(o._q)
{
}

stn0092 · 10-14-09

Click below to show/hide Hidden Text Below!

Original post + a couple edits. This is irrelevant now unless you want to see what I did wrong.

Code:

Rational.h

#ifndef RATIONAL_H_DEF
#define RATIONAL_H_DEF

#include <iostream>
using namespace std;

class Rational
{
	long _p;
	long _q;

	public:

		Rational ( ); //default constructor 
		Rational ( long, long = 1 ); //constructor
		Rational ( const Rational& ); //copy constructor
		Rational& operator= ( const Rational& );
		Rational& operator+= ( const Rational& );
		Rational& operator-= ( const Rational& );
		Rational& operator*= ( const Rational& );
		Rational& operator/= ( const Rational& );

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

		Rational operator+ (const Rational& ) const;
		Rational operator+ (long) const; 
		friend Rational operator+ (long, const Rational&);
};
#endif

Code:

//Rational.cpp
#include <iostream>
#include "Rational.h"
using namespace std;

Rational::Rational()
{
	_p = 1;
	_q = 1;
}

Rational::Rational ( long P, long Q )
{
     _p = P;
     _q = (Q == 0)? 1:Q;
}

Rational::Rational ( const Rational& R)
{
	_p = R._p;
	_q = R._q;
}
	
Rational& Rational::operator= ( const Rational& R)
{
	_p = R._p;
	_q = R._q;
	return *this;
}

Rational& Rational::operator+= ( const Rational& R)
{
	_p = (_p * R._q) + (R._p * _q);
	_q *= R._q;
	return *this;
}

Rational& Rational::operator-= ( const Rational& R)
{
	_p = (_p * R._q) - (R._p * _q);
	_q = (_q * R._q);
	return *this;
}

Rational& Rational::operator*= ( const Rational& R)
{
	_p = _p * R._p;
	_q = _q * R._q;
	return *this;
}

Rational& Rational::operator/= ( const Rational& R)
{
	_p = _p * R._q;
	_q = _q * R._p;
	return *this;
}

ostream& operator<< ( ostream& os, const Rational& R)
{
	os << R._p << "/" << R._q;
	return os;
}


istream& operator>> ( istream& is, Rational& R)
{
	char c;
	is >> R._p >> c >> R._q;
	return is;
}

Rational::Rational operator+ (const Rational& R)
{
	_p = R._p;
	_q = R._q;

//ERRORS IN THESE TWO LINES.
}

Rational operator+ (long L, const Rational& R)
{
	return (L)+=(R);
}

Code:

//Main.cpp 

#include <iostream>
#include "Rational.h"
using namespace std;

int main()
{
	Rational rat1(1, 2);
	Rational rat2(-20, 4);
	Rational temp;

	//+
	temp = rat1;
	cout << rat1 << " + " << rat2 << " = ";
	temp = rat1+rat2;
	cout << temp << endl;

	return 0;
}

Quote:

Rational.cpp: In function âRational operator+(const Rational&)â:
Rational.cpp:78: error: â_pâ was not declared in this scope
Rational.h:13: error: âlong int Rational::_pâ is private
Rational.cpp:78: error: within this context
Rational.cpp:79: error: â_qâ was not declared in this scope
Rational.h:14: error: âlong int Rational::_qâ is private
Rational.cpp:79: error: within this context
Rational.cpp: In function âRational operator+(long int, const Rational&)â:
Rational.cpp:84: error: no match for âoperator+=â in âL += Râ

I still get that compile error. Something wrong with that function...? How should I write that one?

Okay. Everything compiles, but isn't functioning correctly. My + gives me an answer of -16/4 (reducing the fraction is not required in this assignment) instead of some value equivalent of -9/2 and I can't find what I did wrong (yet again...). My += does give me a correct equivalent value of -36/8.

EDIT: I can see that I wrote Rational Rational::operator+ (const Rational& R)const incorrectly...what should I put in there instead? return R;?

Code:

//Rational.h

#ifndef RATIONAL_H_DEF
#define RATIONAL_H_DEF

#include <iostream>
using namespace std;

class Rational
{
	long _p;
	long _q;

	public:

		Rational ( ); //default constructor 
		Rational ( long, long = 1 ); //constructor
		Rational ( const Rational& ); //copy constructor
		Rational& operator= ( const Rational& );
		Rational& operator+= ( const Rational& );
		Rational& operator-= ( const Rational& );
		Rational& operator*= ( const Rational& );
		Rational& operator/= ( const Rational& );

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

		Rational operator+ (const Rational&) const;
		Rational operator+ (long) const; 
		friend Rational operator+ (long, const Rational&);
};
#endif

Code:

//Rational.cpp

#include <iostream>
#include "Rational.h"
using namespace std;

Rational::Rational()
{
	_p = 1;
	_q = 1;
}

Rational::Rational ( long P, long Q )
{
     _p = P;
     _q = (Q == 0)? 1:Q;
}

Rational::Rational ( const Rational& R)
{
	_p = R._p;
	_q = R._q;
}
	
Rational& Rational::operator= ( const Rational& R)
{
	_p = R._p;
	_q = R._q;
	return *this;
}

Rational& Rational::operator+= ( const Rational& R)
{
	_p = (_p * R._q) + (R._p * _q);
	_q *= R._q;
	return *this;
}

ostream& operator<< ( ostream& os, const Rational& R)
{
	os << R._p << "/" << R._q;
	return os;
}


istream& operator>> ( istream& is, Rational& R)
{
	char c;
	is >> R._p >> c >> R._q;
	return is;
}

Rational Rational::operator+ (const Rational& R)const
{
	Rational t;
	t+=R;
	return t;
}

Rational operator+ (long L, const Rational& R)
{
	return Rational(L)+=(R);
}

Code:

//Main.cpp

#include <iostream>
#include "Rational.h"
using namespace std;

int main()
{
	Rational rat1(1, 2);
	Rational rat2(-20, 4);
	Rational temp;

	//+=
	temp = rat1;
	cout << rat1 << " += " << rat2 << " = ";
	temp+=rat2;
	cout << temp << endl;

	//+
	temp = rat1;
	cout << rat1 << " + " << rat2 << " = ";
	temp = (rat1)+(rat2);
	cout << temp << endl;

	return 0;
}

dharmaBum · 10-14-09

Code:

Rational Rational::operator+ (const Rational& R)const
{
	Rational t;
	t+=R;
	return t;
}

Think about it: what is "t" equal to here?

Hint: What is being added to your input (-20/4) to give as output (-16/4)?

10-14-09	#6 (permalink)
Spotswood Case Modder Join Date: Jul 2008 Location: New Hampshire, USA Posts: 236 Rep: 46 Unique Rep: 39 Trader Rating: 0	You need to implement the copy constructor. __________________ Rich Custom Wooden Case Builder

		Overclock.net - Overclocking.net > Software, Programming and Coding > Coding and Programming
Operator Overloading (I think...?)

Currently Active Users Viewing This Thread: 1 (0 members and 1 guests)