• T* の形で宣言された項目は、Tへのネイティブ・ポインタを表し、lvalue を指し示す。
• T* の形で宣言された項目にあてがわれた前置演算子*はT*の参照を外し、lvalueを与える。
• T& の形で宣言された項目は、Tへのネイティブ参照を表し、lvalue自身である。
• &lvalue 表現は T* を与える
• %lvalue 表現は T^ を与える

• "T 型のcv-qualified lvalue" から "T 型のcv-qualified gc-lvalue" への標準的な型変換が存在する。そして、"T 型の cv-qualified gc-lvalue"から"T 型の cv-qualified rvalue"への標準的な型変換も存在する。
• T^ の形で宣言された項目は、T のハンドルであり、gc-lvalue を指し示す。
• T^ の型で宣言された項目に与えられた前置演算子 * は、T^ の参照を外し、gc-lvalueを与える。
• T% の型で宣言された項目は、T の追跡参照であり、gc-lvalue そのものである。
• &gc-lvalue 表現は interior_ptr を与える（下記参照）。
• %gc-lvalue 表現は T^ を与える。

8.3 パラメータ

void F(... array<int>^ args) {
    Console::WriteLine("引数の # : {0}", args->Length);
    for ( int i=0; i<args->Length; i++ )
        Console::WriteLine("\targs[{0}] = {1}", i, args[i]);
}

int main() {
    F();
    F(1);
    F(1, 2);
    F(1, 2, 3);
    F( gcnew array<int> { 1, 2, 3, 4 } );
}

 引数の # : 0
 引数の # : 1
     args[0] = 1
 引数の # : 2
     args[0] = 1
     args[1] = 2
 引数の # : 3
     args[0] = 1
     args[1] = 2
     args[2] = 3
 引数の # : 4
     args[0] = 1
     args[1] = 2
     args[2] = 3
     args[3] = 4

void G(... array<Object^>^args) { ... }
G(10, "Hello", 1.23, 'X');      // 引数 1, 3, 4 はボックス化される

int a = 1, b = 2;
Console::WriteLine("a = {0}, b = {1}", a, b);

namespace System {
    public ref class Object {...};
    public ref class String {...};
    public ref class Console {
    public:
        static void WriteLine(String^ s) {...}
        static void WriteLine(String^ s, Object^ a) {...}
        static void WriteLine(String^ s, Object^ a, Object^ b) {...}
        static void WriteLine(String^ s, Object^ a, Object^ b, Object^ c) {...}
        ...
        static void WriteLine(String^ s, ... array<Object^>^ args) {...}
    };
}

public static void WriteLine(string s, params object[] args)

8.4 自動メモリ管理

public ref class Stack {
public:
    Stack() {
        first = nullptr;
    }

    property bool Empty {
        bool get() {
            return ( first == nullptr );
        }
    }

    Object^ Pop() {
        if ( first == nullptr )
            throw gcnew Exception("空のスタックからは Pop できません。");
        else {
            Object^ temp = first->Value;
            first = first->Next;
            return temp;
        }
    }

    void Push(Object^ o) {
        first = gcnew Node(o, first);
    }

    ref struct Node {
        Node^ Next;
        Object^ Value;
        Node(Object^ value) : Node(value, nullptr) {}
        Node(Object^ value, Node^ next) {
            Next = next;
            Value = value;
        }
    };

private:
    Node^ first;
};

int main() {
    Stack^ s = gcnew Stack();
    for ( int i = 0; i <10; i++ )
        s->Push(i);
    s = nullptr;
}

void f(int *p) { *p = 100; }

int main() {
    array<int>^ arr = gcnew array<int>(100);
    pin_ptr<int> pinp = &arr[0];    // arr の場所を pin する。
    f(pinp);                        // arr[0] の値を変更
}

8.5 演算

1. デリゲートの追加は delegate によってカプセル化された関数呼び出しに関数呼び出し演算子の利用を要請しています。
2. typeid の新しい使い方が追加されています。例えば、Int32::typeid は CLI 型 Int32 を示す System::Type 型の CLI オブジェクトへのハンドルを結果とします。
3. ハンドル型に対応してキャスト演算子が拡張されました。
4. safe_cast 演算子が追加されました。
5. 新しい演算子 gcnew が追加されました。これは CLI ヒープからメモリを領域確保します。
6. 二項演算子 + と - は delegate への追加と削除に期待通りに動作するよう拡張されました。
7. 単純代入が左項としてイベントやプロパティへの代入に対応するよう拡張されました。
8. 複合代入演算子は対応する二項演算子から合成されます。（§19.7.4 ）

