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

p1+p2すなわちp1.operator+(p2)にどのような戻り値が返されるかはクラスPointのメンバ関数operator+の定義次第、関数の型次第となります

つづき・・・

ソーラー「もちろんできます

　　　　　　　　　　　　p1+p2;

　　　　　　　　　 　　 すなわち

　　　　　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数operator+💖

　　　　　　　　　　　　p1.operator+(p2);

が実行されると

　　　　　　　　　　　　戻り値として

　　　　　　　　　 　💖オブジェクトa💖

が

　　　　　　　　　　 　 　p1+p2

　　　　　　　　　　　　 すなわち

　　　　　 💖引数にp2が代入されたオブジェクトp1のメンバ関数operator+💖

　　　　　　　　　　　💖p1.operator+(p2)💖

に

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

なぜなら

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

return a;

と

記述されているからです

えへっ

これでいいかな？」

マックス「そんなの　あたりまえなんじゃないか？」

ソーラー「確かに

　　　　　　　　　 　💖オブジェクトa💖

が

戻り値として

　　　　　　　　　　　　p1.operator+(p2);

に返される

というのは今までにない例だからね

　　　　　　　　　 　💖オブジェクトa💖

が

戻り値として

　　　　　　　　　　　　p1.operator+(p2);

に返されるとはど～いうことなのかの

説明が要るよね

それについては　これからだね

それでは

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

👇

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は

引数にp2が代入されたクラスPoint型のオブジェクトp1のメンバ関数

　　　　　　　　　　　💖p1.operator+(p2);💖

実行されたとき

引数にp2が代入されたクラスPoint型のオブジェクトp1のメンバ関数

　　　　　　　　　　　💖p1.operator+(p2)💖

に戻されるデータ(オブジェクト)を格納する型を

表しています。

その隣の

Point::

は

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

👇

Point Point::operator+(Point p)

{

Point a;

a.x = x + p.x;

a.y = y + p.y;

return a;

}

が

クラスPointのメンバ関数operator+

の定義であることを示すためにつけられています

このように

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

Point Point::operator+(Point p)

と記述していると

　　　　　　　　　　　💖p1.operator+(p2);💖

実行されたとき

引数にp2が代入されたクラスPoint型のオブジェクトp1のメンバ関数

　　　　　　　　　　　💖p1.operator+(p2)💖

に戻されるデータ(オブジェクト)を格納する型は

　　　　　　　　　　　Pointになっているので

　　　　　　　　　　　自然に

引数にp2が代入されたクラスPoint型のオブジェクトp1のメンバ関数

　　　　　　　　　　　💖p1.operator+(p2);💖

実行されたとき

引数にp2が代入されたクラスPoint型のオブジェクトp1のメンバ関数

　　　　　　　　　　　💖p1.operator+(p2)💖

に戻される戻り値は

　　　　　　　　　　　🌞Point型のオブジェクト🌞

になってきます。

　　　　　　　　　　　　　　　　　　　　　　」

マックス「つまり

return a;

で

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

を戻り値として

　　　 　　　　　　　　　p1+p2

　　　　　　　　　　　　すなわち

　　　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　💖p1.operator+(p2)💖

に返すんだろう

その

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

を受け取る

　　　　　　　　　　　　　p1+p2

　　　　　　　　　　　　すなわち

　　　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　💖p1.operator+(p2)💖

は

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

できる必要があるので

Point Point::operator+(Pointdisplay p)

👆ココ

と

👆ココの部分が

クラスPointの型に設定されているわけだ。

そうすることにより

　　　　　　　　　　　　p1+p2

　　　　　　　　　　　　すなわち

　　　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　💖p1.operator+(p2)💖

が

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

の役割をはたすことになり

戻り値として

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

を受け取れるようになるわけだ。」

マックス「にゃはは

ところで

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

👇

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に設定したとなると

もう

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

実行されたとき

クラスPoint型のオブジェクトのメンバ関数operator+に戻される戻り値は

　　　　　　　　　　　🌞Point型のオブジェクト🌞

だと

　　　　　　　　　　　🌞自分で決めちゃったことにならないか？🌞

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　」

ソーラー「そうなんです。

　　　　　　　　　　　自作関数の戻り値を

　　　　　　　　　　　格納する型は

　　　　　　　　　　　自ら決めることになります

　　　　　　　　　　　そして

　　　　　　　　　　　自作関数の戻り値を

　　　　　　　　　　　格納する型を

　　　　　　　　　　　自ら決めたなら

　　　　　　　　　　　returnによって

自作関数に返される戻り値は

　　　　　　　　　　　自作関数の型に格納できるデータである必要があります

具体的には

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

👇

Point Point::operator+(Point p)

{

Point a;

a.x = x + p.x;

a.y = y + p.y;

return a;

}

となっている場合

　💖p1+p2;💖

　　　　　　　　　　　　　　すなわち

　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　　💖p1.operator+(p2);💖

が実行されたとき

戻り値としてオブジェクトaが

　💖p1+p2💖

　　　　　　　　　　　　　　すなわち

　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　　💖p1.operator+(p2)💖

に戻されることになります

　　　　　　　　　　　　　　　このとき

　　　　　　　　　　　　　　💖p1+p2💖

　　　　　　　　　　　　　　　イコール

　　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　　💖p1.operator+(p2)💖

は

クラスPoint型の関数なので

　　　　　　　　クラスPoint型のオブジェクトに相当するものとなっているのですが

　　　　　　　　　　　　そうなると

　　　　　　　　クラスPoint型のオブジェクトである

　　　　　　　　　　　　💖p1+p2💖

　　　　　　　　　　　　　イコール

　　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　💖p1.operator+(p2)💖

に　　　　　

戻される戻り値は

