==== コンストラクタ、デストラクタの呼ばれる順番 ====
=== classが単独（継承関係なし）の時 ===
<code cpp>
class A{
    A();
    ~A();
};
</code>

=== パターン１ ===
<code cpp>
int main(){
    A samp;
}
</code>
  - インスタンスが生成されるときコンストラクタA()が呼ばれる
  - インスタンスが消滅するときデストラクタが~A()呼ばれる。
<figure>
{{:game-engineer:classes:game-programing-1:second-term:02:condes1.png?400|}}
<caption>コンストラクタとデストラクタ</caption>
</figure>
=== パターン２ ===
<code cpp>
int main(){
    A* p =nullptr;
    p = new A;
    delete p;
}
</code>
  - インスタンスが生成されるとき(newをした時）コンストラクタA()が呼ばれる
  - インスタンスが消滅するとき(deleteした時）デストラクタが~A()呼ばれる。
<figure>
{{:game-engineer:classes:game-programing-1:second-term:02:dendes2.png?400|}}
<caption>オブジェクトの動的確保のとき </caption>
</figure>
逆に言うと、newしてメモリを確保すると、明示的にdeleteしなければデストラクタは呼ばれない\\
（そもそも確保したオブジェクトのメモリが消えてくれない）\\
<figure>
{{:game-engineer:classes:game-programing-1:second-term:02:condes3.png?400|}}
<caption>deleteを呼ばなかった時 </caption>
</figure>
=== classが継承関係を持っている時 ===
<code cpp>
class A{
    A();
    ~A();
    foo(){ cout<< "bar\n"; }
};

class B
    :public class A
{
    B();
    ~B();
}
    
</code>
継承関係のあるクラスでは、基本的に\\

  - 親クラスのコンストラクタ
  - 子クラスのコンストラクタ
  - 子クラスのデストラクタ
  - 親クラスのデストラクタ

の順に呼び出されます。\\
=== パターン１ ===
<figure>
{{:game-engineer:classes:game-programing-1:second-term:02:condes4.png?400|}}
<caption>コンストラクタ、デストラクタの順番 </caption>
</figure>　
=== パターン２ ===
動的にメモリを確保したときも同様です。\\
<figure>
{{:game-engineer:classes:game-programing-1:second-term:02:condes5.png?400|}}
<caption>オブジェクトを動的に取得したとき </caption>
</figure>
という事で、ちゃんとdeleteしなければデストラクタが呼ばれないのも一緒です。\\
<figure>
{{:game-engineer:classes:game-programing-1:second-term:02:condes6.png?400|}}
<caption>オブジェクトを動的して、delete忘れたとき </caption>
</figure>

=== 仮想関数を持ったclassを継承していて、ポインタ経由でアクセスするとき ===
派生クラスのインスタンスは、ベースクラスのポインタと関連付けて（ベースクラスのポインタに代入できる）利用することができる。\\
ただし、その時は派生クラス内のベースクラスのメンバにしかアクセスできない。\\

さらにその時に、派生クラスで、ベースクラスのメンバ関数をオーバーライドしていると、\\
__<color #ed1c24>（ベースクラスのポインタからアクセスしているにもかかわらず）</color>__派生クラスのメンバ関数が呼び出される（意味不明）。\\

さらに、さらにその時のコンストラクタとデストラクタの呼び出し順を確認してみる。\\
==== 仮想関数を使わずベースクラスのポインタ経由で派生クラスにアクセス ====
  * ベースクラスのポインタを用意して、そこに派生クラス内のベースクラスを関連付ける
  * ベースクラスと派生クラスに同名の関数があり、内容が異なっている。
  * 派生クラスは動的に生成され、処理の終わりにdeleteされる。
<code cpp>
class A
{
public:
	A(){cout << "const A" << "\n";}	
 	~A(){cout << "dest A" << "\n";}	
	void foo(){ cout<< "bar\n";}
};

class B
:public A
{
public:
	B(){cout << "const B" << "\n";}	
 　　　　~B(){cout << "dest B" << "\n";}	
	void foo() { cout<< "barbar\n";}
};

int main() {
	A* p1 = nullptr;
	p1 = new B;
	p1->foo();
	delete p1;
}
</code>

<figure>
{{:game-engineer:classes:game-programing-1:second-term:02:condes9.png?400|}}
<caption>ベースクラスのポインタから派生クラスにアクセス </caption>
</figure>
現在ベースクラスと派生クラスのfoo()関数は隠蔽関係にある。\\

**<color #22b14c>A::foo() は　B::foo() によって隠蔽されている。\\
（BのインスタンスからはAの同名関数は隠されていて見えない）\\
</color>**
<code cpp>
B samp;
samp.foo();
//barbar が表示される
</code>

しかし、以下のソースコードの様にベースのポインタ経由でアクセスすると。。。\\
<code cpp>
        A* p1 = nullptr;
	p1 = new B;
	p1->foo();
	delete p1;
</code>
イメージとしては下図のようになる。\\
<code>
A*　p = new B;
                        Bのインスタンス
A* p                   +--------------+
+-----------------+--> |0x1111        |
|                 |    +--------------+
|    &A ::A()<----|----|0x1112 A::A() |   
|    &  ::~A()<---|----|0x1113  ::~A()|
|    &  ::foo <---|----|0x1114  ::foo |   
+-----------------+    +--------------+  
                       |0x1115 B:: B()|   
                       |0x1116  ::~B()|
                       |0x1117  ::foo |  
                       +--------------+ 
</code>
図のような関係になるので、pからはベース側のfoo()にしかアクセスできない。\\
したがって、\\
<code cpp>
        A* p1 = nullptr;
	p1 = new B;
	p1->foo();
	delete p1;
</code>
の結果は、\\
（説明のための書き方なのでプログラムではこう書けないよ）\\

  - new Bによって、B内のAのコンストラクタが呼ばれる
  - new Bによって、B内のBのコンストラクタが呼ばれる
  - A* pにBのアドレスが代入される
  - p->(  A::foo() )が呼ばれる
  - delete pによって p->(  A::~A()  )　が呼ばれる

のようになる。\\

==== 仮想関数＋オーバーライドでベースクラスのポインタ経由で派生クラスにアクセス ====
先ほど隠蔽関係だった A::foo()　と　B::foo()　を今度は、AのfooをBのfooで上書きしB::fooの機能を実行するように書き換えてみます。\\
ベース側の関数を仮想関数宣言(virtual)して、派生側でオーバライドすればいいんだったね。(override)\\
<code cpp>
class A
{
public:
	A(){cout << "const A" << "\n";}	
 	~A(){cout << "dest A" << "\n";}	
	virtual void foo(){ cout<< "bar\n";}
};

class B
:public A
{
public:
	B(){cout << "const B" << "\n";}	
 ~B(){cout << "dest B" << "\n";}	
	void foo() override { cout<< "barbar\n";}
};

int main() {
		A* p1 = nullptr;
		p1 = new B;
		p1->foo();
		delete p1;
}
</code>
仮想関数とオーバーライドの効果により、ポインタのつながりの図がちょっと複雑になります。\\
しかしながら、A* pからは、ベースクラスであるAのメンバにしかアクセスできていないのは実は変わりません\\

<code>
A*　p = new B;
                        Bのインスタンス
A* p                   +---------------------+
+-----------------+--> |0x1111               |
|                 |    +---------------------+
|    &A ::A()<----|----|0x1112 A::A()        |       仮想関数テーブル
|    &  ::~A()<---|----|0x1113  ::~A()       |       +---+-------------------+--------+
|    &  ::foo <---|----|0x1114 virtual foo() +---+   | x | A::foo()          |0x2111  |
+-----------------+    +---------------------+   |   +---+-------------------+--------+
                       |0x1115 B:: B()       |   +---+ O | B::foo() override |0x21112 |
                       |0x1116  ::~B()       |       +---+-------------------+--------+
                       +---------------------+ 
</code>

今度は、B内のAにある仮想関数が、B::foo()のアドレスに接続されているのでA::foo()にアクセスすると\\
強制的に上書きされた方の関数（＝B::foo()）にアクセスするようになります。\\
したがって結果は "barbar"と表示されます。
<figure>
{{:game-engineer:classes:game-programing-1:second-term:02:condes7.png?400|}}
<caption>仮想関数とオーバーライド</caption>
</figure>

仮想関数の仕組み的には、仮想関数をオーバライドして関数がすげ変わったんでオッケー！と思ったかもしれないですが、よく見ると\\
Bのコンストラクタが呼ばれていません。。。そりゃそうですね、上のポインタのつながりの図を見ると、Aにしかつながってないもん。\\
という事で、Bのデストラクタ、Aのデストラクタの順に呼ばれるようにするにはどうしたらいいか考えます。\\
そうですね、Aのデストラクタを仮想関数にすればよいです。（デストラクタの名前違うからオーバライドではないんだよね）\\

<code cpp>
class A
{
public:
	A(){cout << "const A" << "\n";}	
 	virtual ~A(){cout << "dest A" << "\n";}	
	virtual void foo(){ cout<< "bar\n";}
};

class B
:public A
{
public:
	B(){cout << "const B" << "\n";}	
        ~B(){cout << "dest B" << "\n";}	
	void foo() override { cout<< "barbar\n";}
};

int main() {
		A* p1 = nullptr;
		p1 = new B;
		p1->foo();
		delete p1;
}
</code>


結果は以下のようになり、ちゃんと<color #22b14c>**Bのデストラクタ => Aのデストラクタ**</color>　の順に呼ばれるようになります。\\
<figure>
{{:game-engineer:classes:game-programing-1:second-term:02:condes10.png?400|}}
<caption>ベースクラスのポインタから派生クラスにアクセス完全版 </caption>
</figure>

===== ポインタとクラスのアクセスについて =====


==== 仮想関数を使わずベースクラスのポインタ経由で派生クラスにアクセス ====
ポインタはアドレスを入れるための、ハコです。\\
アドレスの値はシステムで固定の長さの整数ですが、ポインタには型があります。\\
ポインタの型はその先に何が格納されるかを書きます。\\
この辺は、むかーし昔にやったので、省きます。\\
さて、ポインタの先のメモリにクラスがあるとどうなるでしょうか？\\
クラスにはメンバ変数と、メンバ関数などのメンバがあるので、以下のような図で考えてみます。\\
== まず、ベースクラスのポインタ変数にベースクラスのインスタンスのアドレスを代入 ==

<code>
A* p = nullptr;
+-----------------+--> nullptr　←インスタンスの先頭アドレス用差込口
|                 |
|    &A ::A()<----| ←A()接続用差込口    
|    &  ::~A()<---| ←~A()接続用差込口
|    &  ::foo <---| ←foo()接続用差込口   
+-----------------+      
</code>
これにインスタンスを接続（メモリを確保して、アドレスを代入）してみます。\\
まずインスタンスを生成します。newにより実体が確保されその先頭アドレス（0x1111)が返されます。\\
<code>
A* p = nullptr;
p = new A;

    アドレス0x1111にAのインスタンスが生成される。
    +--------------+
    |0x1111        |
    +--------------+
    |0x1112 A::A() |   
    |0x1113  ::~A()|
    |0x1114  ::foo |   
    +--------------+   
</code>
図のように、インスタンスの先頭アドレスの他に、その中にパックされているメンバもそれぞれアドレスを持っています。\\
（アドレスの値などは説明のためのでたらめな値です）\\
次に p = new A; の文でA* 型のポインタ変数pに、newで取得したインスタンスのアドレス（＝0x1111）を代入します。\\
<code>
A* p                   +--------------+
+-----------------+--> |0x1111        |
|                 |    +--------------+
|    &A ::A()<----|----|0x1112 A::A() |   
|    &  ::~A()<---|----|0x1113  ::~A()|
|    &  ::foo <---|----|0x1114  ::foo |   
+-----------------+    +--------------+   
</code>
その結果、\\  
  * p        0x1111
  * p->A()   0x1112
  * p->~A()  0x1113
  * p->foo() 0x1114
のように、ポインタ変数pからインスタンスの各メンバにアクセスできるようになります。\\

== 次に、ベースクラスのポインタ変数に派生クラスのインスタンスのアドレスを代入 ==
C++では、派生クラスのインスタンスは必ず内部にベースクラスを含んでいます。\\
<figure>
{{:game-engineer:classes:game-programing-1:second-term:02:images.png?400|}}
<caption>クラスの派生</caption>
</figure>

このときに、先ほどと同じようにclass Bのインスタンスを動的に作った時を考えてみます。\\
class Bで追加されたメンバはコンストラクタとデストラクタのみなので、以下のようになります。\\
<code>
B* p = nullptr;
p = new B;

    アドレス0x1111にBのインスタンスが生成される。
    +--------------+
    |0x1111        |
    +--------------+
    |class A       |
    |0x1112 A:: A()|   
    |0x1113  ::~A()|
    |0x1114  ::foo |   
    +--------------+
    |0x1115 B:: B()|   
    |0x1116  ::~B()|
    +--------------+ 
</code>
このときに、生成されたclass Bのインスタンスは丸々class Aを含んでいます。\\
（逆に言うとB内には必ずAが存在する）\\
ので、class AのポインタにBのA部分を接続することができます。
<code>
A*　p = new B;

A* p                   +--------------+
+-----------------+--> |0x1111        |
|                 |    +--------------+
|    &A ::A()<----|----|0x1112 A::A() |   
|    &  ::~A()<---|----|0x1113  ::~A()|
|    &  ::foo <---|----|0x1114  ::foo |   
+-----------------+    +--------------+  
                       |0x1115 B:: B()|   
                       |0x1116  ::~B()|
                       +--------------+ 
</code>
これが、派生クラスにベースクラスのポインタからアクセスする仕組みです。\\
ただし、図を見ると当たり前そうですが、接続されているのはB内のAのメンバのみです。\\
なので、pからはBの持つAのメンバにしかアクセスできません。\\
  * p        0x1111
  * p->A()   0x1112
  * p->~A()  0x1113
  * p->foo() 0x1114
  * p->B()   アクセス不可
  * p->~B()  アクセス不可