8.6 命令文

void display(array<int> ^args) {
    for each ( int i in args )
        Console::WriteLine(i);
}

8.7 デリゲート

 delegate void MyFunction(int value);    // デリゲート型の定義
 public ref struct A {
     static void F(int i) ( Console::WriteLine("F:{0}", i); }
 };
 public ref struct B {
     void G(int i) { Console::WriteLine("G:{0}", i); }
 };

 int main() {
     MyFunction^ d;                    // デリゲート型の参照を作成
     d = gcnew MyFunction(&A::F);      // 呼び出しリストは A::F
     d(10);
 
     B^ b = gcnew B;
     d += gcnew MyFunction(b, &B::G);  // 呼び出しリストは A::F, B::G
     d(20);
 
     d += gcnew MyFunction(&A::F);     // 呼び出しリストは A::F, B::G, A::F
     d(30);
 
     d -= gcnew MyFunction(b, &B::G);  // 呼び出しリストは A::F, A::F
     d(40);
 }

 F:10
 F:20
 G:20
 F:30
 G:30
 F:30
 F:40
 F:40

8.8 ネイティブ・クラスとrefクラス

8.8.1 リテラル・フィールド

ref class X {
    literal int A = 1;
public:
    literan int B = A + 1;
};

ref class Y {
public:
    literal double C = X::B * 5.6;
};

int main() {
    cout << "B = " << X::B << "\n";
    cout << "C = " << Y::C << "\n";
}

 B = 2
 C = 11.2

8.8.2 initonly フィールド

public ref class Data {
    initonly static double coefficient1;
    initonly static double coefficient2;

    static Data() {
        // いくつかのソースから coefficient の値を読み込む
        coefficient1 = ...;    // ok
        coefficient2 = ...;    // ok
    }

public:
    static void F() {
        coefficient1 = ...;    // error
        coefficient2 = ...;    // error
    }
};

8.8.3 関数

• const と volatile 修飾子はインスタンス・メンバ関数には許されません。
• 関数修飾子 override とオーバーライド（上書き）指定子はオーバーライド（上書き）を明示的に指示し、名前付けオーバーライド（上書き）(§8.8.10.1 ) の能力を提供します。
• 仮想メンバ関数にsealedと印を付けることで、派生クラスにその関数をオーバーライド（上書き）することを禁止します。
• 関数修飾子 new は同名で、同じパラメータリストを持ち、同じ識別子を持つ基底クラスの関数を隠して、その関数を許します。そのような隠された関数はどんな基底クラスの関数も、virtual宣言された関数ですらも、オーバーライド（上書き）されません。
• 型安全な可変長引数リストがパラメータ配列を通してサポートされています。

8.8.4 プロパティ

public value class point {
    int Xor;
    int Yor;

public:
    property int X {
        int get()            { return Xor; }
        void set(int value)  { Xor = value; }
    }

    property int Y {
        int get()            { return Yor; }
        void set(int value)  { Yor = value; }
    }

    point(int x, int y) {
        move(x, y);
    }

    void move(int x, int y) {       // 絶対移動
        X = x;
        Y = y;
    }

    void Translate(int x, int y) {       // 相対移動
        X += x;
        Y += y;
    }
    ...
};

point p1;                // (0, 0) に設定
p1.X = 10;               // (10, 0) に設定
p1.Y = 5;                // (10, 5) に設定
p1.move(5, 7);           // (5, 7) に設定
point p2(9, 1);          // (9, 1) に設定
p2.translate(-4, 12);    // 左に 4、上に 12 移動して(5,13)

