In object-oriented programming, in languages such as C++, and Object Pascal, a virtual function or virtual method is an inheritable and overridable function or method for which dynamic dispatch is facilitated. This concept is an important part of the (runtime) polymorphism portion of object-oriented programming (OOP). In short, a virtual function defines a target function to be executed, but the target might not be known at compile time.
Most programming languages, such as JavaScript, PHP and Python, treat all methods as virtual by default and do not provide a modifier to change this behavior. However, some languages provide modifiers to prevent methods from being overridden by derived classes (such as the final and private keywords in Java and PHP).
Purpose
The need of the virtual function or abstract method can be understood as follows:
A class is a user-defined data type. It is used to model an identified Entity in the problem domain. The information required of an entity becomes fields or data members of the class, The actions required of the entity becomes member functions or methods of the class. However, in some situations, It is not possible to provide definition to one or more methods of the class. Let us understand the concept in the following scenario.
The identified Entity is Two-dimensional figure. It has two dimensions. Its area is required to be computed. Triangle, Rectangle, Square, Circle etc. are all two-dimensional figures. However the formula to compute area is different for each of the figures.
In C++, the abstract function is defined as a Pure Virtual Function. A class is a abstract class in C++ if it at least has one pure virtual function. Now in C++, the two-dimensional figure class is implemented as follows:class TwoDFigure { protected: int d1; int d2;
public: TwoDFigure(int d1, int d2) { this->d1 = d1; this->d2 = d2; } // Pure Virtual Function // abstract function as no definition virtual void computeArea() = 0; };The object or an instance of abstract class cannot be created. In other words, it cannot be instantiated. It makes Inheritance and Overriding compulsory.
The concept of the virtual function solves the following problem:
In object-oriented programming, when a derived class inherits from a base class, an object of the derived class may be referred to via a pointer or reference of the base class type instead of the derived class type. If there are base class methods overridden by the derived class, the method actually called by such a reference or pointer can be bound (linked) either 'early' (by the compiler), according to the declared type of the pointer or reference, or 'late' (i.e., by the runtime system of the language), according to the actual type of the object is referred to.
Virtual functions are resolved 'late'. If the function in question is 'virtual' in the base class, the most-derived class's implementation of the function is called according to the actual type of the object referred to, regardless of the declared type of the pointer or reference. If it is not 'virtual', the method is resolved 'early' and selected according to the declared type of the pointer or reference.
Virtual functions allow a program to call methods that don't necessarily even exist at the moment the code is compiled.
In C++, virtual methods are declared by prepending the keyword to the function's declaration in the base class. This modifier is inherited by all implementations of that method in derived classes, meaning that they can continue to over-ride each other and be late-bound. And even if methods owned by the base class call the virtual method, they will instead be calling the derived method. Overloading occurs when two or more methods in one class have the same method name but different parameters. Overriding means having two methods with the same method name and parameters. Overloading is also referred to as function matching, and overriding as dynamic function mapping.
Example
C++
For example, a base class Animal could have a virtual function Eat. Subclass Llama would implement Eat differently than subclass Wolf, but one can invoke Eat on any class instance referred to as Animal, and get the Eat behavior of the specific subclass.
class Animal {
public: // Intentionally not virtual: void Move() { std::cout << "This animal moves in some way" << std::endl; } virtual void Eat() = 0; };
// The class "Animal" may possess a definition for Eat if desired. class Llama : public Animal { public: // The non virtual function Move is inherited but not overridden. void Eat() override { std::cout << "Llamas eat grass!" << std::endl; } };