Editing Double dispatch (section)

==Use cases==
Double dispatch is useful in situations where the choice of computation depends on the runtime types of its arguments. For example, a programmer could use double dispatch in the following situations:
* ''Sorting a mixed set of objects:'' algorithms require that a list of objects be sorted into some canonical order. Deciding if one element comes before another element requires knowledge of both types and possibly some subset of the fields.
* ''Adaptive collision algorithms'' usually require that collisions between different objects be handled in different ways. A typical example is in a game environment where the collision between a spaceship and an asteroid is computed differently from the collision between a spaceship and a spacestation.<ref>More Effective C++ by Scott Meyers(Addison-Wesley, 1996)</ref>
* ''Painting algorithms'' that require the intersection points of overlapping [[sprite (computer graphics)|sprites]] to be rendered in a different manner.
* ''Personnel management'' systems may ''dispatch'' different types of jobs to different personnel. A <code>schedule</code> algorithm that is given a person object typed as an accountant and a job object typed as engineering rejects the scheduling of that person for that job.
* ''Event handling'' systems that use both the event type and the type of the receptor object in order to call the correct event handling routine.
* ''Lock and key'' systems where there are many types of locks and many types of keys and every type of key opens multiple types of locks. Not only do you need to know the types of the objects involved, but the subset of "information about a particular key that are relevant to seeing if a particular key opens a particular lock" is different between different lock types.

===A common idiom===
The common idiom, as in the examples presented above, is that the selection of the appropriate algorithm is based on the call's argument types at runtime. The call is therefore subject to all the usual additional performance costs that are associated with dynamic resolution of calls, usually more than in a language supporting only single method dispatch. In [[C++]], for example, a dynamic function call is usually resolved by a ''single'' [[Offset (computer science)|offset]] calculation - which is possible because the compiler knows the location of the function in the object's [[virtual method table|method table]] and so can statically calculate the offset. In a language supporting ''double'' dispatch, this is slightly more costly, because the compiler must generate code to calculate the method's offset in the method table at runtime, thereby increasing the overall [[instruction path length]] (by an amount that is likely to be no more than the total number of calls to the function, which may not be very significant).