property String^ Name;

 public ref class Stack {
 public:
     ref struct Node {
         Node^ Next;
         Object^ Value;
         Node(Object^ value) : Next(nullptr), Value(value) {}
         Node(Object^ value, Node^ next) {
             Next = next;
             Value = value;
         }
     };
 
 private:
     Node^ first;
     Node^ GetNode(int index) {
         node^ temp = first;
         while (index > 0) {
             temp = temp->Next;
             index--;
         }
         return temp;
     }
     bool ValidIndex(int index) { ... }
 
 public:
     property Object^ default[int] {     // デフォルト・インデックス・プロパティ
         Object^ get(int index) {
             if ( !ValidIndex(index) )
                 throw gcnew Exception("インデックスが配列の範囲外です。");
             else
                 return GetNode(index)->Value;
         }
         void set(int index, Object^ value) {
             if ( !ValidIndex(index) )
                 throw gcnew Exception("インデックスが配列の範囲外です。");
             else
                 GetNode(index)->Value = value;
         }
     }
     Object^ Pop() { ... }
     void Push(Object^ o) { ... }
     ...
 };
 int main() {
     Stack^ s = gcnew Stack;
 
     s->Push(1);
     s->Push(2);
     s->Push(3);
 
     s[0] = 33;         // 先頭アイテムに 3 に変わって 33 が参照される。
     s[1] = 22;         // 真ん中のアイテムが 2 に変わって 22 が参照される。
     s[2] = 11;         // 最後のアイテムが 1 に変わって 11 が参照される。
 }

8.8.5 イベント

public delegate void EventHandler(Object^ sender, EventArgs^ e);

public ref class Button {
public:
    event EventHandler^ Click;
    void Reset() {
        Click = nullptr;
    }
};

public ref class Form1 {
    Button^ Button1;
    void Button1_Click(Object^ sender, EventArgs^ e) {
        Console::WriteLine("Button1 がクリックされました！");
    }
public:
    Form1() {
        Button1 = gcnew Button;
        // Button1_Click を Button1 のクリック・イベント用にイベント・ハンドラとして追加する。
        Button1->Click += gcnew EventHandler(this, &Button1_Click);
    }
    void Disconnect() {
        Button1->Click = gcnew EventHandler(this, &Button1_Click);
    }
};

public ref class Button {
    EventHandler^ handler;
public:
    event EventHandler^ Click {
        void add( EventHandler^ e )    {  handler += e;  }
        void remove( EventHandler^ e ) {  handler -= e;  }
    }
    ...
};

event Eventhandler^ Click;

8.8.6 静的演算子

public ref class IntVector {
    int array<int>^ values;

public:
    property int Length {    // プロパティ
        int get() {  return values->Length;  }
    }

    property int default[int] {    // デフォルト・インデックス・プロパティ
        int get(int index) {  return values[index];  }
        void set(int index, int value) {  values[index] = value;  }
    }

    IntVector(int length);
    IntVector(int length, int value);

    // 単項演算子（負数）
    static IntVector^ operator-(IntVector^ iv) {
        IntVector^ temp = gcnew IntVector(iv->Length);
        for( int i=0; i < iv->Length; ++i ) {
            temp[i] = -iv[i];
        }
        return temp;
    }

    static IntVector^ operator+(IntVector^ iv, int val) {
        IntVector^ temp = gcnew IntVector(iv->Length);
        for( int i=0; i < iv->Length; ++i ) {
            temp[i] = iv[i] + val;
        }
        return temp;
    }

    static IntVector^ operator+(int val, IntVector^ iv) {
        return iv + val;
    }
    ...
};

int main() {
    IntVector^ iv1 = gcnew IntVector(4);      // 4要素で値は0
    IntVector^ iv2 = gcnew IntVector(7, 2);   // 7要素で値は2
    iv1 = -2 + iv2 + 5;
    in2 = -iv1;
}

8.8.7 インスタンス・コンストラクタ

8.8.8 デストラクタとファイナライザ

• デストラクタ : デストラクタは決定的クリーンアップとオブジェクトの生存期間の終了を提供します。標準 C++ にあるように、デストラクタはオブジェクトの基底クラスとメンバのクリーンアップを、そのコンストラクタの過程とは逆順に行います。おのおのの ref クラス毎に、順番に、デストラクタはユーザーが記述したコードを実行し、クラスに付加されているメンバおのおののデストラクタを呼び出し、基底クラス毎のデストラクタを呼び出します。デストラクタの主たる優位性は、プログラムの決定的な場所において呼び出され、ガベージ・コレクションを待っているよりも早く、リソース解放を行うという優位性を持っている点です。
• ファイナライザ : ファイナライザは非決定的クリーンアップを提供します。ファイナライザはガベージ・コレクションの間に実行される"最後のチャンス"関数で、主にデストラクタが実行されていないガベージ・コレクション上のオブジェクトに対して実行されます。ファイナライザは値型（ネイティブ・ヒープから領域確保したネイティブ・ポインタ参照などの）を持つデータ・メンバによって表現されるリソースをデストラクタが実行されていない場合に確実に掃除するので特に便利です。ファイナライザは時々、オブジェクトにアクティブな参照がもうないと決定されたガベージ・コレクトの後に実行されます。（ファイナライザを持つことによるパフォーマンスのペナルティがあります。）

