Operator Overloading
3 minute read
Operator
overloading
1. List the operators which cannot be overloaded?
Ø only operators
that cannot be overloaded are:
ü Class member
access operators (., .*).
ü Scope resolution
operator (::).
ü Size operator (sizeof).
ü Conditional
operator (?:).
2.
List the
operators that a friend cannot be used?
v
Operators
that a friend cannot be used are,
|
Operator
|
-
|
Function
|
|
=
|
-
|
Assignment operator
|
|
()
|
-
|
Function
call operator
|
|
[]
|
-
|
Subscripting operator
|
|
->
|
|
Class member access
operator
|
3.
What is operator
overloading? Explain with example?
Ø C++ has the
ability to provide the operators with a special meaning for a data type.
Ø The mechanism of
giving such special meanings to an operator is known as operator over leading.
Ø Operator
overloading provides a flexible option for the creation of new definitions for
most of the C++ operators.
Ø Although the
semantics of an operator can be extended the syntax, grammatical rules,
precedence, and associativity cannot be changed.
Ø For example,
multiplication operator will enjoy higher precedence than the addition
operator.
Ø When an operator
is overloaded, its original meaning is not lost.
v
Syntax:
return-type
class-name :: operator op (argument-list)
{
: : : : : : // function body
}
v
Example:
# include <iostream.h>
class space
{
int X;
public:
void getdata
(int a)
{
X = a;
}
void display
(void)
{
cout << X
<< “\n”;
}
void operator -
()
{
X = -X;
}
};
int main ()
{
space S;
S. getdata (10);
cout << “S
: ”;
S.display ();
-S;
cout <<
“S:”; S.display ();
return 0;
}
v
Output
of the above program:
S: 10
S : -10
4.
What is an
operator function? Describe the syntax of an operator function?
v
To
define an additional task to an operator, we must specify what is means in
relation to class to which operator is applied; this is done with the help of a
special function, called operator function, which describes the task.
v
Syntax:
return-type class-name :: operator op
(argument-list)
{
//Function body
}
v
Where
return-type is the type of value returned by the specified operation and ‘op’
is the operator being overloaded.
v
The
op is preceded by the keyword operator.
v
Operator
op is the function name.
v
Operator
function must be either member functions (non-static) or friend functions.
5.
When we need
operator function as a friend?
By using either a friend function or a member
function we get the same result.
Ø But, there we
certain situations where we would like to use a friend function rather than a
member function.
Ø For example,
consider a situation where we need to use two different types of operand for a
binary operator, say, one as an object and another as a built-in-type data.
Ø Example:
A = B + 2; (or A
= B * 2;)
Ø where A and B
are objects of the same class.
Ø But for the
statement,
A = 2 + B; (or A
= 2 B;)
Ø will not work
for member function, for that we need friend function.
Ø It works with
friend function because an object need not be used to invoke a friend function.
6. What are the
rules for overloading operators?
Ø
Only
existing operators can be overloaded. New operators cannot be created.
Ø
The
overloaded operator must have at least one operand that is of user-defined
type.
Ø
We
cannot change the basic meaning of an operator. That is to say, we cannot
redefine the plus(+) operator to subtract one value from the other.
Ø
Overloaded
operators follow the syntax rules of the original operators. They cannot be
overridden.
Ø
There
are some operators that cannot be overloaded.
Ø
We
cannot use friend function to overload certain operators. However, member
functions can be used to overload them.
Ø
Unary
operators, overloaded by means of a member function, take no explicit arguments
and return no explicit values, but, those overloaded by means of a friend
function, take one reference argument.
Ø
Binary
operators overloaded through a member function take no explicit argument and those
which are overloaded through a friend function take two explicit arguments.
Ø
When
using binary operators overloaded through a member function, the left hand
operand must be an object of the relevant class.
Ø
Binary
arithmetic operators such as +,-,*, and / must explicitly return a value. They
must not attempt to change their own arguments.