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

クラスの多重継承を行ってみます クラスの多重継承の『美しさ』

ソーラー「クラスの多重継承の仕組みは簡単です。

例えば

クラス

classA

classB

classC

という３つのクラス

具体的には

👇

1.

classA{

クラスclassAのメンバ変数宣言;

クラスclassAのメンバ関数宣言;

};

クラスclassAのメンバ関数の定義

2.

classB{

クラスclassBのメンバ変数宣言;

クラスclassBのメンバ関数宣言;

};

クラスclassBのメンバ関数の定義

3.

classC{

クラスclassCのメンバ変数宣言;

クラスclassCのメンバ関数宣言;

};

クラスclassCのメンバ関数の定義

という３つのクラスとそのメンバ関数の定義があるとします

2つのクラス

classA

classB

を親クラス(基本クラス)

classC

を

子クラス(派生クラス)

として

classA

classB

から

classC

へ

クラスの多重継承を行うには

エディタ上で

classA{

クラスclassAのメンバ変数宣言;

クラスclassAのメンバ関数宣言;

};

クラスclassAのメンバ関数の定義

classB{

クラスclassBのメンバ変数宣言;

クラスclassBのメンバ関数宣言;

};

クラスclassBのメンバ関数の定義

を記述したのち

（Visual Studioをお使いで　クラスをファイルしておくクラスファイルにクラスが保存されている場合

記述する必要はありません）

〇　　〇　　〇　　〇　　〇　　〇

classC:public classA, public classB{

クラスclassCのメンバ変数宣言;

クラスclassCのメンバ関数宣言;

};

クラスclassCのメンバ関数の定義

〇　　〇　　〇　　〇　　〇　　〇

を記述します。

classCのクラス宣言において

classC:public classA, public classB{};

のように

classC:

のあとに

アクセス指定子publicを付けた

public classA

アクセス指定子publicを付けた

public classB

を,コンマで区切って記述することにより

classA

classB

から

classC

へ

classA

の

メンバ変数宣言

メンバ関数宣言

classB

の

メンバ変数宣言

メンバ関数宣言

が

継承されるというわけです。」

マックス「じゃあ

classA

classB

classC

classD

classE

という５つのクラスの

メンバ変数宣言

メンバ関数宣言

を

クラスclassF

に

継承したいと思ったら

classF:public classA,public classB,public classC,public classD,public classE{

クラスclassFのメンバ変数宣言;

クラスclassFのメンバ関数宣言;

};

と記述すればいいってわけか

単純なことじゃないか

超簡単だな。

いくらでも

クラスclassFの機能を強化できるな」

てんC「簡単ですね」

ソーラー「それでは実際に

　　　　　　　　　　　　クラスの多重継承

が行われているプログラムを

実行してみましょう。

そのために

次の3つのクラスを用意してみます。

まず

1つ目のクラスは

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を表示する機能をもつ

クラスRobotbodyです。

クラスRobotbodyのクラス宣言と

そのメンバ関数の定義は

👇

class Robotbody{

public:

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

public:

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

public:

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

public:

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

public:

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

};

void Robotbody::bodydatadisplay() {

cout << "ロボットの胴体につけられたナンバーは" << no << "です" << "\n";

cout << "ロボットの胴体の縦の長さは" << tate << "メートルです" << "\n";

cout << "ロボットの胴体の横の長さは" << yoko << "メートルです" << "\n";

cout << "ロボットの胴体の高さの長さは" << takasa << "メートルです" << "\n";

}

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

👆

とします。

マックス「なんか、どっかでみたようなクラスだな？」

ソーラー「そ、そ～ですか？」

マックス「

クラスRobotbodyを用いれば

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

のスペックデータを表示することができるというわけだ」

ソーラー「次に登場する2つ目のクラスは

ロボットの手の数を取り扱い

ロボットの手の数を表示する機能をもつ

クラスRobothandです。

ロボットの手の数を取り扱い

ロボットの手の数を表示する機能をもつ

クラスRobothandのクラス宣言と

そのメンバ関数の定義は

👇

class Robothand{

public:

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

public:

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

};

void Robothand::handdatadisplay() {

cout << "ロボットの手の数は" << tenokazu << "個です" << "\n";

}

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

