Scribd
Upload
1 views6 pages

Operator Overloading

Uploaded by

valvi kuldip
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
1 views6 pages

Operator Overloading

Uploaded by

valvi kuldip
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 6

C++ Operators Overloading

Operator overloading is a compile-time polymorphism in which the


operator is overloaded to provide the special meaning to the user-
defined data type. Operator overloading is used to overload or
redefines most of the operators available in C++. It is used to perform
the operation on the user-defined data type. For example, C++ provides
the ability to add the variables of the user-defined data type that is
applied to the built-in data types.

The advantage of Operators overloading is to perform different


operations on the same operand.

Operator that cannot be overloaded are as follows:

o Scope operator (::)


o Sizeof
o member selector(.)
o member pointer selector(*)
o ternary operator(?:)

Syntax of Operator Overloading

1) Declaration

Return type operator op()

Body

2)Defin oprator function

return_type class_name : : operator op(argument_list)


{
// body of the function.
}
 Where the return type is the type of value returned by the
function.
 class_name is the name of the class.
 operator op is an operator function where op is the operator
being overloaded, and the operator is the keyword.

3)Calling/invoke operator

Whenever we want to call operator overloading function.

Syntax

Operator sign objectname;

Ex

-s1;

 Operator Overloading can be done by using three approaches, they


are
1. Overloading unary operator.
2. Overloading binary operator.
3. Overloading binary operator using a friend function.

Rules for Operator Overloading

o Existing operators can only be overloaded, but the new operators


cannot be overloaded.
o The overloaded operator contains atleast one operand of the
user-defined data type.
o We cannot use friend function to overload certain operators.
However, the member function can be used to overload those
operators.
o When unary operators are overloaded through a member
function take no explicit arguments, but, if they are overloaded by
a friend function, takes one argument.
o When binary operators are overloaded through a member
function takes one explicit argument, and if they are overloaded
through a friend function takes two explicit arguments.

Overloading Unary Operator: Let us consider to overload


1)
(-) unary operator. In unary operator function, no
arguments should be passed. It works only with one class
objects. It is a overloading of an operator operating on a
single operand.
o Example:
Write a program to overload unary minus(-) operator.

#include<iostream.h>
#include<conio.h>
class temp
{
int x,y,z;
public:
void getdata(int a,int b,int c)
{
x=a;
y=b;
z=c;
}

void display()
{
cout<<”x=”<<x<<endl;
cout<<”y=”<<y<<endl;
cout<<”z=”<<z<<endl;
}
void operator –() // operator overloading function
{
x=-x;
y=-y;
z=-z;
}
};
temp t;
t.getdata(10,-20,30);
cout<<”before overloading”;
t.display();
-t; // invoke operator overloading function
cout<<”after overloading”;
t.display();
getch();
return 0;
}

out put

before overloading
x=10
y=-20
z=30
after overloading
x=-10
y=20
z=-30

Overloading Binary + Operator


It is an overloading of an operator operating on two operands. Let’s
take the same example of class Height, but this time, add two Height
objects h1 and h2.

#include <iostream>
#include<conio.h>
class Height
{
public:
int feet, inch;
Height() // default constructor
{
feet = 0;
inch = 0;
}
Height(int f, int i) //parameterized constructor
{
feet = f;
inch = i;
}
// Overloading (+) operator to perform addition of
// two distance object using binary operator

Height operator+(Height& d2) // Call by reference


{
Height h3; // Create an object to return
h3.feet = feet + d2.feet; // Perform addition of feet and inches
h3.inch = inch + d2.inch;
return h3; // Return the resulting object
}
};

int main()
{
Height h1(3, 7);
Height h2(6, 1);
Height h3;
h3 = h1 + h2; //Use overloaded operator
cout << "Sum of Feet & Inches: " << h3.feet << "'" << h3.inch << endl;
getch();
return 0;
}
Output:

You might also like