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

/演算子に新たな機能を追加する/演算子のオーバーロードを実行してみます

int（イント）「またまた　きまった(´▽｀*)」

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

わっおう　なんて　いい解答

よ～し

じゃあ　次は

/演算子に新たな機能を追加する

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

にとりかかってみるみる？

通常

　　　　　　　　　/演算子には

数値データ1と2

を

1/2;

のように割る機能や

変数aと変数bを

a/b;

のように

割る機能があるのですが

オブジェクトp1をオブジェクトp2で

p1/p2;

のように割る機能はありません

そこで

p1/p2;

が実行できるよう

/演算子に新たな機能を追加したいというわけです。

p1/p2;

が実行されたとき何が実行されるかは

　　　　　　　新たな/演算子の定義次第となります

もう少し詳しく説明すると

次のようなクラスPointがあるとします。

👇

class Point{

public:

int x;

int y;

public:

void pointdisplay();

public:

};

void Point::pointdisplay() {

cout << x << "\n";

cout << y << "\n";

}

👆

このクラスPoint型のオブジェクト宣言

Point p1;

Point p2;

を実行すると

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

p1.x

p1.y

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

p2.x

p2.y

が生成されます。

p1.x/p2.x

p1.y/p2.y

と

記述すれば

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

p1.x

p1.y

を

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

p2.x

p2.y

で割ることができるのですが

　　　　　　　　　p1/p2;

と

記述するだけで

直接

p1.x/p2.x;

p1.y/p2.y;

を記述することなく

p1.x/p2.x;

p1.y/p2.y;

が実行できるようにしたいというわけです。

そうですね。

流れとしては

p1.x/p2.x

p1.y/p2.y

が

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

a.x

a.y

に代入されていて

かつ

p1/p2にオブジェクトaを代入することができたならいいな

ってわけです

それができたなら

p1/p2を

同じクラスPoint型のオブジェクトp3に

p3=p1/p2;

と

代入するだけで

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

p3.x

p3.y

に

p3.x=p1.x/p2.x;

p3.y=p1.y/p2.y;

と

p1.x/p2.x

p1.y/p2.y

が代入できることになります

後は

クラスPoint型のオブジェクトp3のメンバ関数

p3.pointdisplay();

を実行すれば

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

p1.x

を

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

p2.x

で割った

p1.x/p2.x

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

p1.y

を

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

p2.y

で割った

p1.y/p2.y

が

簡単に表示できるというわけです

クラスPoint型のオブジェクトの数が

p1

p2

p3

p4

p5

p6

・

・

・

p100

のように

たくさん存在するとき

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

p1.x

p1.y

p2.x

p2.y

p3.x

p3.y

p4.x

p4.y

p5.x

p5.y

p6.x

p6.y

・

・

・

・

・

p100.x

p100.y

を

p1.x/p2.x/p3.x/p4.x/p5.x/p6.x・・・・・・p100.x

p1.y/p2.y/p3.y/p4.y/p5.y/p6.y・・・・・・p100.y

と

割って

それぞれのクラスPoint型のオブジェクトのメンバ変数の割り算の結果を求めたいとき

直接

p1.x/p2.x/p3.x/p4.x/p5.x/p6.x・・・・・・p100.x

p1.y/p2.y/p3.y/p4.y/p5.y/p6.y・・・・・・p100.y

を記述して実行するよりかは

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

p1/p2/p3/p4/p5/p6-・・・・・・p100;

を実行するだけで

p1.x/p2.x/p3.x/p4.x/p5.x/p6.x・・・・・・p100.x

p1.y/p2.y/p3.y/p4.y/p5.y/p6.y・・・・・・p100.y

が実行できて

それぞれのオブジェクトのメンバ変数の割り算の結果を

求めることができたら

とっても簡単、便利(´▽｀*)

というわけなんです。

でも　通常では

直接

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

p1/p2;

p1/p2/p3/p4/p5/p6-・・・・・・p100;

等を実行することはできません。

実行するとビルドエラーが表示されます。

　　　　　　　　なんとかならないかな？

そこで

直接

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

p1/p2;

p1/p2/p3/p4/p5/p6-・・・・・・p100;

が実行できるように

/演算子の機能を追加する

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

を実行してみたいというわけです。

さてさて　int（イント）ちゃん

/演算子のオーバーロードをどう実行する？する？

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

int（イント)「だいじょ～ぶ(´▽｀*)

これも　超簡単、超楽勝ね！

そのためには

今のクラスPointのクラス宣言内に

関数operator/のクラスPointのメンバ関数宣言

