great explanation by Alan Johnson about static and dynamic dispatch in C++.

static_and_dynamic_dispatch.cpp

/*
 * @link http://stackoverflow.com/questions/13600934/why-is-the-virtual-keyword-needed
 * @author Alan Johnson
 * > Hi,
 * > 
 * > Can someone explain to me what static and dynamic dispatch are and what
 * > the difference is between the two? Do this even occurr in C++?
 * >  
 * > Thanks
 * 
 * In the context of C++, "dispatch" is just a fancy name for calling a
 * member function. A "static" dispatch is one where all the type
 * information needed to decide which function to call is known at compile
 * time. Consider the following example:
 * 
 * Here's another resource: @link http://condor.depaul.edu/ichu/csc447/notes/wk10/Dynamic2.htm
 */
#include <iostream>

class A
{
public:
void f() const { std::cout << "A::f()" << std::endl ; }
} ;

class B
{
public:
void f() const { std::cout << "B::f()" << std::endl ; }
} ;

int main()
{
A a ;
B b ;

a.f() ;
b.f() ;
}

/*
 * Here, the compiler has all the type information needed to figure out
 * which function "f" to call in each case. In the first call, A::f is
 * called, and in the second, B::f is called.
 * 
 * Dynamic dispatching is needed when it cannot be determined until runtime
 * which function to call. In C++, this is implemented using virtual
 * functions. Consider the following:
 */
#include <iostream>

class base
{
public:
virtual void f() const = 0 ;
virtual ~base() {}
} ;

class A : public base
{
public:
virtual void f() const { std::cout << "A::f()" << std::endl ; }
} ;

class B : public base
{
public:
virtual void f() const { std::cout << "B::f()" << std::endl ; }
} ;

void dispatch(const base & x)
{
x.f() ;
}

int main()
{
A a ;
B b ;

dispatch(a) ;
dispatch(b) ;
}

// The line "x.f() ;" gets executed twice, but a different function gets
// called each time.