operator overloading

1. UNIT III
Overloading
09/04/131 VIT - SCSE
By
G.SasiKumar., M.E., (Ph.D).,
Assistant Professor
School of Computing Science and Engineering
VIT University

2. Functions in C++
Experience has shown that the best way to develop and
maintain large programs is to construct it from smaller pieces
(Modules)
This technique Called “Divide and Conquer”
•Easer To
Design
Build
Debug
Extend
Modify
Understand
Reuse
Better Organization
Wise Development Approach
main()
{
-----
----
}
function f1()
{
---
---
}
function f2()
{
---
---
}

3. Function Overloading
C++ supports writing more than one function with the same
name but different argument lists. This could include:
different data types
different number of arguments
The advantage is that the same apparent function can be
called to perform similar but different tasks. The following
will show an example of this.

4. Function Overloading
void swap (int *a, int *b) ;
void swap (float *c, float *d) ;
void swap (char *p, char *q) ;
int main ( )
{
int a = 4, b = 6 ;
float c = 16.7, d = -7.89 ;
char p = 'M' , q = 'n' ;
swap (&a, &b) ;
swap (&c, &d) ;
swap (&p, &q) ;
}
void swap (int *a, int *b)
{ int temp; temp = *a; *a =
*b; *b = temp; }
void swap (float *c, float *d)
{ float temp; temp = *c; *c =
*d; *d = temp; }
void swap (char *p, char *q)
{ char temp; temp = *p; *p
= *q; *q = temp; }

5. 09/04/135 VIT - SCSE
• Operator Overloading refers to giving the normal C++ Operators,
such as +,*,<= etc., additional meanings when they are applied
to user defined data types.
• Simply defined as to create new definitions for operators.
Syntax :
<ret.datatype> operator <operator name>()
{
---
---
}
Operator Overloading

6. The steps involved an operator are :
1. Create a class that defines a data type that is to be
used in the overloading operation
2. Declare the operator function as either a member
function or a friend function inside the class
3. Define the operator function either inside or outside
the class
4. Use the operator in the main() function

7. • All the operators can be overloaded using friend
function except () [] -> and =. These operators must be
defined by using a member function.
ASSIGNMENT OPERATOR OVERLOADING RULES :
• The operator function for the assignment operator are
inherited by any derived class.
• Friend functions cannot be used to overload the
assignment operator

8. The operators that can be overloaded
are
+ - * / % ^ &
| _ != < > <= >= +=
-+ *= != ++ -- [ ] ()
|| &= && -> , new delete
The operators that cannot be overloaded are
#
.(member operator)
::
sizeof
?:

9. 09/04/139 VIT - SCSE
class sample
{
private:
int x;
float y;
public:
sample(int,float);
void operator =(sample s);
void display();
};
sample::sample(int one,float
two)
{
x=one;
y=two;
}
void sample::operator =(sample s)
{
x=s.x;
y=s.y;
}
void sample::display()
{
cout<<”integer
number(x)=:”<<x<<endl;
cout<<”floating
value(y)=:”<<y<<endl;
cout<<endl;
}
(Unary)Overloading Assignment Operator (=)

10. 09/04/1310 VIT - SCSE
void main()
{
sample ob1(10,4.5);
sample ob2(20,6.2);
ob1=ob2;
cout<<”contents of the first object n”;
ob1.display();
cout<<”contents of the second object n”;
ob2.display();
}

11. 09/04/1311 VIT - SCSE
class sample
{
private :
int x;
public :
sample()
{
x=0;
}
int getcount()
{
return x;
}
sample operator ++()
{
++x;
sample t;
t.x=x;
return t;
}};
void main()
{
sample s1,s2;
cout<<"s1
="<<s1.getcount()<<endl;
cout<<"s2
="<<s2.getcount()<<endl;
++s1;
s2=++s1;
cout<<"s1
="<<s1.getcount()<<endl;
cout<<"s2
="<<s2.getcount()<<endl;
getch();
}
Overloading ++ Operator
OUTPUT :
s1 = 0
s2 = 0
s1 = 2
s2 = 2

