混入混入（Mixins） 意味着用不同的编程语言表达的不同的事物。 在D中，一个混入从一个 模版声明 的过程体内提取一个任意的声明集合，并将它们插入到当前的上下文中。 模板混入:
mixin 模板标志符 ;
mixin 模板标志符 混入标志符 ;
mixin 模板标志符 !( 模版参数列表 ) ;
mixin 模板标志符 !( 模版参数列表 ) 混入标志符 ;
混入标志符:
标志符
TemplateMixin:
mixin TemplateIdentifier ;
mixin TemplateIdentifier MixinIdentifier ;
mixin TemplateIdentifier !( TemplateArgumentList ) ;
mixin TemplateIdentifier !( TemplateArgumentList ) MixinIdentifier ;
MixinIdentifier:
Identifier
模版混入 可以出现在模块、类、结构、联合以及语句的声明列表中。模板标志符 是一个 模版声明 。如果 模版声明 没有参数，就可以使用不带 !(模版参数列表) 的混入形式。
不像模板具现化，模板混入的过程体在混入所在的作用域内计算，而不是在定义模板声明的地方。这等价于使用剪切和粘贴将模版的过程体插入混入的位置。这对注入参数化的‘样板文件’是有用的，同时对创建模板化嵌套函数也很有用，而正常情况下是不可能具现化嵌套函数的。 template Foo()
{
int x = 5;
}
mixin Foo;
struct Bar
{
mixin Foo;
}
void test()
{
printf("x = %d\n", x); // 打印出 5
{ Bar b;
int x = 3;
printf("b.x = %d\n", b.x); // 打印出 5
printf("x = %d\n", x); // 打印出 3
{
mixin Foo;
printf("x = %d\n", x); // 打印出 5
x = 4;
printf("x = %d\n", x); // 打印出 4
}
printf("x = %d\n", x); // 打印出 3
}
printf("x = %d\n", x); // 打印出 5
}
混入可以被参数化： template Foo(T)
{
T x = 5;
}
mixin Foo!(int); // 创建类型为 int 的 x
混入可以可以为类添加虚函数： 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(); // 调用 Foo.func()
b = new Code();
b.func(); // 调用 Code.func()
}
混入在它们出现的地方被求值，而不是在模板声明的地方： int y = 3;
template Foo()
{
int abc() { return y; }
}
void test()
{
int y = 8;
mixin Foo; // 使用的是局部的 y ，而不是全局的 y
assert(abc() == 8);
}
混入可以使用别名参数来参数化符号： template Foo(alias b)
{
int abc() { return b; }
}
void test()
{
int y = 8;
mixin Foo!(y);
assert(abc() == 8);
}
这个例子使用了一个混入来为任意语句实现一个泛型 Duff's Device（在这里，那个语句采用粗体表示）。在生成一个嵌套函数的同时也生成了一个委托文字量，他们会通过编译器内联： 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(); // 执行 foo() 10 次
}
混入作用域混入中的声明被‘导入’到周围的作用域中。如果混入和其周围的作用域中有相同的名字，周围的作用域中的声明将覆盖混入中的那个声明： 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
}
如果两个不同的混入被放入同一个作用域，并且他们中定义了同名的声明，就会出现模棱两可的错误：
template Foo()
{
int x = 5;
}
template Bar()
{
int x = 4;
}
mixin Foo;
mixin Bar;
void test()
{
printf("x = %d\n", x); // 错误，x 模棱两可
}
如果一个混入中有 混入标志符 ，它可以用来消除歧义： int x = 6;
template Foo()
{
int x = 5;
int y = 7;
}
template Bar()
{
int x = 4;
}
mixin Foo F;
mixin Bar B;
void test()
{
printf("y = %d\n", y); // 打印出 7
printf("x = %d\n", x); // 打印出 6
printf("F.x = %d\n", F.x); // 打印出 5
printf("B.x = %d\n", B.x); // 打印出 4
}
混入有其自身的作用域，尽管声明会被外围的声明覆盖： 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
}
|
