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

クラスのメンバ関数のプロトタイプ宣言の戻り値の型と関数名の間に クラスの型にスコープ解決演算子::がくっついたものが挟み込まれたものがクラスのメンバ関数の定義に用いられます えっ？もう知ってるって？

マックス「快調そのもの

順調な感じじゃないか😊」

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

　　　　　　　　　　よかったね😊

　　　　　　　　　　　それでは

クラス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 a;

a.x = x + p.x;

a.y = y + p.y;

return a;

}

の

1番左端のPointは

なぜ

Pointになっているのかというと・・・」

int（イント）「きゃ～　さすがね　マックス」

マックス「なぜ

1番左端のPointは

Pointになっているのかというと・・・

　　　　なんでだ・・・

そもそも

Point Point::

となんで

Pointが２つならんでいるんだ？・・・

仕方がないようだな。

　　　　　　　　　　『出でよ』

　　　　　　　　　『int（イント）ォォォォォ』

　　　　　　　　　　　　　　　　　　　　　　　　　」

int（イント）int（イント）int（イント）おおおおおおお！」

int（イント）「もう！　出（い）でてる」

マックス「どうだ　int（イント）

なぜ

Point Point::operator+(Point p)

{

Point a;

a.x = x + p.x;

a.y = y + p.y;

return a;

}

の

1番左端は

Pointになっているんだ」

int（イント）「へ？

ええ？　　

わたし～

簡単じゃなかったのぉ？」

ソーラー「この問題はとても簡単じゃないかな(´▽｀*)

一番左端が

なぜPointになっているかだけでなく

なぜ

Point Point::operator+(Point p)

と

記述されているのかまでわかるよ。」

マックス「な、なんで？」

ソーラー「

だって

Point Point::operator+(Point p)

{

Point a;

a.x = x + p.x;

a.y = y + p.y;

return a;

}

は

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

なんだよ。」

マックス「

Point Point::operator+(Point p)

{

Point a;

a.x = x + p.x;

a.y = y + p.y;

return 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 p)

と記述されるのか何か関係があるのか？」

ソーラー「

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

👇

Point Point::operator+(Point p)

{

Point a;

a.x = x + p.x;

a.y = y + p.y;

return a;

}

👆

が記述してありますが

今のプログラムのPointのクラス宣言を見れば

みなさん　お分かりになられますように👉」

👇

#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

3

ソーラー「👉

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

プロトタイプ宣言

Point operator+(Point p);

が実行されています。

このプロトタイプ宣言

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;

}

👆

で

Point Point::operator+(Point p)

が記述されているかに

関わってきます」

マックス「う・・・んん　なんかわかりそうな・・」

ソーラー「クラスPointのメンバ関数である関数operator+のプロトタイプ宣言

Point operator+(Point p);

と

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

Point Point::operator+(Point p)

を

よ～く

見比べてみてよ」

マックス「もしかして

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

👇

Point Point::operator+(Point p)

👆この点々の部分は

クラスPointのメンバ関数である関数operator+のプロトタイプ宣言

Point operator+(Point p);

の

Point operator+(Point p)

に対応しているんじゃないか？

Point Point::operator+(Point p)

の

1番左側のPointはいまいちなんなのかわからんが•••

Pointにスコープ解決演算子::がくっついた

Point::

に

operator+(Point p)がくっついている

Point::operator+(Point p)

は

クラスPointのメンバ関数operator+を表しているんじゃないかなんじゃないか

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

Point operator+(Point p);

の

Point

は

戻り値の型か？

Point operator+(Point p)

は

戻り値の型がPointの

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

ってことになるのか

？

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

👇

Point Point::operator+(Point p)

👆この点々の部分は

クラスPointのメンバ関数である戻り値の型がPointの関数operator+のプロトタイプ宣言

Point operator+(Point p);

の

Point

と

operator+(Point p)

に対応しているってことにならないか？」

ソーラー「おおう

そうですね

Point（💖💖💖💖💖） operator+(Point p);

と

戻り値の型が

Point（💖💖💖💖💖）の

operator+関数のクラスPoint型のメンバ関数宣言(プロトタイプ宣言)をおこなっている・・・か・・・

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

👇

Point Point::operator+(Point p)

{

Pointdisplay a;

a.x = x + p.x;

a.y = y + p.y;

return a;

}

👆

クラスPointのメンバ関数である関数operator+のプロトタイプ宣言

Point（💖💖💖💖💖） operator+(Point p)（😊😊😊😊😊😊😊😊😊😊😊😊😊😊😊😊😊）

が

Point（💖💖💖💖💖） Point::operator+(Point p)（😊😊😊😊😊😊😊😊😊😊😊😊😊😊😊😊😊）

の一部に

用いられているってことだよね

Pointにスコープ解決演算子::がくっついた

Point::

が

operator+(Point p)

にくっついていることにより

　　　　　　　💖クラスPointの💖

メンバ関数operator+関数の定義がおこなわれているということが

わかるんだね

Point::

は

この関数はクラスPointのメンバ関数であるということを

