Inheritance and Operator Overloading

Inheritance
And
Operator
Overloading
By
Bhagwant Singh
Content
Ambiguity of Multiple inheritance.
Virtual base Classes
Abstract Classes
Constructor in derived Classes
Member Classes: Nesting of Classes
Operator Overloading.
Overloading Unary Operators
Overloading Binary Operators
Overloading Binary Operators using Friends
Manipulation of strings using Operators
Some other Operator Overloading Examples.
Rules for Overloading Operators
Type Conversions.
Multiple Inheritances
It
is that in which a Class inherits the

features from two Base Classes.
In multiple inheritance, there may be
possibility that a class may inherit
member functions with same name from
two or more base classes . It leads to
two ambiguities
Identical Member in more than one class.

Diamond-shape inheritance.
Solution for MI Ambiguity

Using
Scope resolution Operator.

Using :: we can address which base class we are pointing to.
Using Virtual Class.
This solution is effective for the Diamond shape problem and
this will be happen in case of Hybrid inheritance .
For example if we have a child class which is inheriting
properties from two parent classes which them self are
derived from the Grand parent class.
The child inherits the traits of grandparent from two separate
paths.
All the public and protected member of grandparent are
inherited twice.
Grandparent class act as the Indirect Base class.
This Problem can be solved by making the Indirect base class
as virtual.
Class A
{
..
..
};
Class B: virtual public A // Inheriting Class A as Virtual and public
{
..
Hierarchical
..
Inheritance
};
Class B1: virtual public A // Inheriting Class A as Virtual and public
{
..
..
};
Class C: Public B, Public B1
{
ance
..
..
};
Multiple
Inherit
Abstract Classes
A
class is consider as Abstract Class if it has at

least one pure virtual function.
It is the one which are not used to create objects.
It is created or designed only to act as a base
class.
It is a design concepts in program development
and provide a base upon which other class may
be built.
Constructors
They are the special member function used

to initialize the data variable of class.
Constructor of base class cant be inherited
but the derived class can use it.
It no base class constructors takes any
arguments the derived class need not to
have constructor function.
If base class constructor contain a
constructor with one or more argument
then in derived class constructor has to
pass the argument to base class.
Example
# include < iostream.h>
Using namespace std;
Class A
{
Int x;
Public:
A(int i)
{
X= I;
}
Void show_x(void)
{
Cout<<x = << x<<\n;
}
};
Class B
{
float y;
Public:
B(float j)
{
y= j;
}
Void show_y(void)
{
Cout<<y = << y<<\n;
}
};
Class C: public A, public B

{
Int m,n;
Public:
C(int a, float b, int c,int d): A(a),B(b)
{
m= c;
n = d;
}
Void show_mn(void)
{
Cout<<m = << m<<\n;
Cout<<n = << n<<\n;
}
};
Int Main()
{
C c(5,10.75,20,30);
Cout<<\n;
g.show_x();
g.show_y();
g.show_mn();
return 0;
}
Initialization List in Constructor

Class xyz
{
Int a;
Int b;
Public:
xyz(int I, int j):a(i),b(2*j + i){}
};
Void Main()
{
Xyz x(2,3);
}
Overloading
Overloaded functions have the same name but

different signatures ( different parameters and
return values).
In reality Operator Overloading is just a function

call using special notation.
Operator overloading is done for the purpose of

making the use of familiar notation in your
program. For instance, let us say you wanted to
add two matrices. You could overload the +
operator to accomplish this.
Why Operator Overloading?

Readable
code
Extension of language to include userdefined types
I.e., classes
Make
operators sensitive to context
Generalization
of function overloading
General Format
returnType operator*(parameters);
any type
Return
keyword
operator symbol
type may be whatever the operator
returns
Including a reference to the object of the operand
Operator
symbol may be any overloadable

operator from the list.
Either
a non-static member function definition
or
a global function definition
Usually a friend of the class
C++ Philosophy
All operators have context
Even the simple built-in operators of basic

types
E.g., '+', '-', '*', '/' for numerical

types
Compiler generators different code
depending upon type of operands
Operator overloading is a generalization

of this feature to non-built-in types
E.g., '<<', '>>' for bit-shift operations and

also for stream operations
Continued
Operators
retain their precedence and

associativity, even when overloaded
Operators
Cannot
Not
retain their number of operands
redefine operators on built-in types
possible to define new operators
Only
(a subset of) the built-in C++ operators

