class.dd

Ddoc

$(SPEC_S クラス,

        $(P D のオブジェクト指向的な機能は、
	全てクラスで実現されています。
	クラス階層のルートにはObjectクラスがあります。Objectは、
	それぞれの派生クラスが最低限持つ機能と、そのデフォルト実装を定義しています。
        )

        $(P クラスは、プログラマ定義の型です。
	クラスのサポートが、
	カプセル化、継承、多態など、D をオブジェクト指向言語たらしめています。
	D のクラスは、単一継承と、それに加えてインターフェイス継承が可能です。
	クラスオブジェクトは参照によってのみインスタンス化されます。
        )

        $(P クラスはexportできます。
	つまり、DLLやEXEから外部に、
	クラス名やその非privateメンバを公開することができます。
        )

        $(P クラス宣言の定義：
        )

$(GRAMMAR
$(GNAME ClassDeclaration):
    $(B class) $(I Identifier) $(GLINK BaseClassList)$(OPT) $(GLINK ClassBody)
    $(GLINK2 template, ClassTemplateDeclaration)

$(GNAME BaseClassList):
    $(B :) $(GLINK SuperClass)
    $(B :) $(GLINK SuperClass) $(B ,) $(GLINK Interfaces)
    $(B :) $(GLINK Interfaces)

$(GNAME SuperClass):
    $(I Identifier)

$(GNAME Interfaces):
    $(GLINK Interface)
    $(GLINK Interface) $(B ,) $(I Interfaces)

$(GNAME Interface):
    $(I Identifier)

$(GNAME ClassBody):
    $(B {) $(B })
    $(B {) $(GLINK ClassBodyDeclarations) $(B })

$(GNAME ClassBodyDeclarations):
    $(GLINK ClassBodyDeclaration)
    $(GLINK ClassBodyDeclaration) $(I ClassBodyDeclarations)

$(GNAME ClassBodyDeclaration):
    $(GLINK2 module, DeclDef)
    $(GLINK Invariant)
    $(GLINK ClassAllocator)
    $(GLINK ClassDeallocator)
)

クラスは、以下の構成要素からなります：

$(UL
        $(LI 基底クラス)
        $(LI インターフェイス)
        $(LI 動的フィールド)
        $(LI 静的フィールド)
        $(LI 型)
        $(LI $(LINK2 #member-functions, メンバ関数)
        $(UL
            $(LI static member functions)
            $(LI $(DDSUBLINK function, virtual-functions, 仮想関数))
            $(LI $(LINK2 #synchronized-functions, 同期関数))
            $(LI $(LINK2 #constructors, コンストラクタ))
            $(LI $(LINK2 #destructors, デストラクタ))
            $(LI $(LINK2 #StaticConstructor, 静的コンストラクタ))
            $(LI $(LINK2 #StaticDestructor, 静的デストラクタ))
            $(LI $(GLINK shared静的コンストラクタ))
            $(LI $(GLINK shared静的デストラクタ))
            $(LI $(LINK2 #invariants, 不変条件))
            $(LI $(DDSUBLINK unittest, unittest, 単体テスト))
            $(LI $(LINK2 #allocators, クラスアロケータ))
            $(LI $(LINK2 #deallocators, クラスデアロケータ))
$(V2
            $(LI $(LINK2 #AliasThis, alias this)))
        )
        )
)

クラスは次のように定義されます：

------
class Foo {
  ... メンバ ...
}
------

クラス定義の閉じ括弧 } の後ろに ; 
が無いことにご注意下さい。
また、変数を次のように宣言することもできません：

------
class Foo { } var;
------

代わりにこう書きます：

------
class Foo { }
Foo var;
------

<h3>アクセス制御</h3>

	$(P クラスメンバへのアクセスは $(GLINK2 attribute, ProtectionAttribute) によって制御します。
	デフォルトの保護属性は $(D public) です。
	アクセス制御は可視性には影響しません。
	) 

<h3>フィールド</h3>

        $(P クラスのメンバには常に . 演算子でアクセスします。
        )

	$(P 基底クラスのメンバは、
	メンバ名の前に基底クラス名とドットを書くと参照できます:)

---
class A { int a; }
class B : A { int a; }

void foo(B b) {
  b.a = 3;   // B.a にアクセス
  b.A.a = 4; // A.a にアクセス
---

        $(P D コンパイラは、
	クラスのフィールドの順序を自由に並び替えて、
	実装定義の方法で最適なメモリ配置とすることができます。
	フィールドは、
	関数におけるローカル変数のようなものと考えて下さい。
	ローカル変数は、
	最適なフレームレイアウトのために、
	コンパイラが自由に並び替えてスタックやレジスタを割り当てます。
	これによってコードの設計者は、
	マシンに最適な順に従うのではなく、
	読みやすさを重視してフィールドを並べることができます。
	明示的なメモリレイアウトの制御は、
	クラスではなく構造体/共用体で行います。
        )

<h3>フィールドのプロパティ</h3>

        $(P $(B .offsetof)プロパティは、フィールドの、
	クラスの実体の先頭から数えたバイト数を返します。
        $(B .offsetof)
	はフィールドそのものを表す式に対してのみ適用できます。
	クラスの型で修飾されたフィールドには使えません：
        )

------
class Foo {
  int x;
}
...
void test(Foo foo) {
  size_t o;

  o = Foo.x$(B .offsetof); // エラー。Foo.x には 'this' が必要
  o = foo.x$(B .offsetof); // ok
}
------

<h3>クラスのプロパティ</h3>

        $(P $(B .tupleof)
	プロパティは、
	隠しフィールドおよび基底クラスのフィールドを除く、
	全てのフィールドからなる $(I ExpressionTuple) を返します。
        )
---
class Foo { int x; long y; }
void test(Foo foo) {
  foo.tupleof[0] = 1; // foo.x を 1 に
  foo.tupleof[1] = 2; // foo.y を 1 に
  foreach (x; foo.tupleof)
    writef(x);        // 12 と表示
}
---

        $(P プロパティ $(B .__vptr) と $(B .__monitor) は、それぞれ、
	クラスオブジェクトの vtbl[] とモニタを指しています。
	ただし、これらはユーザーコードで使用すべきではありません。
        )

<h3>基底クラス</h3>

	全てのクラスは、１つの基底クラスを継承します。特に指定がなければ
	Object クラスからの継承になります。Object は、
	Dのクラス継承階層のルートです。

<h3>$(LNAME2 member-functions, メンバ関数)</h3>

        $(P staticでないメンバ関数は、
	隠し引数 $(I this) をもち、
	この引数を通して他のクラスメンバにアクセスできます。
        )

$(V2
	$(P staticでないメンバ関数には、通常の
	$(GLINK2 declaration, FunctionAttribute) に加えて、
	$(D const), $(D immutable), $(D shared), $(D inout) という属性を付与できます。
	これらは隠し引数 $(I this) に対して適用されます。
	)
---
class C {
  int a;
  const void foo() {
    a = 3; // エラー。 'this' は const
  }
  void foo() immutable {
    a = 3; // エラー。 'this' は immutable
  }
---
)

<h3>$(LNAME2 synchronized-functions, 同期関数)</h3>

        $(P 同期クラスメンバ関数は、記憶域クラス
        $(CODE synchronized) で宣言されます。
	静的メンバ関数の場合、そのクラスの $(I classinfo)
	オブジェクトによって同期が行われます。つまり、
	そのクラスの全ての静的メンバ関数はすべておなじ一つのモニタを使用します。
	非静的メンバ関数の場合、
	使用されるモニタはオブジェクトごとに用意されます。例えば:
        )

---
class Foo {
  synchronized void bar() { ...statements... }
}
---

        $(P は、（モニタに関しては）以下と同等です:
        )

---
class Foo {
  void bar() {
    synchronized (this) { ...statements... }
  }
}
---

        $(P 構造体には同期メンバ関数はありません。)

<h3>$(LNAME2 constructors, コンストラクタ)</h3>

$(GRAMMAR
$(GNAME Constructor):
        $(B this) $(GLINK2 declaration, Parameters) $(GLINK2 function, FunctionBody)
$(V2          $(GLINK2 template, TemplatedConstructor))
)

        $(P メンバは、
	常にその型の $(LNAME2 class-default-initializer, デフォルト初期化子)
	で初期化されます。
	整数型なら 0、浮動小数点数型なら NaN、
	といった具合です。
	これによって、
	あるコンストラクタでメンバの初期化を忘れたために
	隠れた問題が生じる、という事態を避けることができます。
	クラスの定義では、
	デフォルトを置き換える静的初期化子を指定できます：
        )
------
class Abc {
  int a;      // デフォルトの初期化子は 0
  long b = 7; // デフォルトの初期化子は 7
  float f;    // デフォルトの初期化子は NaN
}
------

	静的な初期化は、
	コンストラクタ呼び出しより前に実行されます。
        <p>

        コンストラクタは返値を持たない、$(B this)
        という名前の関数です：

------
class Foo {
  $(B this)(int x)  // Foo のコンストラクタを宣言
  {   ...
  }
  $(B this)()
  {   ...
  }
}
------

        基底クラスの構築は、基底のコンストラクタを 
        $(B super) という名前で呼び出して行います：

------
class A { this(int y) { } }

class B : A {
  int j;
  this() {
    ...
    $(B super)(3);  // 基底クラスのコンストラクタ A.this(3) を呼び出し
    ...
  }
}
------

        $(P コンストラクタは、同じクラスの他のコンストラクタを呼ぶことで
	初期化処理を共有できます。
        $(LNAME2 delegating-constructors, （移譲コンストラクタ (delegating constructor) と呼びます）):
        )

------
class C {
  int j;
  this() {
    ...
  }
  this(int i) {
    $(B this)();
    j = i;
  }
}
------

        もし $(B this) や $(B super)による他のコンストラクタの呼び出しが
	コンストラクタ中に存在せず、基底クラスがコンストラクタを持っていれば、
	コンストラクタの先頭に $(B super)() の呼び出しが自動で挿入されます。
        <p>

	クラスにコンストラクタが定義されていないが、基底クラスにはある、
	という場合は、次の形式のデフォルトコンストラクタ：

------
this() { }
------

        $(P が暗黙のうちに生成されます。)

        $(P クラスオブジェクトの構築は非常に柔軟性がありますが、
	いくつかの制限も加わります：)

        $(OL
        $(LI お互いを呼び出し合うコンストラクタは不正です。
	ただし、コンパイラがこれを検出することは要求されません。
	相互呼び出しは未定義動作となります。

------
this() { this(1); }
this(int i) { this(); } // 不正, コンストラクタの循環呼び出し
------
        )

        $(LI コンストラクタ内に別のコンストラクタ呼び出しがあるときは、
		どの実行パスを通ってもちょうど１つだけコンストラクタが呼ばれるように
		なっていなければなりません：

------
this()  { a || super(); }       // 不正

this() { (a) ? this(1) : super(); }     // ok

this() {
  for (...) {
    super();  // 不正, ループの内側
  }
}
------
        )

        $(LI コンストラクタ呼び出しより前に、暗黙にも明示的にも $(B this)
        を参照することはできません。)

        $(LI コンストラクタ呼び出しはラベルの後に置くことはできません。
		（gotoが存在するときに、上に書いた条件のチェックを簡単にするためです。）)

        )

        $(P クラスオブジェクトのインスタンスは、$(I NewExpression) で生成します。)

------
A a = new A(3);
------

        $(P 以下のステップが実行されます：)

$(OL
        $(LI オブジェクト用のメモリ領域を割り当てます。
		失敗すると、$(B null) を返すのではなく
        $(B OutOfMemoryError) 例外が投げられます。
		従って、面倒なnullチェックは不要です。
        )

        $(LI クラス定義で与えられた値で、
		データを静的に初期化します。
		ここでvtbl[]
		（仮想関数へのポインタのテーブル）へのポインタが設定されます。
		これによって、
		コンストラクタの時点で、
		完全に構築されて仮想関数も呼び出せるオブジェクトが渡されることを保証します。
		これは静的な初期オブジェクトを新しいメモリ領域へ
		memcpy する操作と同等ですので、
		高性能なコンパイラはそのような最適化を行うかもしれません。
        )

        $(LI  
		もしクラスにコンストラクタが定義されていれば、
		引数リストに合うコンストラクタが呼び出されます。
        )

        $(LI クラス不変条件チェックがONなら、
		コンストラクタの後に invariant() が呼び出されます。
        )
)

<h3>$(LNAME2 destructors, デストラクタ)</h3>

$(GRAMMAR
$(GNAME Destructor):
    $(B ~ this ( )) $(GLINK2 function, FunctionBody)
)

	オブジェクトが削除される際に、
	ガベージコレクタがデストラクタ関数を呼び出します。
	構文は：

------
class Foo {
  ~this() // Foo のデストラクタ
  {
  }
}
------

        $(P 一つのクラスにつき高々一つのデストラクタしか存在できません。
	デストラクタは引数を取らず、属性を何も持ちません。
	常に仮想関数です。
        )

        $(P デストラクタは、
	オブジェクトの保持するリソースを解放する役割を担います。
        )

        $(P プログラムは、オブジェクトがもはや参照されないことを（delete式によって）
	ガベージコレクタへ明示的に伝えることもできます。
	この場合はGCはすぐに
	デストラクタを呼び出し、オブジェクトのメモリを自由領域へ戻します。
	デストラクタが２回以上呼ばれないことは保証されています。
        )

        $(P デストラクタの終了後には、
	自動的に基底クラスのデストラクタが呼び出されます。
	基底クラスのデストラクタを明示的に呼ぶ方法は存在しません。
        )

        $(P GC
	が参照されなくなったオブジェクトを必ず解放するという保証はありません。
	さらに、
	GC がデストラクタを呼び出す順番も保証されません。
	これはつまり、
	GC管理下にあるオブジェクトへの参照をメンバとして持つオブジェクトのデストラクタを
	ガベージコレクタが呼び出すときには、それらの参照は既に無効となっている可能性があるということです。
	従って、
	デストラクタからはメンバオブジェクトを参照できません。
	この規則は、
	auto
	オブジェクトや $(I DeleteExpression) で削除されるオブジェクト
	(GCからのデストラクタ呼び出しではないので、参照は必ず有効)には当てはまりません。
        )

        $(P データセグメントから参照されているオブジェクトは、
	決してGCに回収されることはありません。
        )

<h3>静的コンストラクタ</h3>

$(GRAMMAR
$(GNAME StaticConstructor):
    $(B static this ( )) $(GLINK2 function, FunctionBody)
)

	$(P
        $(V1 静的コンストラクタは、
        $(D main()) に制御が移る前に初期化を実行する関数です。)

        $(V2 静的コンストラクタは、
        メインスレッドで $(D main()) 関数に制御が移る前と、各スレッドの起動時に、
		スレッドローカル記憶域の初期化作業を行うための関数です。)

静的コンストラクタは、
	クラスの静的メンバを、
	コンパイル時には計算できない値で初期化する際に使用します。
        )

        $(P 他の言語では、
	コンパイル時に計算できない値をメンバの初期化子として使うことで、
	暗黙の内に組み込まれます。この方法に関する問題は、
	いつコードが実行されるのか正確な制御ができないことです。
	例えば：
	)

------
class Foo {
  static int a = b + 1;
  static int b = a * 2;
}
------

	aとbは結局どの値になるのか？
	初期化が実行される順序は？
	初期化が始まる前のaとbの値は何なのか、
	これはコンパイルエラーになるのか、
	それとも
	実行時エラーになるのか？
	様々な混乱は、初期化子が静的なのか動的なのか明確でないことが原因となっています。
        <p>

        DD はこれを単純にします。
	全てのメンバ初期化は、
	コンパイラによってコンパイル時に決定されなくてはなりません。
	従って、
	メンバの初期化には評価順序の依存関係はなく、
	初期化されていない値を読みとることはできなくなっています。
	動的な初期化は、特別な構文 $(D static this()) で定義される
	静的コンストラクタによって行われます。

------
class Foo {
  static int a;         // デフォルトの 0 に初期化される
  static int b = 1;
  static int c = b + a; // エラー, 初期化子が定数でない

  $(B static this)()    // 静的コンストラクタ
  {
    a = b + 1;          // a を 2 に設定
    b = a * 2;          // b を 4 に設定
  }
}
------

	$(P
	$(V1
	 $(D main())
		が例外を投げず正常終了した場合、
        静的デストラクタが、
        プログラム終了時に実行される関数のリストに追加されます。
	)
	$(V2
	If $(D main())
		やスレッドが例外を投げず正常終了した場合、
        静的デストラクタが、
        スレッド終了時に実行される関数のリストに追加されます。
	)
	静的コンストラクタは空の引数リストを持ちます。
        )

	$(P
	同一モジュール内の複数の静的コンストラクタは、
	ソース中に登場する順に上から実行されます。
	他のモジュールからimportされているモジュールの静的コンストラクタは、
	全て、
	importする側の静的コンストラクタよりも前に実行されます。
        )

	$(P
        静的コンストラクタ宣言の $(B static) は、属性ではありません。
	必ず $(B this) の直前に書く必要があります：
	)

------
class Foo {
  static this() { ... } // 静的コンストラクタ
  static private this() { ... } // 静的コンストラクタではない
  static {
    this() { ... }      // 静的コンストラクタではない
  }
  static:
    this() { ... }      // 静的コンストラクタではない
}
------

<h3>静的デストラクタ</h3>

$(GRAMMAR
$(GNAME StaticDestructor):
    $(B static ~ this ( )) $(GLINK2 function, FunctionBody)
)

        静的デストラクタは、$(D static ~this())
		という構文で定義される特別な関数です。

------
class Foo {
  static ~this() // 静的デストラクタ
  {
  }
}
------

	$(P
        静的デストラクタは、
	対応する静的コンストラクタが正常に実行完了しているときのみ、
    $(V1 プログラム)$(V2 スレッド)の終了時に呼び出されます。
	静的デストラクタは空の引数リストを持ちます。
	静的デストラクタは、
	静的コンストラクタの呼び出しと逆順で実行されます。
        )

	$(P
        静的デストラクタの宣言の $(B static) は、属性ではありません。
	必ず $(B ~this) の直前に書く必要があります：
	)

------
class Foo {
  static ~this() { ... }  //  静的デストラクタ
  static private ~this() { ... } //  静的デストラクタではない
  static
  {
    ~this() { ... }  //  静的デストラクタではない
  }
  static:
    ~this() { ... }  //  静的デストラクタではない
}
------

$(V2
<h3>shared 静的コンストラクタ</h3>

$(GRAMMAR
$(GNAME SharedStaticConstructor):
    $(B shared static this ( )) $(GLINK2 function, FunctionBody)
)

        $(P shared 静的コンストラクタは、全ての $(GLINK StaticConstructor)
        の前に実行されます。sharedなグローバルデータの初期化のための使用が意図されています。
        )

<h3>shared 静的デストラクタ</h3>

$(GRAMMAR
$(GNAME SharedStaticDestructor):
    $(B shared static ~ this ( )) $(GLINK2 function, FunctionBody)
)

        $(P shared 静的デストラクタはプログラムの終了時に、
        $(GLINK SharedStaticConstructor)
		の逆の順番で実行されます。
        )
)

<h3>$(LNAME2 invariants, クラス不変条件)</h3>

$(GRAMMAR
$(GNAME Invariant):
    $(B invariant ( )) $(GLINK2 statement, BlockStatement)
)

クラス不変条件は、
（メンバ関数の実行途中以外は）常に真でなければならない
クラスの性質を記述するために使われます。例えば、
日時を表現するクラスは、"日"が1..31で"時"が0..23である、という不変条件を持ちます：

------
class Date {
  int day;
  int hour;

  $(B invariant()) {
    assert(1 <= day && day <= 31);
    assert(0 <= hour && hour < 24);
  }
}
------

        $(P クラス不変条件は、
assertがtrueでなければならない、という契約です。
不変条件は、コンストラクタ完了直後、
デストラクタ実行直前に実行されます。
そして、public/export メンバ関数の実行前後の順番は以下の通りです。
        )

	$(OL
	$(LI 事前条件)
	$(LI 不変条件)
	$(LI 本体)
	$(LI 不変条件)
	$(LI 事後条件)
	)

        $(P invariant内では、直接間接を問わず、
そのクラスのstaticでないpublicメンバを
呼び出すことができません。
そのような呼び出し方をすると
再帰的に invariant のチェックが入ってしまい、スタックオーバーフローが発生します。
        )

	$(V2 $(P invariant は暗黙に const 扱いになります。))

        $(P invariant は public や export メンバの開始時に呼び出されるため、
そのようなメンバ関数は
コンストラクタからは呼び出すべきではありません。
        )

------
class Foo {
  public void f() { }
  private void g() { }

  $(B invariant()) {
    f();  // エラー。invariantの中でpublicメンバ関数は呼べない
    g();  // OK。 g() はpublicではない。
  }
}
------

        $(D assert())
		式の引数にクラスオブジェクトを渡したときも、
		不変条件がチェックできます：

------
Date mydate;
...
assert(mydate);         // Dateクラスの不変条件が成立していることのチェック
------

        不変条件が破れていた場合、
        $(D AssertError) 例外が投げられます。
	不変条件は継承されます。
	つまり、全てのクラスの不変条件には、
	暗黙の内に基底クラスの不変条件が追加されます。
        <p>

        クラス１つにつき、$(I invariant) は最大一つしか定義できません。
        <p>

	リリース用にコンパイルする際には不変条件のコードは生成されず、
	プログラムは最高速で動作します。

<h3>$(LNAME2 allocators, クラス・アロケータ)</h3>
$(B 注): クラスアロケータは D2 では非推奨です。
$(GRAMMAR
$(GNAME ClassAllocator):
    $(B new) $(GLINK2 declaration, Parameters) $(GLINK2 function, FunctionBody)
)

        次の形をしたメンバ関数：

------
new(uint size) {
  ...
}
------

	は、クラス・アロケータと呼ばれます。
	クラスアロケータは、第一引数の型がuintでさえあれば、
	任意個数の引数を取ることができます。
	１つのクラスに幾つでも定義することができ、
	通常の関数オーバーロードの規則に従って正しいものが呼び出されます。
	new式：

------
new Foo;
------

	が実行されて、
	Fooがアロケータを持つクラスであれば、
	インスタンスがメモリ上で占めるサイズを第一引数として、
	アロケータが呼び出されます。
	アロケータはメモリを割り当て、
        $(D void*).
        で返さなくてはなりません。
	もしアロケータが失敗したら、 $(B null) を返すのではなく例外を投げるようします。
	アロケータが２個以上の引数を取るのであれば、
     $(I NewExpression) の
        $(B new) の後に、括弧で追加の引数を指定できます：

------
class Foo {
  this(char[] a) { ... }

  new(uint size, int x, int y) {
    ...
  }
}

...

new(1,2) Foo(a);        // new(Foo.sizeof,1,2)の呼び出し
------

        $(P 派生クラスは、
	特に指定が無ければ親クラスからアロケータを継承します。
        )

        $(P インスタンスがスタック上に割り当てられるときには、
	アロケータは呼ばれません。
        )

        $(P 参照:
        $(DPLLINK memory.html#newdelete, 明示的なクラスインスタンス割り当て)
        )

<h3>$(LNAME2 deallocators, クラス・デアロケータ)</h3>
$(B 注): クラス・デアロケータと delete 演算子はD2では非推奨です。
デストラクタを呼び出してオブジェクトを終了させるには $(B clear) 関数を使います。
そのオブジェクトのメモリはすぐには解放され$(B ません)。代わりに、GC
がその後の任意の時点でメモリを回収します:
    
------
class Foo { int x; this() { x = 1; } }
Foo foo = new Foo;
clear(foo);
assert(foo.x == int.init);  // まだアクセス可能
------
    
$(GRAMMAR
$(GNAME ClassDeallocator):
    $(B delete) $(GLINK2 declaration, Parameters) $(GLINK2 function, FunctionBody)
)

	次の形をしたメンバ関数：

------
delete(void *p) {
  ...
}
------

	は、クラス・デアロケータと呼ばれます。
	デアロケータは $(D void*) 型の引数を唯一つ取ります。
	１クラスにつき１つだけ指定できます。
	delete式：

------
delete f;
------

        $(P 実行されて、
	fがデアロケータを持つクラスのインスタンスへの参照であれば、
	（存在すれば）デストラクタが呼ばれた後、
	インスタンスへのポインタを引数に、
	デアロケータが呼ばれます。メモリを解放するのは、デアロケータの責任です。
        )

        $(P 派生クラスは、
	特に指定が無ければ親クラスからデアロケータを継承します。
        )

        $(P インスタンスがスタック上に割り当てられているときには、
	アロケータは呼ばれません。
        )

        $(P 参照:
        $(DPLLINK memory.html#newdelete, 明示的なクラスインスタンス割り当て)
        )

$(V2
<h3>$(LNAME2 AliasThis, alias this)</h3>

$(GRAMMAR
$(GNAME AliasThis):
    $(B alias) $(I Identifier) $(B this;)
)

        $(P $(I AliasThis) 宣言は、
	未定義のメンバ探索を転送する先のメンバを宣言します。$(I Identifier) で指定されたメンバが転送先になります。
        )

        $(P クラスや構造体は$(I AliasThis)
	されたメンバに暗黙変換されます。
        )

---
struct S {
  int x;
  alias x this;
}

int foo(int i) { return i * 2; }

void test() {
  S s;
  s.x = 7;
  int i = -s;  // i == -7
  i = s + 8;   // i == 15
  i = s + s;   // i == 14
  i = 9 + s;   // i == 16
  i = foo(s);  // int への暗黙変換
}
---

        $(P 転送先がクラスや構造体であった場合、
        見つからなかったメンバアクセスは $(I AliasThis) に転送されます
        )

---
struct Foo
{
  int baz = 4;
  int get() { return 7; }
}

class Bar
{
  Foo foo;
  alias foo this;
}

void test() {
  auto bar = new Bar;
  int i = bar.baz; // i == 4
  i = bar.get(); // i == 7
}
---

        $(P $(I Identifier)
		が引数なしのプロパティメンバ関数を指していた場合、
        転送はその関数の返値に向けて行われます。
        )

---
struct S
{
  int x;
  @property int get() {
    return x * 2;
  }
  alias get this;
}

void test() {
  S s;
  s.x = 2;
  int i = s; // i == 4
}
---

        $(P 複数の $(I AliasThis) を書くことが出来ます。
        暗黙変換と転送先を探す際には、すべての $(I AliasThis)
        を試します。複数の $(I AliasThis) 候補がマッチした場合は、
        あいまいなためエラーとなります。
        注: 複数の $(I AliasThis) は現在のところ未実装です。
        )
)

<h3>$(LNAME2 auto, scope クラス)</h3>

        次のように $(B scope) 属性の付いたクラスが、scopeクラスです：

------
scope class Foo { ... }
------

	scope性は継承され、
	scopeクラスから派生したクラスは皆scopeになります。
        <p>

        scopeクラスの参照は、関数のローカル変数としてのみ存在できます。
	その変数は $(B scope) と宣言されていなくてはいけません：

------
scope class Foo { ... }

void func() {
  Foo f;    // エラー、scopeクラスの参照はscopeでなくてはダメ
  scope Foo g = new Foo(); // 正しい
}
------

	scopeクラスの参照がスコープから抜けると、（もし存在すれば）
	デストラクタが自動的に呼ばれます。これは、
	例外によってスコープを抜けた時であっても成り立ちます。

<h3>$(LNAME2 final, final クラス)</h3>

        $(P final と宣言されたクラスは継承できません：)

---
final class A { }
class B : A { }  // エラー。クラス A は final
---

<h2>$(LNAME2 nested, ネストクラス)</h2>

        A $(I ネストクラス)  とは、
	関数や他のクラスのスコープ内で定義されるクラスのことをいいます。
	ネストクラスからは、すぐ外側のクラスと関数内で定義された変数や
	その他のシンボルにアクセスすることができます：

------
class Outer {
  int m;

  class Inner {
    int foo() {
      return m;   // Outerのメンバへアクセスできる
    }
  }
}

void func() {
  int m;

  class Inner {
    int foo() {
      return m; // func() のローカル変数にアクセスできる
    }
  }
}
------

        $(B static) 属性付きで宣言されていた場合、
	スタックローカルの変数や $(B this):
の必要なシンボルなどの周囲のスコープにはアクセスできなくなります：

------
class Outer {
  int m;
  static int n;

  static class Inner {
    int foo() {
      return m;   // エラー。Innerはstaticでmには $(B this)
      return n;   // OK。n は static
    }
  }
}

void func() {
  int m;
  static int n;

  static class Inner {
    int foo() {
      return m;   // エラー。Innerはstaticでmはスタックローカル
      return n;   // OK。n は static
    }
  }
}
------

	非staticネストクラスは、隠しメンバ（コンテクスト・ポインタと呼びます）
	を一つ加えることで実現されています。
	関数内にあるときは周囲の関数のフレームポインタが、
	クラス内にあるときは周囲のクラスの $(B this)
	ポインタが、隠しメンバに格納されています。
        <p>

	非staticネストクラスがインスタンス化される際には、
	コンストラクタの呼び出し前にコンテキスト・ポインタが設定されるので、
	コンストラクタからは周辺の変数へと完全にアクセス可能です。
	非staticネストクラスは、
	必要なコンテキスト・ポインタ情報が入手可能な時のみインスタンス化できます：

------
class Outer {
  class Inner { }

  static class SInner { }
}

void func() {
  class Nested { }

  Outer o = new Outer;        // Ok
  Outer.Inner oi = new Outer.Inner;   // エラー。Outerに'this'がない
  Outer.SInner os = new Outer.SInner; // Ok

  Nested n = new Nested;      // Ok
}
------

$(V1
	非staticなネストクラスは周囲の関数のスタック変数へとアクセスできるのですが、
	その関数が終了した後は、
	アクセスは不正となります：

------
class Base {
  int foo() { return 1; }
}

Base func() {
  int m = 3;

  class Nested : Base {
    int foo() { return m; }
  }

  Base b = new Nested;

  assert(b.foo() == 3);       // Ok, func() はまだ実行中
  return b;
}

int test() {
  Base b = func();
  return b.foo();             // Error, func().m は未定義
}
------

	このような機能が必要な場合は、
	ネストクラスのコンストラクタ内で、
	必要な変数のコピーを作成します：

------
class Base {
  int foo() { return 1; }
}

Base func() {
  int m = 3;

  class Nested : Base {
    int m_;

    this() { m_ = m; }
    int foo() { return m_; }
  }

  Base b = new Nested;

  assert(b.foo() == 3);       // Ok, func() はまだ実行中
  return b;
}

int test() {
  Base b = func();
  return b.foo();             // Ok, func().m のキャッシュされたコピーを使用
}
------
)

        $(P $(I NewExpression) の頭にくっつけることで、
	内部クラスの生成時に $(I this を指定することができます:
        )

---------
class Outer {
  int a;

  class Inner {
    int foo() {
      return a;
    }
  }
}

int bar() {
  Outer o = new Outer;
  o.a = 3;
  Outer.Inner oi = $(B o).new Inner;
  return oi.foo();    // 3を返す
}
---------

        $(P この例では $(B o) が外部クラス $(I Outer)
        のインスタンスを指す $(B this) として機能しています。
        )

        $(P 内部クラスのインスタンスのプロパティ $(B .outer) は、
        外部クラスの $(B this) ポインタを返します。外部コンテキストがクラスでない場合
        $(B .outer) は
        $(B void*) 型でコンテキストへのポインタを返します。
        )

----
class Outer {
  class Inner {
    Outer foo() {
      return this.$(B outer);
    }
  }

  void bar() {
    Inner i = new Inner;
    assert(this == i.foo());
  }
}

void test() {
  Outer o = new Outer;
  o.bar();
}
----

<h3>$(LNAME2 anonymous, 無名ネストクラス)</h3>

        $(P 無名ネストクラスは、
        $(I NewAnonClassExpression)  で定義とインスタンス化が同時に行われます：
        )

$(GRAMMAR
$(GNAME NewAnonClassExpression):
    $(B new) $(GLINK2 expression, AllocatorArguments)$(OPT) $(B class) $(I ClassArguments)$(OPT) $(GLINK SuperClass)$(OPT) $(GLINK Interfaces)$(OPT) $(GLINK ClassBody)

$(GNAME ClassArguments):
	$(B $(LPAREN)) $(GLINK2 expression, ArgumentList)$(OPT) $(B $(RPAREN))
)

        $(P これは次と同等です：
        )

------
class $(I Identifier) : $(I SuperClass) $(I Interfaces)
        $(I ClassBody)

new ($(I ArgumentList)) $(I Identifier) ($(I ArgumentList));
------

        $(P $(I Identifier)
        は無名ネストクラス用に生成されたクラス名とします。
        )

$(V2
$(SECTION3 $(LNAME2 ConstClass, const/immutable/shared クラス))
        $(P $(I ClassDeclaration) が記憶域クラス $(CODE const) か $(CODE immutable)
        か $(CODE shared) で修飾されていた場合、
	そのクラスのすべてのメンバが同じ記憶域クラスで修飾されます。
	基底クラスがconst/immutable/sharedなら、
	その派生クラスも全てconst/immutable/sharedになります。
        )
)

)
)

Macros:
        TITLE=クラス
        WIKI=Class
        CATEGORY_SPEC=$0
        FOO=