ref struct R {
    ~R() { ... }    // デストラクタ、ファイナライザなし
};

 ref struct R {
     ~R() { ... }    // デストラクタ
     !R() { ... }    // ファイナライザ
 };

• ファイナライザは値型で表現される任意のリソースを掃除するべきです。
• デストラクタは可能な限り最大の掃除を行うべきです。これを促すために、プログラマはデストラクタからファイナライザを呼び、デストラクタにそれ以外のクリーンアップ・コードを書くべきでしょう。デストラクタはオブジェクトから参照によって ref クラスの状態に安全にアクセスすることができますが、ファイナライザはできません。

8.8.9 静的コンストラクタ

public ref class data {
private:
    initonly static double coefficient1;
    initonly static double coefficient2;

    static Data() {
        // coefficient値をいくつかのソースから取得する
        coefficient1 = ...;
        coefficient1 = ...;
    }

public:
...
};

8.8.10 継承

8.8.10.1 関数オーバーライド（上書き）

 struct B {
     virtual void f();
     virtual void g();
 };
 struct D {
     virtual void f();    // D::f は B::f を上書きする。
     void g();            // D::g は B::g を上書きする。
 };

1. 派生クラスの関数は override 関数修飾子を使うことで、基底クラスの同じ名前、パラメータ型リスト、cv-修飾を持つ仮想関数を、例え、その様な関数が基底クラスに存在しないようなプログラム的に不正な状態であっても、明示的に上書きします。
2. 派生クラスの関数は new 関数修飾子を使うことによって、基底クラスが同じ名前、パラメータ型リスト、cv-修飾を持っている仮想関数を明示的に上書きしません。
   

   struct B {
       virtual void F();
       virtual void G();
   };
   
   struct D : B {
       virtual void F() override;  // D::F は B::F を上書きする。
       virtual void G() new;       // D::G は B::G を上書きしない。D::G は B::G を隠す。
   };
   

struct B {
    virtual void F();
};

interface struct I : {
    virtual void G();
};

ref struct D : B, I {
    virtual void X() = B::F, I::G {}  // D::X は B::F と I::G を上書きする
};

struct B {
    virtual void F();
    virtual void G();
};
struct D : B {
    virtual void F() override = B::G {}
};

struct B {
    virtual void F();
    virtual void G();
};
struct D : B {
    virtual void F() override = B::F;  // error : B::F は二度上書きされるため
    virtual void G() override;         // B::G は上書きされる
    virtual void H() = B::G {}         // エラー：B::G は二度上書きされるため
};

template<typename T>
ref class R : T {
public:
    virtual void f()  = T::G { ... }
};

8.9 値クラス

value struct Point {
    int x, y;
    Point(int x, int y) {
        this->x = x;
        this->y = y;
    }
};

8.10 インターフェイス

delegate void Eventhandler(Objcet^ sender, EventArgs^ e);

interface class IExample {
    void F(int value);
    property bool P { bool get(); }
    property double default[int] {
        double get(int);
        void set(int, double);
    }
    event EventHandler^ E;
};