12. 09/04/1312 VIT - SCSE
class sample
{
private:
int x;
public:
sample();
sample(int);
sample operator +(sample
s);
void display();
};
sample::sample()
{
x=0;
}
sample::sample(int one)
{
x=one;
}
sample sample::operator +
(sample s)
{
sample t;
t.x=x+s.x;
return(t);
}
void sample::display()
{
cout<<”X=”<<x<<endl;
}
(Binary) Overloading Arithmetic Operators (+)

13. 09/04/1313 VIT - SCSE
void main()
{
sample ob1(10);
sample ob2(20);
sample ob3;
ob3=ob1+ob2;
ob1.display();
ob2.display();
ob3.display();
} OUTPUT :
X=10
X=20
X=30

14. 09/04/1314 VIT - SCSE
class sample
{
private:
int x;
public:
sample();
sample(int);
sample operator -(sample
s);
void display();
};
sample::sample()
{
x=0;
}
sample::sample(int one)
{
x=one;
}
sample sample::operator -
(sample s)
{
sample t;
t.x=x-s.x;
return(t);
}
void sample::display()
{
cout<<”X=”<<x<<endl;
}
(Binary) Overloading Arithmetic Operators (-)

15. 09/04/1315 VIT - SCSE
void main()
{
sample ob1(10);
sample ob2(20);
sample ob3;
ob3=ob1-ob2;
ob1.display();
ob2.display();
ob3.display();
} OUTPUT :
X=10
X=20
X=-10

16. #include<iostream.h>
const int SIZE=5;
class test
{
private :
int a[SIZE];
public:
int operator [] (int i)
{
return i;
}
};
void main()
{
test t1;
int i;
OVERLOADING THE SUBSRIPTOPERATOR [ ]
for(i=1;i<=SIZE;i++)
{
// control is transferred to the operator
function call int operator [] (int i)
cout<<t1[i]<<"t";}
}
OUTPUT :
1
2
3
4
5

17. 09/04/1317 VIT - SCSE
class sample
{
private:
int x;
public:
sample();
sample(int one);
void display();
int operator <(sample s);
};
sample::sample()
{
x=0;
}
sample::sample(int one)
{
x=one;
}
void sample::display()
{
cout<<"X="<<x<<endl;
}
int sample::operator <(sample s)
{
return (x<s.x);
}
void main()
{
sample ob1(20);
sample ob2(100);
cout<<(ob1<ob2)<<endl;
cout<<(ob2<ob1)<<endl;
getch();
}
Overloading Arithmetic Comparison Operators (<)
OUTPUT :
1
0

18. 09/04/1318 VIT - SCSE
class sample
{
private:
int x;
public:
sample();
sample(int);
sample operator +=(sample s);
void display();
};
sample::sample()
{
x=0;
}
sample::sample(int one)
{
x=one;
}
sample sample::operator +=(sample s)
{
return(x+=s.x);
}
void sample::display()
{
cout<<"X="<<x<<endl;
}
void main()
{
sample ob1(10);
sample ob2(20);
ob1.display();
ob2.display();
ob2+=ob1;
ob1.display();
ob2.display();
}
Overloading Compound Assignment Operator (+=)
OUTPUT :
X=10
X=20
X=10
X=30

19. 09/04/1319 VIT - SCSE
class sample
{
private:
int x;
public:
sample();
sample(int one);
void display();
int operator <=(sample s);
};
sample::sample()
{
x=0;
}
sample::sample(int one)
{
x=one;
}
void sample::display()
{
cout<<"X="<<x<<endl;
}
int sample::operator <=(sample s)
{
return (x<=s.x);
}
void main()
{
sample ob1(20);
sample ob2(100);
cout<<(ob1<=ob2)<<endl;
cout<<(ob2<=ob1)<<endl;
getch();
}
Overloading Compound Assignment Operator (<=)
OUTPUT :
1
0

