Virtual Function

In object-oriented programming, a virtual function or virtual method is one whose behavior can be overridden within an inheriting class by a function with the same signature. This concept is a very important part of the polymorphism portion of object-oriented programming (OOP).

Purpose

Further information: Dynamic dispatch

The concept of the virtual function solves the following problem:

In OOP when a derived class inherits from a base class, an object of the derived class may be referred to (or cast) as either being the base class type or the derived class type. If there are base class functions overridden by the derived class, a problem then arises when a derived object has been cast as the base class type. When a derived object is referred to as being of the base's type, the desired function call behavior is ambiguous.

The distinction between virtual and not virtual resolves this ambiguity. If the function in question is designated "virtual" in the base class then the derived class's function would be called (if it exists). If it is not virtual, the base class's function would be called.

Virtual functions overcome the problems with the type-field solution by allowing the programmer to declare functions in a base class that can be redefined in each derived class.

Example

For example, a base class Animal could have a virtual function eat. Subclass Fish would implement eat() differently than subclass Wolf, but you can invoke eat() on any class instance referred to as Animal, and get the eat() behavior of the specific subclass.

This allows a programmer to process a list of objects of class Animal, telling each in turn to eat (by calling eat()), with no knowledge of what kind of animal may be in the list. You also do not need to have knowledge of how each animal eats, or what the complete set of possible animal types might be.

C++

The following is an example in C++. Note that this example is not exception-safe. In particular, it may leak resources if new or vector::push_back throws an exception.

#include 
#include 

using namespace std;
class Animal
{
public:
 virtual void eat() const { cout << "I eat like a generic Animal." <<
 class="br0">}
 virtual ~Animal() {}
};

class Wolf : public Animal
{
public:
 void eat() const { cout << "I eat like a wolf!" << class="br0">}
};

class Fish : public Animal
{
public:
 void eat() const { cout << "I eat like a fish!" << class="br0">}
};

class GoldFish : public Fish
{
public:
 void eat() const { cout << "I eat like a goldfish!" << class="br0">}
};


class OtherAnimal : public Animal
{
};

int main()
{
 std::vector animals;
 animals.push_back( new Animal() );
 animals.push_back( new Wolf() );
 animals.push_back( new Fish() );
 animals.push_back( new GoldFish() );
 animals.push_back( new OtherAnimal() );

 for( std::vector::const_iterator it = animals.begin();
    it != animals.end(); ++it)
 {
     (*it)->eat();
     delete *it;
 }

return 0;
}

Output with the virtual function Animal::eat():

I eat like a generic Animal.
I eat like a wolf!
I eat like a fish!
I eat like a goldfish!
I eat like a generic Animal.

Output if Animal::eat() were not declared as virtual:

I eat like a generic Animal.
I eat like a generic Animal.
I eat like a generic Animal.
I eat like a generic Animal.
I eat like a generic Animal.

Abstract classes and pure virtual functions

A pure virtual function or pure virtual method is a virtual function that is required to be implemented by a derived class that is not abstract. Classes containing pure virtual methods are termed "abstract;" they cannot be instantiated directly, and a subclass of an abstract class can only be instantiated directly if all inherited pure virtual methods have been implemented by that class or a parent class. Pure virtual methods typically have a declaration (signature) and no definition (implementation).

As an example, an abstract base class "MathSymbol" may provide a pure virtual function doOperation(), and derived classes "Plus" and "Minus" implement doOperation() to provide concrete implementations. Implementing doOperation() would not make sense in the "MathSymbol" class as "MathSymbol" is an abstract concept whose behaviour is defined solely for each given kind (subclass) of "MathSymbol". Similarly, a given subclass of "MathSymbol" would not be complete without an implementation of doOperation().

Although pure virtual methods typically have no implementation in the class that declares them, pure virtual methods in C++ are permitted to contain an implementation in their declaring class, providing fallback or default behaviour that a derived class can delegate to if appropriate.

Pure virtual functions are also used where the method declarations are being used to define an interface for which derived classes will supply all implementations. An abstract class serving as an interface contains only pure virtual functions, and no data members or ordinary methods. Use of purely abstract classes as interfaces works in C++ as it supports multiple inheritance. Because many OO languages do not support multiple inheritance they often provide a separate interface mechanism.

In C++, pure virtual functions are declared using a special syntax [ = 0 ] as demonstrated below.

class Abstract {
public:
virtual void pure_virtual() = 0;
};

The pure virtual function declaration provides only the prototype of
the method. Although an implementation of the pure virtual function is
typically not provided in an abstract class, it may be included,
although the definition may not be included at the point of declaration
[1].
Every non-abstract child class is still required to override the
method, but the implementation provided by the abstract class may be
called in this way:

void Abstract::pure_virtual() {
// do something
}

class Child : public Abstract {
virtual void pure_virtual(); // no longer abstract, this class may be
                             // instantiated.
};

void Child::pure_virtual() {
Abstract::pure_virtual(); // the implementation in the abstract class 
                          // is executed
}

Behavior During Construction and Destruction

Languages differ in their behaviour while the constructor or destructor of an object is running. For some languages, notably C++, the virtual dispatching mechanism has different semantics during construction and destruction of an object. While it is recommended that virtual function calls in constructors should be avoided for C++ ^[2], in some other languages, for example Java and C#, the derived implementation can be called during construction and design patterns such as the Abstract Factory Pattern actively promote this usage in languages supporting the ability.

#include 
#include 

using namespace std;

struct A
{
virtual std::string name() const { return "A"; }
virtual ~A() { cout << "Destructing " << class="br0">(); }
};

struct B : A
{
B() { cout << "Constructing " << class="br0">() << class="br0">}
virtual std::string name() const { return "B"; }
};

struct C : B
{
virtual std::string name() const { return "C"; }
};

int main()
{
C c; // Output: "Constructing B"

} // Output: "Destructing A"

Virtual destructors

Object-oriented languages typically manage memory allocation and deallocation automatically when objects are created and destroyed, however some object-oriented languages allow a custom destructor method to be implemented if desired. One such language is C++, and as illustrated in the following example, it is important for a C++ base class to have a virtual destructor to ensure that the destructor from the most derived class will always be called.

In the example below having no virtual destructor, while deleting an instance of class B will correctly call destructors for both B and A if the object is deleted as an instance of B, an instance of B deleted via a pointer to its base class A will produce undefined behaviour. On many implementations, the destructor for B will not be called in this situation.

#include 
using namespace std;

class A
{
public:

A() { }
~A() { cout << "Destroy A" << class="br0">}
};

class B : public A
{
public:

B() { }
~B() { cout << "Destroy B" << class="br0">}
};

int main()
{
A* b1 = new B;
B* b2 = new B;

delete b1; // According to the C++ standard,
           // the behaviour of this is undefined.
           // Usually, only ~A() is called though b1 is an instance
           // of class B because ~A() is not declared virtual. 
delete b2; // Calls destructors ~B() and ~A()

return 0;
}

Possible output:

Destroy A
Destroy B
Destroy A

Correctly declaring the destructor for class A as virtual ~A() will
ensure that thedestructor for class B is called in both cases with
the example above.