Possible Duplicate:
Can someone explain C++ Virtual Methods?
I have a question regarding to the C++ virtual functions.
Why and when do we use virtual functions? Can anyone give me a real time implementation or use of virtual functions?
A virtual function is a member function that you expect to be redefined in derived classes. When you refer to a derived class object using a pointer or a reference to the base class, you can call a virtual function for that object and execute the derived class's version of the function.
The main advantage of virtual functions are that they directly support object oriented programming. When you declare a function as virtual you're saying that exactly what code is executed depends on the type of the object you call it against. you can't tell exactly what code path it's going to follow.
A virtual function allows derived classes to replace the implementation provided by the base class. The compiler makes sure the replacement is always called whenever the object in question is actually of the derived class, even if the object is accessed by a base pointer rather than a derived pointer.
If you don't use virtual functions, you don't understand OOP yet. Because the virtual function is intimately bound with the concept of type, and type is at the core of object-oriented programming, there is no analog to the virtual function in a traditional procedural language.
You use virtual functions when you want to override a certain behavior (read method) for your derived class rather than the one implemented for the base class and you want to do so at run-time through a pointer to the base class.
The classic example is when you have a base class called Shape
and concrete shapes (classes) that derive from it. Each concrete class overrides (implements a virtual method) called Draw()
.
The class hierarchy is as follows:
The following snippet shows the usage of the example; it creates an array of Shape
class pointers wherein each points to a distinct derived class object. At run-time, invoking the Draw()
method results in the calling of the method overridden by that derived class and the particular Shape
is drawn (or rendered).
Shape *basep[] = { &line_obj, &tri_obj, &rect_obj, &cir_obj}; for (i = 0; i < NO_PICTURES; i++) basep[i] -> Draw ();
The above program just uses the pointer to the base class to store addresses of the derived class objects. This provides a loose coupling because the program does not have to change drastically if a new concrete derived class of shape
is added anytime. The reason is that there are minimal code segments that actually use (depend) on the concrete Shape
type.
The above is a good example of the Open Closed Principle of the famous SOLID design principles.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With