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

クラスPointのメンバ変数宣言 int x,int y のアクセス指定子がprivateに設定されているとメンバ変数x,yが用いられた普通の自作関数operator+を実行することはできません

マックス「それなら

以下のプログラムをビルド実行できるようにするには

👇

#include <iostream>

using namespace std;

class Point{

private://🌞アクセス指定子がprivateになっています　ここがポイントです

int x;

int y;

public:

void pointdisplay();

};

void Point::pointdisplay() {

cout << x << "\n";

cout << y << "\n";

}

Point operator+(Point p, Point q) {

Point a;

a.x = p.x + q.x;

a.y = p.y + q.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=operator+(p1,p2);と記述してもOKです🌞

p3.pointdisplay();

return 0;

}

ビルド実行結果

重大度レベル コード 説明 プロジェクト ファイル 行 抑制状態

エラー (アクティブ) E0265 メンバー "Point::y" (宣言された 行 9) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::y" (宣言された 行 9) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::y" (宣言された 行 9) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::y" (宣言された 行 9) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::y" (宣言された 行 9) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::x" (宣言された 行 8) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::x" (宣言された 行 8) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::x" (宣言された 行 8) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::x" (宣言された 行 8) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::x" (宣言された 行 8) にアクセスできません

エラー C2248 'Point::y': private メンバー (クラス 'Point' で宣言されている) にアクセスできません。

エラー C2248 'Point::y': private メンバー (クラス 'Point' で宣言されている) にアクセスできません。

エラー C2248 'Point::y': private メンバー (クラス 'Point' で宣言されている) にアクセスできません。

エラー C2248 'Point::x': private メンバー (クラス 'Point' で宣言されている) にアクセスできません。

エラー C2248 'Point::x': private メンバー (クラス 'Point' で宣言されている) にアクセスできません。

エラー C2248 'Point::x': private メンバー (クラス 'Point' で宣言されている) にアクセスできません。

マックス「👆このプログラムが実行できるようにするためには

ど～したらいいかということだな？

実行するには・・・

そうだな・・・

そうだ！

クラスPointのメンバ変数宣言

int x;

int y;

のアクセス指定子が

privateに設定されているため

このプログラムのmain関数内のこの部分

👇

Point p1;

p1.x = 1;

p1.y = 1;

p1.pointdisplay();

Point p2;

p2.x = 2;

p2.y = 2;

p2.pointdisplay();

👆

の

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

p1.x

p1.y

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

p2.x

p2.y

が

　　　　　　　　　　　　　　　直接用いられた

p1.x = 1;

p1.y = 1;

p2.x = 2;

p2.y = 2;

は実行できないってわけだ

さらに

p3=p1+p2;

//🌞p3=operator+(p1,p2);と記述してもOKです🌞

の実行時

つまり

p1+p2;

の実行時

Point operator+(Point p, Point q) {

Point a;

a.x = p.x + q.x;

a.y = p.y + q.y;

return a;

}

の

pにp1

qにp2

が代入された

Point a;

a.x = p1.x + p2.x;

a.y = p1.y + p2.y;

return a;

が実行されるんだろう

だが

Point operator+(Point p, Point q)の

Point p

Point q

に

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

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

を代入しても

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

p1.x

p1.y

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

p2.x

p2.y

を使用することはできないだろう・・・・・・・・・・

・・・・・・・・・・

さらに

そもそも

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

Point a;

を実行して

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

を生成しても

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

a.x

a.y

を使用することはできない・・・・・・・・・・

・・・なのに使用しているからビルドエラーが表示されているんだろう

となると

このプログラムのmain関数内のこの部分

👇

Point p1;

p1.x = 1;

p1.y = 1;

p1.pointdisplay();

Point p2;

p2.x = 2;

p2.y = 2;

p2.pointdisplay();

👆

の

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

p1.x

p1.y

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

p2.x

p2.y

が用いられた

p1.x = 1;

p1.y = 1;

