VIRTUAL FUNCTIONS RITIKA SHARMA

POLYMORPHISM Polymorphism means many (poly) shapes (morph) It can be defined one interface multiple methods which means that one interface can be used to perform different but related activities. It is achieved by two ways: Overloading. Overriding. RITIKA SHARMA

Classification of Polymorphism It can be classified in two ways on the basis of binding performed by the compiler for all the related but different operations having a common name. The concept of binding refers to the linking of function call to the code of the function to be executed in response to the function call. (i)Compile time(or static) polymorphism. (ii)Run time (Or Dynamic) polymorphism. RITIKA SHARMA

Compile Time Polymorphism In compile time polymorphism ,static binding is performed. In this compiler makes the decision regarding selection of appropriate function to be called in response to function call at compile time. This is because all the address information requires to call a function is known at compile time. RITIKA SHARMA

Compile Time Polymorphism It is also known as early binding as decision of binding is made by the compiler at the earliest possible moment. The advantage is its efficiency as it often requires less memory and function calls are faster. The disadvantage is lack of flexibility. The compile time polymorphism is implemented using function overloading and operator overloading RITIKA SHARMA

Run time(Dynamic)Polymorphism In this dynamic binding is performed In dynamic binding the decision regarding the selection of appropriate function to be called is made by compiler at run time. This is because the information pertaining to the selection of appropriate function definition corresponding to a function call is known only at the run time. RITIKA SHARMA

Run time(Dynamic)Polymorphism It is also called the late binding as the compiler delays the binding decision until run time. The advantage is that it allows greater flexiability by enabling user to create class libraries that can be reused and extended as per requirement The disadvantage is that there is little less od execution speed as compiler will have to perform certain overheads at run time RITIKA SHARMA

Compile Time Polymorphism One should note that if polymorphism is not explicilty specified is run time polymorphism. Run time polymorphism is implemented using virtual functions. RITIKA SHARMA

Pointer to derived class object Base class pointers can point to derived class objects and invoke members functions that manipulate those objects. The fact that the pointer of the base class can point to objects if the derived classes is absolutely fine because each derived class object is an object of its base class also. Even though the base class pointer has been assigned the address of the object of one of its derived classes it still cannot access the public members which are defined in the derived class. RITIKA SHARMA

It can access only those members that are in-heritated from the base class to derived class Any reference to the same named inherited the members using base class pointer will result in accessing the base class member and not the member of derived class. RITIKA SHARMA

VIRTUAL FUNCTIONS A virtual function is a member function declared in the base class using the keyword virtual whose functionality is redefined(same function name) by its derived classes. The virtual function declared in the base class represent the single interface and its redefinition by the derived classes implements operations specific of each derived class. To implement run time polymorphism using virtual function ,it must be invoked through the base class pointer that can contain the address of objects of different derived classes. When the virtual function is invoked through the base class pointer the compiler chooses the appropriate member function of the derived class at run time depending upon the contents of base class pointer and not the type of pointer. RITIKA SHARMA

PURE VIRTUAL FUNCTIONS A virtual function is defined inside the base class and redefined in the derived classes. But in most situations,a virtual function defined in the base class does not have any meaningful operation for it to perform. A better way to change the virtual function cal_area() in the base class is: virtual void cal_area() =0; Thus by making the base class pointer pointing to objects of different classes ,the different versions of virtual functions can be called at run time RITIKA SHARMA

The above statement is not an assignment statement but it’s a way to inform the compiler that the function has no body. Such a virtual function having intializer=0 in its declaration and whichdoes not provide any implementation (no body) is known as pure virtual functions. A pure virtual function is also known as dummy functions or do nothing function. they serve merely as an interface to be overriden by subsequent derieved classes RITIKA SHARMA

The main difference between pure virtual function and virtual function is that :-a virtual function has a body and provide the derieved class the option of overriding the base class virtual function a pure virtual function doesnot have any body and derive class must override the base class pure virtual function. Pure virtual function doesnot have any body so a class in which a pure virtual function is declared cannot be instantiated,i.e we cannot create objects of such a class.This is known as ABSTRACT CLASS. A class whose objects cannot be created and contain aatleast one pure virtual function is known as abstract class RITIKA SHARMA

We cannot create the objects of a abstract class and if we try it gives a error message. But we can use abstract base class to declare pointers for storing the address of the objects of concerete classes derieved from it. RITIKA SHARMA

Virtual Destructor Destructor can also be declared as virtual If we want to create an object of a derived class dynamically using the base class pointer. If we destroy this derived object with non-virtual destructor explicitly using the delete operator in association with the base class pointer then only the destructor of the base class is executed and not the derived class’s destructor . The reason behind the non execution of derieved class destructor is that the compiler uses static binding when calling the destructor. The solution to this problem is to make the destructor to be dynamically bound which is achieved by making the base class destructor as virtual RITIKA SHARMA

Virtual Destructor Now if you destroy the derieved object explicity using delete operator in association with the base class pointer,the destructor of appropriate derieved class is called depending upon the object to which pointer of base class points RITIKA SHARMA

this pointer Every object has a special pointer "this" which points to the object itself. This pointer is accessible to all members of the class but not to any static members of the class. Can be used to find the address of the object in which the function is a member. Presence of this pointer is not included in the sizeof calculations. RITIKA SHARMA

Object Slicing Object slicing is a concept where additional attributes of a derived class object is sliced to form a base class object. Object slicing doesn't occur when pointers or references to objects are passed as function arguments since both the pointers are of the same size. Object slicing will be noticed when pass by value is done for a derived class object for a function accepting base class object. Object slicing could be prevented by making the base class function pure virtual there by disallowing object creation. RITIKA SHARMA

Object Slicing When a Derived Class object is assigned to Base class, the base class' contents in the derived object are copied to the base class leaving behind the derived class specific contents. This is referred as Object Slicing. That is, the base class object can access only the base class members. This also implies the separation of base class members from derived class members has happened. RITIKA SHARMA

Object Slicing class base {      public:           int i, j; }; class derived : public base {       public:            int k; }; int main() {       base b;       derived d;       b=d;       return 0; } here b contains i and j where as d contains i, j& k. On assignment only i and j of the d get copied into i and j of b. k does not get copied. on the effect object d got sliced. RITIKA SHARMA