 Introduction

Basic Operator Overloading

In C++, you can overload operators (e.g., +,-, = =, …) so that they work with the operands in the classes you define.
Operators may be overloaded outside or inside the class definition. Both have advantages and disadvantages.

Operators overloaded outside the class definition do not have access to the private members of the class. The disadvantage is that they must use the accessor and mutator functions. An advantage is that you specify both operands and can have automatic type conversion of both operands.
Operators overloaded inside the class definition have access to the private members of the class (an advantage), but there is no automatic type conversion of the first operand (disadvantage) since the first operand is the calling object itself.

// Example Program.

class RaceEvent

{

public:

RaceEvent() {}

RaceEvent(int distance) : _distance(distance) {}

void setDistance(int distance);

int getDistance() const { return _distance; }

private:

int _distance;

};

void RaceEvent::setDistance(int distance)

{

_distance = distance;

}

// Example declarations of overloaded operators

const RaceEvent operator +(const RaceEvent& R1, const RaceEvent& R2);

const RaceEvent operator -(const RaceEvent& R1, const RaceEvent& R2);

bool operator ==(const RaceEvent& R1, const RaceEvent& R2);

bool operator <=(const RaceEvent& R1, const RaceEvent& R2);

// Example definitions of overloaded operators

const RaceEvent operator +(const RaceEvent& R1, const RaceEvent& R2)

{

RaceEvent temp;

temp.setDistance(R1.getDistance() + R2.getDistance());

return temp;

}

const RaceEvent operator -(const RaceEvent& R1, const RaceEvent& R2)

{

return RaceEvent(R1.getDistance() - R2.getDistance());

}

bool operator ==(const RaceEvent& R1, const RaceEvent& R2)

{

return (R1.getDistance() == R2.getDistance());

}

bool operator <=(const RaceEvent& R1, const RaceEvent& R2)

{

return (R1.getDistance() <= R2.getDistance());

}

// Example driver code that tests the overloaded operators

#include <iostream>

#include <cmath>

using namespace std;

int main()

{

RaceEvent race1(100), race2(400), race3;

int meters;

{

cout << "\nRace 1 = " << race1.getDistance()

<< "\nRace 2 = " << race2.getDistance() << endl;

if(race1 == race2)

cout << "Race 1 and Race 2 are the same distance.\n";

else

cout << "Race 1 and Race 2 difference is "

<< abs((race2 - race1).getDistance())

<< " meters.\n";

race3 = race1 + race2;

cout << "Race 1 and Race 2 sum up to "

<< race3.getDistance() << " meters.\n";

cout << "\nEnter new distance for Race 1: ";

cin >> meters;

race1.setDistance(meters);

} while (race1 <= race2);

return 0;

}

// Output of a sample session

Race 1 = 100

Race 2 = 400

Race 1 and Race 2 difference is 300 meters.

Race 1 and Race 2 sum up to 500 meters.

Enter new distance for Race 1: 300

Race 1 = 300

Race 2 = 400

Race 1 and Race 2 difference is 100 meters.

Race 1 and Race 2 sum up to 700 meters.

Enter new distance for Race 1: 400

Race 1 = 400

Race 2 = 400

Race 1 and Race 2 are the same distance.

Race 1 and Race 2 sum up to 800 meters.

Enter new distance for Race 1: 401

Press any key to continue

Returning by const Value

You should return class types by const value unless you have an explicit reason not to do so. This will provide added protection by the compiler if an object is inadvertently changed.

// Example. The following is legal and changes

// the anonymous object that is created from

// (race1 + race2).

(race1 + race2).setDistance(1000);

// If the code were changed to the following,

// then the 1000 would override the sum of

// race1 + race2. See the blue italics text for

// the differences between the code below and the

// example above.

class RaceEvent

{

public:

RaceEvent() {}

RaceEvent(int distance) : _distance(distance) {}

int setDistance(int distance);

int getDistance() const { return _distance; }

private:

int _distance;

};

int RaceEvent::setDistance(int distance)

{

_distance = distance;

return _distance;

}

// From main()