p2.x = 2;

p2.y = 2;

の

命令文は取り消しだな😊

さらに

p1.x = 1;

p1.y = 1;

p2.x = 2;

p2.y = 2;

を取り消したので

p1.pointdisplay();

p2.pointdisplay();

も取り消しだな

なぜなら

確かに

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

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

のメンバ関数

p1.pointdisplay();

p2.pointdisplay();

は実行することができるが

p1.pointdisplay();

p2.pointdisplay();

が実行されるということは

クラスPointのメンバ関数pointdisplay()

の定義

👇

void Point::pointdisplay() {

cout << x << "\n";

cout << y << "\n";

}

の

x

y

に

p1.x

p1.y

p2.x

p2.y

が代入された

cout <<p1.x << "\n";

cout <<p1.y << "\n";

cout <<p2.x << "\n";

cout <<p2.y << "\n";

が実行されることになる

　　　　　　　　　　　　が

p1.x = 1;

p1.y = 1;

p2.x = 2;

p2.y = 2;

を取り消したので

p1.x

p1.y

p2.x

p2.y

には

どのような数値データが格納されているかわからず

cout <<p1.x << "\n";

cout <<p1.y << "\n";

cout <<p2.x << "\n";

cout <<p2.y << "\n";

が

実行されると

どのような数値データが表示されるかわからないからな

で

p1.pointdisplay();

p2.pointdisplay();

も取り消しだな

となると

今のプログラムはこうなる

👇

#include <iostream>

using namespace std;

class Point {

private:

int x;

int y;

public:

void pointdisplay();

};

void Point::pointdisplay() {

cout << x << "\n";

cout << y << "\n";

}

Point operator+(Point p, Point q) {

Point a;

a.x = p.x + q.x;

a.y = p.y + q.y;

return a;

}

int main() {

Point p1;

Point p2;

Point p3;

p3 = p1 + p2;

//🌞p3=operator+(p1,p2);と記述してもOKです🌞

p3.pointdisplay();

return 0;

}

ビルド実行結果

重大度レベル コード 説明 プロジェクト ファイル 行 抑制状態

エラー (アクティブ) E0265 メンバー "Point::y" (宣言された 行 9) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::y" (宣言された 行 9) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::y" (宣言された 行 9) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::x" (宣言された 行 8) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::x" (宣言された 行 8) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::x" (宣言された 行 8) にアクセスできません

エラー C2248 'Point::y': private メンバー (クラス 'Point' で宣言されている) にアクセスできません。

エラー C2248 'Point::x': private メンバー (クラス 'Point' で宣言されている) にアクセスできません。

マックス「う、うむ　まだビルドエラーが表示されるかい」

ソーラー「何が原因なのかな？　ははっ

いや

もう

p3 = p1+p2;

の部分しか怪しい部分は残っていないね😊」

マックス「まあ、そうだな

p1+p2

が実行されると

普通の自作関数operator+の定義

👇

Point operator+(Point p, Point q) {

Point a;

a.x = p.x + q.x;

a.y = p.y + q.y;

return a;

}

👆

の

Point pにp1

Point qにp2

が代入された

Point a;

a.x = p1.x + p2.x;

a.y = p1.y + p2.y;

return a;

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

ソーラー「

あっ

そうか

p1+p2

すなわち

普通の自作関数operator+の定義

👇

Point operator+(Point p, Point q) {

Point a;

a.x = p.x + q.x;

a.y = p.y + q.y;

return a;

}

👆

の

pにp1

qにp2

が代入された

Point a;

a.x = p1.x + p2.x;

a.y = p1.y + p2.y;

return a;

は

a.x

p1.x

p2.x

a.y

p1.y

p2.y

が用いられているので実行できず

ビルドエラーが表示されているというわけなんだね」

マックス「ど～いうことん？」

ソーラー「えっ　もうわかってるんじゃ・・・」

てんC「マックスさん

クラスPointのメンバ変数宣言

