overloading in C++

For More Https:www.ThesisScientist.com
UNIT 7
OVERLOADING
The term overloading means ‘providing multiple definitions of’. Overloading
of functions involves defining distinct functions which share the same name,
each of which has a unique signature. Function overloading is appropriate for:
 Defining functions which essentially do the same thing, but operate on
different data types.
 Providing alternate interfaces to the same function.
Function overloading is purely a programming convenience.
Operators are similar to functions in that they take operands (arguments)
and return a value. Most of the built-in C++ operators are already overloaded.
For example, the + operator can be used to add two integers, two reals, or
two addresses. Therefore, it has multiple definitions. The built-in definitions of
the operators are restricted to built-in types. Additional definitions can be
provided by the programmer, so that they can also operate on user-defined
types. Each additional definition is implemented by a function.
The overloading of operators will be illustrated using a number of simple
classes. We will discuss how type conversion rules can be used to reduce the
need for multiple overloadings of the same operator. We will present
examples of overloading a number of popular operators, including << and >>
for IO, [] and () for container classes, and the pointer operators. We will also
discuss memberwise initialization and assignment, and the importance of their
correct implementation in classes which use dynamically-allocated data
members.
Funtion Overloading
Consider a function, GetTime, which returns in its parameter(s) the current
time of the day, and suppose that we require two variants of this function: one
which returns the time as seconds from midnight, and one which returns the
time as hours, minutes, and seconds. Given that these two functions serve the
same purpose, there is no reason for them to have different names.
C++ allows functions to be overloaded, that is, the same function to have
more than one definition:
long GetTime (void); // seconds from midnight
void GetTime (int &hours, int &minutes, int &seconds);

When GetTime is called, the compiler compares the number and type of
arguments in the call against the definitions of GetTime and chooses the one
that matches the call. For example:
int h, m, s;
long t = GetTime(); // matches GetTime(void)
GetTime(h, m, s); // matches GetTime(int&, int&, int&);
To avoid ambiguity, each definition of an overloaded function must have a
unique signature.
Member functions of a class may also be overloaded:
class Time {
//...
long GetTime (void); // seconds from midnight
void GetTime (int &hours, int &minutes, int &seconds);
};
Function overloading is useful for obtaining flavors that are not possible
using default arguments alone. Overloaded functions may also have default
arguments:
void Error (int errCode, char *errMsg = "");
void Error (char *errMsg);
Operator Overloading
C++ allows the programmer to define additional meanings for its predefined
operators by overloading them. For example, we can overload the + and -
operators for adding and subtracting Point objects:
class Point {
public:
Point (int x, int y) {Point::x = x; Point::y = y;}
Point operator + (Point &p) {return Point(x + p.x,y + p.y);}
Point operator - (Point &p) {return Point(x - p.x,y - p.y);}
private:
int x, y;
};
After this definition, + and - can be used for adding and subtracting points,
much in the same way as they are used for adding and subtracting numbers:
Point p1(10,20), p2(10,20);
Point p3 = p1 + p2;
Point p4 = p1 - p2;
The above overloading of + and - uses member functions. Alternatively,
an operator may be overloaded globally:
class Point {

public:
Point (int x, int y) {Point::x = x; Point::y = y;}
friend Point operator + (Point &p, Point &q)
{return Point(p.x + q.x,p.y + q.y);}
friend Point operator - (Point &p, Point &q)
{return Point(p.x - q.x,p.y - q.y);}
private:
int x, y;
};
The use of an overloaded operator is equivalent to an explicit call to the
function which implements it. For example:
operator+(p1, p2) // is equivalent to: p1 + p2
Figure 7.1 Overloadable operators.
Unary: + - * ! ~ & ++ -- () -> -
>*
ne
w
delete
Binary: + - * / % & | ^ << >>
= += -= /= %= &= |= ^= <<
=
>>
=
== != < > <= >= && || [] () ,
A strictly unary operator (e.g., ~) cannot be overloaded as binary, nor can
a strictly binary operator (e.g., =) be overloaded as unary.
C++ does not support the definition of new operator tokens, because this
can lead to ambiguity. Furthermore, the precedence rules for the predefined
operators is fixed and cannot be altered. For example, no matter how you
overload *, it will always have a higher precedence than +.
Operators ++ and -- can be overloaded as prefix as well as postfix.
Equivalence rules do not hold for overloaded operators. For example,
overloading + does not affect +=, unless the latter is also explicitly overloaded.
Operators ->, =, [], and () can only be overloaded as member functions, and
not globally.
To avoid the copying of large objects when passing them to an
overloaded operator, references should be used. Pointers are not suitable for
this purpose because an overloaded operator cannot operate exclusively on
pointers.

