Unit III Virtual Functions. Developed By Ms. K.M.Sanghavi

Transcription

1 Unit III Virtual Functions Developed By Ms. K.M.Sanghavi

2 Topics Pointers- indirection Operators Memory Management: new and delete : Slide / (Covered In Unit I Too) Accessing Arrays using pointers : 25 Slide Function pointers Pointers to Objects Pointer to Pointers Linked List Example

3 Topics Smart pointers Shared pointers Unique Pointers

4 Introduction A pointer is a variable which contains the address (in memory) of another variable. Pointers are symbolic representation of addresses We can have a pointer to any variable type.

5

6

7 Declare Type of data stored in the address of the variable. Indirection operator

8

9 Declaring pointer Passing Address

10

11

12 Example #include <iostream.h> void main( ) int data = 100; float value = 56.47; data cout << data << &data << endl; cout << value << &value << endl; Output: 100 FFF FFF0 value FFF0 FFF1 FFF2 FFF3 FFF4 FFF5 FFF CSC Data Structures/Algorithms 12

13 //Demonstration. #include<conio.h> #include<iostream.h> void main() int x ; float y; Pointers. Every Block is a memory cell Cell no s / Address Memory x = 10; 10 x y 4007 y = 20.0; 20.0 cout<< Value s of x and y = <<x<<y; getch();

14 & * Pointer Operator s. Address of (Reference) Operator. Value At Address (Indirection) operator. void main() int *int_ptr; float *float_ptr; int x = 10 ; float y = 20.0; Value at Address. Address Name od address x cout<< Value s of x and y = <<x<< <<y; int_ptr = &x; float_ptr = &y; cout<<"int_ptr = "<<int_ptr; cout<<"\n float_ptr = "<<float_ptr; cout<<"\n value in int_pointer = "<< *int_ptr; cout<<"\n value in float_ptr = "<< *float_ptr; getch(); y

15 Pointers contd. & Address of (Reference) Operator. * Value At Address (Indirection) operator. // Demonstration. #include <iostream.h> #include<conio.h> void main () int variable ; int *mypointer; mypointer = &variable; *mypointer = 50; variable Address of variable = mypointer 50 = value at address cout << "value in variable is " <<variable<<endl; getch(); Value in variable is 50

16 //Demonstration #include <iostream.h> #include<conio.h> main () int x=10; int *y; int **z; cout<<"value of x = "<<x; cout<<"\nadd of x = "<<&x; cout<<"\nvalue of x = "<<*(&x); y=&x; cout<<"\nadd of y = "<<&y; cout<<"\nadd in y = "<<y; z=&y; cout<<"\nadd of z = "<<&z; cout<<"\nadd in z = "<<z; getch(); & Address of (Reference) Operator. * Value At Address (Indirection) operator x Value of x = 10 *y Add of x = 2554 Value of x = 10 Add of y = 5888 Add in y = 2554 Add of y = 6550 Add in z = **z

17 //Demonstration #include <iostream.h> #include<conio.h> main () int x=10; int *y; int **z; & Address of (Reference) Operator. * Value At Address (Indirection) operator x *y **z cout<<"value of x = "<<x; cout<<"\nadd of x = "<<&x; Value of x = 10 y=&x; cout<< Accessing x via ptr y = <<*y; Add of x = 2554 z=&y; x via prt y = 10 cout<< Accessing x via ptr z <<**z; getch(); x via prt z = 10

18 Facts & Address of (Reference) Operator. * Value At Address (Indirection) operator. 1. *& variable = variable 2. *(&)variable = *&variable Example 1 : int x =10; cout<<*&x; cout<<*(&)x; Example 2 : int x = 10; int * p; p = &x; cout<<* p; 10 10

19 Operations on Pointer Variables Assignment the value of one pointer variable can be assigned to another pointer variable of the same type Relational operations - two pointer variables of the same type can be compared for equality, and so on Some limited arithmetic operations integer values can be added to and subtracted from a pointer variable value of one pointer variable can be subtracted from another pointer variable 19

