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 Multiple{ Inheritance…..…..};

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 can’t 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 ConstructorClass 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 user-

defined typesI.e., classes

Make operators sensitive to context

Generalization of function overloading

General FormatreturnType operator*(parameters);

any type keyword operator symbol

Return 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 retain their number of operands

Cannot redefine operators on built-in types

Not possible to define new operators Only (a subset of) the built-in C++ operators

can be overloaded

Operators that Can and Cannot be Overloaded * Operators that can be overloaded

+ - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= && || ++ -- ->* , -> [] () new delete new[] delete[]

Operators that 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>Using namespace std;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);DeclarationVoid operator – (space &s){s.x = = s.x;s.y = = s.y;s.z = = s.z;}Definition

Overloading of Binary Operator *#include <iostream.h>Using namespace std;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 can’t be overloaded.

(. |.*|::|?:|) There are some operator that can’t 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 built-in 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

=

Conversion here

Conversion here

Casting Operator Function

Constructor Function

Obj x Obj y

Class Y(Source Class)

Class X(Destination Class

Data assess function

Class Y(Source Class)

#include<iostream>Using namespace std;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