int x;

int y;

のアクセス指定子が

privateに設定されているため

　　　　　　　main関数内で

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

p1.x

p1.y

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

p2.x

p2.y

を使用することはできません

ですので

p1.x

p1.y

p2.x

p2.y

を

取り扱うことができないため

p1+p2;

を実行する

すなわち

普通の自作関数operator+の定義

👇

Point operator+(Point p, Point q) {

Point a;

a.x = p.x + q.x;

a.y = p.y + q.y;

return a;

}

👆

の

pにp1

qにp2

が代入された

Point a;

a.x = p1.x + p2.x;

a.y = p1.y + p2.y;

return a;

を実行しようとすると

ビルドエラーが表示されるというわけなのですね

さらに

Point a;

が実行されて

クラスPoint型のオブジェクトaが生成されていますが

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

a.x

a.y

を使用することはできないのに

使用しているため

ビルドエラーが表示されるのですね」

マックス「なんだ　そういうわけか」

ソーラー「ただ

クラスPointのメンバ変数宣言

int x;

int y;

のアクセス指定子が

privateに設定されていても

以前のエピソードで解説されたように

　　　　　　　　operator+関数がクラスPointのメンバ関数のときは

　　　　　　　　クラスPointのメンバ関数であるoperator+関数を通して

　　　　　　　　　　　　　　　　間接的に

p1.x

p2.x

p1.y

p2.y

を取り扱うことができたね(^_-)-☆

そのときの

クラスPointのメンバ関数であるoperator+関数の定義は以下のようになっていましたね

👇

Point Point::operator+(Point p){

Point a;

a.x = x + p.x;

a.y = y + p.y;

return a;

}

👆

このように

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

定義されている場合

p1+p2

つまり

p1.operator+(p2)

が実行されると

xにp1.x

yにp1.y

Point p

に

p2

が代入された

Point a;

a.x =p1.x + p2.x;

a.y =p1.y + p2.y;

return a;

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

クラスPointのメンバ変数宣言

int x;

int y;

のアクセス指定子が

privateに設定されている、いないにかかわらず

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

クラスPointのメンバ変数

x

y

を記述して

使用することができましたね

そして

クラスPoint型のオブジェクトp1,p2が生成されると

xにp1.x

yにp1.y

Point p

に

p2

が代入された

Point a;

a.x =p1.x + p2.x;

a.y =p1.y + p2.y;

return a;

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

Point a;

によって生成される

a.x

a.y

も

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

使用することができます

このようにoperator+関数がクラスPointのメンバ関数である場合

Point a;

a.x =p1.x + p2.x;

a.y =p1.y + p2.y;

return a;

の実行は可能となるわけです

そこで

最初のプログラムの

普通の自作関数operator+の定義

👇

Point operator+(Point p, Point q) {

Point a;

a.x = p.x + q.x;

a.y = p.y + q.y;

return a;

}

を取り消し

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

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

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;

}

を設定してプログラムを実行してみたいと思います」

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

👇

#include <iostream>

using namespace std;

class Point {

private:

int x;

int y;

public:

void pointdisplay();

public:

Point Point::operator+(Point p);

};

void Point::pointdisplay() {

cout << x << "\n";

cout << y << "\n";

}

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

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=p1operator+(p2);と記述してもOKです🌞

p3.pointdisplay();

return 0;

ビルド実行結果

重大度レベル コード 説明 プロジェクト ファイル 行 抑制状態

エラー (アクティブ) E0265 メンバー "Point::y" (宣言された 行 9) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::y" (宣言された 行 9) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::x" (宣言された 行 8) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::x" (宣言された 行 8) にアクセスできません

エラー C2248 'Point::y': private メンバー (クラス 'Point' で宣言されている) にアクセスできません。

エラー C2248 'Point::y': private メンバー (クラス 'Point' で宣言されている) にアクセスできません。

エラー C2248 'Point::x': private メンバー (クラス 'Point' で宣言されている) にアクセスできません。