20

21

22 Example: Pointer Arithmetic #include <iostream.h> void main() int* p1; // simple way of defining pointers int* p2; int* p3; int x; p2 = &x; p1 = p2; p2 = p2 + 5; cout << (p2 - p1);// prints the number of elements // between the two pointers, which is 5 // p3 = p2 + p1; is illegal operation

23 Allowed Pointer Arithmetic Following are the allowed pointer operations: Subtraction of pointers results in the number of elements between the pointers Addition of integral values in pointers Add or subtract pointers with an integral value Adding two pointers is not allowed

24 Dynamic memory management new operator allocates memory and returns a pointer to the newly created object. When an object, that is allocated by new, is no longer referenced, an operator delete must be applied to the object, through its pointer, to avoid memory leakage

25 Cont. Example: string *str_ptr; str_ptr = new string("hello"); cout<< *str_ptr << endl; //Hellow cout<< (*str_ptr).length() <<endl; //5 delete str_ptr;

26 Relationship Between Pointers and Arrays Arrays and pointers closely related Array name like constant pointer Pointers can do array subscripting operations Accessing array elements with pointers Element b[ n ] can be accessed by *( bptr + n ) Called pointer/offset notation Addresses &b[ 3 ] same as bptr + 3 Array name can be treated as pointer b[ 3 ] same as *( b + 3 ) Pointers can be subscripted (pointer/subscript notation) bptr[ 3 ] same as b[ 3 ] 1

27

28 Pointers to arrays A pointer variable can be used to access the eleme of an array of the same type. int gradelist[8] = 92,85,75,88,79,54,34,96; int *mygrades = gradelist; cout << gradelist[1]; cout << *mygrades; cout << *(mygrades + 2); cout << mygrades[3]; Note that the array name gradelistacts like the pointer variable mygrades. 3

29 // Using subscripting and pointer notations with arrays. #include <iostream> using std::cout; using std::endl; int main() int b[] = 10, 20, 30, 40 ; int *bptr = b; // set bptr to point to array b // output array b using array subscript notation cout << "Array b printed with Array subscript notation\n"; for ( int i = 0; i < 4; i++ ) cout << "b[" << i << "] = " << b[ i ] << '\n'; Using array sub notation. // output array b using the array name and pointer/offset notation cout << "\npointer/offset notation where the pointer is the array name\n";

30 for ( int offset1 = 0; offset1 < 4; offset1++ ) cout << "*(b + " << offset1 << ") = " << *( b + offset1 ) << '\n'; // output array b using bptr and array subscript notation cout << "\npointer subscript notation\n"; for ( int j = 0; j < 4; j++ ) cout << "bptr[" << j << "] = " << bptr[ j ] << '\n'; cout << "\npointer/offset notation\n"; // output array b using bptr and pointer/offset notation for ( int offset2 = 0; offset2 < 4; offset2++ ) cout << "*(bptr + " << offset2 << ") = " << *( bptr + offset2 ) << '\n'; return 0; // indicates successful termination // end main

31

32 Arrays of Pointers Arrays can contain pointers Commonly used to store array of strings char *suit[ 4 ] = "Hearts", "Diamonds", "Clubs", "Spades" ; Each element of suit points to char * (a string) Array does not store strings, only pointers to strings suit[0] H e a r t s \0 suit[1] D i a m o n d s \0 suit[2] C l u b s \0 suit[3] S p a d e s \0 suitarray has fixed size, but strings can be of any size 7

33 Example // string and pointer example #include < iostream> using namespace std; int main ( ) int n; char *seasons [ ] = Winter, Spring, Summer, Fall ; cout << \n Enter a month (use 1 for Jan, 2 for Feb, etc): ;

