３つのポリモルフィズムと多重ディスパッチについて C++ と Julia での理解がどこか間違っていると思われるがどこか分からない。

Question

Julia では（例えばここで） multiple dispatch / 多重ディスパッチできるよ！と言われ、C++ ではできないよ！と言われていますが、

The choice of which method to execute when a function is applied is called dispatch. Julia allows the dispatch process to choose which of a function's methods to call based on the number of arguments given, and on the types of all of the function's arguments. This is different than traditional object-oriented languages, where dispatch occurs based only on the first argument, which often has a special argument syntax, and is sometimes implied rather than explicitly written as an argument. [1] Using all of a function's arguments to choose which method should be invoked, rather than just the first, is known as multiple dispatch. Multiple dispatch is particularly useful for mathematical code, where it makes little sense to artificially deem the operations to "belong" to one argument more than any of the others: does the addition operation in x + y belong to x any more than it does to y? The implementation of a mathematical operator generally depends on the types of all of its arguments. Even beyond mathematical operations, however, multiple dispatch ends up being a powerful and convenient paradigm for structuring and organizing programs.

[1]: In C++ or Java, for example, in a method call like obj.meth(arg1,arg2), the object obj "receives" the method call and is implicitly passed to the method via the this keyword, rather than as an explicit method argument. When the current this object is the receiver of a method call, it can be omitted altogether, writing just meth(arg1,arg2), with this implied as the receiving object.

自分が思っていた多重ディスパッチの定義だと C++ でも動くようなので、何かの理解を間違えていると思うのですがどこを間違えているのか分かりません。私は３つの polymorphism / ポリモルフィズム（ad hoc / アドホック, subtype / 部分型, parametric / パラメトリック）を Julia と C++ でそれぞれ書くならば、以下のことが行えることと理解しています。

# ad hoc polymorphism

mutable struct A end

mutable struct B end

function adhoc(::A)
    println("A")
end

function adhoc(::B)
    println("B")
end

function adhoc(::A, ::A)
    println("A A")
end

function adhoc(::B, ::B)
    println("B B")
end

function adhoc(::A, ::B)
    println("A B")
end

function adhoc(::B, ::A)
    println("B A")
end

a = A()
b = B()

adhoc(a)
adhoc(b)
adhoc(a, a)
adhoc(b, b)
adhoc(a, b)
adhoc(b, a)

# subtype polymorphism

abstract type Animal end

mutable struct Dog <: Animal end

mutable struct Cat <: Animal end

function is(::Animal)
    println("animal")
end

function is(::Cat)
    println("cat")
end

function is(::Animal, ::Animal)
    println("animal animal")
end

function is(::Cat, ::Animal)
    println("cat animal")
end

function is(::Animal, ::Cat)
    println("animal cat")
end

function is(::Cat, ::Cat)
    println("cat cat")
end

dog = Dog()
cat = Cat()

is(dog)
is(cat)
is(dog, dog)
is(cat, cat)
is(dog, cat)
is(cat, dog)

# parametric polymorphism

mutable struct Box{T}
    object::T
end

function content(::Box{<:Animal})
    println("This box has an animal.")
end

function content(::Box{Cat})
    println("This box has a cat.")
end

box_with_dog = Box(dog)
box_with_cat = Box(cat)

content(box_with_dog)
content(box_with_cat)

#include <iostream>

using std::cout, std::endl;

// ad hoc polymorphism

struct A {};

struct B {};

auto adhoc(A x) {
    cout << "A" << endl;
}

auto adhoc(B x) {
    cout << "B" << endl;
}

auto adhoc(A x, A y) {
    cout << "A A" << endl;
}

auto adhoc(B x, B y) {
    cout << "B B" << endl;
}

auto adhoc(A x, B y) {
    cout << "A B" << endl;
}

auto adhoc(B x, A y) {
    cout << "B A" << endl;
}