はっきり示すために

つけられているんだ」

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

　　　　　　みんな

　　　　　　そうなんで～す

　　　　　　なぜ

クラス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+(Pointdisplay p)

が記述されているのか

それは

　　　　　　　　　　　　🦚単純に🦚

クラスのメンバ関数の定義を記述する形式だからなんです

そのことをわかりやすく説明するために

以前登場した

クラスCubeのクラス宣言と

クラスCubeのメンバ関数であるdisplay()

の定義をみてね。

👇

class Cube {

public:

int no; //変数noはクラスCubeのメンバ変数とよばれます

float tate; //変数tateはクラスCubeのメンバ変数とよばれます

float yoko; //変数yokoはクラスCubeのメンバ変数とよばれます

float takasa; //変数takasaはクラスCubeのメンバ変数とよばれます

void display(); //自作関数display()はクラスCubeのメンバ関数とよばれます

};

void Cube::display() {

cout << "立方体につけられたナンバーは" << no << "です" << "\n";

cout << "立方体の縦の長さは" << tate << "です" << "\n";

cout << "立方体の横の長さは" << yoko << "です" << "\n";

cout << "立方体の高さの長さは" << takasa << "です" << "\n";

}

//👆クラスCubeのメンバ関数となっている自作関数display()の定義をおこなっています

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

マックス「そういえば・・・」

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

どう？　　思い出した？

クラスCube のクラス宣言と

そのメンバ関数であるdisplay()

の定義をよ～くみると・・・

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

マックス「もしやあ」

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

　　　　　　きゃはっ

クラスCubeのメンバ関数宣言

void display();

と

クラスCubeのメンバ関数となっている自作関数display()の定義

👇

void Cube::display() {

cout << "立方体につけられたナンバーは" << no << "です" << "\n";

cout << "立方体の縦の長さは" << tate << "です" << "\n";

cout << "立方体の横の長さは" << yoko << "です" << "\n";

cout << "立方体の高さの長さは" << takasa << "です" << "\n";

}

👆

の

void Cube::display()

を

みても

おわかりになられますように・・・

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

マックス「これは　もう　わかりそうだ・・・」

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

display()のクラスCubeのメンバ関数宣言

つまり

クラスCubeのメンバ関数display()のプロトタイプ宣言である

void display();

の

　　　　　　　　　　　　　void(戻り値の型（💖💖💖💖💖）)

　　　　　　　　　　　　　　　　と

　　　　　　　　　　　　　　　　display()

の間に

Cubeにスコープ解決演算子::がくっついた

Cube::

が挟み込まれたもの

👇

void Cube::display()

が

クラスCubeのメンバ関数display()の定義

で用いられています。

cube::はdisplay()

が

クラスCubeのメンバ関数であることを示すためにつけられています

マックス「なにぃ

そういえばそうだ

　　　　　　　　　　　　　void(戻り値の型（💖💖💖💖💖）)

　　　　　　　　　　　　　　　　と

　　　　　　　　　　　　　　　　display()

の間に

cube::

が

つけられていた

voidは戻り値の型か！

じゃあ

やはり

Point Point::operator+(Point p)

の

1番左側のPointは

戻り値の型というわけだ

だが

なぜ

戻り値を格納する型がPointになるのかはよくわからないな

」

ソーラー「そう

voidは戻り値の型です

同様に

Point Point::operator+(Point p)

の

1番左側のPointは

戻り値の型なんです

Cube::

は

この定義

👇

void Cube::display() {

cout << "立方体につけられたナンバーは" << no << "です" << "\n";

cout << "立方体の縦の長さは" << tate << "です" << "\n";

cout << "立方体の横の長さは" << yoko << "です" << "\n";

cout << "立方体の高さの長さは" << takasa << "です" << "\n";

}

👆

が

クラスCubeのメンバ関数display()の定義であることを

はっきり示すために付け加えられています。

つまり

クラスCubeのメンバ関数display()のプロトタイプ宣言

void display();

の

　　　　　　　　　　　　　💖戻り値の型💖void

と

　　　　　　　　　　　　　　💖関数名💖 display()

の

　　　　　　　　　　🌞🌞🌞🌞🌞間（あいだ）に🌞🌞🌞🌞🌞

クラス名Cubeにスコープ解決演算子::がくっついた

cube::が

挟み込まれたものが

クラスCubeのメンバ関数の定義に用いられるんです

ですので

同様に

クラスPointのメンバ関数operator+のプロトタイプ宣言が

Point operator+(Point p);

となっていると

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

🌞Point(戻り値を格納する型)🌞👈(なぜ戻り値を格納する型がPointになるのかは後に説明されます😊)

と

🌞operator+(Point p)（関数名）🌞

に

Point::が挟み込まれた

Point Point::operator+(Point p)

が記述されることになるというわけなんです

このことは

すでに

今までやってきたことなんだよ～ん」

マックス「じゃあ　ちょちょっと簡単じゃないか

わかっていたことだったな

int（イント）よ」

int（イント）「めでたし、めでたし」