{

cout << "\nRace 1 = " << race1.getDistance()

<< "\nRace 2 = " << race2.getDistance() << endl;

if(race1 == race2)

cout << "Race 1 and Race 2 are the same distance.\n";

else

cout << "Race 1 and Race 2 difference is "

<< abs((race2 - race1).getDistance())

<< " meters.\n";

race3 = race1 + race2;

cout << "Race 1 and Race 2 sum up to "

<< race3.getDistance() << " meters.\n";

// Look how I can mess up the results of race3 !!!

cout << endl;

cout << "Below is an Error for not returning by const\n";

race3.setDistance((race1 + race2).setDistance(10000));

cout << "Race 1 and Race 2 sum up to "

<< race3.getDistance() << " meters.\n";

cout << "\nEnter new distance for Race 1: ";

cin >> meters;

race1.setDistance(meters);

} while (race1 <= race2);

// Output of a sample session

Race 1 = 100

Race 2 = 400

Race 1 and Race 2 difference is 300 meters.

Race 1 and Race 2 sum up to 500 meters.

Below is an Error for not returning by const

Race 1 and Race 2 sum up to 10000 meters.

Enter new distance for Race 1: 200

Race 1 = 200

Race 2 = 400

Race 1 and Race 2 difference is 200 meters.

Race 1 and Race 2 sum up to 600 meters.

Below is an Error for not returning by const

Race 1 and Race 2 sum up to 10000 meters.

Enter new distance for Race 1: 401

Press any key to continue

Operator Overloading as a member function

The example for RaceEvent is rewritten below with the operator overloading as part of the class definition, i.e., as a member function.

// Example rewritten.

class RaceEvent

{

public:

// Constructors

RaceEvent();

RaceEvent(int distance);

// Accessor and Mutator Function

void setDistance(int distance);

int getDistance() const;

// Operators

const RaceEvent operator +(const RaceEvent& R2) const;

const RaceEvent operator -(const RaceEvent& R2) const;

bool operator ==(const RaceEvent& R2) const;

bool operator <=(const RaceEvent& R2) const;

private:

int _distance;

};

// Constructor

RaceEvent::RaceEvent()

{}

// Constructor

RaceEvent::RaceEvent(int distance) : _distance(distance)

{}

// Mutator Function

void RaceEvent::setDistance(int distance)

{

_distance = distance;

}

// Accessor Function

int RaceEvent::getDistance() const

{

return _distance;

}

// Example definitions of overloaded operators

const RaceEvent RaceEvent::operator +(const RaceEvent& R2) const

{

return RaceEvent(_distance + R2.getDistance());

}

const RaceEvent RaceEvent::operator -(const RaceEvent& R2) const

{

return RaceEvent(_distance - R2.getDistance());

}

bool RaceEvent::operator ==(const RaceEvent& R2) const

{

return (_distance == R2.getDistance());

}

bool RaceEvent::operator <=(const RaceEvent& R2) const

{

return (_distance <= R2.getDistance());

}

// Example driver that overloaded operators

#include <iostream>

#include <cmath>

using namespace std;

int main()

{

RaceEvent race1(100), race2(400), race3;

int meters;

{

cout << "\nRace 1 = " << race1.getDistance()

<< "\nRace 2 = " << race2.getDistance() << endl;

if(race1 == race2)

cout << "Race 1 and Race 2 are the same distance.\n";

else

cout << "Race 1 and Race 2 difference is "

<< abs((race2 - race1).getDistance())

<< " meters.\n";

race3 = race1 + race2;

cout << "Race 1 and Race 2 sum up to "

<< race3.getDistance()

<< " meters.\n";

cout << "\nEnter new distance for Race 1: ";

cin >> meters;

race1.setDistance(meters);

} while (race1 <= race2);

return 0;

}

// Output of a sample session

Race 1 = 100

Race 2 = 400

Race 1 and Race 2 difference is 300 meters.

Race 1 and Race 2 sum up to 500 meters.

Enter new distance for Race 1: 150

Race 1 = 150

Race 2 = 400

Race 1 and Race 2 difference is 250 meters.

Race 1 and Race 2 sum up to 550 meters.

Enter new distance for Race 1: 400

Race 1 = 400

Race 2 = 400

Race 1 and Race 2 are the same distance.

Race 1 and Race 2 sum up to 800 meters.

Enter new distance for Race 1: 401

Press any key to continue

Friend Functions

Friend Functions are nonmember functions that have all the privileges of member functions of a class

Friend Functions are declared within the class definition just as a member function would be with the exception of placing the keyword friend in front of the declaration. (Note: the friend function, however, is not considered to be a member function of the class).

