回答編集履歴

文章ちょっと修正

2017/03/20 07:10

投稿

raccy

スコア21784

answer CHANGED Viewed

@@ -1,4 +1,4 @@
-結論
+Chironianさんのコメントからの結論
 ```C++
 #include <iostream>

結論だけ書いた

2017/03/20 07:09

投稿

raccy

スコア21784

answer CHANGED Viewed

@@ -1,3 +1,50 @@
+結論
+```C++
+#include <iostream>
+class ComplexInt
+{
+private:
+	int real;
+	int imag;
+public:
+	ComplexInt(int real, int imag = 0) : real(real), imag(imag) {}
+	friend ComplexInt operator+(const ComplexInt &x, const ComplexInt &y)
+	{
+		return ComplexInt(x.real + y.real, x.imag + y.imag);
+	}
+	friend std::ostream &operator<<(std::ostream &os, const ComplexInt &ci)
+	{
+		os << ci.real;
+		if (ci.imag >= 0) {
+			os << "+";
+		}
+		os << ci.imag << "i";
+		return os;
+	}
+};
+int main()
+{
+	const ComplexInt a(2, 3);
+	const ComplexInt b(1, -5);
+	std::cout << a << std::endl;
+	std::cout << b << std::endl;
+	std::cout << (a + b) << std::endl;
+	std::cout << (a + 1) << std::endl;
+	std::cout << (1 + a) << std::endl;
+	return 0;
+}
+```
+何も問題なし、以上。
+以下、駄文。
+---
 C++がだめな理由を考えました。
 ---

補足を追加

2017/03/20 07:05

投稿

raccy

スコア21784

answer CHANGED Viewed

@@ -239,8 +239,10 @@
 ぶっちゃけ、C++とScalaでは、単にScalaは暗黙の型変換とか使えば、実装が少なくて済むので楽だよね、程度しか無いと思います。ただ、C++の方が細かく実装できる分、コストがー、コストがー、と言っている深淵を覗くことが大好きな人達には好まれるでしょう。
-C++で何か嫌だと思う点の一つは、メンバー関数として実装できないことだと思います。オブジェクト指向原理主義者からみると、メソッドでない奴は駄目な奴だと勘違いしているのかも知れません。Scalaの暗黙の型変換もさほど変わらないと思うのですが、objectのメソッドだからいいとか言い出すのでしょうか…。
+C++で何か嫌だと思う点の一つは、メンバー関数として実装できないことだと思います※。オブジェクト指向原理主義者からみると、メソッドでない奴は駄目な奴だと勘違いしているのかも知れません。Scalaの暗黙の型変換もさほど変わらないと思うのですが、objectのメソッドだからいいとか言い出すのでしょうか…。
+※ friendsだとできるそうです。追記しています。
 あと、たぶん、何か嫌だと思ってしまうのは、標準型に新たなメンバー関数を追加しているように見えると言うことではないでしょうか。じゃあ、ScalaやRubyはどうなのかというと、確かに、元々の標準型に何かを追加している訳ではありませんが、一歩離れれば、やっていることはさほどかわりありません。やり方が違うだけで目くじら立てるのはどうなのかとは思ってしまいます。
 最後にHaskellを見てみましょう。Haskellの`a + b`は`(+)(a)(b)`です。他の関数と同じようにオーバーロードできます。オブジェクト指向なんかにして、無理にメソッドとかメンバー関数とか、そんなことをするより、全部関数にしておけば良かったのかも知れません。

崩れてた

2017/03/20 04:26

投稿

raccy

スコア21784

answer CHANGED Viewed

@@ -231,6 +231,7 @@
 	std::cout << (1 + a) << std::endl;
 	return 0;
 }
+```
 では、これで一安心だねっていうかと思うと、ちょっと使っただけで、グローバルに動作を影響を与えています。あ、Scalaと暗黙の型変換を検索するところと検索の仕方だけは同じ所に戻っただけのようです。

C\+\+フレンズ

2017/03/20 04:17

投稿

raccy

スコア21784

answer CHANGED Viewed

@@ -242,4 +242,65 @@
 あと、たぶん、何か嫌だと思ってしまうのは、標準型に新たなメンバー関数を追加しているように見えると言うことではないでしょうか。じゃあ、ScalaやRubyはどうなのかというと、確かに、元々の標準型に何かを追加している訳ではありませんが、一歩離れれば、やっていることはさほどかわりありません。やり方が違うだけで目くじら立てるのはどうなのかとは思ってしまいます。
