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

Static Function

// staticfun.cpp : Defines the exported functions for the DLL application. // #include "stdafx.h" #include <iostream> class c1 { static int resource; public: static int get_resource(); void free_resou() { resource = 0; } }; int c1::resource; int c1::get_resource() { if(resource) return 0; else resource = 1; return 1; } int main() { c1 obj1, obj2; if(c1::get_resource()) std::cout << "resource occupied by obj1"; if(!c1::get_resource()) std::cout << " resource denied"; obj1.free_resou(); if(c1::get_resource()) std::cout << " resouce occpied by obj2"; }
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

C++ mutable keyword

C++ mutable keyword Be self controlled and alert. Your enemy the devil prowls around like a roaring lion looking for someone to devour. 1 Peter 5:8 (Bible) The mutable storage class specifier in C++ (or use of mutable keyword in C++) auto, register, static and extern are the storage class specifiers in C. typedef is also considered as a storage class specifier in C. C++ also supports all these storage class specifiers. In addition to this C++, adds one important storage class specifier whose name is mutable. What is the need of mutable? Sometimes there is requirement to modify one or more data members of class / struct through const function even though you don’t want the function to update other members of class / struct. This task can be easily performed by using mutable keyword. Consider this example where use of mutable can be useful. Suppose you go to hotel and you give the order to waiter to bring some food dish. After giving order, you suddenly decide to change the order...
Read more