Type Conversion
The normal built-in type conversion rules of the language also apply to
overloaded functions and operators. For example, in
if ('a' & set)
//...
the first operand of & (i.e., 'a') is implicitly converted from char to int,
because overloaded & expects its first operand to be of type int.
Any other type conversion required in addition to these must be explicitly
defined by the programmer. For example, suppose we want to overload + for
the Point type so that it can be used to add two points, or to add an integer
value to both coordinates of a point:
class Point {
//...
friend Point operator + (Point, Point);
friend Point operator + (int, Point);
friend Point operator + (Point, int);
};
To make + commutative, we have defined two functions for adding an integer
to a point: one for when the integer is the first operand, and one for when the
integer is the second operand. It should be obvious that if we start considering
other types in addition to int, this approach will ultimately lead to an
unmanageable variations of the operator.
A better approach is to use a constructor to convert the object to the
same type as the class itself so that one overloaded operator can handle the
job. In this case, we need a constructor which takes an int, specifying both
coordinates of a point:
class Point {
//...
Point (int x) { Point::x = Point::y = x; }
friend Point operator + (Point, Point);
};
For constructors of one argument, one need not explicitly call the constructor:
Point p = 10; // equivalent to: Point p(10);
Hence, it is possible to write expressions that involve variables or constants of
type Point and int using the + operator.
Point p(10,20), q = 0;
q = p + 5; // equivalent to: q = p + Point(5);

Overloading << for Output
The simple and uniform treatment of output for built-in types is easily
extended to user-defined types by further overloading the << operator. For any
given user-defined type T, we can define an operator<< function which
outputs objects of type T:
ostream& operator << (ostream&, T&);
The first parameter must be a reference to ostream so that multiple uses of <<
can be concatenated. The second parameter need not be a reference, but this is
more efficient for large objects.
For example, instead of the Binary class’s Print member function, we
can overload the << operator for the class. Because the first operand of <<
must be an ostream object, it cannot be overloaded as a member function. It
should therefore be defined as a global function:
class Binary {
//...
friend ostream& operator << (ostream&, Binary&);
};
ostream& operator << (ostream &os, Binary &n)
{
char str[binSize + 1];
strncpy(str, n.bits, binSize);
str[binSize] = '0';
cout << str;
return os;
}
Given this definition, << can be used for the output of binary numbers in a
manner identical to its use for the built-in types. For example,
Binary n1 = "01011", n2 = "11010";
cout << n1 << " + " << n1 << " = " << n1 + n2 << 'n';
will produce the following output:
0000000000001011 + 0000000000011010 = 0000000000100101
In addition to its simplicity and elegance, this style of output eliminates
the burden of remembering the name of the output function for each user-
defined type. Without the use of overloaded <<, the last example would have
to be written as (assuming that n has been removed from Print):
Binary n1 = "01011", n2 = "11010";
n1.Print(); cout << " + "; n2.Print();

cout << " = "; (n1 + n2).Print(); cout << 'n';

Overloading >> for Input
Input of user-defined types is facilitated by overloading the >> operator, in a
manner similar to the way << is overloaded. For any given user-defined type T,
we can define an operator>> function which inputs objects of type T:
istream& operator >> (istream&, T&);
The first parameter must be a reference to istream so that multiple uses of >>
can be concatenated. The second parameter must be a reference, since it will
be modified by the function.
Continuing with the Binary class example, we overload the >> operator
for the input of bit streams. Again, because the first operand of >> must be an
istream object, it cannot be overloaded as a member function:
class Binary {
//...
friend istream& operator >> (istream&, Binary&);
};
istream& operator >> (istream &is, Binary &n)
{
char str[binSize + 1];
cin >> str;
n = Binary(str); // use the constructor for simplicity
return is;
}
Given this definition, >> can be used for the input of binary numbers in a
manner identical to its use for the built-in types. For example,
Binary n;
cin >> n;
will read a binary number from the keyboard into to n.