A friend function can be a friend of more than one class. To make it a friend of multiple classes, give the declaration of the friend function in each class definition for which you want it to be a friend.

The most common kinds of friend functions are overloaded operators. Why? For example, if overloading the + operator as a friend, we can access member variables directly and also have automatic type conversion for all operands.

A friend function is not truly in the spirit of OOP because it is not a true member function of the class.

// Example. The example is rewritten again using friend functions.

// See the changes in blue italics below. All other code is the same.

class RaceEvent

{

public:

// Constructors

RaceEvent();

RaceEvent(int distance);

// Accessor and Mutator Function

void setDistance(int distance);

int getDistance() const;

// Operators

friend const RaceEvent operator +(const RaceEvent& R1, const RaceEvent& R2);

friend const RaceEvent operator -(const RaceEvent& R1, const RaceEvent& R2);

friend bool operator ==(const RaceEvent& R1, const RaceEvent& R2);

friend bool operator <=(const RaceEvent& R1, const RaceEvent& R2);

private:

int _distance;

};

// Example of friend functions. Note that the friend functions have

// direct access to the private member data of the object parameters.

const RaceEvent operator +(const RaceEvent& R1, const RaceEvent& R2)

{

RaceEvent temp;

// Friend function can access the private parameters.

temp._distance = R1._distance + R2._distance;

return temp;

}

const RaceEvent operator -(const RaceEvent& R1, const RaceEvent& R2)

{

// Creates and returns an anonymous object.

return RaceEvent(R1._distance - R2._distance);

}

bool operator ==(const RaceEvent& R1, const RaceEvent& R2)

{

return (R1._distance == R2._distance);

}

bool operator <=(const RaceEvent& R1, const RaceEvent& R2)

{

return (R1._distance <= R2._distance);

}

// Output of a sample session

Race 1 = 100

Race 2 = 400

Race 1 and Race 2 difference is 300 meters.

Race 1 and Race 2 sum up to 500 meters.

Enter new distance for Race 1: 211

Race 1 = 211

Race 2 = 400

Race 1 and Race 2 difference is 189 meters.

Race 1 and Race 2 sum up to 611 meters.

Enter new distance for Race 1: 401

Press any key to continue

Here are some basic rules on overloading operators

When overloading an operator, at least one operand of the resulting overloaded operator must be of a class type.

Most operators can be overloaded as a member of the class, a friend of the class, or a nonmember of the class. For example, the assignment operator, =, cannot be overloaded as a nonmember of a class.

The following operators can only be overloaded as nonstatic members of the class: =, [], ->, and ().

You cannot create a new operator. You can only overload existing operators.

You cannot change the number of arguments that an operator takes. Example, you can’t change % from a binary to unary operator when you overload it.

You cannot change the precedence of an operator.

The following operators cannot be overloaded: . (dot operator), :: (scope resolution operator), sizeof (sizeof operator), and ?: (conditional operator).

Overloaded operators cannot have default arguments.

References and More Overloaded Operators

Reference – A reference is an alias or a name to an existing object. They are similar to pointers in that they must be initialized before they can be used.

A standalone reference is a direct reference to a variable and can cause trouble if you’re not careful.

// Example

#include <iostream>

using namespace std;

int main()

{

int a = 1, c = 2;

int& b = a;

cout << a << " " << b << " " << c << endl;

b = c;

cout << a << " " << b << " " << c << endl;

a = 5;

cout << a << " " << b << " " << c << endl;

return 0;

}

// Output. Note: b is always a reference (alias) to

// a throughout the program. b must be initialized

// in the declaration or there will be a compiler

// error. That is, all references must be

// initialized in the declaration. You could not

// have the following:

int& b; // ERROR!

b = a;

// However, this is valid

int& b = a;

// do some stuff

b = c; // b, alias to a, now equals c

// do some stuff

1 1 2

2 2 2

5 5 2

Returning by reference can be thought of as returning an alias to a variable. The return expression must be something with a reference. It cannot be an expression or local variable.

L-Values and R-Values – l-values appear on the Left-Hand-Side (LHS) of an assignment operator. r-values appear on the Right-Hand-Side (RHS) of an assignment operator. If you want an object returned to be an l-value, you must use return by reference. An exception to this rule applies when using the this pointer. This (no pun) will be discussed later.

// Example

#include <iostream>

using namespace std;

int& fun(int& num)

{

return num;

}

