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

編集履歴

質問編集履歴

リンクを見やすくした。

2020/03/20 18:48

投稿

Paalon

スコア266

test CHANGED Viewed

File without changes

test CHANGED Viewed

@@ -606,6 +606,8 @@
-文字数上限に達してしまったので別の質問をたてて、続きを書きました。
+文字数上限に達してしまったので別の質問をたてて、続きを書きます。リンクはこちらです。
-https://teratail.com/questions/248408
+* [C++ で多重ディスパッチをする方法と Julia ２](https://teratail.com/questions/248408)

追記３。

2020/03/20 18:48

投稿

Paalon

スコア266

test CHANGED Viewed

File without changes

test CHANGED Viewed

@@ -595,3 +595,17 @@
 がどういう意味か分かりません。 `Animal ≠ Dog`, `Animal ≠ Cat` ではないということでしょうか？
+---
+**追記３**：
+文字数上限に達してしまったので別の質問をたてて、続きを書きました。
+https://teratail.com/questions/248408

追記２。

2020/03/20 18:46

投稿

Paalon

スコア266

test CHANGED Viewed

File without changes

test CHANGED Viewed

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

cat を追加。

2020/03/14 16:31

投稿

Paalon

スコア266

test CHANGED Viewed

File without changes

test CHANGED Viewed

@@ -588,6 +588,8 @@
 Animal dog = Dog();
+Animal cat = Cat();
 ```

日本語として修正。

2020/03/14 15:00

投稿

Paalon

スコア266

test CHANGED Viewed

File without changes

test CHANGED Viewed

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

追記２。

2020/03/14 14:59

投稿

Paalon

スコア266

test CHANGED Viewed

File without changes

test CHANGED Viewed

@@ -569,3 +569,27 @@
 にすべきでした。
+---
+**追記２**：
+どこが分かってないのか分かってきた気がします。Julia では `abstract type` はインスタンス化できないので、`Animal` 型のオブジェクトは存在しないので、私が Julia 脳になっているので C++ での
+```cpp
+Animal dog = Dog();
+```
+がどういう意味か分かりません。

追記１。

2020/03/14 14:58

投稿

Paalon

スコア266

test CHANGED Viewed

File without changes

test CHANGED Viewed

@@ -507,3 +507,65 @@
 私の理解のうち何が間違っているのでしょうか？
+---
+**追記１**：
+```julia
+function content(::Box{<:Animal})
+    println("This box has an animal.")
+end
+```
+```cpp
+template <typename T>
+auto content(Box<T> box) {
+    cout << "This box has an animal." << endl;
+}
+```
+の部分の Julia の `<:Animal` の部分が C++ だと表現できてないので C++20 の機能を使って
+```cpp
+#include <concepts>
+template <typename T>
+requires std::derived_from<T, Animal>
+auto content(Box<T> box) {
+    cout << "This box has an animal." << endl;
+}
+```
+にすべきでした。

再調整

2020/03/14 13:28

投稿

Paalon

スコア266

test CHANGED Viewed

File without changes

test CHANGED Viewed

@@ -4,45 +4,9 @@
 >
-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](https://en.wikipedia.org/wiki/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.
+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](https://en.wikipedia.org/wiki/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.

引用部分を見やすく変更した。

2020/03/14 07:25

投稿

Paalon

スコア266

test CHANGED Viewed

File without changes

test CHANGED Viewed

@@ -4,13 +4,45 @@
 >
-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.
+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](https://en.wikipedia.org/wiki/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.
+[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.