34 Example (Cont..) cin >> n; n = (n % 12) / 3; // create the correct subscript cout << The month entered is a << seasons [ n // or * (seasons + n) << month << endl; return 0;

35 Example The following example is the modification to previous example in this case a function is used to print seasons. #include <iostream> using namespace std; void st_pt ( char *ys [ ], int n); int main ( ) int n; char *seasons [ ] = Winter, Spring, Summer, Fall ;

36 Example (Cont..) cout << \n Enter a month ( use 1 for Jan, etc.) : ; cin >> n; st_pt (seasons, n); return 0; void st_pt (char *ys [ ], int n)

37 Example (Cont..) n = (n%12)/3; cout << The month entered is a << *(ys + n) << month. <<endl;

38 Example (Cont..) The output of the above program is: Enter a month ( use 1 for Jan 2 for Feb, etc.) : 12 The month entered is a Winter month

39 Function Pointers Pointer that can hold function addresses is called Function Pointer Steps required are Define a function pointer Initialise the pointer with function address Call the function by using pointer While defining a function pointer, parenthesis are required otherwise it becomes function declaration

40 Example: Function Pointer void func() cout << "func() called..." << endl; int main() void (*fp)(); // define a function pointer fp = func; // Initialise it, assign function address (*fp)(); // call function using function pointer

41 Pointer To Objects Just like other pointers, the object pointers are declared by placing in front of a object pointer's name. It takes the following general form : class-name object-pointer ; where class-name is the name of an already defined class and object-pointer is the pointer to an object of this class type. For example, to declare optr as an object pointer of Sample class type, we shall write Sample optr ; where Sample is already defined class. When accessing members of a class using an object pointer, the arrow operator (->) is used instead of dot operator.

42 Pointer To Objects Consider Rational r(4,3); Rational rptr = &r; To select a member of r using rptr and member selection, operator precedence requires Invokes member Insert() of the object to which rptr points (r) (*rptr).insert(cout); This syntax is clumsy, so C++ provides the indirect member selector operator -> Invokes member Insert() of the object to which rptr points (r) rptr->insert(cout);

43 Pointer To Objects The following program illustrates how to access an object given a pointer to it. This C++ program illustrates the use of object pointer #include<iostream.h> #include<conio.h> class Time short int hh, mm, ss; public: Time() hh = mm = ss = 0; void getdata(int i, int j, int k)

44 Pointer To Objects void getdata(int i, int j, int k) hh = i; mm = j; ss = k; void prndata(void) cout<<"\ntime is<< hh<< ": << mm << ": <<ss<<"\n"; ; //class Time Ends

45 Pointer To Objects void main() clrscr(); Time T1, *tptr; cout<<"initializing data members using the object\n"; T1.getdata(12,22,11); cout<<"printing members using the object "; T1.prndata(); tptr = &T1; cout<<"printing members using the object pointer "; tptr->prndata(); cout<<"\ninitializing data members using the object pointer, \n";

46 Pointer To Objects tptr->getdata(15, 10, 16); cout<<"printing members using the object "; T1.prndata(); cout<<"printing members using the object pointer "; tptr->prndata(); getch();

47 Pointer To Pointers A pointer to a pointer is a form of multiple indirection or a chain of pointers. Normally, a pointer contains the address of a variable. When we define a pointer to a pointer, the first pointer contains the address of the second pointer, which points to the location that contains the actual value as shown below. A variable that is a pointer to a pointer must be declared as such. This is done by placing an additional asterisk in front of its name. For example, following is the declaration to declare a pointer to a pointer of type int int **var;

48 Pointer To Pointers What is the output?

49 Pointer To Pointers When a target value is indirectly pointed to by a pointer to a pointer, accessing that value requires that the asterisk operator be applied twice, as is shown below in the example #include <iostream> using namespace std; int main () int var; int *ptr; int **pptr; var = 3000;