int main()

{

int a = 100;

cout << a << endl;

cout << fun(a) << endl;

fun(a) = 5; // Return by reference allows LHS of =

cout << a << endl;

cout << fun(a) << endl;

return 0;

}

// Output

100

Overloading the Insertion, <<, and Extraction, >>, Operators – The << and >> operators are normally overloaded as friend functions to a class where the first operand is the cout or cin object, and the second operand is an object of the class type. The type used for the output stream is ostream and the type used for the input stream is istream.

By overloading << and >> as friend functions, we can use the object by name rather than using the access and mutator functions.

//Example

Money amount;

...

cout << "The amount is " << amount << endl;

...

cout << "Enter new amount: ";

cin >> amount;

Overloading the Assignment Operator , = This must be done as a member operator. If you do not overload the assignment operator, then you automatically get an assignment operator for your class that will copy the values of the member variables from one object of the class to member variables of another object of the class. This is called a shallow copy. This will work fine if there are no pointers or dynamically allocated data involved. When pointers are used, we want to do a deep copy, which will account for allocated memory.

Overloading the array operator, [] The square brackets can be overloaded so that they can be used with objects of the class. If you want to use [] in an expression on the LHS of an assignment operator, then the operator must be defined to return a reference. When overloading [], it must be overloaded as a member function.

Pointers and Dynamic Arrays

A pointer is a variable that holds a memory address. Using this variable, we are able to indirectly access and change whatever the pointer is pointing to.

A pointer is declared using the Indirection Operator, *. This operator is also known as the dereference operator.

// Example

int num1 = 50, num2 = 100;

int *p1 = &num1, *p2;

p2 = &num2;

To retrieve and set the value at the address stored by the pointer we also use the Indirection Operator.

// Example

cout << "num1 = " << num1 << endl;

cout << "num1 = " << *p1 << endl;

cout << "num2 = " << num2 << endl;

cout << "num2 = " << *p2 << endl;

num1 = 10;

*p2 = 20;

cout << "num1 = " << num1 << endl;

cout << "num1 = " << *p1 << endl;

cout << "num2 = " << num2 << endl;

cout << "num2 = " << *p2 << endl;

// Output

num1 = 50

num2 = 100

num1 = 10

num2 = 20

Press any key to continue

You can assign one pointer to another and both pointers will point to the same memory; however you cannot have one pointer point to more than one memory location simultaneously.

// Example

int num1 = 50, num2 = 100;

int *p1 = &num1, *p2 = &num2;

cout << "num1 = " << num1 << endl;

cout << "num1 = " << *p1 << endl;

cout << "num2 = " << num2 << endl;

cout << "num2 = " << *p2 << endl;

p1 = p2;

cout << "num1 = " << num1 << endl;

cout << "num1 = " << *p1 << endl;

cout << "num2 = " << num2 << endl;

cout << "num2 = " << *p2 << endl;

// Output

num1 = 50

num2 = 100

num1 = 50

num1 = 100

num2 = 100

Press any key to continue

To dynamically allocate memory in C++, we use the new operator. The new operator will dynamically create a nameless variable that can be pointed to by a pointer of the same type.

// Example

double *pRate;

pRate = new double;

*pRate = 0.0675;

cout << "The rate = " << (*pRate * 100) << "%\n";

// Output

The rate = 6.75%

Press any key to continue

To eliminate a dynamic variable and return the memory to the heap we use the delete operator.

// Example

class Person

{ };

char *pName = new char;

int *pNumbers = new int[50];

Person *pPerson = new Person;

// Do some stuff until and then free the memory

delete pName; // pName becomes undefined after delete

delete [] pNumbers; // Must use [] for an array

delete pPerson;

Memory Management – There are generally 5 areas of memory that a programmer needs to be concerned with. They are listed below. We will be concerned with the heap for dynamically allocated memory variables.

The Stack – Local variables and function parameters are on the stack. The stack is cleaned automatically when a function returns. All local variables and function parameters go out of scope and they are removed from the stack.
Code Space – Code is located in the code space
Global Name Space – Global variables are in the global name space
Registers – Used for things such as keeping track of the top of the stack, the instruction pointer, etc...
Heap – The remaining memory is given to the free store, referred to as the heap. This gets cleaned automatically when your program ends, but you should develop the habit of freeing the memory as soon as you are done with it. This will maximize the memory available on the heap while your program is running.

