【C#】C#とC++ その2 型の扱い

##概要
最近またプログラミングをする機会が増えたのでお勉強したことを記しておきます。
C++からC#に浮気しました。
今回はC#とC++の型の扱いの違いについて記していこうと思います。

##値型・参照型
C#では型の種類を大きく２つに分けると、**値型**か**参照型**となります。

***値型***はローカル宣言した時に***値(中身)を直接スタック上に置く***型です。
***参照型***は中身を直接持たず、値(中身)がある場所、つまり***参照情報(アドレス)をスタック上に置く***型です。

###C#の値の値型/参照型
####値型
struct、int、float、double、charなど

####参照型
class、string、delegateなど

C++から移行する方はstructが値型でclassが参照型になっていることに留意するとあとあと面倒にならなくて済むかもしれません。



###C++の値型/参照型
####値型
struct、class、int、float、double...全部？

####参照型(ポインタ型も含む)
型名に「&」や「＊」がついてるやつ

C＃の概念ならC++の***プリミティブ型***も***複合型***(class/struct)もローカル宣言するとスタック上に値（中身）が置かれるので***値型***といえるでしょう。（ただし抽象クラスはローカル宣言できませんが・・・）
C++の参照型は型名に「&」や「＊」を修飾することで***参照型***となります。
C#の「ref」「out」「in」キーワードと用途は似ていますが、ここでいう参照型・値型とちょっと違う概念です。


###C++ to C＃
class A{
public:
    int content=1;
}
があるとします。

C++のクラスは値型なのでnewなどせずに直接スタックに中身を置けます。
C++では以下のように使えます。

``` Example.cpp
A a;           // 値型 中身1そのもの
A a2;          // 値型 中身1そのもの

a2.content=2;  // a2の中身を2にする
a = a2;        // aにa2の中身をコピーする
a.content=3;   // aの中身を3にする

// この段階で 
// a.content==3 
// a2.content==2 

```

Aはスタックに置かれるので高速です。

しかしC#のクラスは参照型なので中身をスタック上に置くことはできません。
必ずnewをしてヒープ上に値(中身)を置いて、その場所のアドレス(参照)を保持する形になります。
C++で実現できるC#に近い感じのコードは以下のようになります。


``` Example.cpp
A* a = new A();  // 参照型 どっかに中身1をつくってその参照(アドレス)をaに格納
A* a2 = new A(); // 参照型 どっかに中身1をつくってその参照(アドレス)をa2に格納

a2->content=2;   // a2の中身を2にする
a = a2;          // aにa2が格納している参照(アドレス)をコピーする ←ここがちがう！
a->content=3;    // aの中身を3にする

// この段階で 
// a->content==3 
// a2->content==3  ←aとa2は同じ参照先なので 同じ値になっちゃう

```
deleteしてないしスマートポインタすら使わないこんなアホなコード書くなとか突込まないでね。趣旨がずれちゃう・・・

C/C++のポインター(型名＊)がC#でいう参照型に近いです。
C++の参照型(型名&)はほかの言語では見ない特殊な感じがします。


上記のC++コードと近いC#コードは以下のようになります。

``` Example.cs
A a= new A();  // 参照型 どっかに中身1をつくってその参照(アドレス)をaに格納
A a2= new A(); // 参照型 どっかに中身1をつくってその参照(アドレス)をa2に格納

a2.content=2;  // a2の中身を2にする
a = a2;        // aにa2が格納している参照(アドレス)をコピーする
a.content=3;   // aの中身を3にする

// この段階で 
// a.content==3 
// a2.content==3

```


まーたdeleteも書かないで・・・
いえ、C#ではdeleteキーワードはありません。ガーベッジコレクションという仕組みが自動的にメモリーを開放してくれます。IDisposableが実装されていないならユーザーが明確に管理する必要はありません。というかできないのです。




##object型
C♯にはobject型というのがあります。ざっくりというならば、intとかstructとかclassとかいろんな型の参照を入れられる型です。Cの**voidポインタ**、C++の**std::any**のようなものが言語仕様で備わっています。

**voidポインター**と異なるところは、型情報を持っているので間違った型にキャストしようとすると例外なりnullを返すなりして危険なアクセスが起こらない仕組みになっているところです。