エラー C2248 'Point::x': private メンバー (クラス 'Point' で宣言されている) にアクセスできません。

ソーラー「ビルド実行でき・・・ない・・・

そっか

ここでもそうだ・・・

クラスPointのメンバ変数宣言

int x;

int y;

のアクセス指定子が

privateに設定されているので

main関数内で

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

Point p1;

Point p2;

を実行して

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

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

を作製しても

p1.x

p1.y

p2.x

p2.y

を使用することはできず

p1.x = 1;

p1.y = 1;

p2.x = 2;

p2.y = 2;

が記述されているとビルドエラーが表示されるというわけなんだね

じゃあ

private:

int x;

int y;

のアクセス指定子を

public

にしてやれば

このプログラムの実行が可能となるわけだね

そのことを示すプログラムはこちらです

👇

#include <iostream>

using namespace std;

class Point {

public://🌞ここに注目

int x;

int y;

public:

void pointdisplay();

public:

Point Point::operator+(Point p);

};

void Point::pointdisplay() {

cout << x << "\n";

cout << y << "\n";

}

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

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=p1operator+(p2);と記述してもOKです🌞

p3.pointdisplay();

return 0;

}

プログラムの実行結果

1

1

2

2

3

3

🐈　　　

　　　　　　　　　　　　　　　　　🐈

おまけのコーナーです

クラスPointのメンバ変数宣言

int x;

int y;

のアクセス指定子が

privateに設定されているので

main関数内で

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

Point p1;

Point p2;

を実行して

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

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

を作製しても

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

p1.x

p1.y

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

p2.x

p2.y

は使用できないので

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

p1.x

p1.y

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

p2.x

p2.y

が用いられた

p1.x = 1;

p1.y = 1;

p2.x = 2;

p2.y = 2;

が記述されているとビルドエラーが表

　　　　　　　　　カプセル化

が行われているなら

クラスPointのメンバ関数を通して

p1.x = 1;

p1.y = 1;

p2.x = 2;

p2.y = 2;

を実行すればいいのかな

そこで

オブジェクトp1のメンバ変数

p1.x

p1.y

オブジェクトp2のメンバ変数

p2.x

p2.y

に間接的に

数値データが代入できるよう

クラスPointに

新たに

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

void pointdisplay2(int i,int j);

を設定してみたいと思います

void pointdisplay2(int i,int j)の定義は

👇

void Point::pointdisplay2(int i, int j) {

x = i;

y = j;

cout << x << "\n";

cout << y << "\n";

}

👆

このように設定してみます

オブジェクト宣言

Point p1;

Point p2;

を

実行して

生成される

オブジェクトp1のメンバ関数

p1.pointdisplay2(int i,int j)

オブジェクトp2のメンバ関数

p2.pointdisplay2(int i,int j)

の

int i

int j

に

1

1

2

2

が代入された

オブジェクトp1のメンバ関数

p1.pointdisplay2(1,1);

オブジェクトp2のメンバ関数

p2.pointdisplay2(2,2);

を実行すれば

void pointdisplay2(int i,int j)の定義

👇

void Point::pointdisplay2(int i, int j) {

x = i;

y = j;

cout << x << "\n";

cout << y << "\n";

}

👆

の

int i

int j

に

1

1

ｘ

ｙ

に

p1.x

p1.y

が代入された

p1.x = 1;

p1.y = 1;

cout << p1.x << "\n";

cout << p1.y << "\n";

が実行され

かつ

void pointdisplay2(int i,int j)の定義

👇

void Point::pointdisplay2(int i, int j) {

x = i;

y = j;

cout << x << "\n";

cout << y << "\n";

}

👆

の

int i

int j

に

2

2

ｘ

ｙ

に

p2.x

p2.y

が代入された

p2.x =2;

p2.y =2;

cout << p2.x << "\n";

cout << p2.y << "\n";

が

実行されるので