Overloading ()
Listing 7.1 defines a matrix class. A matrix is a table of values (very similar to
a two-dimensional array) whose size is denoted by the number of rows and
columns in the table. An example of a simple 2 x 3 matrix would be:
10 20 30
21 52 19
M =
The standard mathematical notation for referring to matrix elements uses
brackets. For example, element 20 of M (i.e., in the first row and second
column) is referred to as M(1,2). Matrix algebra provides a set of operations
for manipulating matrices, which includes addition, subtraction, and
multiplication.
Listing 7.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream.h>
class Matrix {
public:
Matrix (const short rows, const short cols);
~Matrix (void) {delete elems;}
double& operator () (const short row, const short col);
friend ostream& operator << (ostream&, Matrix&);
friend Matrix operator + (Matrix&, Matrix&);
friend Matrix operator - (Matrix&, Matrix&);
friend Matrix operator * (Matrix&, Matrix&);
private:
const short rows; // matrix rows
const short cols; // matrix columns
double *elems; // matrix elements
};
Annotation
4 The constructor creates a matrix of the size specified by its arguments, all
of whose elements are initialized to 0.
6 The overloaded () operator is used for accessing matrix elements. The
function which overloads () may have zero or more parameters. It returns
a reference to the specified element’s value.
7 The overloaded << is used for printing a matrix in tabular form.
8-10 These overloaded operators provide basic matrix operations.
14 The matrix elements are represented by a dynamic array of doubles.
The implementation of the first three member functions is as follows:

Matrix::Matrix (const short r, const short c) : rows(r), cols(c)
{
elems = new double[rows * cols];
}
double& Matrix::operator () (const short row, const short col)
{
static double dummy = 0.0;
return (row >= 1 && row <= rows && col >= 1 && col <= cols)
? elems[(row - 1)*cols + (col - 1)]
: dummy;
}
ostream& operator << (ostream &os, Matrix &m)
{
for (register r = 1; r <= m.rows; ++r) {
for (int c = 1; c <= m.cols; ++c)
os << m(r,c) << " ";
os << 'n';
}
return os;
}
As before, because Matrix::operator() must return a valid reference, a
reference to a dummy static double is returned when the specified element
does not exist. The following code fragment illustrates that matrix elements
are lvalues:
Matrix m(2,3);
m(1,1) = 10; m(1,2) = 20; m(1,3) = 30;
m(2,1) = 15; m(2,2) = 25; m(2,3) = 35;
cout << m << 'n';
This will produce the following output:
10 20 30
15 25 35


Memberwise Initialization
Consider the following definition of the overloaded + operator for Matrix:
Matrix operator + (Matrix &p, Matrix &q)
{
Matrix m(p.rows, p.cols);
if (p.rows == q.rows && p.cols == q.cols)
for (register r = 1; r <= p.rows; ++r)
for (register c = 1; c <= p.cols; ++c)
m(r,c) = p(r,c) + q(r,c);
return m;
}
This function returns a matrix object which is initialized to m. The initialization
is handled by an internal constructor which the compiler automatically
generates for Matrix:
Matrix::Matrix (const Matrix &m) : rows(m.rows), cols(m.cols)
{
elems = m.elems;
}
This form of initialization is called memberwise initialization because the
special constructor initializes the object member by member. If the data
members of the object being initialized are themselves objects of another class,
then those are also memberwise initialized, etc.
As a result of the default memberwise initialization, the elems data
member of both objects will point to the same dynamically-allocated block.
However, m is destroyed upon the function returning. Hence the destructor
deletes the block pointed to by m.elems, leaving the returned object’s elems
data member pointing to an invalid block! This ultimately leads to a runtime
failure (typically a bus error). Figure 7.2 illustrates.
Figure 7.2 The danger of the default memberwise initialization of objects with pointers.
rows
cols
elems
rows
cols
elems
Matrixm
Memberwise
Copyof m Dynamic
Block rows
cols
elems
Memberwise
Copyof m Invalid
Block
A memberwise copyof m is made After m is destroyed
Memberwise initialization occurs in the following situations:

 When defining and initializing an object in a declaration statement that