// subtype polymorphism

struct Animal {};

struct Dog : Animal {};

struct Cat : Animal {};

auto is(Animal animal) {
    cout << "animal" << endl;
}

auto is(Cat cat) {
    cout << "cat" << endl;
}

auto is(Animal animal1, Animal animal2) {
    cout << "animal animal" << endl;
}

auto is(Cat cat1, Cat cat2) {
    cout << "cat cat" << endl;
}

auto is(Animal animal, Cat cat) {
    cout << "animal cat" << endl;
}

auto is(Cat cat, Animal animal) {
    cout << "cat animal" << endl;
}

// parametric polymorphism

template <typename T>
struct Box {
    T object;
    Box(T x) {}
};

template <typename T>
auto content(Box<T> box) {
    cout << "This box has an animal." << endl;
}

auto content(Box<Cat> cat) {
    cout << "This box has a cat." << endl;
}

int main() {

    // ad hoc polymorphism

    auto a = A();
    auto b = B();

    adhoc(a);
    adhoc(b);
    adhoc(a, a);
    adhoc(b, b);
    adhoc(a, b);
    adhoc(b, a);

    // subtype polymorphism

    auto dog = Dog();
    auto cat = Cat();

    is(dog);
    is(cat);
    is(dog, dog);
    is(cat, cat);
    is(dog, cat);
    is(cat, dog);

    // parametric polymorphism

    auto box_with_dog = Box(dog);
    auto box_with_cat = Box(cat);

    content(box_with_dog);
    content(box_with_cat);
}

多重ディスパッチはここで言うところの部分型ポリモルフィズムを１つの引数に限らず、全ての引数について行えることだと理解していて C++ だとコンパイルできないのかと思っていたのですが、このコードは以下の出力のようにどちらも自分の思ったように動きます。

A
B
A A
B B
A B
B A
animal
cat
animal animal
cat cat
animal cat
cat animal
This box has an animal.
This box has a cat.

私の理解のうち何が間違っているのでしょうか？

---

追記１：

function content(::Box{<:Animal})
    println("This box has an animal.")
end

template <typename T>
auto content(Box<T> box) {
    cout << "This box has an animal." << endl;
}

の部分の Julia の <:Animal の部分が C++ だと表現できてないので C++20 の機能を使って

#include <concepts>

template <typename T>
requires std::derived_from<T, Animal>
auto content(Box<T> box) {
    cout << "This box has an animal." << endl;
}

にすべきでした。

---

追記２：

どこが分かってないのか分かってきた気がします。Julia では abstract type はインスタンス化できないので、Animal 型のオブジェクトは存在しません。私が Julia 脳になっているので C++ での

Animal dog = Dog();
Animal cat = Cat();

がどういう意味か分かりません。 Animal ≠ Dog, Animal ≠ Cat ではないということでしょうか？

---

追記３：

文字数上限に達してしまったので別の質問をたてて、続きを書きます。リンクはこちらです。

• C++ で多重ディスパッチをする方法と Julia ２

Comments

[t_obara]

こちらはクローズされてはいかがでしょうか。

Answer 1

C++の場合、親のポインタを介すと

Animal *dog = new Dog();
Animal *cat = new Cat();
is(*dog, *cat);  // => animal animal

になります。

ここで仮想メンバ関数を用いていた場合

class Animal{
  virtual std::string is(Animal*){ return "animal animal"; }
};
class Dog : Animal{
  virtual std::string is(Animal*){ return "dog animal"; }
};
dog->is(*cat);  // => dog animal

は第一引数の型はディスパッチに使われますので自動で判別できます。

---

現実的に問題になるのは配列の場合でしょうか

Animal *animals[] = { new Dog, new Cat };

みたいな事が言いたいのかなと推測します。

---

追記2

Julia では abstract type はインスタンス化できないので、Animal 型のオブジェクトは存在しません。

