This article needs additional citations for verification .(March 2013) |
Polymorphism |
---|
Ad hoc polymorphism |
Parametric polymorphism |
Subtyping |
In object-oriented programming such as is often used in C++ and Object Pascal, a virtual function or virtual method is an inheritable and overridable function or method that is dispatched dynamically. Virtual functions are an important part of (runtime) polymorphism in object-oriented programming (OOP). They allow for the execution of target functions that were not precisely identified at compile time.
Most programming languages, such as JavaScript, PHP and Python, treat all methods as virtual by default [1] [2] 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 [3] and PHP [4] ).
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.[ citation needed ]
In C++, virtual methods are declared by prepending the virtual
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.
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.
classAnimal{public:// Intentionally not virtual:voidMove(){std::cout<<"This animal moves in some way"<<std::endl;}virtualvoidEat()=0;};// The class "Animal" may possess a definition for Eat if desired.classLlama:publicAnimal{public:// The non virtual function Move is inherited but not overridden.voidEat()override{std::cout<<"Llamas eat grass!"<<std::endl;}};
This allows a programmer to process a list of objects of class Animal
, telling each in turn to eat (by calling Eat
), without needing to know what kind of animal may be in the list, how each animal eats, or what the complete set of possible animal types might be.
In C, the mechanism behind virtual functions could be provided in the following manner:
#include<stdio.h>/* an object points to its class... */structAnimal{conststructAnimalVTable*vtable;};/* which contains the virtual function Animal.Eat */structAnimalVTable{void(*Eat)(structAnimal*self);// 'virtual' function };/* Since Animal.Move is not a virtual function it is not in the structure above.*/voidMove(conststructAnimal*self){printf("<Animal at %p> moved in some way\n",(void*)(self));}/* unlike Move, which executes Animal.Move directly, Eat cannot know which function (if any) to call at compile time. Animal.Eat can only be resolved at run time when Eat is called.*/voidEat(structAnimal*self){conststructAnimalVTable*vtable=*(constvoid**)(self);if(vtable->Eat!=NULL){(*vtable->Eat)(self);// execute Animal.Eat}else{fprintf(stderr,"'Eat' virtual method not implemented\n");}}/* implementation of Llama.Eat this is the target function to be called by 'void Eat(struct Animal *self).'*/staticvoid_Llama_eat(structAnimal*self){printf("<Llama at %p> Llama's eat grass!\n",(void*)(self));}/* initialize class */conststructAnimalVTableAnimal={NULL};// base class does not implement Animal.EatconststructAnimalVTableLlama={_Llama_eat};// but the derived class doesintmain(void){/* init objects as instance of its class */structAnimalanimal={&Animal};structAnimalllama={&Llama};Move(&animal);// Animal.MoveMove(&llama);// Llama.MoveEat(&animal);// cannot resolve Animal.Eat so print "Not Implemented" to stderrEat(&llama);// resolves Llama.Eat and executes}
A pure virtual function or pure virtual method is a virtual function that is required to be implemented by a derived class if the derived class is not abstract. Classes containing pure virtual methods are termed "abstract" and they cannot be instantiated directly. 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 some languages (e.g. C++ and Python) are permitted to contain an implementation in their declaring class, providing fallback or default behaviour that a derived class can delegate to, if appropriate. [5] [6]
Pure virtual functions can also be used where the method declarations are being used to define an interface - similar to what the interface keyword in Java explicitly specifies. In such a use, derived classes will supply all implementations. In such a design pattern, the abstract class which serves as an interface will contain only pure virtual functions, but no data members or ordinary methods. In C++, using such purely abstract classes as interfaces works because C++ supports multiple inheritance. However, because many OOP languages do not support multiple inheritance, they often provide a separate interface mechanism. An example is the Java programming language.
Languages differ in their behavior while the constructor or destructor of an object is running. For this reason, calling virtual functions in constructors is generally discouraged.
In C++, the "base" function is called. Specifically, the most derived function that is not more derived than the current constructor or destructor's class is called. [7] : §15.7.3 [8] [9] If that function is a pure virtual function, then undefined behavior occurs. [7] : §13.4.6 [8] This is true even if the class contains an implementation for that pure virtual function, since a call to a pure virtual function must be explicitly qualified. [10] A conforming C++ implementation is not required (and generally not able) to detect indirect calls to pure virtual functions at compile time or link time. Some runtime systems will issue a pure virtual function call error when encountering a call to a pure virtual function at run time.
In Java and C#, the derived implementation is called, but some fields are not yet initialized by the derived constructor (although they are initialized to their default zero values). [11] Some design patterns, such as the Abstract Factory Pattern, actively promote this usage in languages supporting this ability.
Object-oriented languages typically manage memory allocation and de-allocation automatically when objects are created and destroyed. However, some object-oriented languages allow a custom destructor method to be implemented, if desired. If the language in question uses automatic memory management, the custom destructor (generally called a finalizer in this context) that is called is certain to be the appropriate one for the object in question. For example, if an object of type Wolf that inherits Animal is created, and both have custom destructors, the one called will be the one declared in Wolf.
In manual memory management contexts, the situation can be more complex, particularly in relation to static dispatch. If an object of type Wolf is created but pointed to by an Animal pointer, and it is this Animal pointer type that is deleted, the destructor called may actually be the one defined for Animal and not the one for Wolf, unless the destructor is virtual. This is particularly the case with C++, where the behavior is a common source of programming errors if destructors are not virtual.
In object-oriented programming, a class is an extensible program-code-template for creating objects, providing initial values for state and implementations of behavior.
In object oriented programming, the factory method pattern is a creational pattern that uses factory methods to deal with the problem of creating objects without having to specify their exact class. Rather than by calling a constructor, this is done by calling a factory method to create an object. Factory methods can either be specified in an interface and implemented by child classes, or implemented in a base class and optionally overridden by derived classes.
In object-oriented programming, the decorator pattern is a design pattern that allows behavior to be added to an individual object, dynamically, without affecting the behavior of other instances of the same class. The decorator pattern is often useful for adhering to the Single Responsibility Principle, as it allows functionality to be divided between classes with unique areas of concern as well as to the Open-Closed Principle, by allowing the functionality of a class to be extended without being modified. Decorator use can be more efficient than subclassing, because an object's behavior can be augmented without defining an entirely new object.
In object-oriented (OO) and functional programming, an immutable object is an object whose state cannot be modified after it is created. This is in contrast to a mutable object, which can be modified after it is created. In some cases, an object is considered immutable even if some internally used attributes change, but the object's state appears unchanging from an external point of view. For example, an object that uses memoization to cache the results of expensive computations could still be considered an immutable object.
This is a list of terms found in object-oriented programming.
A method in object-oriented programming (OOP) is a procedure associated with an object, and generally also a message. An object consists of state data and behavior; these compose an interface, which specifies how the object may be used. A method is a behavior of an object parametrized by a user.
In programming language theory and type theory, polymorphism is the use of a single symbol to represent multiple different types.
In computer programming, a function object is a construct allowing an object to be invoked or called as if it were an ordinary function, usually with the same syntax. In some languages, particularly C++, function objects are often called functors.
In computer programming, a virtual method table (VMT), virtual function table, virtual call table, dispatch table, vtable, or vftable is a mechanism used in a programming language to support dynamic dispatch.
Method overriding, in object-oriented programming, is a language feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its superclasses or parent classes. In addition to providing data-driven algorithm-determined parameters across virtual network interfaces, it also allows for a specific type of polymorphism (subtyping). The implementation in the subclass overrides (replaces) the implementation in the superclass by providing a method that has same name, same parameters or signature, and same return type as the method in the parent class. The version of a method that is executed will be determined by the object that is used to invoke it. If an object of a parent class is used to invoke the method, then the version in the parent class will be executed, but if an object of the subclass is used to invoke the method, then the version in the child class will be executed. This helps in preventing problems associated with differential relay analytics which would otherwise rely on a framework in which method overriding might be obviated. Some languages allow a programmer to prevent a method from being overridden.
Virtual inheritance is a C++ technique that ensures only one copy of a base class's member variables are inherited by grandchild derived classes. Without virtual inheritance, if two classes B
and C
inherit from a class A
, and a class D
inherits from both B
and C
, then D
will contain two copies of A
's member variables: one via B
, and one via C
. These will be accessible independently, using scope resolution.
In object-oriented programming, a destructor is a method which is invoked mechanically just before the memory of the object is released. It can happen when its lifetime is bound to scope and the execution leaves the scope, when it is embedded in another object whose lifetime ends, or when it was allocated dynamically and is released explicitly. Its main purpose is to free the resources which were acquired by the object during its life and/or deregister from other entities which may keep references to it. Use of destructors is needed for the process of Resource Acquisition Is Initialization (RAII).
In computer programming, an opaque pointer is a special case of an opaque data type, a data type declared to be a pointer to a record or data structure of some unspecified type.
In object-oriented programming, inheritance is the mechanism of basing an object or class upon another object or class, retaining similar implementation. Also defined as deriving new classes from existing ones such as super class or base class and then forming them into a hierarchy of classes. In most class-based object-oriented languages like C++, an object created through inheritance, a "child object", acquires all the properties and behaviors of the "parent object", with the exception of: constructors, destructors, overloaded operators and friend functions of the base class. Inheritance allows programmers to create classes that are built upon existing classes, to specify a new implementation while maintaining the same behaviors, to reuse code and to independently extend original software via public classes and interfaces. The relationships of objects or classes through inheritance give rise to a directed acyclic graph.
A class in C++ is a user-defined type or data structure declared with any of the keywords class
, struct
or union
that has data and functions as its members whose access is governed by the three access specifiers private, protected or public. By default access to members of a C++ class declared with the keyword class
is private. The private members are not accessible outside the class; they can be accessed only through member functions of the class. The public members form an interface to the class and are accessible outside the class.
An interface in the Java programming language is an abstract type that is used to declare a behavior that classes must implement. They are similar to protocols. Interfaces are declared using the interface
keyword, and may only contain method signature and constant declarations. All methods of an Interface do not contain implementation as of all versions below Java 8. Starting with Java 8, default
and static
methods may have implementation in the interface
definition. Then, in Java 9, private
and private static
methods were added. At present, a Java interface can have up to six different types.
The curiously recurring template pattern (CRTP) is an idiom, originally in C++, in which a class X
derives from a class template instantiation using X
itself as a template argument. More generally it is known as F-bound polymorphism, and it is a form of F-bounded quantification.
C++11 is a version of the ISO/IEC 14882 standard for the C++ programming language. C++11 replaced the prior version of the C++ standard, called C++03, and was later replaced by C++14. The name follows the tradition of naming language versions by the publication year of the specification, though it was formerly named C++0x because it was expected to be published before 2010.
In object-oriented computer programming, a null object is an object with no referenced value or with defined neutral (null) behavior. The null object design pattern, which describes the uses of such objects and their behavior, was first published as "Void Value" and later in the Pattern Languages of Program Design book series as "Null Object".
This article describes the syntax of the C# programming language. The features described are compatible with .NET Framework and Mono.