-最後にHaskellを見てみましょう。Haskellの`a + b`は`(+)(a)(b)`です。他の関数と同じようにオーバーロードできます。オブジェクト指向なんかにして、無理にメソッドとかメンバー関数とか、そんなことをするより、全部関数にしておけば良かったのかも知れません。
+最後にHaskellを見てみましょう。Haskellの`a + b`は`(+)(a)(b)`です。他の関数と同じようにオーバーロードできます。オブジェクト指向なんかにして、無理にメソッドとかメンバー関数とか、そんなことをするより、全部関数にしておけば良かったのかも知れません。
+---
+君はC++が得意なフレンズなんだね。
+```C++
+#include <iostream>
+class ComplexInt
+{
+private:
+	int real;
+	int imag;
+public:
+	ComplexInt(int real, int imag) : real(real), imag(imag) {}
+	ComplexInt operator+(const ComplexInt &other) const
+	{
+		return ComplexInt(real + other.real, imag + other.imag);
+	}
+	ComplexInt operator+(int other) const
+	{
+		return ComplexInt(real + other, imag);
+	}
+	std::string toString() const
+	{
+		std::string str("");
+		str += std::to_string(real);
+		if (imag >= 0) {
+			str += "+";
+		}
+		str += std::to_string(imag) += "i";
+		return str;
+	}
+	int getReal() const { return real; }
+	int getImag() const { return imag; }
+	friend std::ostream &operator<<(std::ostream &os, const ComplexInt &ci)
+	{
+		os << ci.toString();
+		return os;
+	}
+	friend ComplexInt operator+(int x, const ComplexInt &y)
+	{
+		return ComplexInt(x, 0) + y;
+	}
+};
+int main()
+{
+	const ComplexInt a(2, 3);
+	const ComplexInt b(1, -5);
+	std::cout << a << std::endl;
+	std::cout << b << std::endl;
+	std::cout << (a + b) << std::endl;
+	std::cout << (a + 1) << std::endl;
+	std::cout << (1 + a) << std::endl;
+	return 0;
+}
+```
+メンバー関数にできたけど、これこれで、ありなんだそうです。C++書くのつかれた。

名前空間を追加

2017/03/20 04:15

投稿

raccy

スコア21784

answer CHANGED Viewed

@@ -61,8 +61,10 @@
 Scalaは演算子がメソッドだ！と言っていますが、C++も演算子はメソッド相当であるメンバー関数として定義できます。その部分に違いはありません。しかし、メンバー関数として定義した場合は、`1 + a`のような整数が前に来るような足し算には対応できません。そのため、`ComplexInt operator+(int x, const ComplexInt &y)`というグローバル関数を別途定義する必要が出てきます。
-グローバル空間を汚すことは**行儀が悪いコード**と言われます。しかし、C++の演算子オーバーロードではグローバル関数として定義せざるをえない場合があります。
+グローバル空間を汚すことは**行儀が悪いコード**と言われます(つまり、Cだと関数一個も作れないと言うこと)。しかし、C++の演算子オーバーロードではグローバル関数として定義せざるをえない場合があります※。
+※ 名前空間は汚す必要ない！って話なので、名前空間を汚さないの後から追記しています。
 対して、Scalaでは左辺も含めた暗黙の型変換を定義できるため、次のようになります。
 ```Scala
@@ -117,7 +119,7 @@
 }
 ```
-ぱっとみ、C++とは違ってグローバル関数を使ってないですので、グローバルを汚すと言うことはしていないように思えます。しかし、暗黙の型変換も暗黙のクラスもグローバルに影響を与えています。ただ、足し算という処理は一つにまとめることができますので、C++よりはマシであると言えるのではないでしょうか。
+ぱっと見、C++とは違ってグローバル関数を使ってないですので、グローバルを汚すと言うことはしていないように思えます。しかし、暗黙の型変換も暗黙のクラスもグローバルに影響を与えています。**どっちにしろグローバルを汚します。**ただ、足し算という処理は一つにまとめることができますので、C++よりはマシであると言えるのではないでしょうか。
 おまけで、Rubyを見てみましょう。