👆

とします。」

マックス「ロボットの胴体のスペックデータをとりあつかい

ロボットの胴体のスペックデータ

を表示する

クラスRobotbody

の次は

ロボットの手の数をとりあつかい

ロボットの手の数を

表示する機能をもつ

クラスRobothandか・・・

これもどこかで見たよう～な・・・」

ソーラー「ええ？？　そ～ですか？初登場ですが・・・」

ソーラー「次に登場する３つ目のクラスは

ロボットの足の数を取り扱い

ロボットの足の数を

表示する機能をもつ

クラスRobotlegです。

ロボットの足の数を取り扱い

ロボットの足の数を

表示する機能をもつ

クラスRobotlegのクラス宣言と

そのメンバ関数の定義は

👇

class Robotleg {

public:

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

public:

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

};

void Robotleg::legdatadisplay() {

cout << "ロボットの足の数は" << asinokazu << "個です" << "\n";

}

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

👆

とします。」

ソーラー「以上の

クラスRobotbody

クラスRobothand

クラスRobotleg

👆

これらの3つのクラスを用いて

　　　　　　　　　　🌞クラスの多重継承🌞

を行ってみたいと思います。

まずは

クラスRobotbody

クラスRobothand

👆

これら２つのクラスを

別のクラス

Type2Robotに継承してみたいと思います。」

マックス「別のクラス

Type2Robot？？？」

ソーラー「

クラスType2Robotのクラス宣言と

クラスType2Robotのメンバ関数の定義は

class Type2Robot{

/*🌞クラスType2Robotのメンバ変数宣言、メンバ関数宣言

は記述していません

ですので

クラスType2Robotのメンバ関数の定義がおこなわれることはありません🌞*/

};

とします。」

マックス「クラスType2Robotの

クラス宣言では

メンバ変数宣言

メンバ関数宣言

が

記述されていないようだが・・・」

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

もちろん

クラスType2Robotの

クラス宣言に

メンバ変数宣言

メンバ関数宣言

が記述されていなくても

クラスRobotbody

クラスRobothand

の

メンバ変数宣言

メンバ関数宣言

を

クラスType2Robotに

継承することができます。

クラスRobotbody

クラスRobothand

👆

これら２つのクラスを

別のクラス

Type2Robotに継承するには

子クラス(派生クラス)となるType2Robotのクラス宣言を

次のように記述します

👇

class Type2Robot:public Robotbody,public Robothand{

/*🌞クラスType2Robotのメンバ変数宣言、メンバ関数宣言

は設定されていません

ですので

クラスType2Robotのメンバ関数の定義がおこなわれることはありません🌞*/

};

いかがですか？ 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　」

マックス「ははっ簡単だな

class Type2Robot:

の次に

public Robotbody,public Robothand

をくっつけただけじゃないか」

ソーラー「

では

　　　　　　　　　　　　なぜ

このように

クラスRobotbody

クラスRobothand

の

メンバ変数宣言

メンバ関数宣言

を

メンバ変数宣言

メンバ関数宣言

が記述されていない

空っぽの新しく設定した

クラスType2Robotに

継承するのかというと

それは

　　　　　　　　　　『美しさ』

のためです。」

マックス「＠‘‘‘

なにぃ？

　　　　　　　　　　『美しさ』

　　　　・・・・・・・・・　　　　　　　　　　　　　　　　　　」

マックス「・・・

　　　　　　　　　　『美しさ』

　？？

よくわからん」

　てんC「うふっ

ソーラーさんらしいですね。」

ソーラー「とりあえず

クラスRobotbody

クラスRobothand

👆

これら２つのクラスを

別のクラス

Type2bodyに継承してみたいと思います。

そのプログラムは次のようになります。」

#include <iostream>

using namespace std;

class Robotbody{

public:

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

public:

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

public:

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

public:

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

public:

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

};

void Robotbody::bodydatadisplay() {

cout << "ロボットの胴体につけられたナンバーは" << no << "です" << "\n";

cout << "ロボットの胴体の縦の長さは" << tate << "メートルです" << "\n";

cout << "ロボットの胴体の横の長さは" << yoko << "メートルです" << "\n";

cout << "ロボットの胴体の高さの長さは" << takasa << "メートルです" << "\n";

}

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

