end # ... end class PrinterPort def display_rectangle(object) # code for displaying a rectangle on a PrinterPort end def display_oval(object) # code for displaying an oval on a PrinterPort end # ... end Double dispatch in C++ At first glance, double dispatch appears to be a natural result of function overloading. Function overloading allows the function called to depend on the type of the argument. Function overloading, however, is done at compile time using "name mangling" where the internal name of the function encodes the argument's type. For example, a function foo(int) may internally be called and the function foo(double) may be called . Thus, there is no name collision, and no virtual table lookup. By contrast, dynamic dispatch is based on the type of the calling object, meaning it uses virtual functions (overriding) instead of function overloading, and does result in a vtable lookup. Consider the following example, written in C++, of collisions in a game: class SpaceShip {}; class ApolloSpacecraft : public SpaceShip {}; class Asteroid { public: virtual void CollideWith(SpaceShip&) { std::cout << "Asteroid hit a SpaceShip\n"; } virtual void CollideWith(ApolloSpacecraft&) { std::cout << "Asteroid hit an ApolloSpacecraft\n"; } }; class ExplodingAsteroid : public Asteroid { public: void CollideWith(SpaceShip&) override { std::cout << "ExplodingAsteroid hit a SpaceShip\n"; } void CollideWith(ApolloSpacecraft&) override { std::cout << "ExplodingAsteroid hit an ApolloSpacecraft\n"; } }; If you have: Asteroid theAsteroid; SpaceShip theSpaceShip; ApolloSpacecraft theApolloSpacecraft; then, because of function overloading, theAsteroid.CollideWith(theSpaceShip); theAsteroid.CollideWith(theApolloSpacecraft); will print, respectively, Asteroid hit a SpaceShip and Asteroid hit an ApolloSpacecraft, without using any dynamic dispatch. Furthermore: ExplodingAsteroid theExplodingAsteroid; theExplodingAsteroid.CollideWith(theSpaceShip); theExplodingAsteroid.CollideWith(theApolloSpacecraft); will print ExplodingAsteroid hit a SpaceShip and ExplodingAsteroid hit an ApolloSpacecraft respectively, again without dynamic dispatch. With a reference to an Asteroid, dynamic dispatch is used, and this code: Asteroid& theAsteroidReference = theExplodingAsteroid; theAsteroidReference.CollideWith(theSpaceShip); theAsteroidReference.CollideWith(theApolloSpacecraft); prints ExplodingAsteroid hit a SpaceShip and ExplodingAsteroid hit an ApolloSpacecraft, again as expected. However, the following code does not work as desired: SpaceShip& theSpaceShipReference = theApolloSpacecraft; theAsteroid.CollideWith(theSpaceShipReference); theAsteroidReference.CollideWith(theSpaceShipReference); The desired behaviour is to bind these calls to the function that takes theApolloSpacecraft as its argument, as that is the instantiated type of the variable, meaning the expected output would be Asteroid hit an ApolloSpacecraft and ExplodingAsteroid hit an ApolloSpacecraft. However, the output is actually Asteroid hit a SpaceShip and ExplodingAsteroid hit a SpaceShip. The problem is that, while virtual functions are dispatched dynamically in C++, function overloading is done statically. The problem described above