Menu
This is in fact an interview question, I can't figure out the answer. Anyone knows about this? You can talk about any difference, for example, the data that are push into stack.
368
So polymorphic behaviour works even when a virtual function is called inside a non-virtual function. The output can be guessed from the fact that the function to be called is decided at run-time using the vptr and vtable.
Non-virtual member functions are resolved statically. That is, the member function is selected statically (at compile-time) based on the type of the pointer (or reference) to the object. In contrast, virtual member functions are resolved dynamically (at run-time).
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.
With the virtual keyword on the base class method and the override keyword on the method in the derived class, both methods are said to be virtual. Methods that don't have either the virtual or override keywords, or that have the new keyword, are said to be non-virtual.
Though virtualism/dynamic dispatch is strictly implementation defined, most(read all known) compilers implement it by using vptr and vtable.
Having said that, the difference between calling a non virtual function and virtual function is:
Non-virtual functions are resolved statically at Compile-time, While Virtual functions are resolved dynamically at Run-time.
In order to achieve this flexibility of being able to decide which function to call at run-time, there is an little overhead in case of virtual functions.
An additional fetch call that needs to be performed and it is the overhead/price you pay for using dynamic dispatch.
In case of non-virtual function the sequence of calls is:
fetch-call
The compiler needs to fetch address of the function and then call it.
While in case of virtual functions the sequence is:
fetch-fetch-call
The compiler needs to fetch the vptr from the this, then fetch the address of the function from the vptr and then call the function.
This is just a simplified explanation the actual sequence maybe far more complex than this but this is what you really need to know, One does not really need to know the implementation nitty gritty's.
Good Read:
Inheritance & Virtual Functions
157
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