uses another object as its initializer, e.g., Matrix n = m in Foo below.
 When passing an object argument to a function (not applicable to a
reference or pointer argument), e.g., m in Foo below.
 When returning an object value from a function (not applicable to a
reference or pointer return value), e.g., return n in Foo below.
Matrix Foo (Matrix m) // memberwise copy argument to m
{
Matrix n = m; // memberwise copy m to n
//...
return n; // memberwise copy n and return copy
}
It should be obvious that default memberwise initialization is generally
adequate for classes which have no pointer data members (e.g., Point). The
problems caused by the default memberwise initialization of other classes can
be avoided by explicitly defining the constructor in charge of memberwise
initialization. For any given class X, the constructor always has the form:
X::X (const X&);
Memberwise Initialization
Objects of the same class are assigned to one another by an internal
overloading of the = operator which is automatically generated by the
compiler. For example, to handle the assignment in
Matrix m(2,2), n(2,2);
//...
m = n;
the compiler automatically generates the following internal function:
Matrix& Matrix::operator = (const Matrix &m)
{
rows = m.rows;
cols = m.cols;
elems = m.elems;
}
This is identical in its approach to memberwise initialization and is called
memberwise assignment. It suffers from exactly the same problems, which in
turn can be overcome by explicitly overloading the = operator. For example,
for the Matrix class, the following overloading of = would be appropriate:

Matrix& Matrix::operator = (const Matrix &m)
{
if (rows == m.rows && cols == m.cols) { // must match
int n = rows * cols;
for (register i = 0; i < n; ++i) // copy elements
elems[i] = m.elems[i];
}
return *this;
}
In general, for any given class X, the = operator is overloaded by the
following member of X:
X& X::operator = (X&)
Operator = can only be overloaded as a member, and not globally.

Overloading new and delete
Objects of different classes usually have different sizes and frequency of usage.
As a result, they impose different memory requirements. Small objects, in
particular, are not efficiently handled by the default versions of new and
delete. Every block allocated by new carries some overhead used for
housekeeping purposes. For large objects this is not significant, but for small
objects the overhead may be even bigger than the block itself. In addition,
having too many small blocks can severely slow down subsequent allocation
and deallocation. The performance of a program that dynamically creates
many small objects can be significantly improved by using a simpler memory
management strategy for those objects.
The dynamic storage management operators new and delete can be
overloaded for a class, in which case they override the global definition of
these operators when used for objects of that class.
As an example, suppose we wish to overload new and delete for the
Point class, so that Point objects are allocated from an array:
#include <stddef.h>
#include <iostream.h>
const int maxPoints = 512;
class Point {
public:
//...
void* operator new (size_t bytes);
void operator delete (void *ptr, size_t bytes);
private:
int xVal, yVal;
static union Block {
int xy[2];
Block *next;
} *blocks; // points to our freestore
static Block *freeList; // free-list of linked blocks
static int used; // blocks used so far
};
The type name size_t is defined in stddef.h. New should always return a
void*. The parameter of new denotes the size of the block to be allocated (in
bytes). The corresponding argument is always automatically passed by the
compiler. The first parameter of delete denotes the block to be deleted. The
second parameter is optional and denotes the size of the allocated block. The
corresponding arguments are automatically passed by the compiler.