class Robothand{

public:

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

public:

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

};

void Robothand::handdatadisplay() {

cout << "ロボットの手の数は" << tenokazu << "個です" << "\n";

}

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

class Type2Robot : public Robotbody, public Robothand {

/*🌞クラスType2Robotのメンバ変数宣言、メンバ関数宣言

は設定していません

ですので

クラスType2Robotのメンバ関数の定義がおこなわれることはありません🌞*/

};

int main() {

Type2Robot robotMIRA;

robotMIRA.no = 1;

robotMIRA.tate = 1.0;

robotMIRA.yoko = 1.0;

robotMIRA.takasa = 1.0;

robotMIRA.bodydatadisplay();

robotMIRA.tenokazu = 2;

robotMIRA.handdatadisplay();

return 0;

}

プログラムの実行結果

ロボットの胴体につけられたナンバーは1です

ロボットの胴体の縦の長さは1メートルです

ロボットの胴体の横の長さは1メートルです

ロボットの胴体の高さの長さは1メートルです

ロボットの手の数は2個です　　　　　　　　　

マックス「いい感じじゃないか

クラスの多重継承　成功したな😊

Type2Robot : public Robotbody, public Robothandの実行により

子クラス(派生クラス)

Type2Robot

の誕生というわけだ。」

ソーラー「このプログラムでは

クラスRobotbodyの

メンバ変数宣言

メンバ関数宣言

クラスRobothandの

メンバ変数宣言

メンバ関数宣言

が

クラスType2Robotに

継承されています。

ですので

robotMIRAのクラスType2Robotのオブジェクト宣言

Type2Robot robotMIRA;

を実行することにより

クラスType2Robot型のオブジェクトrobotMIRAのメンバ変数

robotMIRA.no

robotMIRA.tate

robotMIRA.yoko

robotMIRA.takasa

robotMIRA.tenokazu

クラスType2Robot型のオブジェクトrobotMIRAのメンバ関数

robotMIRA.bodydatadisplay();

robotMIRA.handdatadisplay();

を

生成することができるというわけです。

あとは

robotMIRA.no = 1;

robotMIRA.tate = 1.0;

robotMIRA.yoko = 1.0;

robotMIRA.takasa = 1.0;

robotMIRA.bodydatadisplay();

robotMIRA.tenokazu = 2;

robotMIRA.handdatadisplay();

を実行すれば

プログラムの実行結果

ロボットの胴体につけられたナンバーは1です

ロボットの胴体の縦の長さは1メートルです

ロボットの胴体の横の長さは1メートルです

ロボットの胴体の高さの長さは1メートルです

ロボットの手の数は2個です　

が表示されます。」

マックス「クラスの多重継承のタイプのシステムは

1つのクラスを別のクラスへ継承するタイプと

同じシステムだな」

ソーラー「あっ！そうだ

　　　　　　　　後で使えるように

パソコンのファイルに今まで登場した３つのクラス

１．Robotbody

２．Robothand

３． Type2Robot : public Robotbody, public Robothand

のクラス宣言と

そのメンバ関数の定義を保存しておこうっと」　　　　　」

以下がパソコンのファイルに保存されるクラスと

そのクラスのメンバ関数宣言となります。

👇

1つ目のクラス

class Robotbody{

public:

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

public:

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

public:

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

public:

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

public:

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

};

void Robotbody::bodydatadisplay() {

cout << "ロボットの胴体につけられたナンバーは" << no << "です" << "\n";

cout << "ロボットの胴体の縦の長さは" << tate << "メートルです" << "\n";

cout << "ロボットの胴体の横の長さは" << yoko << "メートルです" << "\n";

cout << "ロボットの胴体の高さの長さは" << takasa << "メートルです" << "\n";

}

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

2つ目のクラス

class Robothand{

public:

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

public:

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

};

void Robothand::handdatadisplay() {

cout << "ロボットの手の数は" << tenokazu << "個です" << "\n";

}

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

3つ目のクラス

