D語言遊戲編程（10）：D語言基礎之函數和操作符重載

關於D語言的函數和操作符重載：
1. 不需要聲明虛函數，默認所有成員函數都爲虛函數，編譯器會自動優化；
2. 函數參數支持in, out, inout等修飾符；
3. 支持函數指針，不支持類成員函數指針，但是支持更方便的方式－－委託（delegate）。
4. 支持豐富的操作符重載

下面是一些特性的演示代碼。

import std.stdio;

void main()
...{
    tryFunction();
    tryOperator();
}

// functions
//--------------------------------------
class MyBaseClass
...{
    void func(int a)
    ...{
        writefln("MyBaseClass.func");
    }
    final public void finalFunc()
    ...{
        writefln("MyBaseClass.finalFunc");
    }
    
    void overrideFunc()
    ...{
        writefln("MyBaseClass.overrideFunc");
    }
}

class MySubClass : MyBaseClass
...{
    void func(int a)    // 自動變爲virtual
    ...{
        writefln("MySubClass.func");
    }
    
    void finalFunc() //???
    ...{
        writefln("MySubClass.finalFunc");
    }
    
    override void overrideFunc()
    ...{
        writefln("MySubClass.overrideFunc");
    }
}

// function parameters
//-------------------------------------------
void myFunc(in float x, out float y, inout float z)
...{
    x = 5;
    y = 6;
    z = 7;
}

// Function Pointers
void function(in float x, out float y, inout float z) fp;

void tryFunction()
...{
    MySubClass s = new MySubClass;
    s.func(1);
    s.finalFunc();
    s.overrideFunc();
    
    MyBaseClass b = s;
    b.func(1);    // 調用派生類的func
    b.finalFunc();    // 調用基類的finalFunc
    b.overrideFunc(); // 調用派生類的overrideFunc
    
    float x,y,z;
    myFunc(x,y,z);
    writefln("x = ", x,
            ", y = ", y,
            ", z = ",z);
            
    fp = &myFunc;
    writefln(fp);
    
    // delegate
    //------------------------
    void delegate(int a) dg;
    dg = &s.func;
    dg(1);
    writefln(dg.ptr);
    writefln(dg.funcptr);

}

// Operator Overloading
//----------------------------------
class TestClass
...{
    // 一元操作符(Unary Operator)
    void opNeg()
    ...{
        writefln("TestClass.opNeg");
    }
    
    // 二元操作符(Binary Operator)
    void opAdd(int i)
    ...{
        writefln("TestClass.opAdd");
    }
    void opAdd_r(int i)
    ...{
        writefln("TestClass.opAdd_r");
    }
    
    // ==和!=都調用這一個函數
    int opEquals(int i)
    ...{
        writefln("TestClass.opEquals");
        return 1;
    }
    
    // <, <=, > 和 >=都調用下面這個函數
    int opCmp(int i)
    ...{
        return i;
    }
}

struct MyStruct
...{
    int x,y;
    
    static MyStruct opCall(int xx, int yy)
    ...{
        MyStruct ret;
        ret.x = xx;
        ret.y = yy;
        return ret;
    }
    
    // Array Operator Overloading
    //------------------------------
    int opIndex(int i)
    ...{
        assert(i>=0 && i<2);
        if(i == 0)
            return x;
        else
            return y;
    }
    
    void opIndexAssign(int value, int i)
    ...{
        assert(i>=0 && i<2);
        if(i == 0)
            x = value;
        else
            y = value;
    }
    
    // Assignment Operator Overloading
    void opAssign(int value)
    ...{
        x = value;
        y = value;
    }
}

void tryOperator()
...{
    TestClass t = new TestClass;
    
    -t;    // 調用TestClass.opNeg
    
    t + 1;    // 調用TestClass.opAdd
    1 + t;    // 調用TestClass.opAdd_r
    
    // 調用TestClass.opEquals
    int b = t != 1;
    t == 1;
    
    // 調用TestClass.opCmp
    bool r1 = t >= 1; // 相當於“t.opCmp(1) > 0”
    bool r2 = t >= -1;
    writefln(r1, ", ", r2);
    
    //
    MyStruct s = MyStruct(99,98);    // 調用MyStruct.opCall
    int x = s[0];    // 調用MyStruct.opIndex
    writefln(x);
    
    s[0] = 100;    // 調用MyStruct.opIndexAssign
    writefln(s.x);
    
    s = 101;    // 調用MyStruct.opAssign
    writefln(s.y);
}