4 ms·

Multiple (virtual) dispatch is a central feature of C++ (and I suspect Java as well).

groovy2shoes 9y ago
Virtual dispatch in C++ and Java is dynamic dispatch, but it is singly so rather than multiply so as found in CLOS, Dylan, Julia, etc. If you want multiple dispatch in C++ and its kin, you need to jump through hoops with visitor patterns and such.
foota 9y ago
The difference confused me for a bit, but consider the following: Print(Vehicle v){ print("vehicle"); } Print(Car c){ print("car"); } Print(Boat b){ print("boat"); } Vehicle test = Boat(); Print(test); In a language with multi dispatch I believe this prints boat, whereas with single dispatch it prints vehicle.
- lmitchell 9y ago
  Not quite. Multiple dispatch (as mentioned in sibling comments) is basically 'virtual on both object and argument types', so like: class Vehicle { virtual void Collide(Vehicle other); } class Car { void Collide(Truck other) { /* hit a truck */ } void Collide(Car other) { /* hit another car */ } } class Truck { void Collide(Truck other) { /* hit another truck */ } void Collide(Car other) { /* hit a car */ } } Vehicle c = Car(); Vehicle t = Truck(); c.Collide(t); // with multiple dispatch, calls Car::Collide(Truck)
  - seanmcdirmid 9y ago
    You are using static overloading on the argument rather than dynamic dispatch. If the static type of truck is obscured to a super class, your behavior won't be as expected. In general, overloading shouldn't be used as a replacement for dynamic dispatch, rather it should be used to accommodate multiple incompatible types (e.g. foo(X) and foo(Y) but never foo(Z) if X <: Z and Y <: Z unless foo(Z) maintains the behavior of foo(X) and foo(Y) given an x or a y under subsumption). Multiple dispatch is typically meant to be purely dynamic in meaning, as wiki puts it: > Multiple dispatch or multimethods is a feature of some programming languages in which a function or method can be dynamically dispatched based on the run-time (dynamic) type or, in the more general case some other attribute, of more than one of its arguments.[1] (https://en.wikipedia.org/wiki/Multiple_dispatch https://en.wikipedia.org/wiki/Multiple_dispatch)
    - yorwba 9y ago
      The static type of both c and t is Vehicle, but by dynamic multiple dispatch Car::Collide(Truck) is selected. That's not how C++ works, but the example was exactly about illustrating how C++ doesn't work.
zenhack 9y ago
Unless it's via some new-fangled C++ feature I haven't heard of yet, I'm pretty sure C++ doesn't have multiple dispatch. Can you elaborate on what you're referring to?
- bstamour 9y ago
  C++ doesn't have multiple dispatch. I think the OP was referring to multiple inheritance, which is not the same thing.
  - ZephyrP 9y ago
    I was thinking of runtime single dispatch with compile-time type of the arguments to that function.
    - bstamour 9y ago
      So virtual function overloading? Can you give a small bit of sample code to demonstrate what you mean?
      - ZephyrP 9y ago
        just ordinary virtual function that discriminates upon arguments (at compile-time).
        zenhack 9y ago
        Yeah, multiple dispatch implies more than one argument involved in the dispatch decision at runtime. So that's not the same thing.
barrkel 9y ago
Multiple dispatch is overriding virtual member functions on argument types, not just receiver type. Overloading and overriding are duals; the former is statically determined, the latter dynamically determined. Just like you can overload on the full argument list, multiple dispatch lets you override on the full argument list. This lets you do things like implement the visitor pattern without double dispatch. And C++ doesn't support it without libraries.

Virtual dispatch in C++ and Java is dynamic dispatch, but it is singly so rather than multiply so as found in CLOS, Dylan, Julia, etc. If you want multiple dispatch in C++ and its kin, you need to jump through hoops with visitor patterns and such.

foota 9y ago

The difference confused me for a bit, but consider the following: Print(Vehicle v){ print("vehicle"); } Print(Car c){ print("car"); } Print(Boat b){ print("boat"); } Vehicle test = Boat(); Print(test); In a language with multi dispatch I believe this prints boat, whereas with single dispatch it prints vehicle.

lmitchell 9y ago
Not quite. Multiple dispatch (as mentioned in sibling comments) is basically 'virtual on both object and argument types', so like: class Vehicle { virtual void Collide(Vehicle other); } class Car { void Collide(Truck other) { /* hit a truck */ } void Collide(Car other) { /* hit another car */ } } class Truck { void Collide(Truck other) { /* hit another truck */ } void Collide(Car other) { /* hit a car */ } } Vehicle c = Car(); Vehicle t = Truck(); c.Collide(t); // with multiple dispatch, calls Car::Collide(Truck)
- seanmcdirmid 9y ago
  You are using static overloading on the argument rather than dynamic dispatch. If the static type of truck is obscured to a super class, your behavior won't be as expected. In general, overloading shouldn't be used as a replacement for dynamic dispatch, rather it should be used to accommodate multiple incompatible types (e.g. foo(X) and foo(Y) but never foo(Z) if X <: Z and Y <: Z unless foo(Z) maintains the behavior of foo(X) and foo(Y) given an x or a y under subsumption). Multiple dispatch is typically meant to be purely dynamic in meaning, as wiki puts it: > Multiple dispatch or multimethods is a feature of some programming languages in which a function or method can be dynamically dispatched based on the run-time (dynamic) type or, in the more general case some other attribute, of more than one of its arguments.[1] (https://en.wikipedia.org/wiki/Multiple_dispatch https://en.wikipedia.org/wiki/Multiple_dispatch)
  - yorwba 9y ago
    The static type of both c and t is Vehicle, but by dynamic multiple dispatch Car::Collide(Truck) is selected. That's not how C++ works, but the example was exactly about illustrating how C++ doesn't work.

zenhack 9y ago

Unless it's via some new-fangled C++ feature I haven't heard of yet, I'm pretty sure C++ doesn't have multiple dispatch. Can you elaborate on what you're referring to?

bstamour 9y ago
C++ doesn't have multiple dispatch. I think the OP was referring to multiple inheritance, which is not the same thing.
- ZephyrP 9y ago
  I was thinking of runtime single dispatch with compile-time type of the arguments to that function.
  - bstamour 9y ago
    So virtual function overloading? Can you give a small bit of sample code to demonstrate what you mean?
    - ZephyrP 9y ago
      just ordinary virtual function that discriminates upon arguments (at compile-time).
      - zenhack 9y ago
        Yeah, multiple dispatch implies more than one argument involved in the dispatch decision at runtime. So that's not the same thing.

barrkel 9y ago

Multiple dispatch is overriding virtual member functions on argument types, not just receiver type. Overloading and overriding are duals; the former is statically determined, the latter dynamically determined. Just like you can overload on the full argument list, multiple dispatch lets you override on the full argument list. This lets you do things like implement the visitor pattern without double dispatch. And C++ doesn't support it without libraries.