class Type2Robot : public Robotbody, public Robothand{

/*🌞クラスType2Robotのメンバ変数宣言、メンバ関数宣言

は記述していません

ですので

クラスType2Robotのメンバ関数の定義がおこなわれることはありません🌞*/

};

ソーラー「💻（パソコン）のファイルに保存完了っと」

マックス「作製したクラスをパソコンのファイルに保存しておけば

それらのクラスを

別のプログラムを作製するときでも利用することができ

あとで新たに0からクラスを作製する必要がないってわけだ。」

てんC「ここがC++言語の優れているところなのですね。」

ソーラー「そうなんだよ

さてと

　　　　　　　お話は戻って

ここで

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を

表示する機能をもつ

クラスRobotbody

ロボットの手の数を取り扱い

ロボットの手の数を

表示する機能を持つ

クラスRobothand

👆

これら２つのクラスを

クラスType2Robot

ではなく

ロボットの足の数を取り扱い

ロボットの足の数を

表示する機能を持つ

クラスRobotleg

に継承して

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

そのプログラムは以下のようになります」

#include <iostream>

using namespace std;

class Robotbody {

public:

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

public:

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

public:

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

public:

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

public:

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

};

void Robotbody::bodydatadisplay() {

cout << "ロボットの胴体につけられたナンバーは" << no << "です" << "\n";

cout << "ロボットの胴体の縦の長さは" << tate << "メートルです" << "\n";

cout << "ロボットの胴体の横の長さは" << yoko << "メートルです" << "\n";

cout << "ロボットの胴体の高さの長さは" << takasa << "メートルです" << "\n";

}

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

class Robothand{

public:

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

public:

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

};

void Robothand::handdatadisplay() {

cout << "ロボットの手の数は" << tenokazu << "個です" << "\n";

}

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

class Robotleg:public Robotbody, public Robothand

{

public:

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

public:

void legdatadisplay();//legdatadisplay()はクラスRobotlegのメンバ関数とよばれます

};

void Robotleg::legdatadisplay() {

cout << "ロボットの足の数は" << asinokazu << "個です" << "\n";

}

int main() {

Robotleg robotMIRA;

robotMIRA.no = 1;

robotMIRA.tate = 1.0;

robotMIRA.yoko = 1.0;

robotMIRA.takasa = 1.0;

robotMIRA.bodydatadisplay();

robotMIRA.tenokazu = 2;

robotMIRA.handdatadisplay();

return 0;

}

ビルド実行結果

ロボットの胴体につけられたナンバーは1です

ロボットの胴体の縦の長さは1メートルです

ロボットの胴体の横の長さは1メートルです

ロボットの胴体の高さの長さは1メートルです

ロボットの手の数は2個です　

マックス「

さっきのプログラムと

同じ実行結果だな。」

ソーラー「このプログラムでは

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

表示する機能をもつ

クラスRobotbody

と

ロボットの手の数をとりあつかい

ロボットの手の数を

表示する機能を持つ

クラスRobothand

👆

これら２つのクラスを

ロボットの足の数を取り扱い

ロボットの足の数を表示する機能を持つ

クラスRobotleg

に継承しています。

ということは

ロボットの足の数を表示する機能を持つ

クラスRobotleg

に

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を表示する機能と

ロボットの手の数を

取り扱い

ロボットの手の数を

表示する機能が

付け加えられているというわけです。」

マックス「ほ～　な～るほど～」

ソーラー「あっそうだ

このプログラムで新たに子クラス(派生クラス)

Robotleg:public Robotbody, public Robothand

が作製されたところで

この

新たに作製された子クラス(派生クラス)

Robotleg:public Robotbody, public Robothand

のクラス宣言と

そのメンバ関数の定義を

Visual Studio内のクラスを格納するクラスファイルに保存します

そして

親クラス(基本クラス)

Robotbody

のクラス宣言と

そのメンバ関数の定義

と

親クラス(基本クラス)

Robothand

のクラス宣言と

そのメンバ関数の定義

と

新たに作製された子クラス(派生クラス)

Robotleg:public Robotbody, public Robothand

のクラス宣言と

そのメンバ関数の定義を

パソコン内のどっかの

（Visual Studioとは関係ない）