50 // take the address of var ptr = &var; Pointer To Pointers // take the address of ptr using address of operator & pptr = &ptr; // take the value using pptr cout << "Value of var :" << var << endl; cout << "Value available at *ptr :" << *ptr << endl; cout << "Value available at **pptr :" << **pptr << endl; return 0;

51 Output When the above code is compiled and executed, it produces the following result Value of var :3000 Value available at *ptr :3000 Value available at **pptr :3000

52 Linked List Example struct link // one element of list int data; // data item link *next; // pointer to next element ; class linklist private: link* first; // pointer to first link public: linklist() first = NULL; // no argument constructor void additem(int d); // add data item (one link) void display(); // display all links

53 Linked List Example void linklist::additem(int d) // add data item link* newlink = new link; // create a new link newlink->data = d; // give it data d newlink->next=first; // it points to the next link first = newlink; // now first points to this link void linklist::display() // display all links link* current=first; // set ptr to first link while(current!= NULL) // until ptr points beyond last link cout << current->data << ; // print data current=current->next; // move to next link

54 Smart Pointers class Person int age; char* pname; public: Person(): pname(0),age(0) Person(char* pname, int age): pname(pname), age(age) ~Person() void Display() cout<< Name = <<pname<< Age = <<age;

55 Smart Pointers void prin() cout<< Hello ; ; void main() Person* pperson = new Person("Scott", 25); pperson->display(); delete pperson;

56 Smart Pointers Now look at this code, every time I create a pointer, I need to take care of deleting it. This is exactly what we need to avoid. An automatic mechanism is needed which deletes the pointer. Using smart pointers, we can make pointers to work in way that we don t need to explicitly call delete.

57 Smart Pointers Smart pointer is a wrapper class over a pointer with operator like * and -> overloaded. The objects of smart pointer class look like pointer, but can do many things that a normal pointer can t, like automatic destruction reference counting and more. The idea is to make a class with a pointer, destructor and overloaded operators like * and ->.

58 Smart Pointers Since destructor is automatically called when an object goes out of scope, the dynamically allocated memory would automatically deleted (or reference count can be decremented).

59 Example for Smart Pointers #include<iostream> using namespace std; class SmartPtr Person *ptr; // Actual pointer public: // Constructor SmartPtr(Person *p) ptr = p;

60 Example for Smart Pointers // Destructor ~SmartPtr() delete ptr; // Overloading dereferencing operator Peron &operator *() return *ptr; Person *operator ->() //Overloading Access operator return ptr; ;

61 Example for Smart Pointers int main() SmartPtr ptr(new Person()); *ptr = 20; cout << *ptr; // We don't need to call delete ptr: when the object // ptr goes out of scope, destructor for it is automatically // called and destructor does delete ptr. return 0;

62 Use of Smart Pointers Automatic cleanup. Automatic initialization Ownership transfer Reference counting To shorten allocation and deallocation time. Since C++ does not provide automatic garbage collection like some other languages, smart pointers can be used for that purpose.

63 Smart Pointers We can make Smart pointers to work on all types. For this we need to use Templates (covered in next unit) C++ libraries provide implementations of smart pointers in the form of auto_ptr : deprecated unique_ptr : Same as auto_ptr shared_ptr and weak_ptr All these pointers exist in <memory> header file

64 Unique Pointers unique_ptr is a container for a raw pointer, which the unique_ptr is said to own. A unique_ptr explicitly prevents copying of its contained pointer (as would happen with normal assignment), But the std::move function can be used to transfer ownership of the contained pointer to another unique_ptr. A unique_ptr cannot be copied because its copy constructor and assignment operators are explicitly deleted.

65 Unique Pointers std::unique_ptr<int> p1(new int(5)); std::unique_ptr<int> p2 = p1; //Compile error. std::unique_ptr<int> p3 = std::move(p1); //Transfers ownership. p3 now owns the memory and p1 is rendered invalid. p3.reset(); //Deletes the memory. p1.reset(); //Does nothing.

