const3.dd

Ddoc

$(D_S Const と Immutable,

	$(P データ構造やインターフェイスを調べるときには、
	どのデータが不変でどのデータが可変で、変更を行う可能性があるのは誰か、
	といった情報が簡単にわかると非常に便利です。
	そしてこれは、言語の型システムの助けによって実現することができます。
	データは const あるいは immutable とマーク付けすることができ、
	デフォルトでは変更可能 ($(I mutable)) となっています。
	)

	$(P $(I immutable) は、
	一度構築されたら決して変更されることのないデータに適用します。
	immutable なデータ値は、
	プログラムの実行中一貫して同じ値であり続けます。
	immutable なデータは ROM (Read Only Memory)
	や、ハードウェアによって読み取り専用とされたメモリページに配置することができます。
	immutable なデータは決して変更されないので、
	さまざまなプログラム最適化の機会をもたらします。また、
	アプリケーションをより関数型のプログラミングスタイルで書くことを可能にします。
	)

	$(P $(I const) は、そのconst参照を通しては変更を加えることのないデータに適用します。
	ただし、データ自体の値は、
	同じデータを指す別の参照経由で変化するかもしれません。
	アプリケーション内で const を使用することで、
	渡されたデータを変更せずに読み取りだけであるというインターフェイスを表現することができます。
	)

	$(P immutable と const のどちらも、$(I  推移的) です。つまり、
	immutable な参照経由でアクセスできるデータは全てimmutableですし、
	const の場合にも同様のことが成り立ちます。
	)

$(SECTION2 immutable 記憶域クラス,

	$(P
	一番単純な immutable は、記憶域クラスとしての使い方です。
	これは記号定数(manifest constant)を宣言するのに使用することができます。
	)

---
immutable int x = 3;  // x は 3 になる
x = 4;        // エラー。x は immutable
char[x] s;    // s は char 3つの配列
---

	$(P immutable変数の型は初期化子から推論されます:
	)
---
immutable y = 4; // int型のy
y = 5;           // エラー。y は immutable
---

	$(P 初期化子を与えていない場合、
	immutable を対応するコンストラクタで初期化することが可能です：
	)

---
immutable int z;
void test() {
  z = 3; // エラー。z は immutable
}
static this() {
  z = 3; // ok
         // 静的初期化子のないimmutableの値は設定できる
}
---
	$(P
	非ローカルな
	immutable
	宣言の初期化子はコンパイル時評価可能でなければなりません：
	)

---
int foo(int f) { return f * 3; }
int i = 5;
immutable x = 3 * 4;      // ok, 12
immutable y = i + 1;      // エラー。コンパイル時評価不可能
immutable z = foo(2) + 1; // ok。 foo(2) はコンパイル時に7に評価される
---

	$(P staticでないローカルなimmutable宣言の初期化子は、
	実行時に評価されます:
	)
---
int foo(int f)
{
  immutable x = f + 1;  // 実行時に評価
  x = 3;                // エラー。x は immutable
}
---

	$(P
	immutable は推移的なので、
	immutableから参照されているデータもまたimmutableです:
	)

---
immutable char[] s = "foo";
s[0] = 'a';  // エラー。s は immutable なデータを指している
s = "bar";   // エラー。s は immutable
---

	$(P immutable宣言はlvalueとして使うことができます。
	つまり、アドレスを取ることが可能です。
	)
)

$(SECTION2 const 記憶域クラス,

	$(P
	const 宣言は、以下の違いを除いて、
	immutable とほぼ同じです：
	)

	$(UL
	$(LI const宣言された変数を通してデータを書き換えることはできないが、
	同じデータを参照する別の箇所がデータを書き換えることは
	あるかもしれない)

	$(LI const宣言された変数の型は、const)
	)

$(COMMENT
$(TABLE1

$(TR $(TH  ) $(TH AddrOf) $(TH CTFEInit) $(TH Static) $(TH Field) $(TH Stack) $(TH Ctor))

$(TR $(TD  )
 $(TD Can the address be taken?)
 $(TD Is compile time function evaluation done on the initializer?)
 $(TD allocated as static data?)
 $(TD allocated as a per-instance field?)
 $(TD allocated on the stack?)
 $(TD Can the variable be assigned to in a constructor?)
)


$(TR $(TH Global data))

$(TR $(TD1 const T x;)		$(Y)	$(N)	$(Y)	$(N)	$(N)	$(Y))
$(TR $(TD1 const T x = 3;)		$(N)	$(Y)	$(N)	$(N)	$(N)	$(N))
$(TR $(TD1 static const T x;)	$(Y)	$(N)	$(Y)	$(N)	$(N)	$(Y))
$(TR $(TD1 static const T x = 3;)	$(Y)	$(Y)	$(Y)	$(N)	$(N)	$(N))


$(TR $(TH Class Members))

$(TR $(TD1 const T x;)		$(Y)	$(N)	$(N)	$(Y)	$(N)	$(Y))
$(TR $(TD1 const T x = 3;)		$(N)	$(Y)	$(N)	$(N)	$(N)	$(N))
$(TR $(TD1 static const T x;)	$(Y)	$(N)	$(Y)	$(N)	$(N)	$(Y))
$(TR $(TD1 static const T x = 3;)	$(Y)	$(Y)	$(Y)	$(N)	$(N)	$(N))


$(TR $(TH Local Variables))

$(TR $(TD1 const T x;)		$(Y)	$(Y)	$(N)	$(N)	$(Y)	$(N))
$(TR $(TD1 const T x = 3;)		$(Y)	$(N)	$(N)	$(N)	$(Y)	$(N))
$(TR $(TD1 static const T x;)	$(Y)	$(Y)	$(Y)	$(N)	$(N)	$(N))
$(TR $(TD1 static const T x = 3;)	$(Y)	$(Y)	$(Y)	$(N)	$(N)	$(N))

$(TR $(TH Function Parameters))

$(TR $(TD1 const T x;)		$(Y)	$(N)	$(N)	$(N)	$(Y)	$(N))
)


$(P Notes:)

$(OL
$(LI If CTFEInit is true, then the initializer can also be used for
constant folding.)
)


$(TABLE1
<caption>Template Argument Deduced Type</caption>
$(TR $(TH &nbsp;)               $(TH mutable $(CODE T)) $(TH1 const(T)) $(TH1 immutable(T)))
$(TR $(TD1 foo(U))              $(TDE T) $(TDE T) $(TDE T))
$(TR $(TD1 foo(U:U))            $(TDE T) $(TDE const(T)) $(TDE immutable(T)))
$(TR $(TD1 foo(U:const(U)))     $(TDI T) $(TDE T) $(TDI T))
$(TR $(TD1 foo(U:immutable(U))) $(NM) $(NM) $(TDE T))
)

$(P Where:)

$(TABLE1
$(TR $(TD $(GREEN green)) $(TD exact match))
$(TR $(TD $(ORANGE orange)) $(TD implicit conversion))
)
)
)

$(SECTION2 immutable 型,

	$(P
	immutableと修飾された型の値は、決して変更されません。
	予約語 immutable は <i>type constructor</i> として使うことができます:
	)

---
immutable(char)[] s = "hello";
---

	$(P
	immutable は、括弧の中に書かれた型に適用されます。
	例えばこの例の場合、変数 $(CODE s) に別の値を代入することはできますが、
	$(CODE s[]) の中身に別の値を入れることはできません：
	)

---
s[0] = 'b';  // エラー。s[] は immutable
s = null;    // ok。sそのものはimmutableでない
---

	$(P
	immutable性は推移的です。つまり、immutable性は、
	immutable型から参照されるすべてのものに伝搬します：
	)

---
immutable(char*)** p = ...;
p = ...;        // ok, p はimmutableでない
*p = ...;       // ok, *p はimmutableでない
**p = ...;      // エラー。 **p は immutable
***p = ...;     // エラー。***p は immutable
---

	$(P 記憶域クラスとして使われる
	immutable
	は、宣言の型全体をimmutableで修飾したのと同じ効果になります:)

---
immutable int x = 3;   // x は immutable(int) 型
immutable(int) y = 3;  // y は immutable
---
)


$(SECTION2 immutable なデータを作る,

	$(P
	一番単純な方法は、最初からimmutableとされているリテラルを使うことです。
	例えば、文字列リテラルは immutable です。
	)

---
auto s = "hello";   // s は immutable(char)[5]
char[] p = "world"; // エラー。暗黙キャストで
		    // immutableを外すことはできない
---

	$(P
	二つめの方法は、データを明示的にimmutableにキャストすることです。
	この方法をとるときは、
	そのデータを他に書き換えるような参照がないことをプログラマが保証する必要があります。
	)

---
char[] s = ...;
immutable(char)[] p = cast(immutable)s;     // 未定義動作
immutable(char)[] p = cast(immutable)s.dup; // ok。pがs.dupへの唯一の参照
---

	$(P
	$(CODE .idup) ロパティを使うと、
	配列のimmutableなコピーを簡単に作ることができます：
	)

---
auto p = s.idup;
p[0] = ...;	  // エラー。p[] は immutable
---

<h2>キャストでimmutableを取り除く</h2>

	$(P
	immutable をキャストで除去することは可能です：
	)

---
immutable int* p = ...;
int* q = cast(int*)p;
---

	$(P
	しかし、だからといって、データを書き換えられるようになるわけではありません：
	)

---
*q = 3; // コンパイルは通るが、未定義動作
---

	$(P
	immutable性を取り除くキャストは、正しく静的型がついていないくて、
	しかもそれが修正できないという場面で必要となってしまうことがあります。
	例えば、正しく型のついていないライブラリを使う場合などです。
	キャストは使い方次第で毒にも薬にもなる道具です。
	コンパイラが保証するimmutable性の正しさをキャストで取り除く以上、
	データの immutable
	性に関してプログラマが責任を持つことが前提となります。
	)
)


$(SECTION2 immutable メンバ関数,

	$(P
	immutable メンバ関数では、
	$(CODE this) 参照経由で参照される全てのデータがimmutableであることが保証されます。
	以下のように宣言します:
	)

---
struct S {   
  int x;

  void foo() immutable {
    x = 4;      // エラー。 x は immutable
    this.x = 4; // エラー。 x は immutable
  }
}
---
    $(P 関数の左側に $(D_KEYWORD immutable) を書くのは、返値型への修飾にはなりません:
    )

---
struct S {
  immutable int[] bar()  // bar は immutable ですが、返値型はそうではありません！
  {
  }
}
---
    $(P 返値型を $(D_KEYWORD immutable) にするには、括弧で囲う必要があります:
    )

---
struct S {
  immutable(int[]) bar()  // 今度は bar は mutable で、返値型が immutable.
  {
  }
}
---
    $(P メソッドと返値の両方を $(D_KEYWORD immutable) にするには、こうします:
    )
---
struct S {
  immutable(int[]) bar() immutable
  {
  }
}
---
)


$(SECTION2 const 型,

	$(P
	const 型は immutable 型に似ていますが、const は
	データの読み込み専用の $(I view) を表します。
	他に参照があってデータを書き換える可能性は残っています。
	)
)


$(SECTION2 const メンバ関数,

	$(P
	const メンバ関数は、
	thisの指すオブジェクト自身のメンバを書き換えることが許されない
	メンバ関数です。
	)
)


$(SECTION2 暗黙の変換,

	$(P
	書き換え可能な型とimmutable型のデータは、constに暗黙変換できます。
	書き換え可能な型をimmutableに変換したり、
	その逆の変換が暗黙に行われることはありません。
	)
)


$(SECTION2 Dのimmutable,const と C++のconstの比較,

	<table border=2 cellpadding=4 cellspacing=0 class="comp">
	<caption>const, immutable の比較</caption>

	<thead>
	$(TR
	$(TH 機能)
	$(TH D)
	$(TH C++98)
	)
	</thead>

	<tbody>

	$(TR
	$(TD 予約語 const)
	$(TD Yes)
	$(TD Yes)
	)

	$(TR
	$(TD 予約語 immutable)
	$(TD Yes)
	$(TD No)
	)

	$(TR
	$(TD const の記法)
	$(TD 関数的:
---
// const int への const ポインタ へのポインタ
const(int*)* p;
---
	)
	$(TD 後置:
$(CPPCODE
// const int への const ポインタ へのポインタ
const int *const *p;
)
	)
	)

	$(TR
	$(TD 推移的 const)
	$(TD Yes:
---
// const intへのconstポインタへのconstポインタ
const int** p;
**p = 3; // エラー
---
	 )
	$(TD No:
$(CPPCODE
// intへのポインタへのconstポインタ
int** const p;
**p = 3;    // ok
)
	 )
	)

	$(TR
	$(TD const除去キャスト)
	$(TD Yes:
---
// const intへのポインタ
const(int)* p;
int* q = cast(int*)p; // ok
---
	)
	$(TD Yes:
$(CPPCODE
// const intへのポインタ
const int* p;
int* q = const_cast&lt;int*&gt;p; //ok
)
	)
	)

	$(TR
	$(TD const除去後の書き換え)
	$(TD No:
---
// const intへのポインタ
const(int)* p;
int* q = cast(int*)p;
*q = 3;   // 未定義動作
---
	)
	$(TD Yes:
$(CPPCODE
// const intへのポインタ
const int* p;
int* q = const_cast&lt;int*&gt;p;
*q = 3;   // ok
)
	)
	)

	$(TR
	$(TD トップレベルのconstでのoverload)
	$(TD Yes:
---
void foo(int x);
void foo(const int x);  //ok
---
	)
	$(TD No:
$(CPPCODE
void foo(int x);
void foo(const int x);  //エラー
)
	)
	)

	$(TR
	$(TD constとmutableの別名参照)
	$(TD Yes:
---
void foo(const int* x, int* y)
{
   bar(*x); // bar(3)
   *y = 4;
   bar(*x); // bar(4)
}
...
int i = 3;
foo(&i, &i);
---
	)
	$(TD Yes:
$(CPPCODE
void foo(const int* x, int* y)
{
   bar(*x); // bar(3)
   *y = 4;
   bar(*x); // bar(4)
}
...
int i = 3;
foo(&amp;i, &amp;i);
)
	)
	)

	$(TR
	$(TD immutableとmutableの別名参照)
	$(TD No:
---
void foo(immutable int* x, int* y) {
 bar(*x); // bar(3)
 *y = 4;  // 未定義動作
 bar(*x); // bar(??)
}
...
int i = 3;
foo(cast(immutable)&i, &i);
---
	)
	$(TD immutable はナシ)
	)

	$(TR
	$(TD 文字列リテラルの型)
	$(TD immutable(char)[])
	$(TD const char*)
	)


	$(TR
	$(TD 文字列リテラルから非const型への暗黙変換)
	$(TD なし)
	$(TD あり、ただし非推奨)
	)

	</tbody>
	</table>
)


)

Macros:
	TH1=<th nowrap="nowrap">$(CODE $0)</th>
	TD1=<td nowrap="nowrap">$(CODE $0)</td>
	TDE=<td nowrap="nowrap">$(GREEN $(CODE $0))</td>
	TDI=<td nowrap="nowrap">$(ORANGE $(CODE $0))</td>
	NM=$(TD $(RED no match))
	Y=$(TD $(GREEN Yes))
	N=$(TD $(RED No))
	TITLE=Const と Immutable
	WIKI=ConstInvariant
	CATEGORY_SPEC=$0
	NO=<td class="compNo">No</td>
	NO1=<td class="compNo"><a href="$1">No</a></td>
	YES=<td class="compYes">Yes</td>
	YES1=<td class="compYes"><a href="$1">Yes</a></td>
	D_CODE = <pre class="d_code2">$0</pre>
	CPPCODE2 = <pre class="cppcode2">$0</pre>
	ERROR = $(RED $(B error))
	COMMA=,
META_KEYWORDS=D Programming Language, const, immutable
META_DESCRIPTION=Comparison of const between the
D programming language, C++, and C++0x