オブジェクトp1のメンバ変数

p1.x

p1.y

オブジェクトp2のメンバ変数

p2.x

p2.y

に

　　　　　　　　　　　　　　間接的に

数値データ

1

1

2

2

が

代入できるようになります

このように改良を加えれば

今のプログラムが実行できると思われる方もおられるかもしれません

　　　　　　　　　　　　　　　　　　　　　　　solarplexussより

マックス「なんだ

その改良したプログラムはこうなるんだろう(￣ー￣)ﾆﾔﾘ

👇

#include <iostream>

using namespace std;

class Point{

private:

int x;

int y;

public:

void pointdisplay();

public:

void pointdisplay2(int i, int j);

};

void Point::pointdisplay() {

cout << x << "\n";

cout << y << "\n";

}

void Point::pointdisplay2(int i, int j) {

x = i;

y = j;

cout << x << "\n";

cout << y << "\n";

}

Point operator+(Point p, Point q) {

Point a;

a.x = p.x + q.x;

a.y = p.y + q.y;

return a;

}

int main() {

Point p1;

p1.pointdisplay2(1, 1);

Point p2;

p2.pointdisplay2(2, 2);

Point p3;

p3 = p1 + p2;

p3.pointdisplay();

return 0;

}

マックス「

どうだ　この改良プログラムは

絶好調だぜぃ

これで

Point p3;

p3=p1+p2;

//🌞p3=operator+(p1,p2);と記述してもOKです🌞

も実行できることになるんだろう

ビルド実行結果が華麗に表示されるのが楽しみだなあ

ソーラー

int（イント）よ😊

にゃははは(￣∇￣;)ハッハッハァ～～～」

マックス「それでは

　　　　　　　　　　　　ビルドォォォ

にゃはははははははははははははぁぁ～～～～～

」

#include <iostream>

using namespace std;

class Point{

private:

int x;

int y;

public:

void pointdisplay();

public:

void pointdisplay2(int i, int j);

};

void Point::pointdisplay() {

cout << x << "\n";

cout << y << "\n";

}

void Point::pointdisplay2(int i, int j) {

x = i;

y = j;

cout << x << "\n";

cout << y << "\n";

}

Point operator+(Point p, Point q) {

Point a;

a.x = p.x + q.x;

a.y = p.y + q.y;

return a;

}

int main() {

Point p1;

p1.pointdisplay2(1, 1);

Point p2;

p2.pointdisplay2(2, 2);

Point p3;

p3 = p1 + p2;

p3.pointdisplay();

return 0;

}

ビルド実行結果

重大度レベル コード 説明 プロジェクト ファイル 行 抑制状態

エラー (アクティブ) E0265 メンバー "Point::y" (宣言された 行 9) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::y" (宣言された 行 9) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::y" (宣言された 行 9) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::x" (宣言された 行 8) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::x" (宣言された 行 8) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::x" (宣言された 行 8) にアクセスできません

エラー C2248 'Point::y': private メンバー (クラス 'Point' で宣言されている) にアクセスできません。

エラー C2248 'Point::x': private メンバー (クラス 'Point' で宣言されている) にアクセスできません。

マックス「なんだ・・・」

int（イント）「？」

ソーラー「？」

てんC「？」

マックス「なんで

ビルド実行できぃんんんんん」

ソーラー「ビルドエラー

エラー (アクティブ) E0265 メンバー "Point::x" (宣言された 行 8) にアクセスできません

エラー (アクティブ) E0265 メンバー "Point::y" (宣言された 行 9) にアクセスできません

が

表示されているね。

どういうことかな・・・

あっ

そうか

p3=p1+p2;

が

実行できないので

ビルドエラーが表示されているというわけなのか」

マックス「ど～いうことん？」

ソーラー「確かに

オブジェクトp1のメンバ関数

p1.pointdisplay2(1,1);

オブジェクトp2のメンバ関数

p2.pointdisplay2(2,2);

を実行すれば