66

67

68

69 Shared Pointers Shared_ptr is a container for a raw pointer. It maintains reference counting ownership of its contained pointer in cooperation with all copies of the shared_ptr. An object referenced by the contained raw pointer will be destroyed when and only when all copies of the shared_ptr have been destroyed.

70 Shared Pointers std::shared_ptr<int> p1(new int(5)); std::shared_ptr<int> p2 = p1; //Both now own the memory. p1.reset(); //Memory still exists, due to p2. p2.reset(); //Deletes the memory, since no one else owns the memory.

71 Pointers to Derived Classes C++ allows base class pointers to point to derived class objects. Let we have class base ; class derived : public base ; Then we can write: base *p1; derived d_obj; p1 = &d_obj;

72 class Base public: void show() cout << base\n ; ; class Derv1 : public base public: void show() cout << derived1\n ; class Derv2 : public base public: void show() cout << derived2\n ; ; void main() Derv1 dv1; Derv2 dv2; Base *ptr ptr = &dv1; ptr->show(); ptr = &dv2; ptr ->show(); return 0; OUTPUT : base base

73 class Base public: virtual void show() cout << base\n ; ; class Derv1 : public base public: void show() cout << derived1\n ; class Derv2 : public base public: void show() cout << derived2\n ; ; void main() Derv1 dv1; Derv2 dv2; Base *ptr ptr = &dv1; ptr->show(); ptr = &dv2; ptr ->show(); return 0; OUTPUT : derived1 derived2

74 Virtual Functions A virtual function is a member function that is declared within a base class and redefined by a derived class. Virtual functions implements the "one interface, multiple methods" philosophy under polymorphism.

75 Virtual Functions The virtual function within the base class defines the form of the interface to that function. Each redefinition of the virtual function by a derived class implements its operation as it relates specifically to the derived class. That is, the redefinition creates a specific method.

76 Non-Virtual Pointer Access

77 Virtual Functions A virtual function is a member function that is declared within a base class and redefined by a derived class. Virtual functions implements the "one interface, multiple methods" philosophy under polymorphism.

78 Virtual Functions The virtual function within the base class defines the form of the interface to that function. Each redefinition of the virtual function by a derived class implements its operation as it relates specifically to the derived class. That is, the redefinition creates a specific method.

79 Virtual Functions To create a virtual function, precede the function s declaration in the base class with the keyword virtual. Example: class base public: virtual void member_func() ;

80 Virtual Functions Base Virtual function Derived1 Derived2 override override

81 Virtual Functions How to implement run-time polymorphism? - create base-class pointer can be used to point to an object of any class derived from that base - initialize derived object(s) to base class object. Based upon which derived class objects assignment to the base class pointer, c++ determines which version of the virtual function to be called. And this determination is made at run time.

82 Virtual Functions The redefinition of a virtual function by a derived class appears similar to function overloading? No The prototype for a redefined virtual function must match exactly the prototype specified in the base class.

83 Restrictions: Virtual Functions All aspects of its prototype must be the same as base class virtual function. Virtual functions are of non-static members. Virtual functions can not be friends. Constructor functions cannot be virtual. But destructor functions can be virtual. NOTE: Function overriding is used to describe virtual function redefinition by a derived class.

84 Virtual Functions When accessed "normally" virtual functions behave just like any other type of class member function. But virtual functions importance and capacity lies in supporting the run-time polymorphism when they accessed via a pointer.

85 Abstract Classes and Pure Virtual Functions A base class whose objects are never instantiated is called an abstract class. Such a class exists only to act as a parent of derived classes that will be used to instantiate objects. A base class made as an abstract class must contain at least one pure virtual function. A pure virtual function is one with the expression =0 added to the function declaration. e.g., virtual void show() = 0;