can be overloaded
Operators that Can and

Cannot be Overloaded *
Operator Functions as Class

Members*
Leftmost
operand must be of same class as

operator function.
Use this keyword to implicitly get left
operand argument.
Operators (), [], -> or any assignment
operator must be overloaded as a class
member function.
Called when
Left operand of binary operator is of this class.
Single operand of unary operator is of this class.
Operator Functions as Global

Members
Need
parameters for both operands.
Can
have object of different class than

operator.
Can
be made a friend to access

private or protected data.
Overloading Unary Operator

#include <iostream.h>
Class space
{
Int x;
Int y;
Int z;
Public:
Void getdata(int a, int b, int c);
Void display(void);
Void operator ();
};
Void space :: getdata(int a,int b, int c)
{
x= a;
y= b;
z= c;
}
Void space :: display(void)
{
Cout<x= << x<< ;
Cout<x= << x<< ;

Cout<x= << x<< ;
}
Void space :: operator-()
{
x= -x;
y = -y;
z= -z;
}
Int main()
{
space S;
S.getdata(10,-20,30);
Cout<< S: ;
S.display();
-S;
Cout<< -S : ;
S.display();
Return 0;
}
Using Friend Function

friend void operator (space &s);
Declaration
Void operator (space &s)
{
s.x = = s.x;
s.y = = s.y;
s.z = = s.z;
}
Definition
Overloading of Binary Operator *