interface class I1 { void F(); };  // F は暗黙のうちに virtual abstract である。
ref class R1 : I1 { virtual void F() { /* I1::F を実装 */ }

interface class IControl {
    void Paint();
};
interface class ITextBox : IControl {
    void SetText(String^ text);
};
interface class IListBox : IControl {
    void SetItems(array<String^>^ items);
};
interface class IComboBox : ITextBox, IListBox {};

interface class IDataBound {
    void Bind(Binder^ b);
};
public ref class EditBox : Control, IControl, IDataBound {
public:
    void Paint() {...}
    void Bind(Binder^ b) {...}
};

public ref class EditBox : IControl, IDataBound {
private:
    virtual void Paint() = IControl::Paint {...}
    virtual void Bind(Binder^ b) = IDataBound::Bind {...}
};

int main() {
    EditBox^ editbox = gcnew EditBox;
    editbox->Paint();                  // error : Paint は private です。
    IControl^ control = editbox;
    control->Paint();                  // EditBox の Paint 実装を呼び出す。
}

8.11 列挙型

• enum はその親のアセンプリの外側に対する認識性を制御できるようにするために、 public もしくは、private に宣言することができます。
• enum の背景となる型を指定することができます。
• enum 型と／もしくは、その列挙子は属性を持つことができます。
• enum 型を強く型付けして、そのため、整数推進を持たないようにしたりするような定義をする新しい構文があります。

8.12 名前空間とアセンブリ

// DisplayHelloLibrary.cpp
namespace MyLibrary {
    public ref struct DisplayMessage {
        static void Display() {
            Console::WriteLine("hello, world");
        }
    };
}

// HelloApp.cpp
#using <DisplayHelloLibrary.dll>
int main() {
    MyLibrary::DisplayMessage::Display();
}

cl /LD DisplayHelloLibrary.cpp
cl HelloApp.cpp

8.13 バージョン化

public ref struct Base {        // version 1
    ...
};
public ref struct Derived : Base {
    virtual void F() {
        Console::WriteLine("Derived::F");
    }
};

 public ref struct Base {        // version 2
     virtual void F() {          // version 2 で追加
         Console::WriteLine("Base::F");
     }
 };

public ref struct Base {             // version 2
    virtual void F() {               // version 2 で追加
        Console::WriteLine("Base::F");
    }
};
public ref struct Derived : Base {   // version 2a: new
    virtual void F() new {
        Console::WriteLine("Derived::F");
    }
};

public ref struct Base {             // version 2
    virtual void F() {               // version2 で追加
        Console::WriteLine("Base::F");
    }
};
public ref struct Derived : Base {   // version 2b: override
    virtual void F() override {
        Base::F();
        Console::WriteLine("Derived::F");
    }
};

8.14 属性

[AttributeUsage(AttributeTargets::All)]
public ref class HelpAttribute : Attribute {
    String^ url;
public:
    HelpAttribute(String^ url) {
        this->url = url;
    }
    String^ Topic;
    property String^ Url {
        String^ get() { return url; }
    }
};

[Help("http://www.mycompany.com/.../Class1.htm")]
public ref class Class1 {
public:
    [Help("http://www.mycompany.com/.../Class1.htm", Topic = "F")]
    void F() {}
};

int main() {
    Type^ type = Class1::typeid;
    array<Object^>^ arr = type->GetCustomAttribute(HelpAttribute::typeid, true);
    if ( arr->Length == 0 )
        Console::WriteLine("Class1 は Help 属性を保持していません。");
    else {
        HelpAttribute^ ha = (HelpAttribute^) arr[0];
        Console::WriteLine("Url = {0}, Topic = {1}", ha->Url, ha->Topic);
    }
}

8.15 ジェネリクス

8.15.1　ジェネリクスの作成と消費

generic<typename ItemType>
public ref class Stack {
    array<ItemType>^ items;
public:
    Stack(int size) {
        items = gcnew array<ItemType>(size);
    }

    void Push(Itemtype data) {...}
    ItemType Pop() {...}
};

Stack<int>^ s = gcnew Stack<int>(5);

Stack<Customer^>^ s = gcnew Stack<Customer^> (10);
s->Push(gcnew Customer);
Customer^ c = s->Pop();

generic<typename KeyType, typename ElementType>
public ref class Dictionary {
public:
    void Add(KeyType key, ElementType val) {...}
    property ElementType default[KeyType] {      // インデックス・プロパティ
        ElementType get(KeyType key) {...}
        void set(KeyType value, ElementType key) {...}
    }
};

 Dictionary<String^, Customer^>^ dict = gcnew Dictionary<String^, Customer^>;
 dict->Add("Peter", gcnew Customer);
 Customer^ c = dict["Peter"];

8.15.2 拘束

generic<typename KeyType, typename ElementType>
public ref class Dictionary {
public:
    void Add(KeyType key, ElementType val) {
        ...
        if ( key->CompareTo(val) < 0 ) { ... }    // コンパイル時エラー
        ...
    }
};

generic<typename KeyType, typename ElementType>
public ref class Dictionary {
public:
    void Add(KeyType key, ElementType val) {
        ...
        if ( static_cast<IComparable^>(key)->CompareTo(val) < 0 ) { ... }
        ...
    }
};