Point operator/(Point p);

を追加し

クラスPointのメンバ関数operator/の定義

Point Point::operator/(Point p)

{

Point a;

a.x = x / p.x;

a.y = y / p.y;

return a;

}

を

記述することになるんでしょう

+演算子のオーバーロードの定義の+の部分を

/に

変更しただけね」

マックス「おお」

int（イント)「

/演算子のオーバーロードが実行されたプログラムはこちら💖になるよ」

👇

👇

#include <iostream>

using namespace std;

class Point{

public:

int x;

int y;

public:

void pointdisplay();

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;

}

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 = p1 / p2;

p3.pointdisplay();

return 0;

}

プログラムの実行結果

1

1

2

2

0

0

マックス「おお　

０

０

がでてきた

このプログラムでは

何がおこなわれているんだ？」

int（イント）「このプログラムでは

p1/p2

が記述されているので

クラスPoint型のオブジェクトp1のメンバ関数

p1.operator/(p2);

が実行されることになる。

すると

クラスPointのメンバ関数operator/の定義内の

Point a;

a.x = x / p.x;

a.y = y / p.y;

return a;

の

xにp1.x

yにp1.y

p.xにp2.x

p.yにp2.y

が代入された

a.x=p1.x/p2.x;

a.y= p1.y/p2.y;

が

実行されることになります

p1.operator/(p2);

と記述すれば

直接

p1.x/p2.x;

p1.y/p2.y;

を記述して実行することなく

p1.x/p2.x;

p1.y/p2.y;

を実行することができるってわけね

このときの

p1.x/p2.x

p1.y/p2.y

は

クラスPointのメンバ関数operator/の定義内の

aのクラスPoint型のオブジェクト宣言

Point a;

によって

生成される

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

a.x

a,y

に格納されることになるの

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

p1.xには数値データ1

p1.yには数値データ1

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

p2.xには数値データ2

p2.yには数値データ2

が

代入されているので

p1.x/p2.x

p1.y/p2.y

は

0.5

0.5

をあらわすことになりそうですが

p1.x/p2.x

p1.y/p2.y

は

p1.x

p2.x

p1.x

p2.x

がint型の変数なので

int型の変数割るint型の変数の計算となります

ですので

計算結果も

int型に格納されるので

小数点以下の数値を格納することができず

p1.x/p2.x

p1.y/p2.y

は

0.5

0.5

の

小数点以下が切り捨てられた

0

0

の値をもつことになります。

つまり

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

a.x

a,y

には

0

0

が代入されることになるんだ～

そして

return a;

により

p1.operator/(p2)

つまり

p1 / p2

には

戻り値として

クラスPoint型のオブジェクトa

が返されることになります

ですので

p3 = p1 / p2;

は

あたかも

p3=a;

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

（実際には

自作関数である

p1.operator/(p2);

が実行されると

自作関数内でオブジェクト宣言され

生成されたクラスPoint型のオブジェクトaはメモリから消去されています

ですので

p3=a;

が実行されているわけではありません

クラスPoint型のオブジェクトaが

p1.operator/(p2)イコールp1 / p2に戻り値として返されたあと

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

a.x

a.y

に格納されている数値データが

p3 = p1 / p2;

により

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

p3.x

p3.y

に代入されることになります

ここがポイントなのよね😊」

マックス「 p1 / p2が

p1.operator/(p2)をあらわし

p1 / p2

に

クラスPoint型のオブジェクトaが代入されるというのは

/演算子のオーバーロードの面白い仕組みだよな～」

int（イント）「

p3 = p1 / p2;

つまり

あたかも

p3=a;

が実行される

するとね

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

p3.x

p3.y

に

直接

p3.x=p1.x/p2.x;

p3.y=p1.y/p2.y;

を記述して

実行することなく

p1.x/p2.x

p1.y/p2.y

が代入されることになります

つまり

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

p3.x

p3.y

には

p1.x/p2.x

p1.y/p2.y

の格納している値

0

0

が代入されることになるんだ

やったね

あとは

クラスPoint型のオブジェクト宣言

Point p3;

により生成される

クラスPoint型のオブジェクトp3のメンバ関数

p3.pointdisplay();

が実行されると

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

p3.x

p3.y

に代入された値

0

0

が

コマンドプロンプト画面に表示されるというわけでぇ～す

どう　マックス」

マックス「おおっ

簡単に

/演算子のオーバーロードが実行されることになるプログラムを作製できたな

これで

+演算子

-演算子

*演算子

/演算子

の

4つの演算子を

オーバーロードする方法がわかったな

縁起よさげ～

」