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

コンストラクタを用いてクラスCube型の配列宣言を初期化します クラスCube型の配列宣言を行う場合は引数を持たないコンストラクタを設定しないで引数を持つコンストラクタだけを設定することはできません

てんC「

💖💖💖クラスCube型のオブジェクトの配列宣言💖💖💖

Cube cube[3];

をおこなって

オブジェクト

cube[0]

cube[1]

cube[2]

を作成した場合

引数を持たない

Cube::Cube() {

no = 0;

tate = 0.0;

yoko = 0.0;

takasa = 0.0;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

と定義された方のクラスのコンストラクタの

no

tate

yoko

takasa

に

オブジェクトcube[0]のメンバ変数

cube[0].no

cube[0].tate

cube[0].yoko

cube[0].takasa

が代入された

cube[0].no=0;

cube[0].tate=0.0;

cube[0].yoko=0.0;

cube[0].takasa=0.0;

が実行され

さらに

引数を持たない

👇

Cube::Cube() {

no = 0;

tate = 0.0;

yoko = 0.0;

takasa = 0.0;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

👆

と定義された方のコンストラクタの

no

tate

yoko

takasa

に

オブジェクトcube[1]のメンバ変数

cube[1].no

cube[1].tate

cube[1].yoko

cube[1].takasa

が代入された

cube[1].no=0;

cube[1].tate=0.0;

cube[1].yoko=0.0;

cube[1].takasa=0.0;

が実行され

さらに

引数を持たない

👇

Cube::Cube() {

no = 0;

tate = 0.0;

yoko = 0.0;

takasa = 0.0;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

👆

と定義された方のコンストラクタの

no

tate

yoko

takasa

に

オブジェクトcube[2]のメンバ変数

cube[2].no

cube[2].tate

cube[2].yoko

cube[2].takasa

が代入された

cube[2].no=0;

cube[2].tate=0.0;

cube[2].yoko=0.0;

cube[2].takasa=0.0;

が実行されます（笑）

つまり

オブジェクト

cube[0]

cube[1]

cube[2]

のメンバ関数である

オブジェクトcube[0]のコンストラクタ

オブジェクトcube[1]のコンストラクタ

オブジェクトcube[2]のコンストラクタ

が実行されます。

その様子は次のプログラムをご覧ください。」

#include <iostream>

using namespace std;

class Cube {

public:

int no;

public:

float tate;

public:

float yoko;

public:

float takasa;

public:

Cube();

//🌞🌞🌞コンストラクタCube()のメンバ関数宣言を行っています🌞🌞🌞

public:

Cube(int a, float b, float c, float d);

/*🌞🌞🌞コンストラクタCube(int a,float b,float c,float d)のメンバ関数宣言を行っています🌞🌞🌞*/

public:

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

};

Cube::Cube() {

no = 0;

tate = 0.0;

yoko = 0.0;

takasa = 0.0;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

//👆🌞🌞🌞コンストラクタCube()の定義を行っています🌞🌞🌞

Cube::Cube(int a, float b, float c, float d) {

no = a;

tate = b;

yoko = c;

takasa = d;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

/*👆🌞🌞🌞コンストラクタCube(int a,float b,float c,float d)の定義を行っています🌞🌞🌞*/

void Cube::display() {

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

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

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

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

}

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

int main() {

Cube cube[3];

/*🌞🌞🌞配列をつかってクラスCube型のオブジェクト

cube[0]

cube[1]

cube[2]

を作製しています🌞🌞🌞*/

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

cout << "立方体の縦の長さは" << cube[0].no << "です" << "\n";

cout << "立方体の横の長さは" << cube[0].no << "です" << "\n";

cout << "立方体の高さの長さは" << cube[0].no << "です" << "\n";

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

cout << "立方体の縦の長さは" << cube[1].no << "です" << "\n";

cout << "立方体の横の長さは" << cube[1].no << "です" << "\n";

cout << "立方体の高さの長さは" << cube[1].no << "です" << "\n";

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

cout << "立方体の縦の長さは" << cube[2].no << "です" << "\n";

cout << "立方体の横の長さは" << cube[2].no << "です" << "\n";

cout << "立方体の高さの長さは" << cube[2].no << "です" << "\n";

return 0;

}

ビルド実行結果

生成されたオブジェクトのメンバ変数を初期化しました

生成されたオブジェクトのメンバ変数を初期化しました

生成されたオブジェクトのメンバ変数を初期化しました

立方体につけられたナンバーは0です

立方体の縦の長さは0です

立方体の横の長さは0です

立方体の高さの長さは0です

立方体につけられたナンバーは0です

立方体の縦の長さは0です

立方体の横の長さは0です

立方体の高さの長さは0です

立方体につけられたナンバーは0です

立方体の縦の長さは0です

立方体の横の長さは0です

立方体の高さの長さは0です

てんC「このプログラムでは

コンストラクタの定義は

　　　　　　　🍓　引数を持たない　🍓

Cube::Cube() {

no = 0;

tate = 0.0;

yoko = 0.0;

takasa = 0.0;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

👆

タイプと

　　　　　　　　🍓　引数を持つ　🍓

Cube::Cube(int a, float b, float c, float d) {

no = a;

tate = b;

yoko = c;

takasa = d;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

/*👆🌞🌞🌞コンストラクタCube(int a,float b,float c,float d)の定義を行っています🌞🌞🌞*/

👆

タイプの２つが

記述されていますが

クラスCube型のオブジェクトの配列宣言

Cube cube[3];

が実行された場合

　　　　　　　🍓　引数を持たない　🍓

Cube::Cube() {

no = 0;

tate = 0.0;

yoko = 0.0;

takasa = 0.0;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

と定義された方のコンストラクタの

no = 0;

tate = 0.0;

yoko = 0.0;

takasa = 0.0;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

の

no

tate

yoko

takasa

に

オブジェクトcube[0]のメンバ変数

cube[0].no

cube[0].tate

cube[0].yoko

cube[0].takasa

オブジェクトcube[1]のメンバ変数

cube[1].no

cube[1].tate

cube[1].yoko

cube[1].takasa

オブジェクトcube[2]のメンバ変数

cube[2].no

cube[2].tate

cube[2].yoko

cube[2].takasa

が代入されたものが実行されます

つまり

オブジェクト

cube[0]

cube[1]

cube[2]

のメンバ関数である

オブジェクト

cube[0]のコンストラクタ

cube[1]のコンストラクタ

cube[2]のコンストラクタ

が

自動的に実行されることになります。

　　　　　　　　　　　　　　　　😸じゃん😸　　　　　　

　　　　　　　　　　　　　　　そこで問題です

　　　　　　　　💖💖💖クラスCube型の配列宣言💖💖💖

Cube cube[3];

が実行された場合

　　　　　　　🍓　引数を持たない　🍓

Cube::Cube() {

no = 0;

tate = 0.0;

yoko = 0.0;

takasa = 0.0;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

と定義された方のコンストラクタの

no

tate

yoko

takasa

に

オブジェクトcube[0]のメンバ変数

cube[0].no

cube[0].tate

cube[0].yoko

cube[0].takasa

オブジェクトcube[1]のメンバ変数

cube[1].no

cube[1].tate

cube[1].yoko

cube[1].takasa

オブジェクトcube[2]のメンバ変数

cube[2].no

cube[2].tate

cube[2].yoko

cube[2].takasa

が代入された

オブジェクト

cube[0]

cube[1]

cube[2]

のメンバ関数である

オブジェクト

cube[0]のコンストラクタ

cube[1]のコンストラクタ

cube[2]のコンストラクタ

が

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

もし

クラス宣言内で

引数を持たないコンストラクタのメンバ関数宣言

Cube();

が記述されておらず

引数を持つコンストラクタのメンバ関数宣言

Cube(int a, float b, float c, float d);

だけが

記述されていて

コンストラクタの定義が

　　　　　　　　🍓　引数を持つ　🍓

Cube::Cube(int a, float b, float c, float d) {

no = a;

tate = b;

yoko = c;

takasa = d;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

だけが記述されていて

　　　　　　　🍓　引数を持たない　🍓

コンストラクタの定義

👇

Cube::Cube() {

no = 0;

tate = 0.0;

yoko = 0.0;

takasa = 0.0;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

が

記述されていなければ

クラスCube型のオブジェクトの配列宣言

Cube cube[3];

が実行された場合

どのようにオブジェクトのコンストラクタは実行されるのでしょうか?

それとも

オブジェクトのコンストラクタは実行されないのでしょうか?

なんとなく

Cube cube[3];

が実行されて

オブジェクト

cube[0]

cube[1]

cube[2]

だけが作製されただけで

何もおこらない

めでたしめでたしと

なりそうな感じがしますね

さあ

どのようなビルド実行結果が表示されるのでしょうか？

Cube cube[3];

が実行された場合

もしかしたら

　　　　　　　　　　🍓　引数を持つコンストラクタ　🍓

　　Cube::Cube(int a, float b, float c, float d) {

no = a;

tate = b;

yoko = c;

takasa = d;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

の定義の

no

tate

yoko

takasa

に

オブジェクトcube[0]のメンバ変数

cube[0].no

cube[0].tate

cube[0].yoko

cube[0].takasa

が代入された

cube[0].no= a;

cube[0].tate = b;

cube[0].yoko = c;

cube[0].takasa= d;

が実行され

no

tate

yoko

takasa

に

オブジェクトcube[1]のメンバ変数

cube[1].no

cube[1].tate

cube[1].yoko

cube[1].takasa

が代入された

cube[1].no= a;

cube[1].tate = b;

cube[1].yoko = c;

cube[1].takasa= d;

が実行され

no

tate

yoko

takasa

に

オブジェクトcube[2]のメンバ変数

cube[2].no

cube[2].tate

cube[2].yoko

cube[2].takasa

が代入された

cube[2].no= a;

cube[2].tate = b;

cube[2].yoko = c;

cube[2].takasa= d;

が実行されるのでしょうか？

つまり

オブジェクト

cube[0]

cube[1]

cube[2]

のメンバ関数である

オブジェクト

cube[0]

cube[1]

cube[2]

の引数を持つタイプのコンストラクタが

自動的に実行されるのでしょうか？」

さあ💖どうなるのでしょうか？

🐤　　🐤　　🐤　　🐤　　🐤　　🐤　　🐤　　🐤　　🐤　　🐤　　🐤

ソーラー「？？この場合は・・・

クラスCube型のオブジェクトの配列宣言

Cube cube[3];

が実行されて

　　　　　　　　　　　　もし

　　　　　　　　　🍓　引数を持つ　🍓

　　Cube::Cube(int a, float b, float c, float d) {

no = a;

tate = b;

yoko = c;

takasa = d;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

と定義されたコンストラクタ

の

no

tate

yoko

takasa

に

オブジェクトcube[0]のメンバ変数

cube[0].no

cube[0].tate

cube[0].yoko

cube[0].takasa

が代入された

cube[0].no=a;

cube[0].tate=b;

cube[0].yoko=c;

cube[0].takasa=d;

が実行され

no

tate

yoko

takasa

に

オブジェクトcube[1]のメンバ変数

cube[1].no

cube[1].tate

cube[1].yoko

cube[1].takasa

が代入された

cube[1].no=a;

cube[1].tate=b;

cube[1].yoko=c;

cube[1].takasa=d;

が実行され

no

tate

yoko

takasa

に

オブジェクトcube[2]のメンバ変数

cube[2].no

cube[2].tate

cube[2].yoko

cube[2].takasa

が代入された

cube[2].no=a;

cube[2].tate=b;

cube[2].yoko=c;

cube[2].takasa=d;

が実行されたとしても

　　　　　　　　🍓　引数を持つ　🍓

コンストラクタの定義の引数部分

👇

　　Cube::Cube(int a, float b, float c, float d)

👆

の

int a

float b

float c

float d

に

数値データを代入することが全然できないから

結局

Cubeのクラス宣言内に

　　　　　　　　　🍓　引数を持つタイプの　🍓

👇

　　Cube::Cube(int a, float b, float c, float d) {

no = a;

tate = b;

yoko = c;

takasa = d;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

👆

と定義されたコンストラクタだけが

記述されていたとしても

オブジェクト

cube[0]

cube[1]

cube[2]

のコンストラクタは

実行されないんじゃないかな？

となると

なんとなく

Cube cube[3];

が実行されて

オブジェクト

cube[0]

cube[1]

cube[2]

だけが作製されただけで

何もおこらない

めでたしめでたしとなるんじゃないかな？

😊」

てんC「そうですね

では

Cubeのクラス宣言内で

引数を持たないコンストラクタのメンバ関数宣言

Cube();

が記述されておらず

引数を持つコンストラクタのメンバ関数宣言

Cube(int a, float b, float c, float d)

だけが記述されていて

クラスCubeのコンストラクタの定義が

　　　　　　　　🍓　引数を持つ　🍓

Cube::Cube(int a, float b, float c, float d) {

no = a;

tate = b;

yoko = c;

takasa = d;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

だけが記述されていて

　　　　　　　🍓　引数を持たない　🍓

Cube::Cube() {

no = 0;

tate = 0.0;

yoko = 0.0;

takasa = 0.0;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

が

記述されていない場合

クラスCube型の配列宣言

Cube cube[3];

が実行された場合

どのように

オブジェクト

cube[0]

cube[1]

cube[2]

のコンストラクタは実行されるのでしょうか?

それとも

オブジェクト

cube[0]

cube[1]

cube[2]

のコンストラクタは実行されないのでしょうか?

どのようなビルド実行結果が表示されるのでしょうか？

プログラムを実行して確かめてみたいと思います。」

ソーラー「そうだね😊」

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

👇

#include <iostream>

using namespace std;

class Cube {

public:

int no;

public:

float tate;

public:

float yoko;

public:

float takasa;

public:

Cube(int a, float b, float c, float d);

/*🌞🌞🌞引数を持つコンストラクタCube(int a,float b,float c,float d)のメンバ関数宣言だけを行っています🌞🌞🌞*/

public:

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

};

Cube::Cube(int a, float b, float c, float d) {

no = a;

tate = b;

yoko = c;

takasa = d;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

/*👆🌞🌞🌞引数を持つコンストラクタCube(int a,float b,float c,float d)の定義を行っています🌞🌞🌞*/

void Cube::display() {

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

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

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

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

}

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

int main() {

Cube cube[3];

/*🌞🌞🌞配列システムをつかってクラスCube型のオブジェクト

cube[0]

cube[1]

cube[2]

を作製しています🌞🌞🌞*/

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

cout << "立方体の縦の長さは" << cube[0].tate << "です" << "\n";

cout << "立方体の横の長さは" << cube[0].yoko << "です" << "\n";

cout << "立方体の高さの長さは" << cube[0].takasa<< "です" << "\n";

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

cout << "立方体の縦の長さは" << cube[1].tate << "です" << "\n";

cout << "立方体の横の長さは" << cube[1].yoko<< "です" << "\n";

cout << "立方体の高さの長さは" << cube[1].takasa<< "です" << "\n";

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

cout << "立方体の縦の長さは" << cube[2].tate << "です" << "\n";

cout << "立方体の横の長さは" << cube[2].yoko << "です" << "\n";

cout << "立方体の高さの長さは" << cube[2].takasa << "です" << "\n";

return 0;

}

ビルド実行結果

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

エラー (アクティブ) E0291 クラス "Cube" の既定のコンストラクターは存在しません

エラー C2512 'Cube': クラス、構造体、共用体に既定のコンストラクターがありません。

ソーラー「

クラス "Cube" の既定のコンストラクターは存在しません

・・・・か？

これは

引数を持たないコンストラクタが定義されていないということかな？」

てんC「

　　　　　　　💖💖💖クラスCube型の配列宣言💖💖💖

　　　　　　　　　　　　　Cube cube[3];

を実行する際

🍓引数を持つタイプのコンストラクタ🍓

だけが設定されていて

🍓引数を持たないコンストラクタ🍓

が設定されていない場合

このように

クラス "Cube" の既定のコンストラクターは存在しません

と警告文が表示されることになります

つまり

クラスCubeのメンバ関数として

Cube(int a, float b, float c, float d)

のような

引数を持つコンストラクタを設定するなら

同時に

クラスCubeのメンバ関数として

Cube()

のような

引数を持たないコンストラクタを設定しておく

必要があるわけです

ですので

今のプログラムで

引数を持つコンストラクタの設定を取り除いてしまえば

プログラムは実行できることになりますが・・・」

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

👇

#include <iostream>

using namespace std;

class Cube {

public:

int no;

public:

float tate;

public:

float yoko;

public:

float takasa;

public:

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

};

void Cube::display() {

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

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

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

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

}

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

int main() {

Cube cube[3];

/*🌞🌞🌞配列システムをつかってクラスCube型のオブジェクト

cube[0]

cube[1]

cube[2]

を作製しています🌞🌞🌞*/

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

cout << "立方体の縦の長さは" << cube[0].tate << "です" << "\n";

cout << "立方体の横の長さは" << cube[0].yoko << "です" << "\n";

cout << "立方体の高さの長さは" << cube[0].takasa << "です" << "\n";

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

cout << "立方体の縦の長さは" << cube[1].tate << "です" << "\n";

cout << "立方体の横の長さは" << cube[1].yoko << "です" << "\n";

cout << "立方体の高さの長さは" << cube[1].takasa << "です" << "\n";

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

cout << "立方体の縦の長さは" << cube[2].tate << "です" << "\n";

cout << "立方体の横の長さは" << cube[2].yoko << "です" << "\n";

cout << "立方体の高さの長さは" << cube[2].takasa << "です" << "\n";

return 0;

}

ビルド実行結果

立方体につけられたナンバーは-858993460です

立方体の縦の長さは-1.07374e+08です

立方体の横の長さは-1.07374e+08です

立方体の高さの長さは-1.07374e+08です

立方体につけられたナンバーは-858993460です

立方体の縦の長さは-1.07374e+08です

立方体の横の長さは-1.07374e+08です

立方体の高さの長さは-1.07374e+08です

立方体につけられたナンバーは-858993460です

立方体の縦の長さは-1.07374e+08です

立方体の横の長さは-1.07374e+08です

立方体の高さの長さは-1.07374e+08です

てんC「→ビルド実行はできるものの

コンストラクタが

全く設定されていないため

オブジェクトcube1のコンストラクタが実行されることもありません

ですので

オブジェクトcube[0]のメンバ変数

cube[0].no

cube[0].tate

cube[0].yoko

cube[0].takasa

オブジェクトcube[1]のメンバ変数

cube[1].no

cube[1].tate

cube[1].yoko

cube[1].takasa

オブジェクトcube[2]のメンバ変数

cube[2].no

cube[2].tate

cube[2].yoko

cube[2].takasa

は初期化されないので

オブジェクトcube[0]のメンバ変数

cube[0].no

cube[0].tate

cube[0].yoko

cube[0].takasa

オブジェクトcube[1]のメンバ変数

cube[1].no

cube[1].tate

cube[1].yoko

cube[1].takasa

オブジェクトcube[2]のメンバ変数

cube[2].no

cube[2].tate

cube[2].yoko

cube[2].takasa

が

初期化されないときに

元から格納されている数値データが

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

cout << "立方体の縦の長さは" << cube[0].tate << "です" << "\n";

cout << "立方体の横の長さは" << cube[0].yoko << "です" << "\n";

cout << "立方体の高さの長さは" << cube[0].takasa << "です" << "\n";

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

cout << "立方体の縦の長さは" << cube[1].tate << "です" << "\n";

cout << "立方体の横の長さは" << cube[1].yoko << "です" << "\n";

cout << "立方体の高さの長さは" << cube[1].takasa << "です" << "\n";

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

cout << "立方体の縦の長さは" << cube[2].tate << "です" << "\n";

cout << "立方体の横の長さは" << cube[2].yoko << "です" << "\n";

cout << "立方体の高さの長さは" << cube[2].takasa << "です" << "\n";

によって

コマンドプロンプト画面に表示されることになります」

マックス「なるほどぉ

コンストラクタが初期化にもちいられていないので

このようなビルド実行結果になったわけだ」

ソーラー「つまるところ

　　　　　💖クラス型の配列宣言を行う場合💖

引数を持たないコンストラクタを設定しないで

　引数を持つコンストラクタだけを設定してはいけないってことなんだね

では

クラスCube型の配列宣言

Cube cube[3];

が実行された場合に

　　　　　　　🍓　引数を持つコンストラクタ　🍓

Cube::Cube(int a, float b, float c, float d) {

no = a;

tate = b;

yoko = c;

takasa = d;

cout << "生成されたオブジェクトのメンバ変数を初期化しました" << "\n";

}

の

no

tate

yoko

takasa

に

オブジェクトcube[0]のメンバ変数

cube[0].no

cube[0].tate

cube[0].yoko

cube[0].takasa

が代入された

cube[0].no=a;

cube[0].tate=b;

cube[0].yoko=c;

cube[0].takasa=d;

が実行され

no

tate

yoko

takasa

に

オブジェクトcube[1]のメンバ変数

cube[1].no

cube[1].tate

cube[1].yoko

cube[1].takasa

が代入された

cube[1].no=a;

cube[1].tate=b;

cube[1].yoko=c;

cube[1].takasa=d;

が実行され

no

tate

yoko

takasa

に

オブジェクトcube[2]のメンバ変数

cube[2].no

cube[2].tate

cube[2].yoko

cube[2].takasa

が代入された

cube[2].no=a;

cube[2].tate=b;

cube[2].yoko=c;

cube[2].takasa=d;

が実行されるようにするにはどうしたらいいのかな？

オブジェクトcube[0]

オブジェクトcube[1]

オブジェクトcube[2]

の引数を持つコンストラクタ

が実行されるようにしたい場合はど～したらいいのかな？」

マックス「ええ？それはちょっち？？？？？？

Cube cube[3];

が実行されただけで

cube[0].no=a;

cube[0].tate=b;

cube[0].yoko=c;

cube[0].takasa=d;

cube[1].no=a;

cube[1].tate=b;

cube[1].yoko=c;

cube[1].takasa=d;

cube[2].no=a;

cube[2].tate=b;

cube[2].yoko=c;

cube[2].takasa=d;

の

a

b

c

d

に

数値データを代入する方法は・・・

さすがにないんじゃないか？」