a is b
是操作符.is(...)
是表达式.
是表达式,确定表达式是否为真
.在static if
和限制模板
时特别有用.
is(T)
,确定T是个有效类型.
static if (is (int)) {
writeln("valid");
} else {
writeln("invalid");
}
整数有效
.void
不能作为关联类型的键类型.
static if (is (string[void])) {//假
writeln("valid");
} else {//真
writeln("invalid");
}
is (T Alias)
.是T,然后在语句块中用Alias
static if (is (int NewAlias)) {
writeln("valid");
NewAlias var = 42; // int == NewAlias
} else {
writeln("invalid");
}
在有更复杂的is
表达式中有用.
is (T : OtherT)
,T是否是个OtherT类型
,或者T
是否能转为OtherT
类型.
import std.stdio;
interface Clock {
void tellTime();
}
class AlarmClock : Clock {
override void tellTime() {
writeln("10:00");
}
}
void myFunction(T)(T parameter) {
static if (is (T : Clock)) {//如果是个`钟`
writeln("这是钟;我们可告诉时间");
parameter.tellTime();
} else {
writeln("这不是钟");
}
}
void main() {
auto var = new AlarmClock;
myFunction(var);
myFunction(42);
}
is (T Alias : OtherT)
,如果T/Alias
可转为OtherT
.
is (T == Specifier)
,如T为限定器
类型,精确的类型.
static if (is (T == Clock)) {//完全相同的钟
writeln("这是钟;我们可讲时间");
parameter.tellTime();
} else {
writeln("这不是钟");
}
限定符可为struct union class interface enum function delegate const immutable shared
void myFunction(T)(T parameter) {
static if (is (T == class)) {
writeln("这是类类型");
} else static if (is (T == enum)) {
writeln("这是枚类型");
} else static if (is (T == const)) {
writeln("这是常类型");
} else {
writeln("这是其他类型");
}
}
这是大致的限制.这样模板
可根据不同参数类型而变化.
is (T 别名 == Specifier)
Specifier可为struct union class interface super enum function delegate return 双下划线parameters const immutable shared
只要类型满足这些限定符,就可以了.
auto var = new AlarmClock;
myFunction(var);
// (enum WeekDays见下面)
myFunction(WeekDays.Monday);
const double number = 1.2;
myFunction(number);myFunction(42);
定义些结构:
struct Point {
// ...
}
interface Clock {
// ...
}
class AlarmClock : Clock {
// ...
}
enum WeekDays {
Monday, Tuesday, Wednesday, Thursday, Friday,
Saturday, Sunday
}
char foo(double d, int i, Clock c) {
return 'a';
}
然后:
void myFunction(T)(T parameter) {
static if (is (T LocalAlias == struct)) {
//用不同限定符,相当于加了句`alias Loc... = T;
writefln("\n--- struct ---");
writefln("复制它来构造个新%s对象.",LocalAlias.stringof);
LocalAlias theCopy = parameter;
}
static if (is (T baseTypes == super)) {
writeln("\n--- super ---");
//如果T为父(基)类型.
writefln("class %s has %s base types.",
T.stringof, baseTypes.length);
writeln("所有基: ", baseTypes.stringof);
writeln("最高基: ", baseTypes[0].stringof);
}
static if (is (T ImplT == enum)) {
writeln("\n--- enum ---");//T为枚举类型
writefln("The implementation type of enum %s is %s",T.stringof, ImplT.stringof);
}
static if (is (T ReturnT == return)) {
writeln("\n--- return ---");
//函数返回类型指针
writefln("带%s返回类型的函数:",ReturnT.stringof);
writeln(" ", T.stringof);
write("调用它... ");
ReturnT result = parameter(1.5, 42, new AlarmClock);
//T为返回类型
writefln("结果为'%s'", result);
}
}
//调用
myFunction(Point());//构对象
myFunction(new AlarmClock);// 类引用
myFunction(WeekDays.Monday);// 枚举
myFunction(&foo);//函数指针
is (/* ... */ Specifier, TemplateParamList)
四种语法:
is (T : Specifier, TemplateParamList)
is (T == Specifier, TemplateParamList)
is (T identifier : Specifier, TemplateParamList)
is (T identifier == Specifier, TemplateParamList)
:
相当于继承,==
完全相同,限定符,具体限定类型
模板参数列表,自身也是条件,如条件满足,也可定义额外别名,与推导模板类型一样
static if (is (T == Value[Key], // (1)
Value, // (2)
Key : string)) { // (3)
is
需要满足是键为串的关联数组
.
1,T为值[键]
类型.
2,值
为类型.
3,键
为串
类型.
示例:
import std.stdio;
void myFunction(T)(T parameter) {
writefln("\n--- Called with %s ---", T.stringof);
static if (is (T == Value[Key],Value,Key : string)) {
//更多限制(,,,)
writeln("Yes,满足条件.");
writeln("value type: ", Value.stringof);
writeln("key type : ", Key.stringof);
} else {
writeln("No,不满足.");
}
}
void main() {
int number;myFunction(number);
int[string] intTable;myFunction(intTable);
double[string] doubleTable;
myFunction(doubleTable);
dchar[long] dcharTable;
myFunction(dcharTable);
}