Operator Overloading in C++

p.plus(q)

+	-	*	/	%	^	&	|	~	!
=	<	>	+=	-=	*=	/=	%=	^=	&=
|=	<<	>>	>>=	<<=	==	!=	<=	>=	&&
||	++	--	->*	,	->	[]	()	new	delete

class Rational {

public:

Rational();

Rational(int numerator, int denominator);

int numerator() const;

int denominator() const;

Rational operator+(const Rational& r) const;

Rational operator-(const Rational& r) const;

Rational operator*(const Rational& r) const;

Rational operator/(const Rational& r) const;

Rational& operator=(const Rational& r);

private:

int gcd(int a, int b);  // compute greatest common divisor of _a_ and _b_

void reduce();          // reduce my numerator and denominator

// to lowest terms

int myNum;              // my numerator

int myDenom;            // my denominator

};

Rational r1(1, 2);

Rational r2(1, 4);

Rational r3();

r3 = r1 + r2;   // Uses operator+ and then operator= for assignment

Rational r1(1, 2);

Rational r2(1, 4);

Rational r3();

r3.operator=( r1.operator+(r2) );

Rational Rational::operator+(const Rational& r) const {

int num = (myNum * r.myDenom) + (r.myNum * myDenom);

int denom = (myDenom * r.myDenom);

Rational sum(num, denom);

return sum;

}

Rational& Rational::operator=(const Rational& r) {

myNum = r.myNum;       // copy r's numerator to mine

myDenom = r.myDenom;   // copy r's denominator to mine

return *this;          // return myself!

}

if ( r1 = r2 ) // should be r1 == r2

Rational r1(1, 2);

Rational r3;

int n = 100;

r3 = n + r1;

Rational operator+(int i, const rational& r) {

Rational sum( i * r.denominator() + r.numerator(), r.denominator() );

return sum;

}

n + r1

operator+(n, r1)

1. Operator overloading is a very nice feature of C++ from the perspective of support for abstraction. At the same time, it can be very frustrating to learn how to use it. Since the textbook, as well as many designers of C++ classes, use operator overloading quite a bit, you should be familiar with the concept, syntax, and semantics. However, do not feel obligated to define overloaded operators. Postpone their use until after you have mastered other basic concepts of the language.
2. Operators are not the only things that can be overloaded in a C++ program. Functions and member functions can also be overloaded--that is, two or more member functions in the same class can have the same name and two or more functions can have the same name. Thus, for example, two functions called abs can be defined to compute the absolute value of a number:

   int abs(int i);

   float abs(float x);

   Every function has a signature, determined by the name of the function, the number and types of its formal parameters, and whether or not it is declared const. [The return type of the function is not part of the signature.] Since the signatures of the two abs functions are different--even though they have the same function name--then these functions can co-exist in the same program. Whenever a call   abs(b) is encountered during compilation, the compiler considers the type of b in determining which of the overloaded functions to call. Thus, the call abs(-7) is considered a call to the first function listed above since -7 is of type int since the single int argument matches the argument called for in that function's signature. The call abs(z), where z is declared as a variable of type float, is considered a call to the second function listed above since the single float argument matches the argument called for in that function's signature.

   In the same program, the following functions could also defined since their signatures are unique:

   Boolean abs(int i, int j);

   Boolean abs(float x, float y);

   Rational abs(const Rational& r);

   void abs()

   Of course, if all functions have the same name, a program becomes very difficult to read! However, the opportunity to overload function names in programs is very useful at times and should not be avoided if their use supports abstraction. For example, being able to use the function abs to compute the absolute value of either a float or an int value is more natural than having to use, say, iabs to compute the absolute value of an int value and fabs to compute the absolute value of a float value.

3. Overloading of member functions is particularly useful. When more than one constructor is defined in a class, overloading occurs. [The signature of the constructors is used to determine which to use.] A useful member function for the Rational class would support addition of integers, meaning the operator+ operation would be overloaded, adding into the class interface the declaration:

   Rational operator+(int i) const;