Operator overloading
Operator overloading is a very important feature of Object Oriented
Programming. Curious to know why!!? It is because by using this
facility programmer would be able to create new definitions to
existing operators. In fact in other words a single operator can take
up several functions as desired by programmers depending on the
argument taken by the operator by using the operator overloading
facility. After knowing about the feature of operator overloading now
let us see how to define and use this concept of operator overloading
in C++ programming language. We have seen in previous sections the
different types of operators. Broadly classifying operators are of
two types namely:
- Unary Operators
- Binary Operators
Unary Operators:
As the name implies takes operate on only one operand. Some unary
operators are namely ++ called as Increment operator, -- called as
Decrement Operator, ! , ~, unary minus.
Binary Operators:
The arithmetic operators, comparison operators, and arithmetic
assignment operators all this which we have seen in previous section
of operators come under this category. Both the above classification
of operators can be overloaded. So let us see in detail each of this.
Operator Overloading – Unary operators
As said before operator overloading helps the programmer to define a
new functionality for the existing operator. This is done by using
the keyword operator.
The general syntax for defining an operator overloading is as
follows:
return_ type class name :: operator symbol(argument)
{
…………..
statements;
}
{
…………..
statements;
}
Thus the above clearly specifies that operator overloading is defined
as a member function by making use of the keyword operator.
In the above:
- return type – is the data type returned by the function
- class name - is the name of the class
- operator – is the keyword
- operator symbol – is the symbol of the operator which is being overloaded or
- defined for new functionality
- :: - is the scope resolution operator which is used to use the function definition outside the class. The
- usage of this is clearly defined in our earlier section of How to define class members.
For example
Suppose we have a class say Item and if the programmer wants to
define a operator overloading for unary operator say ++, the function
is defined as
Inside the class Item the data type that is returned by
the overloaded operator is defined as
class Item
{
private:
……….
public:
void operator ++( );
…………
};
{
private:
……….
public:
void operator ++( );
…………
};
So the important steps involved in defining an operator overloading
in case of unary operators are namely:
Inside the class the operator overloaded member function is defined
with the return data type as member function or a friend function.
The concept of friend function we will define in later sections. If
in this case of unary operator overloading if the function is a
member function then the number of arguments taken by the operator
member function is none as seen in the below example. In case if the
function defined for the operator overloading is a friend function
which we will discuss in later section then it takes one argument.
The operator overloading is defined as member function outside the
class using the scope resolution operator with the keyword operator
as explained above
Now let us see how to use this overloaded operator member function in
the program
#include <iostream.h>
class Item
{
private:
int x;
public:
Item( ) { x=0; } //Constructor
void display();
void Item ++( );
};
class Item
{
private:
int x;
public:
Item( ) { x=0; } //Constructor
void display();
void Item ++( );
};
void Item :: display()
{
cout<<”\nValue of x is: “ << x;
}
{
cout<<”\nValue of x is: “ << x;
}
void Item :: operator ++( ) //Operator Overloading for
operator ++ defined
{
++x;
}
{
++x;
}
void main( )
{
Item e1,e2; //Object e1 and e2 created
cout<<”Before Increment”
cout <<”\nObject e1: ”<<e1.display();
cout <<”\nObject e2: ”<<e2.display();
++e1; //Operator overloading applied
++e2;
cout<<”\n After Increment”
cout <<”\nObject e1: ”<<e1.display();
cout <<”\nObject e2: ”<<e2.display();
}
{
Item e1,e2; //Object e1 and e2 created
cout<<”Before Increment”
cout <<”\nObject e1: ”<<e1.display();
cout <<”\nObject e2: ”<<e2.display();
++e1; //Operator overloading applied
++e2;
cout<<”\n After Increment”
cout <<”\nObject e1: ”<<e1.display();
cout <<”\nObject e2: ”<<e2.display();
}
The output of the above program is:
Before Increment
Object e1:
Value of x is: 0
Object e1:
Value of x is: 0
Before Increment
Object e1:
Value of x is: 1
Object e1:
Value of x is: 1
Object e1:
Value of x is: 0
Object e1:
Value of x is: 0
Before Increment
Object e1:
Value of x is: 1
Object e1:
Value of x is: 1
In the above example we have created 2 objects e1 and e2 f class
Item. The operator ++ is overloaded and the function is defined
outside the class Item. When the program starts the constructor Item
of the class Item initialize the values as zero and so when the
values are displayed for the objects e1 and e2 it is displayed as
zero. When the object ++e1 and ++e2 is called the operator
overloading function gets applied and thus value of x gets
incremented for each object separately. So now when the values are
displayed for objects e1 and e2 it is incremented once each and gets
printed as one for each object e1 and e2. This is how unary operators
get overloaded. We will see in detail how to overload binary
operators in next section.
Operator Overloading – Binary Operators
Binary operators, when overloaded, are given new functionality. The
function defined for binary operator overloading, as with unary
operator overloading, can be member function or friend function.
The difference is in the number of arguments used by the function. In
the case of binary operator overloading, when the function is a
member function then the number of arguments used by the operator
member function is one (see below example). When the function defined
for the binary operator overloading is a friend function, then it
uses two arguments.
Binary operator overloading, as in unary operator overloading, is
performed using a keyword operator.
Binary operator overloading example:
|
#include <iostream.h> class Item { private: int x; int y;
public:
Item() //Constructor { x=0; y=0; }
void getvalue( )
//Member Function for Inputting Values
{ cout << “\n Enter value for x: “; cin >> x; cout << “\n Enter value for y: “; cin>> y; }
void displayvalue( )
//Member Function for Outputting Values
{ cout <<”value of x is: “ << x <<”; value of y is: “<<y }
Item operator +(Item);
};
Item Item :: operator + (Item e2)
//Binary operator overloading for + operator defined { int x1 = x+ e2.x; int y1 = y+e2.y; return Item(x1,y1); }
void main( )
{ Item e1,e2,e3; //Objects e1, e2, e3 created cout<<\n”Enter value for Object e1:”; e1.getvalue( ); cout<<\n”Enter value for Object e2:”; e2.getvalue( ); e3= e1+ e2; //Binary Overloaded operator used cout<< “\nValue of e1 is:”<<e1.displayvalue(); cout<< “\nValue of e2 is:”<<e2.displayvalue(); cout<< “\nValue of e3 is:”<<e3.displayvalue(); } |
The output of the above program is:
Enter value for Object e1:
Enter value for x: 10
Enter value for y: 20
Enter value for Object e2:
Enter value for x: 30
Enter value for y: 40
Value of e1 is: value of x is: 10; value of y is: 20
Value of e2 is: value of x is: 30; value of y is: 40
Value of e3 is: value of x is: 40; value of y is: 60
Enter value for x: 10
Enter value for y: 20
Enter value for Object e2:
Enter value for x: 30
Enter value for y: 40
Value of e1 is: value of x is: 10; value of y is: 20
Value of e2 is: value of x is: 30; value of y is: 40
Value of e3 is: value of x is: 40; value of y is: 60
In the above example, the class Item has created three objects e1,
e2, e3. The values are entered for objects e1 and e2. The binary
operator overloading for the operator ‘+’ is declared as a member
function inside the class Item. The definition is performed outside
the class Item by using the scope resolution operator and the keyword
operator.
The important aspect is the statement:
e3= e1 + e2;
The binary overloaded operator ‘+’ is used. In this statement,
the argument on the left side of the operator ‘+’, e1, is the
object of the class Item in which the binary overloaded operator ‘+’
is a member function. The right side of the operator ‘+’ is e2.
This is passed as an argument to the operator ‘+’ . Since the
object e2 is passed as argument to the operator’+’ inside the
function defined for binary operator overloading, the values are
accessed as e2.x and e2.y. This is added with e1.x and e1.y, which
are accessed directly as x and y. The return value is of type class
Item as defined by the above example.
There are important things to consider in operator overloading with
C++ programming language. Operator overloading adds new functionality
to its existing operators. The programmer must add proper comments
concerning the new functionality of the overloaded operator. The
program will be efficient and readable only if operator overloading
is used only when necessary.
Some
operators cannot be overloaded:
scope resolution operator denoted by ::
member access operator or the dot operator denoted by .
The conditional operator denoted by?
and pointer to member operator denoted by .*
scope resolution operator denoted by ::
member access operator or the dot operator denoted by .
The conditional operator denoted by?
and pointer to member operator denoted by .*
No comments:
Post a Comment