🌻天国にいけるC++言語入門🌻 進化し続けるオブジェクト指向プログラミング ver3.2307

+,-,*,/の４つの演算子をオーバーロードしてオブジェクトp1,p2,p3,p4,p5同士の計算p1+p2-p3*p4/p5を実行すると普通の四則演算の実行順序で演算が行われることになります

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

どう？

+演算子のオーバーロードって

親切便利設計でしょ

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

てんC「はい

+演算子のオーバーロードにより

オブジェクトp1

と

オブジェクトp2

同士の足し算

p1+p2;

につづいて

オブジェクトp1

と

オブジェクトp2

ト

オブジェクトp3

同士の足し算

p1+p2+p3;

を

実行することができました

+演算子には

1+2+3;

と

数値

1

2

3

を

足し合わせる機能があるのですが

オブジェクトp1

と

オブジェクトp2

ト

オブジェクトp3

同士を

p1+p2+p3;

と

足し合わせる機能はありません

そこで

+演算子のオーバーロードを実行することにより

オブジェクトp1

と

オブジェクトp2

ト

オブジェクトp3

同士を

p1+p2+p3;

と

足し合わせることができるようになったのですね」

ソーラー「よかった

p1+p2が実行できても

p1+p2+p3が実行できなかったら

機能性が低いからね。」

マックス「int（イント）

お前のおかげで

大分『演算子のオーバーロード』の仕組みがわかったぞ」

int(イント）「もうこれで

『演算子のオーバーロード』

の仕組みの解説はおわったんじゃなぁい」

ダンスを踊り始める妖精。

マックス「そうだな・・・

int (イント）

俺もダンスするぜ」

ずんたか　ずんたか　ずんたか

ずんたか　ずんたか　ずんたか

マックス「ファイヤーああ」

int (イント）「ファイヤーああ」

マックス「ファイヤーああ」

int (イント）「ファイヤーああ」

マックス「ファイヤーああ　ファイヤーああ」

int (イント）「ファイヤーああ　ファイヤーああ

ファイヤーああ　ファイヤーああ　ファイヤーああ

ファイヤーああ　ファイヤーああ　ファイヤーああ

ファイヤーああ　ファイヤーああ　ファイヤーああ

」

マックス「は～はっは～」

int (イント）「は～はっは～」

ソーラー「

演算子のオーバーロードの解説は

だいたいこんなところかな？」

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

では　おまけ

+演算子をオーバーロードして

オブジェクトp1,p2,p3,p4,p5同士の計算

p1+p2-p3*p4/p5を実行してみるっていうのはどう？

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

マックス「

オブジェクトp1,p2,p3,p4,p5同士の計算

p1+p2-p3*p4/p5

か・・・・・

あっ

あれ

+演算子に混ざって

-演算子

*演算子

/演算子

がまじってないか？」

ソーラー「普通の

1+2-3*4/5;

の計算では

まず

3*4/5

が計算されます

3*4が計算されて

12になったあと

12/5

が実行されます

12/5の計算結果は2.4

ではなく

2.4がint型に格納されるので

2ですね。

3*4/5が2なので

1+2-3*4/5;

は

1+2-2;

が実行されることに等しくなります

あとは

1+2が実行されて

1+2の部分が3になった

3-2;

が実行されて

答えは

1になるというわけです

そのときのプログラムはこちらです」

👇

#include <iostream>

using namespace std;

int main(){

int a;

a = 1 + 2 - 3 * 4 / 5;

cout << a << "\n";

return 0;

}

プログラムの実行結果

1

マックス「じゃあ

クラスPoint型のオブジェクト同士の計算

p1+p2-p3*p4/p5

も

p3*p4/p5

が先に実行されることになるのか？」

ソーラー「実際に

p1+p2-p3*p4/p5

を実行してみるのがわかりやすいと思うな」

int (イント）「は～はっは～　猫ちゃん　かわいい」

ぶーにゃん「にゃ～ん」

てんC「

それでは😊　　みなさん

p1+p2-p3*p4/p5

がどのような順序で

計算されていくかを確かめてみたいと思います

そのプログラムはこちらとなります👇」

#include <iostream>

using namespace std;

class Point{

public:

int x;

int y;

public:

void pointdisplay();

public:

Point operator+ (Point p);

public:

Point operator- (Point p);

public:

Point operator* (Point p);

public:

Point operator/ (Point p);

};

void Point::pointdisplay() {

cout << x << "\n";

cout << y << "\n";

}

Point Point::operator+(Point p)

{

Point a;

a.x = x + p.x;

a.y = y + p.y;

return a;

}

Point Point::operator-(Point p)

{

Point a;

a.x = x - p.x;

a.y = y - p.y;

return a;

}

Point Point::operator*(Point p)

{

Point a;

a.x = x * p.x;

a.y = y * p.y;

return a;

}

Point Point::operator/(Point p)

{

Point a;

a.x = x / p.x;

a.y = y / p.y;

return a;

}

int main() {

Point p1;

p1.x = 1;

p1.y = 1;

p1.pointdisplay();

Point p2;

p2.x = 2;

p2.y = 2;

p2.pointdisplay();

Point p3;

p3.x = 3;

p3.y = 3;

p3.pointdisplay();

Point p4;

p4.x = 4;

p4.y = 4;

p4.pointdisplay();

Point p5;

p5.x = 5;

p5.y = 5;

p5.pointdisplay();

Point p6;

p6 = p1+p2-p3*p4/p5;

p6.pointdisplay();

return 0;

}

プログラムの実行結果

1

1

2

2

3

3

4

4

5

5

1

1

マックス「どうなった？どうなった？

p6 =p1+p2-p3*p4/p5;

が

実行出来たっぽいぞ

プログラムの実行結果

1

1

か

クラスPoint型のオブジェクトp6のメンバ変数

p6.x

p6.y

に

1

1

が代入されて

p6.pointdisplay();

の実行により

1

1

がコマンドプロンプト画面に表示されたようだな

ということは・・・」

ソーラー「1+2-3*4/5;

の

実行結果が

1

になっていて

p1+p2-p3*p4/p5;

の

実行結果が

1

1

となっているところをみると

p1+p2-p3*p4/p5;

では

1+2-3*4/5;

が実行されたときと同じように

p3*p4/p5

が実行された後

p1+p2

が実行されて

p1+p2からp3*p4/p5が

p1+p2-(p3*p4/p5)

のように

引かれているみたいだね。」

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

そう

+演算子のオーバーロード

-演算子のオーバーロード

*演算子のオーバーロード

/演算子のオーバーロード

を行って

オブジェクト同士の演算に

+演算子

-演算子

*演算子

/演算子

が用いられる場合

ちゃんと四則演算のルールに従って

*演算子

/演算子

が用いられた

オブジェクト同士の計算から

先に実行されます。

新たに

+演算子のオーバーロード

-演算子のオーバーロード

*演算子のオーバーロード

/演算子のオーバーロード

を

実行したといっても

四則演算のルールに従って

*演算子

/演算子

が用いられた

オブジェクト同士の計算から

先に実行されるというルールは

オーバーロードされた

+演算子

-演算子

*演算子

/演算子

の定義

に

引き継がれているんだよ

　　　まさに・・・

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

マックス「まさに・・・

　　　　　　　　　ファンタジー

　　　　　　　　　　　　　　　　　　　　　　　　　　」

int（イント）「猫ちゃん

お髭

かわいい～」

ぶーにゃん「にゃ～」