86 Pure Virtual Functions When a virtual function is made pure, any derived class must provide its definition. If the derived class fails to override the pure virtual function, a compile-time error will result. NOTE: When a virtual function is declared as pure, then all derived classes must override it.

87 class Base public: virtual void show() = 0; ; class Derv1 : public base public: void show() cout << derived1\n ; class Derv2 : public base public: void show() cout << derived2\n ; ; void main() Base bad; Derv1 dv1; Derv2 dv2; Base *ptr ptr = &dv1; ptr->show(); ptr = &dv2; ptr ->show(); return 0; //ERROR

88 Virtual Destructors Without Normally, when one deletes an instance of a derived class (e.g., Car), the destructors of the derived class and those of all the ancestor classes are executed (in this case, the Vehicle destructor) But let s assume that we are given the following statement Vehicle* a = new Car( Ferrari ); What happens when one executes the following statement? delete a;

89 Virtual Destructors Why? Since the classes involved in the example do not have virtual destructors, only the Vehicle destructor is executed! Further, if additional classes appeared in the hierarchy between Vehicle and Car, their destructors would not be executed, either This behavior can lead to memory leaks and other problems, especially when dynamic memory or class variables are managed by the derived class A solution to the problem is the use of virtual destructors

90 Virtual Destructors What? A virtual destructor is simply a destructor that is declared as a virtual function If the destructor of a base class is declared as virtual, then the destructors of all its descendant classes become virtual, too (even though they do not have the same names)

91 Virtual Destructors - rule Rules of thumb for virtual destructors If any class in a hierarchy manages class variables or dynamic memory, make its destructor virtual If none of the classes in a hierarchy have userdefined destructors, do not use virtual destructors

92 #include iostream.h class Base public: Base() cout<<"constructing Base"; // this is a destructor: ~Base() cout<<"destroying Base"; ;

93 class Derive: public Base public: Derive() cout<<"constructing Derive"; ~Derive() cout<<"destroying Derive"; ; void main() Base *baseptr = new Derive(); delete baseptr; OUTPUT : Constructing Base Constructing Derive Destroying Base

94 Based on the output above, we can see that the constructors get called in the appropriate order when we create the Derive class object pointer in the main function. But there is a major problem with the code above: the destructor for the "Derive" class does not get called at all when we delete baseptr.

95 Remedy..? VIRTUAL DESTRUCTOR Well, what we can do is make the base class destructor virtual, and that will ensure that the destructor for any class that derives from Base (in our case, its the "Derive" class) will be called.

96 #include iostream.h class Base public: Base() cout<<"constructing Base"; // this is a destructor: virtual ~Base() cout<<"destroying Base"; ;

97 class Derive: public Base public: Derive() cout<<"constructing Derive"; ~Derive() cout<<"destroying Derive"; ; void main() Base *baseptr = new Derive(); delete baseptr; OUTPUT : Constructing Base Constructing Derive Destroying Derive Destroying Base

98 Early vs. Late Binding Early binding refers to events that occur at compile time. Early binding occurs when all information needed to call a function is known at compile time. Examples : function calls,overloaded function calls, and overloaded operators.

99 Early vs. Late Binding Late binding refers to function calls that are not resolved until run time. Late binding can make for somewhat slower execution times. Example: virtual functions

100 Containership If we create the object of one class into another class and that object will be a member of the class, then it is called containership. This relation is calles has_a relation. While the inheritance is called kind_of and is_a relation.

101 Class upper Public: Void display() Cout<< hello <<endl; ; Class lower Upper obj; Public: Lower() Obj.display(); o/p hello Void main() Lower l; ;

102 Container class also call upper class constructor first like inheritance.it can use only public member of upper class not the private and protected members

103 Class upper Public: upper() Cout<< it is upper class constructor <<endl ; ; Class lower Upper obj; Public: lower() Cout<< it is lower class constructor <<endl ; ; o/p Void main() lower l; it is upper class constructor it is lower class constructor