p1.x = 1;

p1.y = 1;

cout << p1.x << "\n";

cout << p1.y << "\n";

p2.x = 1;

p2.y = 1;

cout << p2.x << "\n";

cout << p2.y << "\n";

が

実行されるので

オブジェクトp1のメンバ変数

p1.x

p1.y

オブジェクトp2のメンバ変数

p2.x

p2.y

に間接的に

1

1

2

2

が代入されています

そして

p1+p2

が実行されることになるのですが

その場合

　　　　　　　　　　クラスPointのメンバ関数でない

　　　　　　　　　　　　普通の自作関数operator+

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

すると

　　　　　　　　　　クラスPointのメンバ関数でない

　　　　　　　　　　　　普通の自作関数operator+

の定義

👇

Point operator+(Point p, Point q) {

Point a;

a.x = p.x + q.x;

a.y = p.y + q.y;

return a;

}

の

引数部分の

Point p

Point q

に

p1

p2

が代入された

Point a;

a.x = p1.x + p2.x;

a.y = p1.y + p2.y;

return a;

が

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

しかし

クラスPointのメンバ変数宣言

int x;

int y;

のアクセス指定子が

privateに設定されているため

直接

p1.x

p2.x

p1.y

p2.y

を

main関数の中で用いることはできない設定となっているので

p1.x

p2.x

p1.y

p2.y

が用いられている

p1+p2

すなわち

Point a;

a.x = p1.x + p2.x;

a.y = p1.y + p2.y;

return a;

を実行しようとすると

ビルドエラーが表示されるというわけなんだね

クラスPointのメンバ変数宣言

int x;

int y;

のアクセス指定子が

privateに設定されていても

以前のエピソードでもみてきたように

　　　　　　　　operator+関数がクラスPointのメンバ関数のときは

　　　　　　　　　　　　　　　　間接的に

　　　　　　　　クラスPointのメンバ関数であるoperator+関数を通して

p1.x

p2.x

p1.y

p2.y

を取り扱うことができます

そのときの

クラス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のメンバ関数であるoperator+関数が

定義されている場合

p1+p2

つまり

p1.operator+(p2)

が実行されると

xにp1.x

yにp1.y

Point p

に

p2

が代入された

Point a;

a.x =p1.x + p2.x;

a.y =p1.y + p2.y;

return a;

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

お話が逸れますが

クラスPointのメンバ変数宣言

int x;

int y;

のアクセス指定子が

privateに設定されている、いないにかかわらず

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

クラスPointのメンバ変数

x

y

を記述することができます

このことを

クラスPointのメンバ関数

は

クラスPointのメンバ変数

x

y

に

アクセスすることができるともいいます

お話は戻って

p1+p2

すなわち

クラスPointのメンバ関数であるoperator+関数の引数にオブジェクトp2が代入された

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

p1.operator(p2)

の実行を通して

間接的に

p1.x

p1.y

p2.x

p2.y

を取り扱うことができるんです

このことはクラスのメンバ関数の一般的な特徴となっています

ですが

クラスPointのメンバ変数宣言

int x;

int y;

のアクセス指定子が

privateに設定されていると

普通の自作関数operator+関数は普通の自作関数なので

p1+p2

つまり

operator+(p1,p2)

を実行しようとしても

すなわち

普通の自作関数operator+関数の定義

👇

Point operator+(Point p, Point q) {

Point a;

a.x = p.x + q.x;

a.y = p.y + q.y;

return a;

}

の

引数部分の

Point p

Point q

に

p1

p2

が代入された

Point a;

a.x = p1.x + p2.x;

a.y = p1.y + p2.y;

return a;

を実行しようとしても

main関数内では

　　　　　　　　直接

クラスPoint型のメンバ変数

p1.x

p1.y

p2.x

p2.y

を用いることはできないので

p1+p2

つまり

operator+(p1,p2)

を実行しようとしても

ビルドエラーが表示されるんだよ」