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

Smart Pointers in C++ and How to Use Them

Image
  Smart Pointers in C++ and How to Use Them In this article, we will be discussing smart pointers in C++. What are Smart Pointers, why, and how to use them properly? Pointers are used for accessing the resources which are external to the program – like heap memory. So, for accessing the heap memory (if anything is created inside heap memory), pointers are used. When accessing any external resource we just use a copy of the resource. If we make any change to it, we just change it in the copied version. But, if we use a pointer to the resource, we’ll be able to change the original resource. Play Video Click here for the Complete Course! Problems with Normal Pointers Take a look at the code below. C++ #include <iostream> using namespace std;   class Rectangle { private :      int length;      int breadth; };   void fun() {      // By taking a pointer p and      // dynamically creating object      // of class rectangle      Rectangle* p = new Rectangle(); }   int main() {    
Read more

Operator Overloading in C++

Operator Overloading in C++ In C++, we can make operators to work for user defined classes. For example, we can overload an operator ‘+’ in a class like String so that we can concatenate two strings by just using +. Other example classes where arithmetic operators may be overloaded are Complex Number, Fractional Number, Big Integer, etc. A simple and complete example #include<iostream> using namespace std;   class Complex { private :      int real, imag; public :      Complex( int r = 0, int i =0)  {real = r;   imag = i;}             // This is automatically called when '+' is used with      // between two Complex objects      Complex operator + (Complex const &obj) {           Complex res;           res.real = real + obj.real;           res.imag = imag + obj.imag;           return res;      }      void print() { cout << real << " + i" << imag << endl; } };   int main()
Read more

How would you read in a string of unknown length without risking buffer overflow

How would you read in a string of unknown length without risking buffer overflow #include <stdio.h> #include <stdlib.h> char * inputString ( FILE * fp , size_t size ){ //The size is extended by the input with the value of the provisional char * str ; int ch ; size_t len = 0 ; str = realloc ( NULL , sizeof ( char )* size ); //size is start size if (! str ) return str ; while ( EOF !=( ch = fgetc ( fp )) && ch != '\n' ){ str [ len ++]= ch ; if ( len == size ){ str = realloc ( str , sizeof ( char )*( size += 16 )); if (! str ) return str ; } } str [ len ++]= '\0' ; return realloc ( str , sizeof ( char )* len ); } int main ( void ){ char * m ; printf ( "input string : " ); m = inputString ( stdin , 10 ); printf ( "%s\n" , m ); free ( m ); return 0 ; }
Read more