Tutorials C++In this C++ tutorial, you will learn about pure virtual function, declaration of pure virtual function and virtual base class, virtual base class and how to implement a virtual base class, explained with examples.
Pure Virtual Function is a Virtual function with no body.
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:
|
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:
|
Since the above example has no body, the pure virtual function example() is declared with notation =0 in the base class Exforsys. The two derived class named Exf1 and Exf2 are derived from the base class Exforsys. 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 Exforsys. Special care must be taken not to remove the statement of declaration of the pure virtual function in the base class.
In the above example, there are two derived classes Exf1 and Exf2 from the base class Exforsys. 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 Exforsys it would result in error if it is performed like this:
|
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 Exforsys. This results in an error because the derived classes Exf1 and Exf2 (derived from base class Exforsys) create copies of Exforsys called subobjects.
This means that each of the subobjects have Exforsys 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:
|
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 subobject of their base class Exforsys. This results in only one copy that the member function example() of Class Training can access the member data x.
| Explanation is too gud. Its in such a way that every basic learner can understand it. |
|
Can I know what is the exact differece between these two? In the above example, where pure virtual function is declared, if that function is made as virtual will the ouput get effected? |
| These tutorial is nice for beginners.... |
|
this explanation is damn great thnx alot |
| good explanation.. simple yet convincing.. |
| - it it easy to understand. |
| amazing............. |
| Good to understand.Thanks |
| very nice explanation |
| Thanks A Lot |
| Tell me what is the use of pure virtual function as it contains no definition or declaration. |
|
Same question as above.. Why do we need pure virtual if it doesn't have any body at all? We could have declared that function in derived class also where we might need that. Why was there a need to declare it as pure virtual in base class. |
| A pure virtual function is merely an interface and can be thought of as a way to enforce policy. A pure virtual function should be used when subclasses implement the same interface completely differently. This passes only a single copy of variables and functions to its grand childs, and hence avoid compile time confusion for inheriting which variable through which class, as in case of multiple inheritance. |
| If you want to make a program on shapes..then first you will have to make a base class called shape...and the derived classes like circle,rectangle,square etc...all these shapes will have some common fucntions like calculating area length etc...so either defining AREA function in all the classes you must make the AREA function as pure virtual function in the base class SHAPE and then use it in every derived classes..since no definition would be possible of the class AREA in the base class you make it pure virtual |
|
we can use a different function name in each derived class for implementing its own logic.(i.e) areasq for findin the area of square,arearect for rectangle and so on. so why do we need a pure virtual function ? |
| if we declare a function as a pure virtual function then object of that class which has pure virtual function is never created |
|
Pradeep: Since all classes that represent shapes will be children of your Shape class, you can have an array (or other data structure) of Shape objects, as below: Shape myShapes[3] = {Circle(), Square(), Triangle()}; If you wanted to find the area of each Shape without a pure virtual function, you would first have to know which shape was in each index of the array. However, with a pure virtual function in the Shape class and defined methods in each of its children, you can call the area method without knowing which type of Shape you have. This is useful in loops: for (int i = 0; i < 3; ++i) { cout << myShapes[i].area(); //not possible w/o a pure virtual area() method in Shape } |
| your missing a semi Collen in the first 'quote' box after the =0(;) |
| If you don't want to allow others to instantiate your class (i.e create objects of your class type), then you need to put a pure virtual function in your class. By doing this, others can derive from your class but they won't be able to create objects of your class. |
| So the only difference between pure virtual and virtual is you can not instantiate a class with a pure virtual, but can with a virtual. To instantiate a class with a pure virtual you must derive a new class from it? |
