D语言的模板

D语言的模板使用非常方便灵活，受够了C＋＋模板编写之苦的同学们可以感受一下D语言的模板，下面先展示一个D语言编写的多分派委托类，在我的旧BLOG上曾经写过一个C＋＋版本的，整个过程感觉非常痛苦。。。

闲话少说，请看代码：

import std.stdio;


template DelegateHandlers(HandlerType, FunctionType)
{
    HandlerType[] handlers;
    FunctionType[] functions;

    void opAddAssign(HandlerType h)
    {
        handlers.length = handlers.length + 1;
        handlers[length-1] = h;
    }
    void opAddAssign(FunctionType f)
    {
        functions.length = functions.length + 1;
        functions[length-1] = f;
    }
}

template Delegate(Ret)
{
    class Delegate
    {
        alias Ret delegate () HandlerType;
        alias Ret function () FunctionType;
        mixin DelegateHandlers!(HandlerType, FunctionType);

        static if(is(Ret: void))
        {
            void opCall ()
            {
                foreach (HandlerType handler; handlers)
                    handler ();
                foreach (FunctionType _function; functions)
                    _function ();
            }
        }
        else
        {
            Ret opCall ()
            {
                Ret ret;
                foreach (HandlerType handler; handlers)
                    ret = handler ();
                foreach (FunctionType _function; functions)
                    ret = _function ();
                return ret;
            }
        }

    }
}

template Delegate(Ret, Arg1)
{
    class Delegate
    {
        alias Ret delegate (Arg1) HandlerType;
        alias Ret function (Arg1) FunctionType;
        mixin DelegateHandlers!(HandlerType, FunctionType);

        static if(is(Ret: void))
        {
            void opCall (Arg1 a1)
            {
                foreach (HandlerType handler; handlers)
                    handler (a1);
                foreach (FunctionType _function; functions)
                    _function (a1);
            }
        }
        else
        {
            Ret opCall (Arg1 a1)
            {
                Ret ret;
                foreach (HandlerType handler; handlers)
                    ret = handler (a1);
                foreach (FunctionType _function; functions)
                    ret = _function (a1);
                return ret;
            }
        }

    }
}


class Test
{
    void test ()
    {
        writefln ("Test.test");
    }
    int test1 ()
    {
        writefln ("Test.test1");
        return 1;
    }
    void test2(int v)
    {
        writefln ("Test.test2");
    }
    int test3(int v)
    {
        writefln ("Test.test3");
        return 7;
    }
}

void test_func ()
{
    writefln ("test_func");
}
int test_func1 ()
{
    writefln ("test_func1");
    return 2;
}
void test_func2(int v)
{
    writefln ("test_func2");
}
int test_func3(int v)
{
    writefln ("test_func3");
    return 9;
}

void main()
{
    Test t = new Test;

    alias Delegate!(void) DDD;
    DDD d = new DDD;
    d += &t.test;
    d += &test_func;

    d ();

    alias Delegate!(int) DDD1;
    DDD1 d1 = new DDD1;
    d1 += &t.test1;
    d1 += &test_func1;

    int a = d1 ();
    assert (a == 2);

    alias Delegate!(void, int) DDD2;
    DDD2 d2 = new DDD2;
    d2 += &t.test2;
    d2 += &test_func2;

    d2 (1);

    alias Delegate!(int, int) DDD3;
    DDD3 d3 = new DDD3;
    d3 += &t.test3;
    d3 += &test_func3;

    int b = d3 (2);
    assert (b == 9);
}

非常干净，非常简洁，不是吗？这个只花了我10分钟时间来写。。。

D语言的委托非常高效，有兴趣的可以测试一下通过委托和直接调用之间的性能差别。上面这个自己实现的多分派委托类，效率也非常高，我的测试结果是对于性能的影响几乎可以忽略。想起那个历尽千辛万苦实现的C＋＋多分派委托类，实现复杂、调试费时、运行效率还很低，每每一想到这心里那个难受啊。。。。

再来看一下D语言强大的静态检查机制：

template XXX (int v)
{
    int n = v;
    static assert (v > 3);
}

void main ()
{
    int n;
    n = XXX!(4).n; // OK
    n = XXX!(3).n; // 编译错误
}

同样很漂亮。

如果你觉得提示信息不够友好，可以修改为：

template XXX (int v)
{
    int n = v;
    static if (v <= 3)
        pragma (msg, "template value must > 3");
    static assert (v > 3);
}

这是编译时的错误提示：

Compiling test.d ...
template value must > 3
D:\workspace\dace\test.d(94): static assert  (3 > 3) is false
D:\workspace\dace\test.d(173): template instance test.XXX!(3) error instantiating

我想以后有可能会扩充pragma，支持错误输出，这样就不用写重复的语句了，可以简化成这样：

template XXX (int v)
{
    int n = v;
    static if (v <= 3)
        pragma (error, "template value must > 3");
}

这样看起来更好。不过目前有很多重要特性要实现，这种玩意可能要很久以后才会加入了。