ファイルに保存しておこうっと

保管、保管(*^▽^*)

具体的には

以下が

パソコン内のどっかの

（Visual Studioとは関係ない）

ファイルに保存される

クラスと

そのクラスのメンバ関数宣言となります。

👇

1つ目のクラス

class Robotbody{

public:

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

public:

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

public:

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

public:

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

public:

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

};

void Robotbody::bodydatadisplay() {

cout << "ロボットの胴体につけられたナンバーは" << no << "です" << "\n";

cout << "ロボットの胴体の縦の長さは" << tate << "メートルです" << "\n";

cout << "ロボットの胴体の横の長さは" << yoko << "メートルです" << "\n";

cout << "ロボットの胴体の高さの長さは" << takasa << "メートルです" << "\n";

}

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

2つ目のクラス

class Robothand{

public:

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

public:

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

};

void Robothand::handdatadisplay() {

cout << "ロボットの手の数は" << tenokazu << "個です" << "\n";

}

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

3つ目のクラス

class Robotleg:public Robotbody, public Robothand

{

public:

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

public:

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

};

void Robotleg::legdatadisplay() {

cout << "ロボットの足の数は" << asinokazu << "個です" << "\n";

}

マックス「なんで

そんな２度手間をするぅぅ

親クラス(基本クラス)

Robotbody

のクラス宣言と

そのメンバ関数の定義

と

親クラス(基本クラス)

Robothand

のクラス宣言と

そのメンバ関数の定義

と

新たに作製された子クラス(派生クラス)

Robotleg:public Robotbody, public Robothand

のクラス宣言と

そのメンバ関数の定義は

Visual Studioのクラスファイル内に

もう保存されているだろう」

ソーラー「その通り

なぜ

親クラス(基本クラス)

Robotbody

のクラス宣言と

そのメンバ関数の定義

と

親クラス(基本クラス)

Robothand

のクラス宣言と

そのメンバ関数の定義

と

新たに作製された子クラス(派生クラス)

Robotleg:public Robotbody, public Robothand

のクラス宣言と

そのメンバ関数の定義

を

パソコン内のどっかの

（Visual Studioとは関係ない）

ファイルに保存するのか？

　　　それは//

　　　この小説を書くためです」

マックス「えっ！？」

ソーラー「

あとで

新たに作製された派生クラス

Robotleg:public Robotbody, public Robothand

を用いて

この紙面内で

プログラムを記述するときに

新たに作製された派生クラス

Robotleg:public Robotbody, public Robothand

のクラス宣言と

そのメンバ関数の定義

の前に

親クラス(基本クラス)

Robotbody

のクラス宣言と

そのメンバ関数の定義

と

親クラス(基本クラス)

Robothand

のクラス宣言と

そのメンバ関数の定義

を

記述する必要が

あるからなんです。

記述してないと

読者の方は

親クラス(基本クラス)

Robotbody

親クラス(基本クラス)

Robothand

のクラス宣言が記述されていないに

突然

継承が行われている子クラスのクラス宣言

Robotleg:public Robotbody, public Robothand

がでてきたっ　きたきたっ　てなるからね

Visual Studioのエディタ上で

プログラムを記述するとき

親クラス(基本クラス)

Robotbodyのクラス宣言

と

そのメンバ関数の定義

親クラス(基本クラス)

Robothandのクラス宣言

と

そのメンバ関数の定義

が

Visual Studioの

クラスを格納するクラスファイルに保存されていれば

Robotleg:public Robotbody, public Robothand

のクラス宣言

を記述しただけで

いちいち

親クラス(基本クラス)

Robotbody

と

親クラス(基本クラス)

Robothand

のクラス宣言を記述しなくても

きちんと

継承はおこなわれることになります

紙上でプログラムを記述するときは

Robotleg:public Robotbody, public Robothand

のクラス宣言

を記述しただけでは

親クラス(基本クラス)

Robotbody

と

親クラス(基本クラス)

Robothand

ってなんのことかわからないからね

そもそも

読者の方が

親クラス(基本クラス)

Robotbody

と

親クラス(基本クラス)

Robothand

のクラス宣言

を

Visual Studioのクラス内に保存してあるとはかぎらないから

