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);
}