The Arrow Operator, ->

The -> operator is used to combine the actions of the indirection operator and the dot operator to simplify the way we indirectly access members of a structure or class object that has been dynamically allocated.

// Example

class Record

{

public:

int num;

};

Record *p;

p = new Record;

(*p).num = 5;

cout << "The number = " << (*p).num << endl;

p->num = 10;

cout << "The number = " << p->num << endl;

delete p;

// Output

The number = 5

The number = 10

Press any key to continue

The this Pointer – this is a pointer to the object that invokes a member function. Each time a member function is invoked, it is automatically passed a pointer to the object that has invoked it (called this). Thus, this is an implicit parameter to all member functions.

An impractical example of the usage of the this pointer is shown below. Note: the example is for illustrative purposes only, it is not practical to program in this manner.

#include <iostream>

using namespace std;

int main()

{

class Record

{

public:

int getNum1() const { return this->_num1; }

int getNum2() const { return _num2; }

void setNum1(int num1) { _num1 = num1; }

void setNum2(int num2) { this->_num2 = num2; }

private:

int _num1;

int _num2;

};

Record *p;

p = new Record;

p->setNum1(75);

p->setNum2(300);

cout << "The first number = " << p->getNum1() << endl;

cout << "The second number = " << p->getNum2() << endl;

delete p;

return 0;

}

// Output

The first number = 75

The second number = 300

Press any key to continue

Assignment Operator Overloading - A more practical use of the this pointer is for overloading the assignment operator. The assignment operator must be overloaded as a member function. It cannot be overloaded as a friend function because a friend function dose not have access to the this pointer. The example below is a snippet that is taken from the book. Note that in this example, a deep copy is made because we are dynamically allocating memory.

Shallow Copy – The copying of the contents of the member variables from one object to the other. The default assignment operator and default copy constructor perform shallow copies.

Deep Copy – The deep copy does two things: 1) it copies the contents of non-pointer member variables from one object to another and 2) it allocates memory for pointer variables and makes a copy of what each pointer variable is point to so that you end up with two separate, but identical, copies of the object. Note: In the case of a shallow copy, the pointer information would simply get copied and both pointers in both objects would be pointing to the same dynamically allocated memory. This is bad coding practice. Always make a deep copy when using pointers and the new operator.

class StringClass

{

public:

...

void showStuff() const;

...

StringClass& operator=(const StringClass& rtSide);

...

private:

char *a; // Dynamic array for characters in the string

int capacity; // Size of the dynamic array

int length; // Number of characters in a

};

StringClass& StringClass::operator=(const StringClass& rtSide)

{

if(this == &rtSide) // Right is same as the Left side

return *this;

else

{

capacity = rtSide.capacity;

length= rtSide.length

delete [] a;

a = new char[capacity];

for(int i =0; i < length; i++)

a[i] = rtSide.a[i];

return *this;

}

Note: When using the this pointer in the overloaded assignment operator, a return by reference is made. You will probably find that most books will not return by reference for the overloaded assignment operator. Our book does return by reference. What is the added benefit of returning by reference? The added benefit is that return by reference allows you to invoke a member function with the value returned. For example,

StringClass A, B, C;

// Do some stuff (pretend that the C object gets filled in)

// Below will work whether or not we return by reference

A = C;

// Below will work if, and only if, we return by reference

(B = C).showStuff();

Note: In this example, the calling objects are the A and B objects. The C object, in both cases, is the operand (rtSide) of the overloaded assignment operator.

The Copy Constructor – A constructor that has one CBR parameter that is of the same type as the class. The copy constructor for a class is automatically called whenever a function returns a value of the class type. Any class that uses pointers and the new operator should have a copy constructor. The copy constructor should be designed to produce a deep copy.

// Example

StringClass::StringClass(const StringClass& rtSide)

{

capacity = rtSide.capacity;

length = rtSide.length

a = new char[capacity];

for(int i =0; i < length; i++)

a[i] = rtSide.a[i];

}

StringClass A;

// Do some stuff (pretend that the A object gets filled in)

StringClass B(A); // This will perform a deep copy

The Big Three – For good (and safe) coding practice, consider the fact that if you use any of the following: copy constructor, the assignment operator, or the destructor, you should define all three. They have been dubbed as "The Big Three" so that it is easier to remember that they all go together.

Hosted by www.Geocities.ws