[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进来的顺序执行？