Since blocks, freeList and used are static they do not affect the size of
a Point object (it is still two integers). These are initialized as follows:
Point::Block *Point::blocks = new Block[maxPoints];
Point::Block *Point::freeList = 0;
int Point::used = 0;
New takes the next available block from blocks and returns its address.
Delete frees a block by inserting it in front of the linked-list denoted by
freeList. When used reaches maxPoints, new removes and returns the first
block in the linked-list, but fails (returns 0) when the linked-list is empty:
void* Point::operator new (size_t bytes)
{
Block *res = freeList;
return used < maxPoints
? &(blocks[used++])
: (res == 0 ? 0
: (freeList = freeList->next, res));
}
void Point::operator delete (void *ptr, size_t bytes)
{
((Block*) ptr)->next = freeList;
freeList = (Block*) ptr;
}
Point::operator new and Point::operator delete are invoked only
for Point objects. Calling new with any other type as argument will invoke the
global definition of new, even if the call occurs inside a member function of
Point. For example:
Point *pt = new Point(1,1); // calls Point::operator new
char *str = new char[10]; // calls ::operator new
delete pt; // calls Point::operator delete
delete str; // calls ::operator delete
Even when new and delete are overloaded for a class, global new and delete
are used when creating and destroying object arrays:
Point *points = new Point[5]; // calls ::operator new
//...
delete [] points; // calls ::operator delete
The functions which overload new and delete for a class are always
assumed by the compiler to be static, which means that they will not have
access to the this pointer and therefore the nonstatic class members. This is
because when these operators are invoked for an object of the class, the object
does not exist: new is invoked before the object is constructed, and delete is
called after it has been destroyed.

Overloading ->, *, and &
It is possible to divert the flow of control to a user-defined function before a
pointer to an object is dereferenced using -> or *, or before the address of an
object is obtained using &. This can be used to do some extra pointer
processing, and is facilitated by overloading unary operators ->, *, and &.
For classes that do not overload ->, this operator is always binary: the left
operand is a pointer to a class object and the right operand is a class member
name. When the left operand of -> is an object or reference of type X (but not
pointer), X is expected to have overloaded -> as unary. In this case, -> is first
applied to the left operand to produce a result p. If p is a pointer to a class Y
then p is used as the left operand of binary -> and the right operand is
expected to be a member of Y. Otherwise, p is used as the left operand of
unary -> and the whole procedure is repeated for class Y. Consider the
following classes that overload ->:
class A {
//...
B& operator -> (void);
};
class B {
//...
Point* operator -> (void);
};
The effect of applying -> to an object of type A
A obj;
int i = obj->xVal;
is the successive application of overloaded -> in A and B:
int i = (B::operator->(A::operator->(obj)))->xVal;
In other words, A::operator-> is applied to obj to give p, B::operator->
is applied to p to give q, and since q is a pointer to Point, the final result is q-
>xVal.
Unary operators * and & can also be overloaded so that the semantic
correspondence between ->, *, and & is preserved.
As an example, consider a library system which represents a book record
as a raw string of the following format:
"%Aauthor0%Ttitle0%Ppublisher0%Ccity0%Vvolume0%Yyear0n"

Each field starts with a field specifier (e.g., %A specifies an author) and ends
with a null character (i.e., 0). The fields can appear in any order. Also, some
fields may be missing from a record, in which case a default value must be
used.
OverLoading ++ And --
The auto increment and auto decrement operators can be overloaded in both
prefix and postfix form. To distinguish between the two, the postfix version is
specified to take an extra integer argument. For example, the prefix and
postfix versions of ++ may be overloaded for the Binary class as follows:
class Binary {
//...
friend Binary operator ++ (Binary&); // prefix
friend Binary operator ++ (Binary&, int); // postfix
};
Although we have chosen to define these as global friend functions, they
can also be defined as member functions. Both are easily defined in terms of
the + operator defined earlier:
Binary operator ++ (Binary &n) // prefix
{
return n = n + Binary(1);
}
Binary operator ++ (Binary &n, int) // postfix
{
Binary m = n;
n = n + Binary(1);
return m;
}
Note that we have simply ignored the extra parameter of the postfix version.
When this operator is used, the compiler automatically supplies a default
argument for it.
The following code fragment exercises both versions of the operator:
Binary n1 = "01011";
Binary n2 = "11010";
cout << ++n1 << 'n';
cout << n2++ << 'n';
cout << n2 << 'n';
It will produce the following output:
0000000000001100
0000000000011010
0000000000011011

The prefix and postfix versions of -- may be overloaded in exactly the
same way.

overloading in C++

More Related Content

What's hot (19)

Similar to overloading in C++ (20)

More from Prof Ansari (20)

Recently uploaded (20)

overloading in C++