What is dispatch? Does it imply dynamic resolution?

Question

AFAIK, the term dispatch means just a method resolution and calling. It doesn't matter whether it is static or dynamic. I saw many people are using a term like static dispatch and dynamic dispatch.

What makes me confusing is there're also some mysterious descriptions. I was trying to understand what is multiple dispatch, and it seems just selecting a subprogram by parameter types. If I understood it correctly, there can be both of static multiple dispatch and dynamic multiple dispatch, and we can say C++ is providing multiple dispatch via free functions.

But, Wikipedia article about multiple dispatch says C++ has no multiple dispatch because it doesn't have dynamic resolution of function by multiple parameters. And I really don't get conceptual difference between Common Lisp example and C++ overloaded function. Because I can't find any conceptual difference unless the term multiple dispatch implies dynamic dispatch. And I realized that I am confusing what the dispatching really is

I also checked QA entry Multiple Dispatch vs. Function Overloading, and it seems the answer is premising the term dispatch is basically dynamic. That also makes me confusing.

What is correct meaning of the term dispatch? Does it imply dynamic resolution? Is this term well defined or just conventional? What am I missing?

Answer 1

The terms mean the following:

• static dispatch = the dispatch order is defined at compile time. It simply means that any function/method call say foo() or x.foo() will always invoke the very same function -- this is established once and then stays that way. This implies that the compiler can determine the type of x at compile time.

• dynamic dispatch = the dispatch order is resolved at run time. This means the compiler builds a lookup table of all functions/methods and determines which one to actually call at run time. Say there there is class A and B, both of which implement interface X with method X.bar(). At runtime, y is examined and based on its actual class either A.bar() or B.bar() is called.

• multiple dynamic dispatch = the dispatch order is dependent on function/method name + argument types (=a.k.a. signature), and the actual implementation that gets called is determined dynamically at runtime. Say class A implements methods A.fooBar(int) and A.fooBar(char *), and there is a call to a.fooBar(x) in your program. At runtime both a and x are examined and the actual method to call is determined based on the type of x.

See Wikipedia for more on dynamic dispatch and multiple dynamic dispatch.

Answer 2

My advice here is: don't overthink this one. Dispatch simply means send. Dispatch an event to a listener, dispatch an interrupt to a handler, dispatch a message to a receiver, dispatch a call to a procedure or function: all aspects of the same basic concept. Send the data to the code that will handle it. Resolution means choosing between available destinations, and is just one part of dispatch.

In code terms, the dispatch starts with some kind of packet of information and something that indicate where it should be sent, and is finished when the packet has been sent (dispatched). All languages have some kind of dispatch mechanism built in, but many implement resolution and dispatching schemes to suit a unique purpose. Interrupt handling and windows message processing are examples that come to mind.

C++ can use static or dynamic resolution, but if it chooses between functions based on argument types it can only do so at compile time. Smalltalk/Objective C and Ruby resolve dispatches at runtime, as do many dynamic languages.

Single dispatch means that a single argument is thought of as the receiver and determines which method is called. The method is typically in the class for that receiver object, and the method signature is converted into an offset in a dispatch table (vtable) in that class. The privileged object in C++ is the one before the dot, which becomes the 'this' pointer.

Multiple dispatch means no privileged receiver but typically a pattern matching operation across all argument types. The Common Lisp Object System uses this approach. See https://en.wikipedia.org/wiki/Multiple_dispatch.

In C++ with overloaded operators, A+B and B+A must dispatch to different methods. In CLOS they can be the same.

I probably prefer the term MultiMethods, since it's multi-factor resolution rather than multiple dispatch per se. See http://c2.com/cgi/wiki?MultiMethods. Also http://www.codeproject.com/Articles/242749/Multiple-dispatch-and-double-dispatch.

Answer 3

C++ does not have multiple (dynamic) dispatch. Consider the following:

#include <iostream>

struct Foo {
   virtual ~Foo() {}
};

struct FooOne : public Foo {};

struct Bar {
   virtual ~Bar() {}
   virtual void dispatch (const Foo &) {
      std::cout << "Bar::Dispatch(const Foo &)\n";
   }
};

struct BarOne : public Bar {
   using Bar::dispatch;
   virtual void dispatch (const Foo &) {
      std::cout << "BarOne::Dispatch(const Foo &)\n";
   }
   virtual void dispatch (const FooOne &) {
      std::cout << "BarOne::Dispatch(const FooOne &)\n";
   }
};

void process (Bar & bar, const Foo & foo) {
   bar.dispatch (foo);
}

int main () {
   Foo foo;
   Bar bar;
   FooOne foo_one;
   BarOne bar_one;

   process (bar, foo);
   process (bar, foo_one);

   process (bar_one, foo);
   process (bar_one, foo_one);

   bar_one.dispatch (foo_one);

   return 0;
}

The output from the above is

Bar::Dispatch(const Foo &)
Bar::Dispatch(const Foo &)
BarOne::Dispatch(const Foo &)
BarOne::Dispatch(const Foo &)
BarOne::Dispatch(const FooOne &)

Within process(Foo& foo, const Bar& bar), C++ uses dynamic dispatch on argument foo in the statement foo.dispatch(bar). The third and fourth output lines show this C++-style dynamic dispatch in action. The fourth output line demonstrates that C++ does not have multiple dispatch. If it did, that fourth output line would be the same as the last.

That final line? That's static dispatch. The compiler knows at compile time exactly which function needs to be called. This final call does not go through the virtual table.