クラスPoint型のオブジェクトである必要が出てきます。

return a;

と記述した場合は

aはPoint a;

によって生成されたクラスPoint型のオブジェクトなので

　　　　　クラスPoint型のオブジェクトに相当する

　　　　　　　　　　　　　　💖p1+p2💖

　　　　　　　　　　　　　　　イコール

　　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　　💖p1.operator+(p2)💖

に

　　　　　　　　　　　　　　😊無事に😊

クラスPoint型のオブジェクトaを格納することはできるんだけど

return 1;

と記述した場合は

　　　　　クラスPoint型のオブジェクトに相当する

　　　　　　　　　　　　💖p1+p2💖

　　　　　　　　　　　　　イコール

　　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　💖p1.operator+(p2)💖

に戻される戻り値は

数値データ1となるよね。

ですが　この場合

クラスPoint型のオブジェクトともいえる

　　　　　　　　　　　　　　💖p1+p2💖

　　　　　　　　　　　　　　　イコール

　　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　　💖p1.operator+(p2)💖

に

クラスPointの型とは異なる型のデータである数値データ1を

格納することはできません。

もし

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

👇

Point Point::operator+(Point p)

{

Point a;

a.x = x + p.x;

a.y = y + p.y;

return a;

}

の

return a;

の部分を

return 1;

と記述して

Point Point::operator+(Point p)

{

Point a;

a.x = x + p.x;

a.y = y + p.y;

return 1;

}

のように記述してしまうと

プログラムの実行時に

ビルドエラーが

表示されることになります。

マックス「　　　　　　　　　return 1;

　　　　　　　　　　　　と記述しておくと

　　　　　クラスPoint型のオブジェクトに相当する

　　　　　　　　　　　　💖p1+p2💖

　　　　　　　　　　　　イコール

　　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　💖p1.operator+(p2)💖

に戻り値として

数値データ1が返されることになるんだが

クラスPoint型のオブジェクトともいえる

　　　　　　　　　　　　　💖p1+p2💖

　　　　　　　　　　　　　　イコール

　　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　💖p1.operator+(p2)💖

に異なる型のデータである数値データ1を

格納することはできず

プログラムのビルド実行時に

ビルドエラーが表示されるというのなら

じゃあ

今の

return 1;

が記述された

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

👇

Point Point::operator+(Point p)

{

Point a;

a.x = x + p.x;

a.y = y + p.y;

return 1;

}

の

戻り値を格納する型を

クラスPoint型

から

int型に変更してやれば

　　　　　　　　　　　　　　💖p1+p2💖

　　　　　　　　　　　　　　　イコール

　　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　　💖p1.operator+(p2)💖

は

int型の変数の役割を果たすんじゃないか？

すると

戻り値1を格納できることになるので

プログラムのビルド実行時に

ビルドエラーが表示されないんじゃないか

そうおもうだろう😊

つまり

次のように

クラスPointのメンバ関数operator+関数の定義の関数の型を

Pointからintに変えたプログラムを実行したら

👇

int Point::operator+(Point p)

{

Point a;

a.x = x + p.x;

a.y = y + p.y;

return 1;

}

👆

ビルドエラーは表示されないんじゃないか？」

ソーラー「この場合は

プログラムのビルド実行時に

ビルドエラーが表示されることはありません。

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

int Point::operator+(Point p)

{

Point a;

a.x = x + p.x;

a.y = y + p.y;

return 1;

}

のように戻り値を格納する型が

　　　　　　　　　クラスPoint型でなく

　　　　　　　　　　　　　　int型

となっている場合は

　💖p1+p2;💖

　　　　　　　　　　　　　　すなわち

　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　　💖p1.operator+(p2);💖

が実行されたとき

戻り値として数値データ1が

　　　　　　　　　　　　　ちゃんと

　💖p1+p2💖

　　　　　　　　　　　　　　すなわち

　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　　💖p1.operator+(p2)💖

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

だって

　　　　　　　　　　　　　　💖p1+p2💖

　　　　　　　　　　　　　　　イコール

　　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　　💖p1.operator+(p2)💖

は

int型の変数の役割をはたすことになったからだね

つまり

　　　　　　　　　　　　　　💖p1+p2💖

　　　　　　　　　　　　　　　イコール

　　　　💖引数にp2が代入されたクラスPoint型のオブジェクトp1のメンバ関数💖

　　　　　　　　　　　　💖p1.operator+(p2)💖

が

iny型の変数の役割をはたすか

クラスPoint型のオブジェクトの役割をはたすようになるかは

クラスPointのメンバ関数operator+関数の定義次第ということになるんだね」

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

　　　　　　　　みなさ～ん

　　　　　　　　結局のところ

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

次のようになっている場合

👇

Point Point::operator+(Point p)

{

Point a;

a.x = x + p.x;

a.y = y + p.y;

return 1;

}

　　　　　　　　　　この状態で

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

　　 Point p1;

と

　　 Point p2;　

　　　　　　　　　　が実行されて

　　　　　　　　　　　💖p1+p2;💖

　　　　　　　　 　　　すなわち

　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　　p1.operator+(p2);

が実行されると

　　　　　　　　　　　　戻り値として

　　　　　　　　　　💖オブジェクトa💖

　　　　　　　　　　　　　が

　　　　　　　　　　 　💖p1+p2💖

　　　　　　　　　　　　すなわち

　　　　　💖引数にp2が代入されたオブジェクトp1のメンバ関数💖

　　　　　　　　　　　💖p1.operator+(p2)💖

に

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

　　　　　　　　　　　　　　ついに

p1+p2はオブジェクトaを表すことになったんですよ

　　　　　　　　　　　　　　 この

p1+p2がオブジェクトaを表すことになったというところが

とっても重要なんだよ～

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