(转) Virtual function

原文地址：http://en.wikipedia.org/wiki/Virtual_function

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

• 1 Purpose
• 2 Example
• 3 Abstract classes and pure virtual functions
• 4 Behavior during construction and destruction
• 5 Virtual destructors
• 6 See also
• 7 References 

  Purpose[edit]

  Further information: Dynamic dispatch

  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 either the base class type or 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 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 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 the function called is 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 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.

   

// inner block scopes

#include <iostream>

usingnamespacestd;

int main () {

int x = 10;

int y = 20;

    {

        int x;   // ok, inner scope.

        x = 50;  // sets value to inner x

        y = 50;  // sets value to (outer) y

        cout << "inner block: ";

cout << "x: " << x << ' ';

cout << "y: " << y << ' ';

    }

    cout << "outer block: ";

cout << "x: " << x << ' ';

cout << "y: " << y << ' ';

return 0;

}