プログラムを作製するとき

親クラス(基本クラス)

Robotbody

のクラス宣言と

そのメンバ関数の定義

と

親クラス(基本クラス)

Robothand

のクラス宣言と

そのメンバ関数の定義

と

新たに作製された子クラス(派生クラス)

Robotleg:public Robotbody, public Robothand

のクラス宣言と

そのメンバ関数の定義

を

記述する必要があります

そこで

親クラス(基本クラス)

Robotbody

のクラス宣言と

そのメンバ関数の定義

と

親クラス(基本クラス)

Robothand

のクラス宣言と

そのメンバ関数の定義

と

新たに作製された子クラス(派生クラス)

Robotleg:public Robotbody, public Robothand

のクラス宣言と

そのメンバ関数の定義

を

まとめて

パソコン内のどこかのファイルに保存しておきます

そうしておくと

後でコピペ（💖💖💖）が簡単なんだ😊」

🌞　　🌞　　🌞　　🌞　　🌞

そう

それは

この小説を書く場合に必要ということなんです

実際には

親クラス(基本クラス)

Robotbody

と

親クラス(基本クラス)

Robothand

を

Visual Studioのクラスファイルに保存しておけば

プログラム内で

親クラス(基本クラス)

Robotbody

と

親クラス(基本クラス)

Robothand

のクラス宣言を記述しなくても

子クラス(派生クラス)のクラス宣言

👇

class Robotleg:public Robotbody, public Robothand

{

public:

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

public:

void legdatadisplay();//legdatadisplay()はクラスRobotlegのメンバ関数とよばれます

};

👆

を記述するだけで

ちゃんと

クラスファイル内に保存してある

親クラス(基本クラス)

Robotbody

と

親クラス(基本クラス)

Robothand

から

子クラス(派生クラス)Robotlegへ

クラスの継承が自動的にきちんと行われることになります

🌞　　🌞　　🌞　　🌞　　🌞

ソーラー「さて

　　　　　　ここからが本題です

ここでプログラムの

main関数の中の

オブジェクト宣言

Robotleg robotMIRA;

に注目してください

派生クラス

Robotleg:public Robotbody, public Robothand型のオブジェクト宣言は

Robotleg robotMIRA;

となっていますね。

Robotleg:public Robotbody, public Robothand

をそのまんま使った

Robotleg:public Robotbody, public Robothand robotMIRA;

ではありません。

短くなっています

このとき

robotMIRAのRobotleg型のオブジェクト宣言

Robotleg robotMIRA;

の

クラスRobotlegの名前を見ただけでは

クラスRobotlegに

ロボットの足の数を取り扱い、表示する機能があることは

推察することはできても

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能と

ロボットの手の数を取り扱い、表示する機能があることは

推察しにくいですね

そこで

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能をもつ

クラスRobotbody

の

メンバ変数宣言

メンバ関数宣言

ロボットの手の数を取り扱い、表示する機能を持つ

クラスRobothand

の

メンバ変数宣言

メンバ関数宣言

を

　　　　　　クラスType2Robotに

継承しているんです。」

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

なんで

クラスType2Robotなんだ？

それと

なんで

クラスType1Robotでないんだ？」

マックス「・・・？？だが・・・

この設定には何かをかんじるな・・・

それが

　　　　　　　　　　　『美しさ』

というわけか(*´▽｀*)

だが

Type2Robotに

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能をもつ

クラスRobotbody

の

メンバ変数宣言

メンバ関数宣言

ロボットの手の数を取り扱い、表示する機能を持つ

クラスRobothand

の

メンバ変数宣言

メンバ関数宣言

を

Type2Robot:public Robotbody, public Robothand

のように引き継いで

Type2Robot型のrobotMIRAのオブジェクト宣言

Type2Robot robotMIRA;

を実行したとしても

Type2Robot robotMIRA;

の

Type2Robotの名前を見ただけでは

クラスType2Robotに

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能と

ロボットの手の数を取り扱い、表示する機能があることは

推察できないんじゃないか？」

ソーラー「そうなんです

　　　　　　　　　　　　実は

もう

　　　　　　　　　　　僕の中では

