Virtual function

From Wikipedia, the free encyclopedia

In object-oriented programming (OOP), a virtual function or virtual method is a function whose behavior, by virtue of being declared "virtual", is determined by the definition of a function with the same signature furthest in the inheritance lineage of the instantiated object on which it is called. This concept is a very important part of the polymorphism portion of object-oriented programming (OOP).

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 is provided to solve this issue. If the function in question is designated "virtual" 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.

1 Example
2 Abstract classes and pure virtual functions
- 2.1 C++
3 Virtual Destructors
4 See also
5 External references

[edit] 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.

The following is an example in C++:

#include <iostream>

class Animal
{
public:
   virtual void eat() { std::cout << "I eat like a generic Animal.\n"; }
};

class Wolf : public Animal
{
public:
   void eat() { std::cout << "I eat like a wolf!\n"; }
};

class Fish : public Animal
{
public:
   void eat() { std::cout << "I eat like a fish!\n"; }
};

class OtherAnimal : public Animal
{
};

int main()
{
   Animal *anAnimal[4];
   anAnimal[0] = new Animal();
   anAnimal[1] = new Wolf();
   anAnimal[2] = new Fish();
   anAnimal[3] = new OtherAnimal();

   for(int i = 0; i < 4; i++)
       anAnimal[i]->eat();
}

Output with the virtual method eat:

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

Output without the virtual method eat:

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

[edit] 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 not any 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. This is seen in Java for example.

[edit] C++

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

class B {
  virtual void a_pure_virtual_function() = 0;
};

The pure virtual function declaration provides only the prototype of the method. The actual implementation can be provided out-of-line if desired, and must be overriden in derived concrete classes.

The compiler knows which method implementation to call at runtime by creating a table of pointers to all of the virtual functions in a class, called a vtable or virtual table.

[edit] Virtual Destructors

Object-oriented languages typically manage memory allocation and deletion 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, whilst deleting an instance of class B will correctly call destructors for both B and A if deleted as an instance of B, an instance of B deleted via a pointer to its base class A will fail to call the destructor for B.

#include <iostream>

class A
{
public:

  A() { }
  ~A() { std::cout << "Destroy A" << std::endl; }
};

class B : public A
{
public:

  B() { }
  ~B() { std::cout << "Destroy B" << std::endl; }
};

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

  delete b2; // Calls destructors ~B() and ~A()
  delete b1; // Only ~A() is called though b1 is an instance of class B
             // because ~A() is not declared virtual 

  return 0;
}

Output:

Destroy B
Destroy A
Destroy A

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