#include <iostream.h>
Class complex
{
Float x;
float y;
public:
complex(){}
complex(float real, float img)
{ x= real; y= img;
}
complex operator +(complex);
void display(void)
};
complex complex:: operator +
(complex c)
{
complex temp;
temp.x = x + c.x;
temp.y= y + c.y;
Return (temp);
Void complex:: display(void)

{
Cout<< x<< +j <<y<<\n;
}
Int main ()
{
complex c1,c2,c3;
c1 = complex(2.5,3.5);
c2= complex(1.6,2.7);
c3= c1 +c2;
cout<< c1 = ;
c1.display();
cout<< c2 = ;
c2.display();
cout<< c3 = ;
c3.display();
Return 0;
}
Overloading of Binary Operator

using Friend function
friend complex operator +(complex,
complex);
Declaration
complex operator (complex a, complex b)
{
Return complex((a.x + b.x),(a.y +b.y))
}
Definition
If we are using the friend function then we have to

pass two arguments, then why and in which
situation we need to used a friend function for
operator overloading??
Manipulation of string using

operators.
ANSI
C implement string using character

array, pointer and string functions.
There are no operator for manipulating
the strings
C++ committee has added a new class
called strings to the C++ class library
that support all types of string
manipulations.
C++ Code
# include<iostream.h>
#include<string.h>
Class string
{
Char *p;
Int len;
Public:
string(){len = 0; p=0;}
string (const char *s);
string(const string &s);
~ string (){ delete p;}
Friend string operator + (const string &s, const string &t);
Friend void show(const string s);
};
String:: string (const char *s)
{ len = strlen(s);
p = new char[len+1];
Strcpy(p,s);
}
String:: string (const string &s)
{ len = strlen(s);
p = new char[len+1];
Strcpy(p,s.p);
}
String operator + (const string&s, const string &t)
{
String temp;
Temp.len = s.len + t.len;
Temp.p = new char[temp.len+1];
Strcpy(temp.p,s.p);
Strcat(temp.p, t.p);
Return(temp);
}
Int operator<=(const string &s, const string &t)

{
Int m = strlen(s.p);
Int n = strlen(t.p);
if(m<=n) return(1) else return(0);
}
Void show(const string s)
{
Cout<<s.p;
}
Int main()
{ string s1 = new; s2 = york; s3=delhi;
String st1,st2,st3;
St1 = s1;
St2 = s2;
St3 = s1+s3;
Cout<< \n st1 =<< show(st1);
Cout<< \n st2 =<< show(st2);
Cout<< \n st3 =<< show(st3;
If(st1<= st3)
{
Show(st1);
Cout<<Smaller then;
Show(st3);
}
Else
{
Show(st3);
Cout<<Smaller then;
Show(st1);
}
Return 0;
}
Rules of Overloading
Only existing operators can be overloaded
The overloaded operator must have at least one
operand that is user defined type
Overloaded operator follows the syntax rule of
original operator
There are some operator that cant be overloaded.
(. |.*|::|?:|)
There are some operator that cant be overloaded
using friend function.(=|()|[]|->)
Binary arithmetic operator must explicitly return a
value.
Type conversion
Type
conversion in C: (typename) expression

Type conversion in C++: typename(expression)
Assignment operator cause automatic type
conversion.( as long as we are talking about builtin types)
Three types of situations
Conversion of basic type to class type

Conversion of class type to base type
Conversion of class type to class type
Base to Class Type

It
is most simple and can be done with the help of constructors

Class time
{
int hrs;
int mins;
public:
time(int t)
{
hrs = t/60;
mins= t%60; }
};
void main()
{
Time t1;
Int duration = 85;
t1= duration
}
Class to Base type

Overloaded
casting operator
Operator typename()
{}
Satisfy following conditions:
It must be a class member

It must not specify a return type
It must not have any argument.
Class to class type

Can
be done using a casting operator

function or a constructor.
Conversion from class y to class x take
place then y is the source class and x is
the destination class
Depending upon location of the casting
operator function decision between the
constructor and CO function is made
=
Obj x
Obj y
Class Y(Source
Class)
Casting Operator
Function
Conversion here
Class X(Destination
Class
Constructor Function
Conversion here
Class Y(Source
Class)
Data assess
function
#include<iostream>
Class invert1;
Class invert2;
Class invert1
{
Int code;
Int item;
Float price;
Public: invent1(int a, int b, float c)
{
Code = a;
Item = b;
Price c;
}
Void putdata()
{
Cout<< code: << code <<\n;
Cout<< item: << item <<\n;
Cout<< price: << price <<\n;
}
Int getcode() { return code;}
Int getitem(){ return item;}
Float getprice() {return price;}
Operator float(){ return (item*price);
};
Class invent2
{
Int code ;
Float value;
Public:
Invent2()
{
Code = 0; value 0;
}
Invent2(int x, float y)
{
Code = x;
Value = y;
}
Void putdata()
{
Cout<<code: << code << \n;
Cout<<value: << value << \n;
}
Invent2(invent1 p)
{
Code = p.getcode();
Value =p.getitem();*p.getprice();
}
};
Int main()
{
Invent1 s1(100,5,140.0);
Invent2 d1;
Float total_value;
Total_value = s1;
D1= s1;
Cout<<product details invent1 type<<\n;
S1.putdata();
Cout<<\n stock value<<\n;
Cout<<value= << total_value<<\n\n;
Cout<<product details-invent2 type<<\n;
D1.putdata();
Return 0;
}
Thanks

Inheritance and Operator Overloading

Uploaded by

Copyright:

Available Formats

Inheritance and Operator Overloading

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Inheritance and Operator Overloading

Uploaded by

Copyright:

Available Formats

What are some ways to solve the ambiguity problems of multiple inheritance?

What are some ways to solve the ambiguity problems of multiple inheritance?

What is an abstract class and how is it used?

What is an abstract class and how is it used?

Inheritance

is that in which a Class inherits the

Identical Member in more than one class.

Solution for MI Ambiguity

Scope resolution Operator.

class is consider as Abstract Class if it has at

They are the special member function used

Class C: public A, public B

Initialization List in Constructor

Overloaded functions have the same name but

In reality Operator Overloading is just a function

Operator overloading is done for the purpose of

Why Operator Overloading?

operators sensitive to context

type may be whatever the operator

Including a reference to the object of the operand

symbol may be any overloadable

a non-static member function definition

Usually a friend of the class

All operators have context

Even the simple built-in operators of basic

E.g., '+', '-', '*', '/' for numerical

Operator overloading is a generalization

E.g., '<<', '>>' for bit-shift operations and

retain their precedence and

retain their number of operands

redefine operators on built-in types

possible to define new operators

(a subset of) the built-in C++ operators

Operators that Can and

Operator Functions as Class

operand must be of same class as

Operator Functions as Global

parameters for both operands.

have object of different class than

be made a friend to access

Overloading Unary Operator

Cout<x= << x<< ;

Using Friend Function

Overloading of Binary Operator *

Void complex:: display(void)

Overloading of Binary Operator

If we are using the friend function then we have to

Manipulation of string using

C implement string using character

Int operator<=(const string &s, const string &t)

conversion in C: (typename) expression

Conversion of basic type to class type

Base to Class Type

is most simple and can be done with the help of constructors

Class to Base type

It must be a class member

Class to class type

be done using a casting operator

You might also like