Virtual Functions

Wednesday, 10 July 2013

What are Virtual Functions?

Virtual, as the name implies, is something that exists in effect but not in reality. The concept of virtual function is the same as a function, but it does not really exist although it appears in needed places in a program. The object-oriented programming language C++ implements the concept of virtual function as a simple member function, like all member functions of the class.
The functionality of virtual functions can be over-ridden in its derived classes. The programmer must pay attention not to confuse this concept with function overloading. Function overloading is a different concept and will be explained in later sections of this tutorial. Virtual function is a mechanism to implement the concept of polymorphism (the ability to give different meanings to one function).
Need for Virtual Function:
The vital reason for having a virtual function is to implement a different functionality in the derived class.
For example: a Make function in a class Vehicle may have to make a Vehicle with red color. A class called Four-wheeler, derived or inherited from Vehicle, may have to use a blue background and 4 tires as wheels. For this scenario, the Make function for Four-wheeler should now have a different functionality from the one at the class called Vehicle. This concept is called Virtual Function.
Properties of Virtual Functions:
  • Dynamic Binding Property:
Virtual Functions are resolved during run-time or dynamic binding. Virtual functions are also simple member functions. The main difference between a non-virtual C++ member function and a virtual member function is in the way they are both resolved. A non-virtual C++ member function is resolved during compile time or static binding. Virtual Functions are resolved during run-time or dynamic binding
  • Virtual functions are member functions of a class.
  • Virtual functions are declared with the keyword virtual, detailed in an example below.
  • Virtual function takes a different functionality in the derived class.
Declaration of Virtual Function:
Virtual functions are member functions declared with the keyword virtual.

For example, the general syntax to declare a Virtual Function uses:


class classname //This denotes the base class of C++ virtual function
{
public:
virtual void memberfunctionname() //This denotes the C++ virtual function
{
.............
............
}
};

Referring back to the Vehicle example, the declaration of Virtual function would take the shape below:


class Vehicle //This denotes the base class of C++ virtual function
{
public:
virtual void Make() //This denotes the C++ virtual function
{
cout <<"Member function of Base Class Vehicle Accessed"<<endl;
}
};


After the virtual function is declared, the derived class is defined. In this derived class, the new definition of the virtual function takes place.
When the class FourWheeler is derived or inherited from Vehicle and defined by the virtual function in the class FourWheeler, it is written as:



class Vehicle   //This denotes the base class of C++ virtual function
{
public:
virtual void Make()   //This denotes the C++ virtual function
{
cout <<"Member function of Base Class Vehicle Accessed"<<endl;
}
};

class FourWheeler : public Vehicle
{
public:
void Make()
{
cout<<"Virtual Member function of Derived class FourWheeler Accessed"<<endl;
}
};

void main()
{
Vehicle *a, *b;
a = new Vehicle();
a->Make();
b = new FourWheeler();
b->Make();
}


In the above example, it is evidenced that after declaring the member functions Make () as virtual inside the base class Vehicle, class Four-wheeler is derived from the base class Vehicle. In this derived class, the new implementation for virtual function Make () is placed.
The programmer might be surprised to see the function call differs and the output is then printed as above. If the member function has not been declared as virtual, the base class member function is always called because linking takes place during compile time and is therefore static.
In this example, the member function is declared virtual and the address is bounded only during run time, making it dynamic binding and thus the derived class member function is called.
To achieve the concept of dynamic binding in C++, the compiler creates a v-table each time a virtual function is declared. This v-table contains classes and pointers to the functions from each of the objects of the derived class. This is used by the compiler whenever a virtual function is needed.
C++ PURE VIRTUAL FUNCTION AND BASE CLASS
What is Pure Virtual Function?
Pure Virtual Function is a Virtual function with no body.

Declaration of Pure Virtual Function:
Since pure virtual function has no body, the programmer must add the notation =0 for declaration of the pure virtual function in the base class.
General Syntax of Pure Virtual Function takes the form:


class name //This denotes the base class of C++ virtual function
{
public:
virtual void virtualfunctioname() = 0 //This denotes the pure virtual function in C++
};

The other concept of pure virtual function remains the same as described in the previous section of virtual function.
To understand the declaration and usage of Pure Virtual Function, refer to this example:


class Item
{
public:
virtual void example()=0; //Denotes pure virtual Function Definition
};

class Exf1:public Item
{
public:
void example()
{
cout<<"Welcome";
}
};

class Exf2:public Item
{
public:
void example()
{
cout<<"To Training";
}
};

void main()
{
Item* arra[2];
Exf1 e1;
Exf2 e2;
arra[0]=&e1;
arra[1]=&e2;
arra[0]->example();
arra[1]->example();
}


Since the above example has no body, the pure virtual function example() is declared with notation =0 in the base class Item. The two derived class named Exf1 and Exf2 are derived from the base class Item. The pure virtual function example () takes up new definition. In the main function, a list of pointers is defined to the base class.
Two objects named e1 and e2 are defined for derived classes Exf1 and Exf2. The address of the objects e1 and e2 are stored in the array pointers which are then used for accessing the pure virtual function example () belonging to both the derived class EXf1 and EXf2 and thus, the output is as in the above example.
The programmer must clearly understand the concept of pure virtual functions having no body in the base class and the notation =0 is independent of value assignment. The notation =0 simply indicates the Virtual function is a pure virtual function as it has no body.
Some programmers might want to remove this pure virtual function from the base class as it has no body but this would result in an error. Without the declaration of the pure virtual function in the base class, accessing statements of the pure virtual function such as, arra[0]->example() and arra[1]->example() would result in an error. The pointers should point to the base class Item. Special care must be taken not to remove the statement of declaration of the pure virtual function in the base class.
Virtual Base Class
In the above example, there are two derived classes Exf1 and Exf2 from the base class Item. As shown in the above diagram, the Training class is derived from both of the derived classes Exf1 and Exf2. In this scenario, if a user has a member function in the class Training where the user wants to access the data or member functions of the class Item it would result in error if it is performed like this:


class Item
{
protected:
int x;
};

class Exf1:public Item
{ };

class Exf2:public Item
{ };

class Training: public Exf1,public Exf2
{
public:
int example()
{
return x;
}
};

The above program results in a compile time error as the member function example () of class Training tries to access member data x of class Item. This results in an error because the derived classes Exf1 and Exf2 (derived from base class Item) create copies of Item called sub objects. This means that each of the sub objects have Item member data and member functions and each have one copy of member data x. When the member function of the class Training tries to access member data x, confusion arises as to which of the two copies it must access since it derived from both derived classes, resulting in a compile time error.
When this occurs, Virtual base class is used. Both of the derived classes Exf1 and Exf2 are created as virtual base classes, meaning they should share a common subobject in their base class.

For Example:


class Item
{
protected:
int x;
;


class Exf1:virtual public Item
{ };

class Exf2:virtual public Item
{ };

class Training:public Exf1,public Exf2
{
public:
int example()
{
return x;
}
};

In the above example, both Exf1 and Exf2 are created as Virtual base classes by using the keyword virtual. This enables them to share a common sub object of their base class Item. This results in only one copy that the member function example () of Class Training can access the member data x.

No comments:

Post a Comment

Subscribe to: Posts (Atom)