What is the primary value in using virtual functions within C plus plus?

Answer 1

Virtual methods are member methods of a base class that can be overridden by derived classes. Classes that can act as base classes should contain all the functionality that is common to all their derived classes. However, the derived classes may need to alter that functionality in some way by overriding the methods in the base class.

While this is fine when we actually hold pointers or references to a derived object, what happens when we hold pointers or references to the base class of a derived object? We cannot call the overridden methods explicitly unless we expose the runtime class of the derived object, which would incur an unacceptable processing overhead.

Virtual methods allow us to get around this problem in a more elegant fashion. By declaring a method as virtual, calling the method implicitly on a base class will automatically and explicitly call the most-derived implementation in the class hierarchy. If no override exists, the base class method is called explicitly.

While this mechanism incurs a memory penalty in creating the v-table (virtual table), the bulk of that cost is paid with the first virtual method declared. Subsequent methods add very little overhead, so it is not uncommon for programmers to declare all methods virtual. However, if there is at least one virtual method declared, the class destructor must also be declared virtual. Thereafter, you should only declare other methods to be virtual if there is an actual need to do so. After all, there's no point in consuming more memory than is actually required.

Sometimes it is not possible for a base class to provide the implementation for a virtual method, In this case the method should be declared pure-virtual. The same rules apply as for virtual functions, however you can no longer instantiate objects from the base class itself -- it becomes an abstract class -- so you must derive from it and you must provide an implementation for all the pure-virtual methods (otherwise it becomes abstract itself).

Abstract classes will generally have few, if any, member variables, and all member methods will generally be declared as pure-virtual. Abstract classes are primarily intended to provide a common interface to their derivatives. The base class can still provide default implementations for pure-virtual methods, however they must be explicitly called. In some cases, a derived class will simply augment the default implementation, rather than override it completely.

Be aware that base classes that are common to derived classes that can be used by multiple inheritance classes will introduce ambiguities. The multiple inheritance class will inherit two or more instances of the common base class, and therefore must be called explicitly from the multiple inheritance class. However, it is possible to remove the ambiguity altogether, by declaring the common base class to be virtual in its immediate derivatives, in which case all derivatives share the same common base class when multiply inherited. Ideally, the common base class should have very little in the way of implementation, and few, if any, member variables.

Answer 2

To ensure a derived class method is called whenever a call is made implicitly on the base class method. Base classes have no knowledge of their derivatives (if they did, the base class would have to be modified every time a new derivative was created, which would be impossible to maintain), so base classes cannot call derived class overrides without making costly calls to obtain the runtime information of the derived class.

But derived classes already know their own base classes. If the base class has a virtual method, the derived class will also have a virtual table. The virtual table is essentially a list of function pointers arranged in pairs, one pointing at the base class virtual method and the other pointing at the derived class override. When you implicitly call the base class method, the virtual table diverts the call to the derived class override.

On those occasions where the base class method must be called, it can be called explicitly, which bypasses the virtual table.

In this way there is no need to know what class of object you're actually dealing with, so long as you know the base class. You simply call the virtual method and the actual object "does the right thing".

Pure-virtual methods work exactly the same except the base class does not require an implementation, but the derived class must provide an override. Derived classes do not need to override a normal virtual function; it is expected, but not demanded.