[D语言] DMD 0.168发布

新特性：
1、给委托增加ptr属性，指向委托所绑定的对象。
这是一个语法糖，dg.ptr被转化为cast(void*)dg，它只能作右值，所以除了能读取它以外，在语法上禁止对它赋值。要想把委托绑定到不同的对象，你只能自己实现：

<!---->class Foo{
    int foo;
public:
    this(int foo){
        this.foo = foo;
    }

    void bar(){
        writefln(foo);
    }
}

void main(){

    alias void delegate() DG;
    DG dg = &(new Foo(1)).bar;

    Foo[10] foos;
    foreach(int i, inout Foo foo; foos){
        foo = new Foo(i);
    }

    void** ptr = cast(void**)&dg;
    foreach(Foo foo; foos){
        *ptr = cast(void*)foo;
        dg();
    }
}

这种方式也不是我们所希望的，一般来说委托绑定到多个对象时，因为是取到某成员函数指针，再进行绑定。比如模拟一个ActiveSupport所扩展的一个ruby.Array#map用法：

<!---->import std.stdio;

class Foo{
    int foo;
public:
    this(int foo){
        this.foo = foo;
    }

    void bar(){
        writefln(foo);
    }
}

class Array(T){
    private:
    T[] data;

    public:
    this(T[] data){
        this.data = data[0 .. length];
    }

    void map(void function() func){
        void delegate() dg;
        void** funcPtr = cast(void**)&dg + 1;
        *funcPtr = func;
        void ** ptr = cast(void**)&dg;
        foreach(T v; data){
            *ptr = cast(void*)v;
            dg();
        }
    }
}

void main(){
    auto arr = new Array!(Foo)([new Foo(1), new Foo(2), new Foo(3)]);
    arr.map(&Foo.bar);
}

是的，delegate内部保存了2个指针，所以我们可以容易地hack它。

[注：上面的main函数中数组直接量赋给栈对象也是这个版本中新增的内容，显然只能用于static对象是很鸡肋的。这里简单带过不提。]

[注：上面这个map的模拟并不是ActiveSupport的map扩展的全部用途，那个map还是收集返回值，这里只演示调用语法。ActiveSupport中扩展的map调用语法是map(&:to_s)，就可以收集到数组中所有元素调用to_s后的返回值。]

2、给内嵌内的实例增加outer属性，指向外层对象。

<!---->import std.stdio;

class Outer{
    class Inner{}

    this(){
        Inner inner = new Inner;
        inner.outer.foo();
    }

    void foo(){
        writefln("foo");
    }
}

void main(){
    Outer outer = new Outer;
}

这个特性可能应用并不是很广吧。

3、mixin多个析构函数。

<!---->template A(){
    this(){
    }
    ~this(){
        writefln("A::~A()");
    }
}

template B(){
    ~this(){
        writefln("B::~B()");
    }
}

class C{
    mixin A;
    mixin B;
}

void main(){
    C c = new C;
    delete c;
}

这些析构函数会和mixin相反的顺序执行。我不明白的是，为什么不让mixin多个构造函数？为何不让这些构造函数晚于被mixin的类（上面的C类）的构造函数，并按mixin进来的顺序执行？