　　　　　　　　　はるか前のエピソード

　　　　　　　「クラスの継承　実際の導入編」

のときから

クラスType1Robotは

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能を持つクラス

で

クラスType2Robotは

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能と

ロボットの手の数を取り扱い、表示する機能を持つクラス

と決めてあったんです(*´▽｀*)/

Typeのナンバーが大きくなっていくほど

そのクラスは取り扱える機能がふえていくんだ」

マックス「ということは

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能と

ロボットの手の数を取り扱い、表示する機能と

さらあに

ロボットの足の数を取り扱い、表示する機能を持つクラスなら

クラスType3Robot

と決めてたりするわけか？」

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

僕の中では

最初から

クラスType1Robotは

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能を持つクラス

で

クラスType2Robotは

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能と

ロボットの手の数を取り扱い表示する機能を持つクラス

で

クラスType3Robotは

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能と

ロボットの手の数を取り扱い表示する機能と

さらあに

ロボットの足の数を取り扱い表示する機能を持つクラスと

決めてあったというわけです。

だから

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能をもつ

クラスRobotbody

の

メンバ変数宣言

メンバ関数宣言

と

ロボットの手の数を取り扱い表示する機能を持つ

クラスRobothand

の

メンバ変数宣言

メンバ関数宣言

を

Type2Robot:public Robotbody, public Robothand

と

　　　Type2Robotという名前のクラスに

継承しているんです。

クラスType1Robot

クラスType2Robot

クラスType3Robot

・

・

・

と

クラスのタイプの番号が

Type1

Type2

Type3

・

・

・

と

大きくなるにつれて

どんどん

クラスの機能が追加されているというわけです

そのとき

パソコンのファイルには

クラス

Robotbody

Robothand

Robotleg

・

・

・

Type1Robot:public Robotbody

Type2Robot:public Robotbody,public Robothand

Type3Robot:public Robotbody,public Robothand,public Robotleg

・

・

・

が

保存されることになりますね(^_-)-☆

ですから

そうですね。

メモ帳に

クラスType1Robotは

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能を持つクラス

で

クラスType2Robotは

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能と

ロボットの手の数を取り扱い、表示する機能を持つクラス

で

クラスType3Robotは

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能と

ロボットの手の数を取り扱い、表示する機能と

さらに

ロボットの足の数を取り扱い、表示する機能を持つクラスと

メモっておけば

いや

メモってなくても

このクラスが保存されたファイルを見れば

　　　　　Typeナンバーの数が大きいほど機能がアップするので

簡単に

あとで

自分で

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

と

ロボットの手の数をとりあつかいたい

表示したいと思った時に

クラスType2Robot

あるいは

クラスType3Robot

を使えばよいと

きづくというわけです。

まあ、最新のバージョンの

　　　　　　　クラスType3Robot

を使えば

OKかな？」

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

このように

クラスType1Robot

クラスType2Robot

クラスType3Robot

・

・

・

と

クラスのタイプの数が

Type1

Type2

Type3

・

・

・

と

大きくなるにつれて

Type1Robot:public Robotbody

Type2Robot:public Robotbody,public Robothand

Type3Robot:public Robotbody,public Robothand,public Robotleg

と

どんどん

クラスの機能が追加、継承されていくとき

クラスのタイプの番号が大きいクラスは

番号がより小さいクラスの機能をすべて持っていることになります。

ですので

何も考えなくても

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

と

ロボットの手の数を表示したいと思ったならば

最新の最もクラスのタイプの番号が大きいヴァージョンのクラスを

用いればよいということになりますね。

番号の大きなヴァージョンのクラスほど

より

たくさんのクラスの機能が追加されているというわけです。

　　　　　　　　　　　　　　　　　　　solarplexussより

🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞　　　🌞

ソーラー「これに対して

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を表示する機能をもつ

クラスRobotbody

と

ロボットの手の数を表示する機能を持つ

クラスRobothand

👆

これら２つのクラスを

ロボットの足の数を表示する機能を持つ

クラスRobotleg

に継承していたとします

かなりあとで

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

と

ロボットの手の数

と

ロボットの足の数

を

取り扱いたい

表示したいな(*´▽｀*)

と思った時に

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

