operatoroverloading.dd

Ddoc

$(SPEC_S 演算子オーバーロード,

$(V2
	$(P 演算子オーバーロードは、クラスや構造体をオペランドとして持つ演算子式を、
	特別な名前のメンバ関数呼び出しに変換することで実現されています。
	新しい文法の追加はありません。
	)

	$(UL
	$(LI $(LINK2 #Unary, 単項演算子))
	$(LI $(LINK2 #Cast, キャスト演算子))
	$(LI $(LINK2 #Binary, 二項演算子))
	$(LI $(LINK2 #equals, == と !=))
	$(LI $(LINK2 #compare, < <=, >, >=))
	$(LI $(LINK2 #FunctionCall, 関数呼び出し演算子))
	$(LI $(LINK2 #Assignment, 代入演算子))
	$(LI $(LINK2 #OpAssign, 演算代入演算子))
	$(LI $(LINK2 #Array, インデックス演算子))
	$(LI $(LINK2 #Slice, スライス演算子))
	$(LI $(LINK2 #Dispatch, メンバ転送))
	)

<h2><a name="Unary">単項演算子のオーバーロード</a></h2>

	$(TABLE2 オーバーロード可能な単項演算子,

	$(TR $(TH$(I 演算子)) $(TH$(I 書き換え結果)) )

	$(TR
	$(TD -$(I e))
	$(TD $(CODE $(I e).opUnary!("-")()))
	)

	$(TR
	$(TD +$(I e))
	$(TD $(CODE $(I e).opUnary!("+")()))
	)

	$(TR
	$(TD ~$(I e))
	$(TD $(CODE $(I e).opUnary!("~")()))
	)

	$(TR
	$(TD *$(I e))
	$(TD $(CODE $(I e).opUnary!("*")()))
	)

	$(TR
	$(TD ++$(I e))
	$(TD $(CODE $(I e).opUnary!("++")()))
	)

	$(TR
	$(TD --$(I e))
	$(TD $(CODE $(I e).opUnary!("--")()))
	)

	)

	$(P 例えば、- (符号反転) 演算子を構造体 S でオーバーロードし、
	他の演算子はオーバーロードしない場合は、こうなります:)

---
struct S {
  int m;

  int opUnary(string s)() if (s == "-") {
    return -m;
  }
}

int foo(S s) {
  return -s;
}
---

<h3>後置インクリメント $(I e)++ と 後置デクリメント $(I e)-- 演算子</h3>

	$(P これらの演算子は直接オーバーロードはできません。
	代わりに、前置演算の ++$(I e) や --$(I e) を使った書き換えが行われます:
	)

	$(TABLE2 後置演算子の書き換え,

	$(TR $(TH$(I 演算子)) $(TH$(I 書き換え結果)) )

	$(TR
	$(TD $(I e)--)
	$(TD $(CODE (auto t = e, --$(I e), t)))
	)

	$(TR
	$(TD $(I e)++)
	$(TD $(CODE (auto t = e, ++$(I e), t)))
	)
	)

<h3>単項インデックス演算子</h3>

	$(TABLE2 オーバーロード可能な単項インデックス演算子,

	$(TR $(TH$(I 演算子)) $(TH$(I 書き換え結果)) )

	$(TR
	$(TD $(CODE -$(I a)[$(ARGUMENTS)]))
	$(TD $(CODE $(I a).opIndexUnary!("-")($(ARGUMENTS))))
	)

	$(TR
	$(TD $(CODE +$(I a)[$(ARGUMENTS)]))
	$(TD $(CODE $(I a).opIndexUnary!("+")($(ARGUMENTS))))
	)

	$(TR
	$(TD $(CODE ~$(I a)[$(ARGUMENTS)]))
	$(TD $(CODE $(I a).opIndexUnary!("~")($(ARGUMENTS))))
	)

	$(TR
	$(TD $(CODE *$(I a)[$(ARGUMENTS)]))
	$(TD $(CODE $(I a).opIndexUnary!("*")($(ARGUMENTS))))
	)

	$(TR
	$(TD $(CODE ++$(I a)[$(ARGUMENTS)]))
	$(TD $(CODE $(I a).opIndexUnary!("++")($(ARGUMENTS))))
	)

	$(TR
	$(TD $(CODE --$(I a)[$(ARGUMENTS)]))
	$(TD $(CODE $(I a).opIndexUnary!("--")($(ARGUMENTS))))
	)

	)

<h3>単項スライス演算子</h3>

	$(TABLE2 オーバーロード可能な単項スライス演算子,

	$(TR $(TH$(I 演算子)) $(TH$(I 書き換え結果)) )

	$(TR
	$(TD $(CODE -$(I a)[$(SLICE)]))
	$(TD $(CODE $(I a).opSliceUnary!("-")($(SLICE2))))
	)

	$(TR
	$(TD $(CODE +$(I a)[$(SLICE)]))
	$(TD $(CODE $(I a).opSliceUnary!("+")($(SLICE2))))
	)

	$(TR
	$(TD $(CODE ~$(I a)[$(SLICE)]))
	$(TD $(CODE $(I a).opSliceUnary!("~")($(SLICE2))))
	)

	$(TR
	$(TD $(CODE *$(I a)[$(SLICE)]))
	$(TD $(CODE $(I a).opSliceUnary!("*")($(SLICE2))))
	)

	$(TR
	$(TD $(CODE ++$(I a)[$(SLICE)]))
	$(TD $(CODE $(I a).opSliceUnary!("++")($(SLICE2))))
	)

	$(TR
	$(TD $(CODE --$(I a)[$(SLICE)]))
	$(TD $(CODE $(I a).opSliceUnary!("--")($(SLICE2))))
	)

	$(TR
	$(TD $(CODE -$(I a)[ ]))
	$(TD $(CODE $(I a).opSliceUnary!("-")()))
	)

	$(TR
	$(TD $(CODE +$(I a)[ ]))
	$(TD $(CODE $(I a).opSliceUnary!("+")()))
	)

	$(TR
	$(TD $(CODE ~$(I a)[ ]))
	$(TD $(CODE $(I a).opSliceUnary!("~")()))
	)

	$(TR
	$(TD $(CODE *$(I a)[ ]))
	$(TD $(CODE $(I a).opSliceUnary!("*")()))
	)

	$(TR
	$(TD $(CODE ++$(I a)[ ]))
	$(TD $(CODE $(I a).opSliceUnary!("++")()))
	)

	$(TR
	$(TD $(CODE --$(I a)[ ]))
	$(TD $(CODE $(I a).opSliceUnary!("--")()))
	)
	)

<h2><a name="Cast">キャスト演算子のオーバーロード</a></h2>

	$(TABLE2 キャスト演算子,

	$(TR $(TH$(I 演算子)) $(TH$(I 書き換え結果)) )

	$(TR
	$(TD cast($(I type))$(I e))
	$(TD $(CODE $(I e).opCast!($(I type))()))
	)

	)


<h3>bool 演算</h3>

	$(P 単項演算子のオーバーロードの表に欠けているものとして、特に、
	論理否定の ! 演算子があります。微妙なところでは、
	bool 値への暗黙変換演算が欠けています。
	代わりに、これらは以下のような書き換えで実行されます:
	)
---
opCast!(bool)(e)
---

	$(P つまり)

---
if (e)   =>  if (e.opCast!(bool))
if (!e)  =>  if (!e.opCast!(bool))
---

	$(P などのように、bool値が期待される位置の式は処理されます。
	ただし、これは構造体のインスタンスのみに限ります。クラスへの参照は常に、
	null かどうかに応じてboolへと変換されます。
	)

<h2><a name="Binary">二項演算子のオーバーロード</a></h2>

	$(P 以下の二項演算子がオーバーロード可能です。)

	$(TABLE2 オーバーロード可能な二項演算子,

	$(TR $(TD +) $(TD -) $(TD *) $(TD /) $(TD %) $(TD ^^) $(TD &amp;) )
	$(TR $(TD |) $(TD ^) $(TD &lt;&lt;) $(TD &gt;&gt;) $(TD &gt;&gt;&gt;) $(TD ~) $(TD in) )

	)

	$(P 式:)
---
a $(I op) b
---
	$(P は、以下の二通りの書き換えが考慮され:)
---
a.opBinary!("$(I op)")(b)
b.opBinaryRight!("$(I op)")(a)
---

	$(P 型が「より良く」マッチをする方が選択されます。
	どちらのマッチも同程度に良い場合、エラーになります。
	)

	$(P 複数の演算子に対するオーバーロードを同時に定義できます。
	例えば、+ と - 演算子だけをサポートするなら:)

---
T opBinary(string op)(T rhs) {
   static if (op == "+") return data + rhs.data;
   else static if (op == "-") return data - rhs.data;
   else static assert(0, "Operator "~op~" not implemented");
}
---

	$(P 全てを一度にやるならば、こうです:)

---
T opBinary(string op)(T rhs) {
     return mixin("data "~op~" rhs.data");
}
---


<h2><a name="equals">== と != のオーバーロード</a></h2>

	$(P $(CODE a != b) の形の式は、まず $(CODE !(a == b)) に書き換えられます。)

	$(P $(CODE a == b) に対しては:)

$(OL
	$(LI a と b の両方がクラスオブジェクトなら、式は:
---
.object.opEquals(a, b)
---
	$(P このように書き換えられ、この関数は次のように実装されています:)
---
bool opEquals(Object a, Object b) {
  if (a is b) return true;
  if (a is null || b is null) return false;
  if (typeid(a) == typeid(b)) return a.opEquals(b);
  return a.opEquals(b) && b.opEquals(a);
}
---
	)
	$(LIそれ以外の場合、$(CODE a.opEquals(b)) と
	$(CODE b.opEquals(a)) が試みられます。どちらも同じ opEquals
	関数へと解決される場合は $(CODE a.opEquals(b)) が優先されます。
	)
	$(LI 片方がもう一方より良いマッチである場合、
	あるいは片方のみがコンパイルできる場合、そちらが選択されます。)
	$(LI それ以外の場合は、エラーとなります。)
)

	$(P クラスに対して Object.opEquals() をオーバーライドする場合、
	以下のシグネチャとします:)
---
class C {
  override bool opEquals(Object o) { ... }
}
---

	$(P 構造体のメンバ関数として opEquals を定義する場合、
	以下の形式とします:)
---
struct S {
  int opEquals(ref const S s) { ... }
}
---

<h2><a name="compare">&lt;, &lt;=, &gt;, &gt;= のオーバーロード</a></h2>

	$(P 比較演算子は以下のように書き換えられます:)

	$(TABLE2 オーバーロード可能な比較演算子,
	$(TR $(TH 比較) $(TH 書き換え候補1) $(TH 書き換え候補2) )

	$(TR $(TD $(CODE a &lt; b)) $(TD $(CODE a.opCmp(b) &lt; 0)) $(TD $(CODE b.opCmp(a) &gt; 0)))
	$(TR $(TD $(CODE a &lt;= b)) $(TD $(CODE a.opCmp(b) &lt;= 0)) $(TD $(CODE b.opCmp(a) &gt;= 0)))
	$(TR $(TD $(CODE a &gt; b)) $(TD $(CODE a.opCmp(b) &gt; 0)) $(TD $(CODE b.opCmp(a) &lt; 0)))
	$(TR $(TD $(CODE a &gt;= b)) $(TD $(CODE a.opCmp(b) &gt;= 0)) $(TD $(CODE b.opCmp(a) &lt;= 0)))
	)

	$(P 両方の書き換えを試し、片方のみがコンパイル可能なら、そちらを取ります。
	双方とも同じ関数に解決されるならば、
	１つめの書き換えを優先します。異なる関数になる場合は、
	良いマッチとなる方を選びます。どちらのマッチも同じくらい良い場合は、
	あいまいなためエラーとなります。
	)

	$(P クラスに対して Object.opCmp() をオーバーライドする場合、
	以下のシグネチャとします:)
---
class C {
  override int opCmp(Object o) { ... }
}
---

	$(P 構造体のメンバ関数として opCmp を定義する場合、
	以下の形式とします:)
---
struct S {
  int opCmp(ref const S s) const { ... }
}
---

<h2><a name="FunctionCall">関数呼び出し演算子のオーバーロード $(I f)()</a></h2>

	$(P 関数呼び出し演算子 () は
	$(B opCall) という名前の関数を宣言することでオーバーロードできます：
	)

-------
struct F {
  int $(B opCall)();
  int $(B opCall)(int x, int y, int z);
}

void test() {
  F f;
  int i;

  i = f$(B ());      // i = f.opCall(); と同じ
  i = f$(B (3,4,5)); // i = f.opCall(3,4,5); と同じ
}
-------

	$(P このようにして、構造体やクラスオブジェクトを、
	あたかも関数であるかのように振る舞わせることができます。
	)

<h2><a name="Assignment">代入演算子のオーバーロード</a></h2>

	$(P $(CODE =) の左辺が構造体/集成体の左辺値で、
	$(CODE opAssign) メンバ関数が定義されていれば、
	オーバーロードとなります。)

	$(P 右辺値に対しては、
	暗黙に左辺値型にキャスト可能であっても、代入演算子はオーバーロードできません。
	さらに、$(CODE opAssign)
	のシグネチャとして、以下は:)

---
opAssign(...)
opAssign(T)
opAssign(T, ...)
opAssign(T ...)
opAssign(T, U = defaultValue, etc.)
---

	$(P $(I T) が元の型 $(I A) と同じか
	$(I A) へ暗黙変換可能、
	あるいは $(I A) が構造体で $(I T)
	が
	$(I A) へ暗黙変換可能な型へのポインタである場合、許されません。
	)

<h3>インデックス代入演算子のオーバーロード</h3>

	$(P 代入演算子の左辺がクラスや構造体に対するインデックス式であれば、
	opIndexAssign
	メンバ関数を提供することで、オーバーロードできます。
	$(CODE a[$(ARGUMENTS)] = c) の形の式は
	 $(CODE a.opIndexAssign(c, $(ARGUMENTS))) と書き換えられます。
	)

-------
struct A {
  int $(B opIndexAssign)(int value, size_t i1, size_t i2);
}

void test() {
  A a;

  a$(B [)i,3$(B ]) = 7;  // a.opIndexAssign(7,i,3); と同じ
}
-------

<h3>スライス代入演算子のオーバーロード</h3>

	$(P 代入演算子の左辺がクラスや構造体に対するスライス式であれば、
	opSliceAssign
	メンバ関数を提供することで、オーバーロードできます。
	$(CODE a[$(SLICE)] = c) の形の式は
	$(CODE a.opSliceAssign(c, $(SLICE2))) と書き換えられ、
	$(CODE a[] = c) は $(CODE a.opSliceAssign(c)) となります。
	)

-------
struct A {
  int $(B opSliceAssign)(int v);  // overloads a[] = v
  int $(B opSliceAssign)(int v, size_t x, size_t y);  // a[i .. j] = v をオーバーロード
}

void test() {
  A a;
  int v;

  a$(B []) = v;  // a.opSliceAssign(v); と同じ
  a$(B [)3..4$(B ]) = v;  // a.opSliceAssign(v,3,4); と同じ
}
-------

<h2><a name="OpAssign">演算代入演算子のオーバーロード</a></h2>

	$(P 以下の演算代入演算子がオーバーロード可能です:)

	$(TABLE2 オーバーロード可能な演算代入演算子,

	$(TR $(TD +=) $(TD -=) $(TD *=) $(TD /=) $(TD %=) $(TD ^^=) $(TD &amp;=) )
	$(TR $(TD |=) $(TD ^=) $(TD &lt;&lt;=) $(TD &gt;&gt;=) $(TD &gt;&gt;&gt;=) $(TD ~=) $(TD &nbsp;) )

	)

	$(P 以下の式:)
---
a $(I op)= b
---

	$(P は、以下に書き換わります:)

---
a.opOpAssign!("$(I op)")(b)
---

<h3>インデックス演算代入演算子のオーバーロード</h3>

	$(P $(I op)= 演算子の左辺がクラスや構造体に対するインデックス式で、
	opIndexOpAssign というメンバが存在すれば:)

---
a[$(ARGUMENTS)] $(I op)= c
---

	$(P は、以下に書き換わります:)

---
a.opIndexOpAssign!("$(I op)")(c, $(ARGUMENTS))
---

<h3>スライス演算代入演算子のオーバーロード</h3>

	$(P $(I op)= 演算子の左辺がクラスや構造体に対するスライス式で、
	opSliceOpAssign というメンバが存在すれば:)

---
a[$(SLICE)] $(I op)= c
---

	$(P は、以下のように書き換えられ:)

---
a.opSliceOpAssign!("$(I op)")(c, $(SLICE2))
---

	$(P さらに)

---
a[] $(I op)= c
---

	$(P は、以下に書き換わります:)

---
a.opSliceOpAssign!("$(I op)")(c)
---

<h2><a name="Array">インデックス演算子のオーバーロード</a></h2>

	$(P 配列のインデックス演算 $(CODE a[$(ARGUMENTS)])
	は $(B opIndex) という名前の１引数以上の関数を宣言することで、
	オーバーロードできます。
	)

-------
struct A {
  int $(B opIndex)(size_t i1, size_t i2, size_t i3);
}

void test() {
  A a;
  int i;

  i = a$(B [)5,6,7$(B ]);  // i = a.opIndex(5,6,7); と同じ
}
-------

	$(P このようにして、
	構造体やクラスオブジェクトを配列であるかのように振る舞わせることができます。
	)

	$(P インデックス式が opIndexAssign や opIndexOpAssign を用いて書き換え可能な場合は、
	そちらの方が優先されます。
	)


<h2><a name="Slice">スライス演算子のオーバーロード</a></h2>

	$(P スライス演算子のオーバーロードとは、
	$(CODE a[]) や $(CODE a[$(SLICE)]) のような式のオーバーロードを意味します。
	これは、$(B opSlice) という名前のメンバ関数を宣言することで実現します。
	)

-------
class A {
  int $(B opSlice)();  // a[] をオーバーロード
  int $(B opSlice)(size_t x, size_t y); // a[i .. j] をオーバーロード
}

void test() {
  A a = new A();
  int i;
  int v;

  i = a$(B []);         // i = a.opSlice(); と同じ
  i = a$(B [)3..4$(B ]);  // i = a.opSlice(3,4); と同じ
}
-------

	$(P スライス式が opSliceAssign や opSliceOpAssign を用いて書き換え可能な場合は、
	そちらの方が優先されます。
	)

<h2><a name="Dispatch">メンバ転送</a></h2>

	$(P クラスや構造体のメンバとして名前が見つからなかった場合は、
	$(CODE opDispatch) という名前のテンプレート関数が呼び出されます。
	)

---
import std.stdio;

struct S {
  void opDispatch(string s, T)(T i)
  {
    writefln("S.opDispatch('%s', %s)", s, i);
  }
}

class C {
  void opDispatch(string s)(int i) {
    writefln("C.opDispatch('%s', %s)", s, i);
  }
}

struct D {
  template opDispatch(string s) {
    enum int opDispatch = 8;
  }
}

void main() {
  S s;
  s.opDispatch!("hello")(7);
  s.foo(7);

  auto c = new C();
  c.foo(8);

  D d;
  writefln("d.foo = %s", d.foo);
  assert(d.foo == 8);
}
---
)

$(V1
	$(P Overloading is accomplished by interpreting specially named
	struct and class member functions as being implementations of unary and
	binary operators. No additional syntax is used.
	)

	$(UL
	$(LI $(LINK2 #Unary, Unary Operator Overloading))
	$(LI $(LINK2 #Binary, Binary Operator Overloading))
	$(LI $(LINK2 #FunctionCall, Function Call Operator Overloading))
	$(LI $(LINK2 #Array, Array Operator Overloading))
	$(LI $(LINK2 #Assignment, Assignment Operator Overloading))
$(V2
	$(DOT $(LI $(LINK2 #Dot, Forwarding)))
)
	$(LI $(LINK2 #Future, Future Directions))
	)

<h2><a name="Unary">Unary Operator Overloading</a></h2>


	$(TABLE2 Overloadable Unary Operators,

	$(TR $(TH$(I op)) $(TH$(I opfunc)) )

	$(TR
	$(TD -$(I e))
	$(TD $(CODE opNeg))
	)

	$(TR
	$(TD +$(I e))
	$(TD $(CODE opPos))
	)

	$(TR
	$(TD ~$(I e))
	$(TD $(CODE opCom))
	)

	$(TR
	$(TD $(I e)++)
	$(TD $(CODE opPostInc))
	)

	$(TR
	$(TD $(I e)--)
	$(TD $(CODE opPostDec))
	)

	$(TR
	$(TD cast($(I type))$(I e))
	$(TD $(CODE opCast))
	)

	)


	$(P Given a unary
	overloadable operator $(I op) and its corresponding
	class or struct member
	function name $(I opfunc), the syntax:
	)

---
$(I op) a
---

	$(P where $(I a) is a class or struct object reference,
	is interpreted as if it was written as:
	)
---
a.$(I opfunc)()
---

<h3>Overloading ++$(I e) and --$(I e)</h3>

	$(P Since ++$(I e) is defined to be semantically equivalent
	to ($(I e) += 1), the expression ++$(I e) is rewritten
	as ($(I e) += 1), and then checking for operator overloading
	is done. The situation is analogous for --$(I e).
	)

<h3>Examples</h3>

	$(OL 
	$(LI
-------
class A { int $(B opNeg)(); }
A a;
-a;	// equivalent to a.opNeg();
-------
	)
	$(LI
-------
class A { int $(B opNeg)(int i); }
A a;
-a;	// equivalent to a.opNeg(), which is an error
-------
	)
	)

<h3>Overloading cast($(I type))$(I e)</h3>

	$(P The member function $(I e).$(B opCast()) is called,
	and the return value of $(B opCast()) is implicitly converted
	to $(I type). Since functions cannot be overloaded based on
	return value, there can be only one $(B opCast) per struct or
	class.
	Overloading the cast operator does not affect implicit casts, it
	only applies to explicit casts.
	)

-------
struct A {
  int $(B opCast)() { return 28; }
}

void test() {
  A a;

  long i = cast(long)a; // i is set to 28L
  void* p = cast(void*)a; // error, cannot implicitly
                          // convert int to void*
  int j = a;  // error, cannot implicitly convert
              // A to int
}
-------

<h2><a name="Binary">Binary Operator Overloading</a></h2>


	$(TABLE2 Overloadable Binary Operators,

	$(TR $(TH $(I op))
	$(TH commutative?)
	$(TH $(I opfunc))
	$(TH $(I opfunc_r))
	)

	$(TR $(TD +) $(TD yes) $(TD $(CODE opAdd)) $(TD $(CODE opAdd_r)))

	$(TR $(TD -) $(TD no) $(TD $(CODE opSub)) $(TD $(CODE opSub_r)))

	$(TR $(TD *) $(TD yes) $(TD $(CODE opMul)) $(TD $(CODE opMul_r)))

	$(TR $(TD /) $(TD no) $(TD $(CODE opDiv)) $(TD $(CODE opDiv_r)))

	$(TR $(TD %) $(TD no) $(TD $(CODE opMod)) $(TD $(CODE opMod_r)))

	$(TR $(TD &) $(TD yes) $(TD $(CODE opAnd)) $(TD $(CODE opAnd_r)))

	$(TR $(TD |) $(TD yes) $(TD $(CODE opOr)) $(TD $(CODE opOr_r)))

	$(TR $(TD ^) $(TD yes) $(TD $(CODE opXor)) $(TD $(CODE opXor_r)))

	$(TR $(TD &lt;&lt;) $(TD no) $(TD $(CODE opShl)) $(TD $(CODE opShl_r)))

	$(TR $(TD &gt;&gt;) $(TD no) $(TD $(CODE opShr)) $(TD $(CODE opShr_r)))

	$(TR $(TD &gt;&gt;&gt;) $(TD no) $(TD $(CODE opUShr)) $(TD $(CODE opUShr_r)))

	$(TR $(TD ~) $(TD no) $(TD $(CODE opCat)) $(TD $(CODE opCat_r)))

	$(TR $(TD ==) $(TD yes) $(TD $(CODE opEquals)) $(TD  -))

	$(TR $(TD !=) $(TD yes) $(TD $(CODE opEquals)) $(TD  -))

	$(TR $(TD &lt;) $(TD yes) $(TD $(CODE opCmp)) $(TD  -))

	$(TR $(TD &lt;=) $(TD yes) $(TD $(CODE opCmp)) $(TD  -))

	$(TR $(TD &gt;) $(TD yes) $(TD $(CODE opCmp)) $(TD  -))

	$(TR $(TD &gt;=) $(TD yes) $(TD $(CODE opCmp)) $(TD  -))

	$(TR $(TD =) $(TD no ) $(TD $(CODE opAssign)) $(TD -) )

	$(TR $(TD +=) $(TD no) $(TD $(CODE opAddAssign)) $(TD  -))

	$(TR $(TD -=) $(TD no) $(TD $(CODE opSubAssign)) $(TD  -))

	$(TR $(TD *=) $(TD no) $(TD $(CODE opMulAssign)) $(TD  -))

	$(TR $(TD /=) $(TD no) $(TD $(CODE opDivAssign)) $(TD  -))

	$(TR $(TD %=) $(TD no) $(TD $(CODE opModAssign)) $(TD  -))

	$(TR $(TD &=) $(TD no) $(TD $(CODE opAndAssign)) $(TD  -))

	$(TR $(TD |=) $(TD no) $(TD $(CODE opOrAssign)) $(TD  -))

	$(TR $(TD ^=) $(TD no) $(TD $(CODE opXorAssign)) $(TD  -))

	$(TR $(TD &lt;&lt;=) $(TD no) $(TD $(CODE opShlAssign)) $(TD  -))

	$(TR $(TD &gt;&gt;=) $(TD no) $(TD $(CODE opShrAssign)) $(TD  -))

	$(TR $(TD &gt;&gt;&gt;=) $(TD no) $(TD $(CODE opUShrAssign)) $(TD  -))

	$(TR $(TD ~=) $(TD no) $(TD $(CODE opCatAssign)) $(TD  -))

	$(TR $(TD in ) $(TD no ) $(TD $(CODE opIn) ) $(TD $(CODE opIn_r) ))

	)

	$(P Given a binary
	overloadable operator $(I op) and its corresponding
	class or struct member
	function name $(I opfunc) and $(I opfunc_r),
	and the syntax:
	)

---
a $(I op) b
---

	the following sequence of rules is applied, in order, to determine
	which form is used:

	$(OL 
	$(LI The expression is rewritten as both:
---
a.$(I opfunc)(b)
b.$(I opfunc_r)(a)
---
	If any $(I a.opfunc) or $(I b.opfunc_r) functions exist,
	then overloading is applied
	across all of them and the best match is used. If either exist,
	and there is no argument match, then it is an error.
	)

	$(LI If the operator is commutative, then the following
	forms are tried:
---
a.$(I opfunc_r)(b)
b.$(I opfunc)(a)
---
	)

	$(LI If $(I a) or $(I b) is a struct or class object reference,
	it is an error.
	)
	)

<h4>Examples</h4>

	$(OL 
	$(LI

-------
class A { int $(B opAdd)(int i); }
A a;
a + 1;	// equivalent to a.opAdd(1)
1 + a;	// equivalent to a.opAdd(1)
-------
	)
	$(LI

-------
class B { int $(B opDiv_r)(int i); }
B b;
1 / b;	// equivalent to b.opDiv_r(1)
-------
	)
	$(LI
-------
class A { int $(B opAdd)(int i); }
class B { int $(B opAdd_r)(A a); }
A a;
B b;
a + 1;	// equivalent to a.opAdd(1)
a + b;	// equivalent to b.opAdd_r(a)
b + a;	// equivalent to b.opAdd_r(a)
-------
	)
	$(LI
-------
class A { int $(B opAdd)(B b);  int $(B opAdd_r)(B b); }
class B { }
A a;
B b;
a + b;	// equivalent to a.opAdd(b)
b + a;	// equivalent to a.opAdd_r(b)
-------
	)
	$(LI
-------
class A { int $(B opAdd)(B b);  int $(B opAdd_r)(B b); }
class B { int $(B opAdd_r)(A a); }
A a;
B b;
a + b;	// ambiguous: a.opAdd(b) or b.opAdd_r(a)
b + a;	// equivalent to a.opAdd_r(b)
-------
	)
	)

<h3>Overloading == and !=</h3>

	$(P Both operators use the $(CODE $(B opEquals)()) function.
	The expression
	$(CODE (a == b)) is rewritten as $(CODE a.$(B opEquals)(b)),
	and $(CODE (a != b)) is rewritten as $(CODE !a.$(B opEquals)(b)).
	)

	$(P The member function $(CODE $(B opEquals)()) is defined as part of
	Object as:
	)

-------
$(V1 int)$(V2 bool) $(B opEquals)(Object o);
-------

	$(P so that every class object has a default $(CODE $(B opEquals)()).
	But every class definition which will be using == or != should
	expect to need to override opEquals. The parameter to the overriding
	function must be of type $(CODE Object), not the type for the class.
	)

	$(P Structs and unions (hereafter just called structs) can
	provide a member function:
	)

-------
$(V1 int)$(V2 bool) $(B opEquals)(S s)
-------
	$(P or:)
-------
$(V1 int)$(V2 bool) $(B opEquals)(S* s)
-------

	$(P where $(CODE S) is the struct name, to define how equality is
	determined.)

	$(P If a struct has no $(B opEquals) function declared for it,
	a bit compare of the contents of the two structs is done to
	determine equality or inequality.
	)

	$(P $(B Note:) Comparing a reference to a class object against $(B null)
	should be done as:
	)
-------
if (a is null)
-------
	$(P and not as:)
-------
if (a == null)
-------
	$(P The latter is converted to:)
-------
if (a.$(B opEquals)(null))
-------
	$(P which will fail if $(CODE $(B opEquals)()) is a virtual function.)

<h3>Overloading &lt;, &lt;=, &gt; and &gt;=</h3>

	$(P These comparison operators all use the $(CODE $(B opCmp)()) function.
	The expression
	$(CODE (a $(I op) b)) is rewritten as $(CODE (a.$(B opCmp)(b) $(I op) 0)).
	The commutative operation is rewritten as $(CODE (0 $(I op) b.$(B opCmp)(a)))
	)

	$(P The member function $(CODE $(B opCmp)()) is defined as part of Object
	as:
	)

-------
int $(B opCmp)(Object o);
-------

	$(P so that every class object has a $(CODE $(B opCmp)()).
	)

	$(P $(CODE $(B opCmp)) for structs works analogously to
	$(CODE $(B opEquals)) for structs:
	)
$(V1
-------
struct Pair {
  int a, b;
  int $(B opCmp)(Pair rhs) {
    if (a!=rhs.a)
      return a-rhs.a;
    return b-rhs.b;
  }
}
-------
)
$(V2
-------
struct Pair {
  int a, b;
  int $(B opCmp)(ref const Pair *rhs) const {
    if (a!=rhs.a)
      return a-rhs.a;
    return b-rhs.b;
  }
}
-------
)
	$(P If a struct has no $(CODE $(B opCmp)()) function declared for it,
	attempting
	to compare two structs is an error.
	)

<h4>Rationale</h4>

	$(P The reason for having both $(CODE $(B opEquals)) and
	$(CODE $(B opCmp)) is that:)

	$(UL
	$(LI Testing for equality can sometimes be a much more efficient
	operation than testing for less or greater than.)
	$(LI Having an $(CODE $(B opCmp)) defined in $(CODE Object)
	makes it possible to
	make associative arrays work generically for classes.)
	$(LI For some objects, testing for less or greater makes no sense.
	This is why $(CODE Object.$(B opCmp)) throws a runtime error.
	$(CODE $(B opCmp)) must be overridden in each class for which comparison
	makes sense.)
	)

	$(P The parameter to $(B opEquals) and $(B opCmp)
	for class definitions must
	be of type $(CODE Object), rather than the type of the particular class,
	in order to override the $(CODE Object.$(B opEquals)) and
	$(CODE Object.$(B opCmp))
	functions properly.
	)

<h2><a name="FunctionCall">Function Call Operator Overloading $(I f)()</a></h2>

	$(P The function call operator, (), can be overloaded by
	declaring a function named $(B opCall):
	)

-------
struct F {
  int $(B opCall)();
  int $(B opCall)(int x, int y, int z);
}

void test() {
  F f;
  int i;

  i = f$(B ());    // same as i = f.opCall();
  i = f$(B (3,4,5));  // same as i = f.opCall(3,4,5);
}
-------

	$(P In this way a struct or class object can behave as if it
	were a function.
	)

<h2><a name="Array">Array Operator Overloading</a></h2>

<h3>Overloading Indexing $(I a)[$(I i)]</h3>

	$(P The array index operator, [], can be overloaded by
	declaring a function named $(B opIndex) with one
	or more parameters.
	Assignment to an array can be overloaded with a function
	named $(B opIndexAssign) with two or more parameters.
	The first parameter is the rvalue of the assignment expression.
	)

-------
struct A {
  int $(B opIndex)(size_t i1, size_t i2, size_t i3);
  int $(B opIndexAssign)(int value, size_t i1, size_t i2);
}

void test() {
  A a;
  int i;

  i = a$(B [)5,6,7$(B ]); // same as i = a.opIndex(5,6,7);
  a$(B [)i,3$(B ]) = 7;   // same as a.opIndexAssign(7,i,3);
}
-------

	$(P In this way a struct or class object can behave as if it
	were an array.
	)

$(V1
	$(P $(B Note:) Array index overloading currently does not
	work for the lvalue of an $(I op)=, ++, or -- operator.
	)
)
$(V2
	$(P $(B Note:) To use array index overloading
	with the $(I op)=, ++, or -- operators,
	have the opIndex function return a reference type.
	This reference is then used as the lvalue for those operators.
	)
)

<h3>Overloading Slicing $(I a)[] and $(I a)[$(I i) .. $(I j)]</h3>

	$(P Overloading the slicing operator means overloading expressions
	like $(CODE a[]) and $(CODE a[i .. j]).
	This can be done by declaring a function named $(B opSlice).
	Assignment to a slice can be done by declaring $(B opSliceAssign).
	)

-------
class A {
  int $(B opSlice)();                   // overloads a[]
  int $(B opSlice)(size_t x, size_t y); // overloads a[i .. j]

  int $(B opSliceAssign)(int v); // overloads a[] = v
  int $(B opSliceAssign)(int v, size_t x, size_t y); // overloads a[i .. j] = v
}

void test() {
  A a = new A();
  int i;
  int v;

  i = a$(B []);  // same as i = a.opSlice();
  i = a$(B [)3..4$(B ]); // same as i = a.opSlice(3,4);

  a$(B []) = v;          // same as a.opSliceAssign(v);
  a$(B [)3..4$(B ]) = v; // same as a.opSliceAssign(v,3,4);
}
-------

<h2><a name="Assignment">Assignment Operator Overloading</a></h2>

	$(P The assignment operator $(CODE =) can be overloaded if the
	lvalue is a struct $(V1 or class) aggregate, and $(CODE opAssign)
	is a member function of that aggregate.)

	$(P The assignment operator cannot be overloaded for rvalues
	that can be implicitly cast to the lvalue type.
	Furthermore, the following parameter signatures for $(CODE opAssign)
	are not allowed:)

---
opAssign(...)
opAssign(T)
opAssign(T, ...)
opAssign(T ...)
opAssign(T, U = defaultValue, etc.)
---

	$(P where $(I T) is the same type as the aggregate type $(I A),
	is implicitly
	convertible to $(I A), or if $(I A) is a struct and $(I T)
	is a pointer to a type that is
	implicitly convertible to $(I A).
	)

$(V2
$(DOT
<h2><a name="Dot">Forwarding</a></h2>

	$(P Providing a struct or class member function $(CODE opDot) enables
	the forwarding
	of any names not found in the struct's scope to be forwarded
	to the return type of the $(CODE opDot) function. In other words:
	)

---
struct T {
  ...
  S opDot() { ... }
}
T t;
...
t.m
---

	$(P is rewritten as:)

---
t.opDot().m
---

	$(P if m does not exist as a member of the struct T.)

	$(P The members .sizeof, .init, .offsetof, .alignof, .mangleof
	and .stringof are not forwarded to $(CODE opDot).)

---
struct S {
  int a, b, c;
}

struct T {
  S s;
  int b = 7;

  S* opDot() {
    return &s; // forwards to member s
  }
}

void main() {
  T t;
  t.a = 4;
  t.b = 5;
  t.c = 6;
  assert(t.a == 4);
  assert(t.b == 5);    // T.b overrides S.b
  assert(t.c == 6);
  assert(t.s.b == 0);
  assert(t.sizeof == 4*4); // sizeof T, not sizeof S
}
---
)
)

<h2><a name="Future">Future Directions</a></h2>

	$(P The operators $(CODE ! && || ?:) and a few others will
	likely never be overloadable.
	)
)
)

Macros:
	TITLE=演算子オーバーロード
	WIKI=OperatorOverloading
	CATEGORY_SPEC=$0
	SUB=<sub>$0</sub>
	ARGUMENTS=$(I b)$(SUB 1), $(I b)$(SUB 2), ... $(I b)$(SUB n)
	SLICE=$(I i)..$(I j)
	SLICE2=$(I i), $(I j)
	FOO=