Virtual Functions


Introduction

           A virtual function is a member function that is declared within a base class and redefined by a derived class. To create a virtual function, precede the function's declaration in the base class with the keyword virtual. When a class containing a virtual function is inherited,the derived class redefines the virtual function to fit its own needs. In essence, virtual functions implement the "one interface, multiple methods" philosophy that underlies polymorphism. 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 plements its operation as it relates specifically to the derived class. That is, the redefinition
creates a specific method.

// Virtual.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
using namespace std;

class base
{
public:
void virtual vFun()
{
cout<< "Base VFun" <<endl;
}
};
class D1 : public base
{
public:
 void virtual vD1fun()
 {
 cout << "D1 Function()"<<endl;
 }
 void vFun()
 {
 cout << "D1 vFun"<<endl;
 }
};
class D2 : public D1
{
public:
 void vD1fun()
 {
 cout << "D2 Function()"<<endl;
 }
  void vFun()
 {
 cout << "D2 vFun"<<endl;
 }
};
void vRefFun(base &b)
{
b.vFun();
}
int _tmain(int argc, _TCHAR* argv[])
{
base *b_ptr , b_obj;

cout<< sizeof(base) <<endl;
cout<< sizeof(D1) <<endl;
cout<< sizeof(D2) <<endl;

b_ptr = new D1();
b_ptr->vFun();

D1 *d_ptr , d_obj;
d_ptr = static_cast<D1 *> (new base()) ; // No Safe becasue b_ptr can only hold base values and not derived
d_ptr->vFun();


D1 *D1_ptr , D1_obj;
D2 *D2_ptr , D2_obj;

D1_ptr = &D2_obj;
D1_ptr->vD1fun();
D1_ptr->vFun();

D2_ptr = static_cast<D2*>(&D1_obj);
D2_ptr->vD1fun();
D2_ptr->vFun();

vRefFun(b_obj);
vRefFun(D1_obj);
vRefFun(D2_obj);

D2_ptr = dynamic_cast<D2*>(&D1_obj);
D2_ptr->vD1fun();
D2_ptr->vFun();
return 0;
}



Comments

Post a Comment

Popular posts from this blog

Vector

// Vectorpgm.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream> #include <vector> #include <algorithm> using namespace std; int _tmain(int argc, _TCHAR* argv[]) { ////Space for vector of int, called iVector // vector <int> iVektor; // //we will add the elements at the end of vector // do // { // //space for next element of the vector // cout<<"Next Element->"; int iElement; cin>>iElement; // //to remove the element from the back use pop_back // iVektor.push_back(iElement); // cout<<"Size of the vector is ="<<iVektor.size()<<endl // <<"Capacity of the vector="<<iVektor.capacity()<<endl; // cout<<"More elements yes(y)/no(n)->"; // char cRespond; cin>>cRespond; // if((cRespond == 'y')||(cRespond=='Y')) continue; // break; ...
Read more

Selection Sort

// Sectionsort.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <vector> using namespace std; int _tmain(int argc, _TCHAR* argv[]) { int i,j,n,loc,temp,min,a[30];     printf("Enter the number of elements:");     scanf("%d",&n);     printf("\nEnter the elements\n");     for(i=0;i<n;i++)     {         scanf("%d",&a[i]);     }     for(i=0;i<n-1;i++)     {         min=a[i];         loc=i;         for(j=i+1;j<n;j++)         {             if(min>a[j])             {                 min=a[j];                 loc=j;             }       ...
Read more

Difference Between LIB and DLL

LIB vs DLL When developing software, we are often asked whether we want to use LIB or DLLs in containing functions for the application. LIB is a static library where functions and procedures can be placed and called as the application is being compiled. A DLL or Dynamic Link Library does the same function but is dynamic in a sense that the application can call these libraries during run-time and not during the compilation. This presents a few significant advantages compared to using LIB. For starters, you would have a single file that is significantly bigger as it contains all of the code while you would have multiple smaller files when using DLL. Compiling your functions and procedures would also allow you more reusability as once you are happy with the functions on the DLL because you can keep it as is with each version of the application and not have to mess with it. You can also use the same DLL if you want to create another application that uses the same functions and proced...
Read more