と

ロボットの手の数

と

ロボットの足の数

を

表示する機能を持つクラスを

探すとします。

そのとき

クラスRobotbody

クラスRobothand

クラスRobotleg

・

・

・

クラスRobothand:public Robotbody

クラスRobotleg:public Robothand,public Robotbody

・

・

・

のようなクラスが

パソコンのファイル内に

用意されているとします」

マックス「え～と

クラスRobothand:public Robotbody

クラスRobotleg:public Robothand,public Robotbody

て・・・

すべてのクラスを継承している最新のクラスは・・・

？？？

クラスRobotleg・・・なのか？

？」

ソーラー「

この場合では

クラスRobotbody

クラスRobothand

クラスRobotleg

がはじめに制作され

そのクラスRobotbodyがクラスRobothandに継承された

子クラス(派生クラス)

Robothand:public Robotbody

が制作され

さらに

クラスRobotbody

と

クラスRobothandが継承された

子クラス(派生クラス)

クラスRobotleg:public Robotbody,public Robothand

が制作され

パソコンのファイルに保存されています

クラスRobotbody

クラスRobothand:public Robotbody

クラスRobotleg:public Robotbody,public Robothandmo

・

・

・

をみただけでも

クラスRobot:public Robotbody,public Robothand

の

コロン以下の:public Robotbody,public Robothand

に注目すれば

クラスRobot:public Robotbody,public Robothand

が

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

と

ロボットの手の数

と

ロボットの足の数

を

取り扱い

表示する機能を継承しているクラスとわかるのですが

保存しているクラスがとても多いと

探すのが難しいかもしれません

このクラス

Robotleg:public Robotbody,public Robothand

の機能を使うためには

main関数の中で

Robotleg型のオブジェクト宣言を実行する必要があります

Robotleg型のオブジェクト宣言は

Robotleg robotMIRA;

のように実行することになりますが

このとき

Robotleg robotMIRA;

の

Robotlegの名前を見ただけでは

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

と

ロボットの手の数

と

ロボットの足の数

を

取り扱い、表示する機能を継承しているクラスのオブジェクト宣言が実行されているとは

わかりにくいよね。

それに

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

と

ロボットの手の数

と

ロボットの足の数

を

取り扱い、表示する機能を持つクラスが

足の名前が用いられた

Robotleg

では

違和感があるよね

」

マックス「まあ　そうだよな。」

ソーラー「

そこで

あらかじめ

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を取り扱い、表示する機能

と

ロボットの手の数を取り扱い、表示する機能

と

ロボットの足の数を取り扱い、表示する機能

を継承するとあらかじめ決めておいた

クラスType3Robotに

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を表示する機能をもつ

クラスRobotbody

と

ロボットの手の数を表示する機能を持つ

クラスRobothand

と

ロボットの足の数を表示する機能を持つ

クラスRobotleg

👆

これら3つのクラスを

Type3Robot:public Robotbod,public Robothand,public Robotleg

のように記述して

継承するというわけです。

そうしておけば

クラスType3Robotは

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

を表示する機能

と

ロボットの手の数を表示する機能

と

ロボットの足の数を表示する機能

を継承するとあらかじめ決めておいたので

オブジェクト宣言

Type3Robot robotMIRA;

がプログラム内に記述してあれば

Type3Robot の名前を見ただけで

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

と

ロボットの手の数

と

ロボットの足の数

を

取り扱い

表示する機能を継承しているクラス型の

オブジェクト宣言が行われていると

すぐにわかるよね。

もちろん

そのオブジェクトを用いれば

あるロボット(プロトタイプオブジェクト)の

ロボットの胴体につけられたナンバー

ロボットの胴体の縦の長さ

ロボットの胴体の横の長さ

ロボットの胴体の高さの長さ

と

ロボットの手の数

と

ロボットの足の数

を

取り扱い

表示することができます

＼(^o^)／」

てんC「それが

　　　　　　　　　　『美しさ』

なのですね。

ソーラーさん

素晴らしいアイデアですね。」

マックス「そこまで考えていたとは・・・

　　　　　　　　　　　やるな😊

　　　　　　　　　　　　　　　　　　　　　　　」