そういえばC++の方は抽象クラスじゃなかったですね。

struct Animal{ virtual ~Animal() = 0; };

Animal dog = Dog();
Animal cat = Cat();

Dogクラスのインスタンスを作って、コピーコンストラクタでAnimal型の変数にコピーし
結果として、Animal型の変数になりDogとしての部分は切り落とされます。

dog = Animal()
dog .= Dog()

みたいな感じですかね

Comments

[Paalon]

```cpp
auto dog = Dog()
auto cat = Cat()

std::vector<Animal> xs {dog, cat, dog, cat};

for (auto x: xs) {
is(x);
}
```

が

```text
animal
cat
animal
cat
```

ではなく

```text
animal
animal
animal
animal
```

になってしまうということですか？

[asm]

そもそも、std::vector<Animal> xs {dog, cat, dog, cat};の時点でかなりマズいですがそういう事です。

[Paalon]

追記を書こうとしたのですが、文字数上限に達してしまったので新しく質問を作り、続きを書きました。https://teratail.com/questions/248408 よろしければ見ていただけると嬉しいです。

Answer 2

こんにちは。

ポリモーフィズムの用語についてWikipediaのこの記事の定義に従うと、PaalonさんのC++のコードは全てアドホック（オーバーロード）です。
is()はAnimal, Dog, Catクラスのメンバ関数でさえなく、まして仮想関数になっていませんので、部分型多相ではなくオーバーロード（＝アドホック）です。
content()は関数テンプレート（≒パラメータ多相）ではあるのですが、単なるオーバーロードとして使っています。

ところで、多重ティスパッチについてWikipediaのこの記事の冒頭の定義を見る限り、多重ディスパッチはオーバーロードで実現可能です。
しかし、何故か非staticなメンバ関数を持ち出して、これはthis引数を１つしか取れないことを取り上げて単一ディスパッチと呼んでいます。非staticなメンバ関数は「それが便利」なのでthisを特別扱いするものです。
インスタンスに縛られずにオーバーロードしたい場合は、staticメンバ関数やグローバル関数を使えばよいだけです。特に制約はありません。

Comments

[Paalon]

`is` が `Animal`, `Dog`, `Cat` のメンバ関数であることが部分型ポリモルフィズムの必要条件なのですか？ 型 `Dog` を持つ `dog` について `is(Dog dog)` が定義されていないのに、`is(dog)` と書くと `Dog` は `Animal` を継承しているから、`is(Animal animal)` が参照されることが部分型ポリモルフィズムであると考えていたのですが違うのでしょうか？

`content` が関数テンプレート（≒ パラメータ多相）であるのであれば、`content` はパラメトリックポリモルフィズムになっていると言うのは間違っているのでしょうか？

[Chironian]

> と考えていたのですが違うのでしょうか？
回答でリンクしたWikipediaの記事の用語の定義に従うと、違います。
> と言うのは間違っているのでしょうか？
同定義に従うと、間違っています。

同記事によるとsubtype polymorphismの定義を見る限り、これは仮想関数を使ったポリモーフィズムのことを指しています。動的ポリモーフィズムとも呼ばれます。
また、テンプレートを使ったポリモーフィズムは、型パラメータに渡した型が「同じ名前」のメンバ（関数でも変数でも型でも良い）を持っている時、その型パラメータのインスタンスに対して「同じ名前」でそのメンバを呼び出せることを指す場合が多いです。静的ポリモーフィズムとも呼ばれます。
↓ぴったりの解説とサンプル・コードがありました。
https://qiita.com/Riyaaaa_a/items/887f6190e710c6410994
これらのサンプル・コードとPaalonさんのコードを見比べてみて下さい。ご理解頂けると思います。

[Paalon]

追記を書こうとしたのですが、文字数上限に達してしまったので新しく質問を作り、続きを書きました。https://teratail.com/questions/248408 よろしければ見ていただけると嬉しいです。