Upload
asasasas
View
30
Download
1
Embed Size (px)
DESCRIPTION
Inheritance and Operator Overloading
Citation preview
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