20. Increment and Decrement Operators
We have used n++; and ++n; to replace for n = n + 1;
and we have used --n and n--; to replace for n = n - 1;
The expressions n++ and ++n have values.
The expression n++ returns the value of n before to
incrementing, then increments the value of n.
++n increments the value of n, then returns the
incremented value.
The expressions n-- and --n have values as well.
The expression n-- returns the value of n before to
decrementing, then decrements the value of n.
--n decrements the value of n, then returns the decremented
value.

21. Overloading ++ and - -
With C++, you use ++ to increment variables, and - -
to decrement variables
When a prefix operator such as ++ is used in an
expression, the mathematical operation takes place
before the expression is evaluated
When the postfix operator is used, the expression is
evaluated before the mathematical operation takes
place

22. Using the Prefix and Postfix ++
Operators with an Integer

23. Generic Programming for Templates
A methodology for the development of reusable software
libraries
Three primary tasks:
Categorize the abstractions in a domain into concepts
Implement generic algorithms based on the concepts
Build concrete models of the concepts
Concepts make templates easier to use
Express requirements directly in code
Provide complete type-checking of templates

24. Characteristics of Generic Libraries
Reusable: able to operate on user-defined data types
Composable: able to operate on data types defined in
another library
Efficient: performance on par with non-generic, hand-
coded implementations

25. C++ Templates
 C++ Function Templates
-- C++ Function templates are those functions which can
handle different data types without separate code for each of
them.
 C++ Class Templates
-- C++ Class Templates are used where we have multiple
copies of code for different data types with the same logic.

26. Templates
Constructs a family of related functions or class
Different Approach – Function
Example 1 & 2 : int Add(int a,int b) { return a+b;} // function Without C++ template
float Add(float a, float b) { return a+b;} // function Without C++ template
1. Naïve Approach
Different Function Definitions
Different Function Names
2. Function Overloading
Different Function Definitions
Same Function Name
3. Template Functions
One Function Definition (a function template)
Compiler Generates Individual Functions

27. Approach 3: Function Template
• A C++ language construct that allows the compiler
to generate multiple versions of a function by
allowing parameterized data types.
Template < TemplateParamList >
FunctionDefinition
FunctionTemplate
TemplateParamDeclaration: placeholder
class typeIdentifier
typename variableIdentifier

28. Example of a Function Template
template<class T>
T Add(T a,T b)//C++ Fucntion Template sample
{
return a+b;
}
Template parameter
(class, user defined
type, built-in types)

29. Class Template
• A C++ language construct that allows the compiler
to generate multiple versions of a class by allowing
parameterized data types.
Template < TemplateParamList >
ClassDefinition
Class Template
TemplateParamDeclaration: placeholder
class typeIdentifier
typename variableIdentifier

30. Example of a Class Template
template<class ItemType>
class GList
{
public:
bool IsEmpty() const;
bool IsFull() const;
int Length() const;
void Insert( /* in */ ItemType item );
void Delete( /* in */ ItemType item );
bool IsPresent( /* in */ ItemType item ) const;
void SelSort();
void Print() const;
GList(); // Constructor
private:
int length;
ItemType data[MAX_LENGTH];
};
Template
parameter

31. Advantages of C++ Class Templates:
One C++ Class Template can handle different types of
parameters.
Compiler generates classes for only the used types. If the
template is instantiated for int type, compiler generates only
an int version for the c++ template class.
Templates reduce the effort on coding for different data types
to a single set of code.
Testing and debugging efforts are reduced.

32. Standard Template Library
In the late 70s Alexander Stepanov first observed that some
algorithms do not depend on some particular
implementation of a data structure but only on a few
fundamental semantic properties of the structure
Developed by Stepanov and Lee at HP labs in 1992
Become part of the C++ Standard in 1994

33. What’s in STL?
Container classes: vector, list, deque, set, map, and etc…
A large collection of algorithms, such as reverse, swap, heap,
and etc.
Vector
A sequence that supports random access to elements
Elements can be inserted and removed at the beginning, the
end and the middle
Constant time random access
Commonly used operations
begin(), end(), size(), [], push_back(…), pop_back(), insert(…),
empty()

34. Recap
Templates are mechanisms for generating functions
and classes on type parameters. We can design a single
class or function that operates on data of many types
function templates
class templates