Specifies that a non-staticmember function isvirtual and supports dynamic dispatch. It may only appear in thedecl-specifier-seq of the initial declaration of a non-static member function (i.e., when it is declared in the class definition).

[edit]Explanation

Virtual functions are member functions whose behavior can be overridden in derived classes. As opposed to non-virtual functions, the overriding behavior is preserved even if there is no compile-time information about the actual type of the class. That is to say, if a derived class is handled using pointer or reference to the base class, a call to an overridden virtual function would invoke the behavior defined in the derived class. Such a function call is known asvirtual function call orvirtual call. Virtual function call is suppressed if the function is selected usingqualified name lookup (that is, if the function's name appears to the right of the scope resolution operator::).

#include <iostream> struct Base{virtualvoid f(){std::cout<<"base\n";}}; struct Derived: Base{void f() override// 'override' is optional{std::cout<<"derived\n";}}; int main(){    Base b;    Derived d; // virtual function call through reference    Base& br= b;// the type of br is Base&    Base& dr= d;// the type of dr is Base& as well    br.f();// prints "base"    dr.f();// prints "derived" // virtual function call through pointer    Base* bp=&b;// the type of bp is Base*    Base* dp=&d;// the type of dp is Base* as well    bp->f();// prints "base"    dp->f();// prints "derived" // non-virtual function call    br.Base::f();// prints "base"    dr.Base::f();// prints "base"}

[edit]In detail

If some member functionvf is declared asvirtual in a classBase, and some classDerived, which is derived, directly or indirectly, fromBase, has a declaration for member function with the same

• name
• parameter type list (but not the return type)
• cv-qualifiers
• ref-qualifiers

Then this function in the classDerived is alsovirtual (whether or not the keywordvirtual is used in its declaration) andoverrides Base::vf (whether or not the specifieroverride is used in its declaration).

Base::vf does not need to be accessible or visible to be overridden. (Base::vf can be declared private, orBase can be inherited using private inheritance. Any members with the same name in a base class ofDerived which inheritsBase do not matter for override determination, even if they would hideBase::vf during name lookup.)

class B{virtualvoid do_f();// private memberpublic:void f(){ do_f();}// public interface}; struct D:public B{void do_f() override;// overrides B::do_f}; int main(){    D d;    B* bp=&d;    bp->f();// internally calls D::do_f();}

For every virtual function, there is thefinal overrider, which is executed when a virtual function call is made. A virtual member functionvf of a base classBase is the final overrider unless the derived class declares or inherits (through multiple inheritance) another function that overridesvf.

struct A{virtualvoid f();};// A::f is virtualstruct B: A{void f();};// B::f overrides A::f in Bstruct C:virtual B{void f();};// C::f overrides A::f in C struct D:virtual B{};// D does not introduce an overrider, B::f is final in D struct E: C, D// E does not introduce an overrider, C::f is final in E{using A::f;// not a function declaration, just makes A::f visible to lookup}; int main(){    E e;    e.f();// virtual call calls C::f, the final overrider in e    e.E::f();// non-virtual call calls A::f, which is visible in E}

If a function has more than one final overrider, the program is ill-formed:

struct A{virtualvoid f();}; struct VB1:virtual A{void f();// overrides A::f}; struct VB2:virtual A{void f();// overrides A::f}; // struct Error : VB1, VB2// {//     // Error: A::f has two final overriders in Error// }; struct Okay: VB1, VB2{void f();// OK: this is the final overrider for A::f}; struct VB1a:virtual A{};// does not declare an overrider struct Da: VB1a, VB2{// in Da, the final overrider of A::f is VB2::f};

A function with the same name but different parameter list does not override the base function of the same name, buthides it: whenunqualified name lookup examines the scope of the derived class, the lookup finds the declaration and does not examine the base class.

struct B{virtualvoid f();}; struct D: B{void f(int);// D::f hides B::f (wrong parameter list)}; struct D2: D{void f();// D2::f overrides B::f (doesn't matter that it's not visible)}; int main(){    B b;    B& b_as_b= b;     D d;    B& d_as_b= d;    D& d_as_d= d;     D2 d2;    B& d2_as_b= d2;    D& d2_as_d= d2;     b_as_b.f();// calls B::f()    d_as_b.f();// calls B::f()    d2_as_b.f();// calls D2::f()     d_as_d.f();// Error: lookup in D finds only f(int)    d2_as_d.f();// Error: lookup in D finds only f(int)}

struct B{virtualvoid f(int);}; struct D: B{virtualvoid f(int) override;// OK, D::f(int) overrides B::f(int)virtualvoid f(long) override;// Error: f(long) does not override B::f(int)};

struct B{virtualvoid f()const final;}; struct D: B{void f()const;// Error: D::f attempts to override final B::f};

Non-member functions and static member functions cannot be virtual.

Function templates cannot be declaredvirtual. This applies only to functions that are themselves templates - a regular member function of a class template can be declared virtual.

struct A{virtualvoid f() requirestrue;// Error: constrained virtual function};

Default arguments for virtual functions are substituted at the compile time.

[edit]Covariant return types

If the functionDerived::f overrides a functionBase::f, their return types must either be the same or becovariant. Two types are covariant if they satisfy all of the following requirements:

• both types are pointers or references (lvalue or rvalue) to classes. Multi-level pointers or references are not allowed.
• the referenced/pointed-to class in the return type ofBase::f() must be an unambiguous and accessible direct or indirect base class of the referenced/pointed-to class of the return type ofDerived::f().
• the return type ofDerived::f() must be equally or less cv-qualified than the return type ofBase::f().

The class in the return type ofDerived::f must be eitherDerived itself, or must be acomplete type at the point of declaration ofDerived::f.

When a virtual function call is made, the type returned by the final overrider isimplicitly converted to the return type of the overridden function that was called:

class B{}; struct Base{virtualvoid vf1();virtualvoid vf2();virtualvoid vf3();virtual B* vf4();virtual B* vf5();}; class D:private B{friendstruct Derived;// in Derived, B is an accessible base of D}; class A;// forward-declared class is an incomplete type struct Derived:public Base{void vf1();// virtual, overrides Base::vf1()void vf2(int);// non-virtual, hides Base::vf2()//  char vf3();    // Error: overrides Base::vf3, but has different// and non-covariant return type    D* vf4();// overrides Base::vf4() and has covariant return type//  A* vf5();      // Error: A is incomplete type}; int main(){    Derived d;    Base& br= d;    Derived& dr= d;     br.vf1();// calls Derived::vf1()    br.vf2();// calls Base::vf2()//  dr.vf2(); // Error: vf2(int) hides vf2()     B* p= br.vf4();// calls Derived::vf4() and converts the result to B*    D* q= dr.vf4();// calls Derived::vf4() and does not convert the result to B*}

[edit]Virtual destructor

Even though destructors are not inherited, if a base class declares its destructorvirtual, the derived destructor always overrides it. This makes it possible to delete dynamically allocated objects of polymorphic type through pointers to base.

class Base{public:virtual ~Base(){/* releases Base's resources */}}; class Derived:public Base{    ~Derived(){/* releases Derived's resources */}}; int main(){    Base* b= new Derived;    delete b;// Makes a virtual function call to Base::~Base()// since it is virtual, it calls Derived::~Derived() which can// release resources of the derived class, and then calls// Base::~Base() following the usual order of destruction}

Moreover, if the destructor of the base class is not virtual, deleting a derived class object through a pointer to the base class isundefined behavior regardless of whether there are resources that would be leaked if the derived destructor is not invoked, unless the selected deallocation function is a destroyingoperator delete(since C++20).

A useful guideline is that the destructor of any base class must bepublic and virtual or protected and non-virtual, whenever delete expressions are involved, e.g. when implicitly used instd::unique_ptr(since C++11).

[edit]During construction and destruction

When a virtual function is called directly or indirectly from a constructor or from a destructor (including during the construction or destruction of the class’s non-static data members, e.g. in a memberinitializer list), and the object to which the call applies is the object under construction or destruction, the function called is the final overriderin the constructor’s or destructor’s class and not one overriding it in a more-derived class. In other words, during construction or destruction, the more-derived classes do not exist.

When constructing a complex class with multiple branches, within a constructor that belongs to one branch, polymorphism is restricted to that class and its bases: if it obtains a pointer or reference to a base subobject outside this subhierarchy, and attempts to invoke a virtual function call (e.g. using explicit member access), the behavior is undefined:

struct V{virtualvoid f();virtualvoid g();}; struct A:virtual V{virtualvoid f();// A::f is the final overrider of V::f in A}; struct B:virtual V{virtualvoid g();// B::g is the final overrider of V::g in B    B(V*, A*);}; struct D: A, B{virtualvoid f();// D::f is the final overrider of V::f in Dvirtualvoid g();// D::g is the final overrider of V::g in D // note: A is initialized before B    D(): B((A*) this, this){}}; // the constructor of B, called from the constructor of DB::B(V* v, A* a){    f();// virtual call to V::f (although D has the final overrider, D doesn't exist)    g();// virtual call to B::g, which is the final overrider in B     v->g();// v's type V is base of B, virtual call calls B::g as before     a->f();// a’s type A is not a base of B. it belongs to a different branch of the// hierarchy. Attempting a virtual call through that branch causes// undefined behavior even though A was already fully constructed in this// case (it was constructed before B since it appears before B in the list// of the bases of D). In practice, the virtual call to A::f will be// attempted using B's virtual member function table, since that's what// is active during B's construction)}

[edit]Keywords

virtual

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]See also

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文