@@ -168,4 +170,76 @@
 RubyにはNumeric#coerceという仕組みがあります。これは、自分が知らない型なら相手のcoerceを呼び出して型をあわせようとする動作です。Numeric、つまり、数値をあらわす型のみですが、この仕組みにより、任意の数値のような型を追加することができます。実際にBigDecimal(任意精度十進数小数点数)やMatrix(行列)ではこの仕組みを使って、通常のInteger(整数)と足し算などができるようになっています。
-この仕組みの利点は、グローバルを汚さないということです。他の型と動作が変わったわけではありません。しかし、欠点として、もともとの定義がcoerceを考慮していなければなりません。実質使えるのは数値のみです。
+この仕組みの利点は、グローバルを汚さないということです。他の型と動作が変わったわけではありません。しかし、欠点として、もともとの定義がcoerceを考慮していなければなりません。実質使えるのは数値のみです。
+---
+名前空間を汚さなくても大丈夫だそうです。
+```C++
+#include <iostream>
+namespace ci {
+	class ComplexInt
+	{
+	private:
+		int real;
+		int imag;
+	public:
+		ComplexInt(int real, int imag) : real(real), imag(imag) {}
+		ComplexInt operator+(const ComplexInt &other) const
+		{
+			return ComplexInt(real + other.real, imag + other.imag);
+		}
+		ComplexInt operator+(int other) const
+		{
+			return ComplexInt(real + other, imag);
+		}
+		std::string toString() const
+		{
+			std::string str("");
+			str += std::to_string(real);
+			if (imag >= 0) {
+				str += "+";
+			}
+			str += std::to_string(imag) += "i";
+			return str;
+		}
+		int getReal() const { return real; }
+		int getImag() const { return imag; }
+	};
+	std::ostream &operator<<(std::ostream &os, const ComplexInt &ci)
+	{
+		os << ci.toString();
+		return os;
+	}
+	ComplexInt operator+(int x, const ComplexInt &y)
+	{
+		return ComplexInt(x, 0) + y;
+	}
+}
+int main()
+{
+	const ci::ComplexInt a(2, 3);
+	const ci::ComplexInt b(1, -5);
+	std::cout << a << std::endl;
+	std::cout << b << std::endl;
+	std::cout << (a + b) << std::endl;
+	std::cout << (a + 1) << std::endl;
+	std::cout << (1 + a) << std::endl;
+	return 0;
+}
+では、これで一安心だねっていうかと思うと、ちょっと使っただけで、グローバルに動作を影響を与えています。あ、Scalaと暗黙の型変換を検索するところと検索の仕方だけは同じ所に戻っただけのようです。
+---
+ぶっちゃけ、C++とScalaでは、単にScalaは暗黙の型変換とか使えば、実装が少なくて済むので楽だよね、程度しか無いと思います。ただ、C++の方が細かく実装できる分、コストがー、コストがー、と言っている深淵を覗くことが大好きな人達には好まれるでしょう。
+C++で何か嫌だと思う点の一つは、メンバー関数として実装できないことだと思います。オブジェクト指向原理主義者からみると、メソッドでない奴は駄目な奴だと勘違いしているのかも知れません。Scalaの暗黙の型変換もさほど変わらないと思うのですが、objectのメソッドだからいいとか言い出すのでしょうか…。
+あと、たぶん、何か嫌だと思ってしまうのは、標準型に新たなメンバー関数を追加しているように見えると言うことではないでしょうか。じゃあ、ScalaやRubyはどうなのかというと、確かに、元々の標準型に何かを追加している訳ではありませんが、一歩離れれば、やっていることはさほどかわりありません。やり方が違うだけで目くじら立てるのはどうなのかとは思ってしまいます。
+最後にHaskellを見てみましょう。Haskellの`a + b`は`(+)(a)(b)`です。他の関数と同じようにオーバーロードできます。オブジェクト指向なんかにして、無理にメソッドとかメンバー関数とか、そんなことをするより、全部関数にしておけば良かったのかも知れません。

左辺！左辺！左辺！

2017/03/20 04:05

投稿

raccy

スコア21784

answer CHANGED Viewed

@@ -63,7 +63,7 @@
 グローバル空間を汚すことは**行儀が悪いコード**と言われます。しかし、C++の演算子オーバーロードではグローバル関数として定義せざるをえない場合があります。
-対して、Scalaでは暗黙の型変換を定義できるため、次のようになります。
+対して、Scalaでは左辺も含めた暗黙の型変換を定義できるため、次のようになります。
 ```Scala
 class ComplexInt(val real: Int, val imag: Int) {