**std::any**と異なるところは、std::anyは**ラッパー**のようなもので、対象の値や参照を包み込む形になっています。一方、C#のclassはすべて暗黙にobjectを継承しているのでobjectに**アップキャスト**される形になっています。え？じゃあintとかstructもobjectに入れられるけどintやstrcutはclassじゃないよね？？アップキャストできないよね？？？ってなりますよね、そこには**ボックス化(ボクシング)**という仕組みが働いています。(そのボックス化の仕組みはstd::anyの仕組みに近いかもしれません。)

###C流 なんでもこい型
``` Example.c
int a = 3;                     // ごく普通の整数型

void* b = &a;                  // なんでもこいなvoidポインタにaの参照をぶちこむ

int c = *(int*)b;              // voidポインタをintポインタにキャスト cには3が入る

b = "Hello";                    // 今度はvoidポインタに文字列(参照)をぶちこんでみる

const char* d = (const char* )b; // voidポインタを文字列(参照)にキャスト　dには"Hello"が入る

```


###C++流 なんでもこい型
``` Example.cpp
int a = 3;                     // ごく普通の整数型

any b = a;                     // なんでもこいなanyにaの値をぶちこむ

int c = any_cast<int>(b);      // anyをintにキャスト　cには3が入る

b = string("Hello");           // 今度はanyに文字列をぶちこんでみる

string d = any_cast<string>(b); // anyをstringにキャスト　dには"Hello"が入る

```

###C＃流 なんでもこい型
``` Example.cs
int a = 3;                     // ごく普通の整数型

object b = a;                  // なんでもこいなobjectにaの値をぶちこむ(ボックス化)

int c = (int)b;                // objectをintにキャスト　cには3が入る(ボックス解除)

b = "Hello";                   // 今度はobjectに文字列をぶちこんでみる(ボックス化？)

string d = (string)b;          // objectをstringにキャスト　dには"Hello"が入る(ボックス解除？)

```


###ボックス化
int型は値型でクラスのように型情報を持ちません。
C#は安全な型変換を保証するようになっています。
変換ができない場合は例外を投げるかnullを返すかのどちらかです。
(C/C++のように未定義動作ではない)
そこで型情報を持たせる必要がでてきます。


``` .cs
int a = 3;
object b = a; 
```
上記ようにintをobjectに変換しようとすると、以下のように内部でobejctを継承するintのラッパークラスでラップしてしまいます。（イメージ）


``` .cs
class IntWrapper : object{
    public int Value;
    public IntWrapper(int val){
        this.Value = val;
    }
}
object b = new IntWrapper(a);
```

おそらく上記のようなコードに変換されるでしょう(イメージ)。IntWrapperというのは勝手につけた名前ですが、int型の値をラップするクラスだと思ってください。このようにラッパーが生成されラップされてしまうことを**ボックス化・ボクシング**と言います。



``` .cs
int c = (int)b;
```


上記のように逆にobjectからintに変換するときは、以下のようにIntWrapperにキャストして値を取り出す形になるでしょう。



``` .cs
int c = ((IntWrapper)b).Value;
```
このようにラッパーから値を取り出すことを**ボックス解除・アンボクッス**といいます。


その処理を内部でやってくれるのでコーディング上はとっても汎用的でシームレスでキモチイイ～ので多用してしまいそうですね。
しかし、ボクシングは**ラッパークラスの生成**が起こるわけですから、値型をobjectにつっこむのは、派生クラス参照型をobjectに突っ込むのより**処理コストがかかります**。


・・・ところでstringは参照型だけどボックス化は起こるのかなぁ？調査不足...


###キャストのコスト
派生クラスからobjectのアップキャストは参照情報(アドレス)のコピーぐらいで大したことはありません。ダウンキャストはそれなりにありますが、C++のdynamic_castよりかはるかに速いです。とにかく遅いdynamic_cast... C++コンパイラの実装は多数あるので、もしかしたら早い実装もあるかもしれませんが、大体の場合、型チェックの機構を自分で実装しないと多用が難しいレベルで遅いです。どうやら内部では継承するクラスを線形で、しかもなが～い文字列を一個一個比較していってるようです。それとくらべるとC#のダウンキャストは劇的に速いです。型による分岐処理にswitch・case文も使えます。すごいぞC#