查看完整版本: 20 D语言 模板混入 Templates Mixins

20 D语言 模板混入 Templates Mixins

20 D语言 模板混入 Templates Mixins知识若不分享 实在没有意义　http://www.d-programming-language-china.org　20070424点击下面网址查看原文:http://www.d-programming-language-china.org        by:        uFramer        D语言论坛 http://www.d-programming-language-china.org        from:        http://www.digitalmars.com/d/template-mixin.html        version:        基于D 1.013        (Apr 19, 2007)        在D中，一个混入从一个 模版声明 的过程体内提取一个任意的声明集合，并将它们插入到当前的上下文中。        QUOTE:                                模板混入:                    mixin 模板标志符 ;                    mixin 模板标志符 混入标志符 ;                    mixin 模板标志符 !( 模版参数列表 ) ;                    mixin 模板标志符 !( 模版参数列表 ) 混入标志符 ;                                混入标志符:                    标志符                                TemplateMixin:                    mixin TemplateIdentifier ;                    mixin TemplateIdentifier MixinIdentifier ;                    mixin TemplateIdentifier !( TemplateArgumentList ) ;                    mixin TemplateIdentifier !( TemplateArgumentList ) MixinIdentifier ;                                MixinIdentifier:                    Identifier                模版混入 可以出现在模块、类、结构、联合以及语句的声明列表中。模板标志符 是一个 模版声明 。如果 模版声明 没有参数，就可以使用不带 !(模版参数列表) 的混入形式。        不像模板具现化，模板混入的过程体在混入所在的作用域内计算，而不是在定义模板声明的地方。这等价于使用剪切和粘贴将模版的过程体插入混入的位置。这对注入参数化的‘样板文件’是有用的，同时对创建模板化嵌套函数也很有用，而正常情况下是不可能具现化嵌套函数的。        [Copy to clipboard] [ - ]CODE:                                template Foo()                {                    int x = 5;                }                                mixin Foo;                                struct Bar                {                    mixin Foo;                }                                void test()                {                    printf("x = %d\n", x);        // prints 5                    {    Bar b;                        int x = 3;                                        printf("b.x = %d\n", b.x);    // prints 5                        printf("x = %d\n", x);        // prints 3                        {                            mixin Foo;                            printf("x = %d\n", x);    // prints 5                            x = 4;                            printf("x = %d\n", x);    // prints 4                        }                        printf("x = %d\n", x);        // prints 3                    }                    printf("x = %d\n", x);        // prints 5                }                混入可以被参数化：        [Copy to clipboard] [ - ]CODE:                                template Foo(T)                {                    T x = 5;                }                                mixin Foo!(int);        // create x of type int                混入可以可以为类添加虚函数：        [Copy to clipboard] [ - ]CODE:                                template Foo()                {                    void func() { printf("Foo.func()\n"); }                }                                class Bar                {                    mixin Foo;                }                                class Code : Bar                {                    void func() { printf("Code.func()\n"); }                }                                void test()                {                    Bar b = new Bar();                    b.func();        // calls Foo.func()                                    b = new Code();                    b.func();        // calls Code.func()                }                混入在它们出现的地方被求值，而不是在模板声明的地方：        [Copy to clipboard] [ - ]CODE:                                int y = 3;                                template Foo()                {                    int abc() { return y; }                }                                void test()                {                    int y = 8;                    mixin Foo;    // local y is picked up, not global y                    assert(abc() == 8);                }                混入可以使用别名参数来参数化符号：( 本文出处: http://www.d-programming-language-china.org )        [Copy to clipboard] [ - ]CODE:                                template Foo(alias b)                {                    int abc() { return b; }                }                                void test()                {                    int y = 8;                    mixin Foo!(y);                    assert(abc() == 8);                }                这个例子使用了一个混入来为任意语句实现一个泛型 Duff's Device（在这里，那个语句采用粗体表示）。在生成一个嵌套函数的同时也生成了一个委托文字量，他们会通过编译器内联：( 本文出处: http://www.d-programming-language-china.org )        [Copy to clipboard] [ - ]CODE:                                template duffs_device(alias id1, alias id2, alias s)                {                    void duff_loop()                    {                    if (id1 < id2)                    {                        typeof(id1) n = (id2 - id1 + 7) / 8;                        switch ((id2 - id1) % 8)                        {                        case 0:    do {    s();                        case 7:    s();                        case 6:    s();                        case 5:    s();                        case 4:    s();                        case 3:    s();                        case 2:    s();                        case 1:    s();                                    } while (--n > 0);                        }                    }                    }                }                                void foo() { printf("foo\n"); }                                void test()                {                    int i = 1;                    int j = 11;                                    mixin duffs_device!(i, j, delegate { foo(); } );                    duff_loop();    // executes foo() 10 times                }        Mixin Scope混入作用域        混入中的声明被‘导入’到周围的作用域中。如果混入和其周围的作用域中有相同的名字，周围的作用域中的声明将覆盖混入中的那个声明：        [Copy to clipboard] [ - ]CODE:                                int x = 3;                                template Foo()                {                    int x = 5;                    int y = 5;                }                                mixin Foo;                int y = 3;                                void test()                {                    printf("x = %d\n", x);    // 打印出 3                    printf("y = %d\n", y);    // 打印出 3                }                如果两个不同的混入被放入同一个作用域，并且他们中定义了同名的声明，就会出现模棱两可的错误：        [Copy to clipboard] [ - ]CODE:                                template Foo()                {                    int x = 5;                    void func(int x) { }                }                                template Bar()                {                    int x = 4;                    void func() { }                }                                mixin Foo;                mixin Bar;                                void test()                {                    printf("x = %d\n", x);    // error, x is ambiguous                    func();        // error, func is ambiguous                }                The call to func() is ambiguous because Foo.func and Bar.func are in different scopes.        如果一个混入中有 混入标志符 ，它可以用来消除歧义：( 本文出处: http://www.d-programming-language-china.org )        [Copy to clipboard] [ - ]CODE:                                int x = 6;                                template Foo()                {                    int x = 5;                    int y = 7;                    void func() { }                }                                template Bar()                {                    int x = 4;                    void func() { }                }                                mixin Foo F;                mixin Bar B;                                void test()                {                    printf("y = %d\n", y);    // prints 7                    printf("x = %d\n", x);    // prints 6                    printf("F.x = %d\n", F.x);    // prints 5                    printf("B.x = %d\n", B.x);    // prints 4                    F.func();            // calls Foo.func                    B.func();            // calls Bar.func                }                Alias declarations can be used to overload together functions declared in different mixins:        [Copy to clipboard] [ - ]CODE:                                template Foo()                {                    void func(int x) {    }                }                                template Bar()                {                    void func() {    }                }                                mixin Foo!() F;                mixin Bar!() B;                                alias F.func func;                alias B.func func;                                void main()                {                    func();    // calls B.func                    func(1);    // calls F.func                }                混入有其自身的作用域，尽管声明会被外围的声明覆盖：        [Copy to clipboard] [ - ]CODE:                                int x = 4;                                template Foo()                {                    int x = 5;                    int bar() { return x; }                }                                mixin Foo;                                void test()                {                    printf("x = %d\n", x);        // 打印出 4                    printf("bar() = %d\n", bar());    // 打印出 5                }        d-programming-language-china.org整理手记：英文本身比编程更重要        原来的D语言文档翻译于2004年到2005年，现在是20070425，D语言语法已经有一些变化和改进。原来的一些代码例子已经不适合的，改为新的例子，如果一样则不动。新增加的内容，一般是直接给出英文。因为一则d-programming-language-china.org对D语言还不是很熟悉，二则，英文本身比编程更重要。如果可能的话，尽量阅读全英文的文档。        在整理这个D语言文档的过程中，d-programming-language-china.org收获不小，原来的编程知识多是结构化编程的，现在对面向对象编程也有一些了解了。还有和不少英文单词混了个面熟。( lastupdate:20070426　最新文章请访问http://www.d-programming-language-china.org )关于一大步成功社区:yidabu提倡在交流中学习，在分享中提高收集感兴趣的知识，写下心得，通过网络与别人一起分享理解一点就实践一步，收获什么就分享什么，成功就是这样一点点一步步累积起来的网络只是一个工具，只有自己身心提高才是实实在在的。d-programming-language-china.org为大家提供一个学习交流各种知识的平台