关键字

6/21更新
[color=red]5/16更新[/color]
dmd2.0分类下的文章都将作为技术累积出现，既方便自己也方便大家检索，所以以后不会写各种类似的小文章，欢迎大家随时提供各种经验和技巧，我都将及时更新，并公示贡献人。
希望两三年后这里的文章能集成一本很好的入门书籍共大家下载。

各类文章如有更新都会在文章的最开始处标示更新日期，以方便大家辨认，内容上将尽量保持两次更新并以不同颜色显示，以方便大家阅读最新内容。

2.013中共103个

未来一些技巧性用法将索引到这里，免得书上到处找。

    abstract
    不能被直接实例化。它只能被当作另一个非抽象类的基类进行实例化。 
    类被定义时，内部有一个抽象属性(abstract attribute)，或者在它内部的某些虚成员函数被声明成抽象的，那么这个类就是抽象的。

    非虚函数不能被声明成抽象的。

    函数声明成抽象的仍然可以拥有函数体。这就是为什么即使它们必须被重写(override)，仍然能够提供“基类功能。” 


    alias 别名 （尽量别用）
    1、 类型别名  别名类型在语义上等价于原类型。
    2、别名声明  符号可以被声明为另一个符号的“别名”。例如：
       import string;
       alias string.strlen mylen;
        ...
       int len = mylen("hello"); // 实际上调用的是 string.strlen()

     3、别名可以用来从模块中‘导入’一个符号到当前作用域：
     alias string.strlen strlen;

     4、别名不能用于表达式：
     5、类型别名有时会同别名声明十分相似：
      alias foo.bar abc; // 它是一个类型还是一个符号？
              在语义分析是将会区分这两种情况。

    align对齐属性：？？？
    align ( Integer )
    指定结构成员如何对齐。“对齐属性”用于兼容 C ABI

    asm
    assert

    auto 属性     
    用于局部变量和类声明。

	body
	bool
	break
	byte

	case

    cast属性： 类型转换，除此还可用于类的实例判断：
       if (cast(B) o)
           // o 是 B 的一个实例
       else
           //o 不是 B 的一个实例           5/16
       catch

    cdouble
    cent
    cfloat
    char
    class

    const：
    声明可以在编译时进行求值的常量。
    没有初始值的 const 声明在构造函数里（对于类字段）或者在静态构造函数里（对于静态类成员或模块变量声明）必须被初始化。（1.0文档）

    continue
    creal

    dchar
    debug
    default
    delegate
    delete

     deprecated 废弃属性
     保持向后兼容。这类声明可以被标记为废弃，可以通过设置编译器选项，在遇到引用这类声明的代码时产生错误： 

    do
    double

    else
    enum

    export（导出属性）
     表示可执行程序外的任何代码都可以访问这个成员。导出的意思也就是从DLL 中导 出定义。

    extern连接属性(Linkage Attribute)
      extern ( 连接类型 ) 
      D 提供了一种方便的调用 C 函数和操作系统 API 函数的方法。
      extern (C):
      int foo(); // 使用 C 协定调用 foo() 

      对于c，常见的有：         （Colorful 贡献）
      stdcall 对应 extern (Windows): 
      cdecl（默认） 对应 extern (C):
      fastcall 无
      thiscall 。。
      naked call 。。
        本质上指的就是函数参数压栈顺序。

       Windows API 调用约定是： 
       extern (Windows):
       void *VirtualAlloc
      ( 
          。。。
       ); 
带有存储类别 extern 的变量声明不会在该模块里分配存储空间。它们在其它某个目标文件
里被定义，而且要求跟要连接的名称相匹配。它的基本用法就是用于连接在 C 文件里定义
的全局变量。

	false
	final
	finally
	float
	for
	foreach
	foreach_reverse
	function

	goto

	idouble
	if
	ifloat
	import 导入，默认情况下，导入是“private(私有的)”，另外还有“public，static，更名导入import io = std.stdio;选择性导入import std.stdio : writefln, foo = writef;更名带选择性的导入import io = std.stdio : foo = writefln;

导入声明中的循环（循环依赖）是允许的，只要不是两个模块都含有静态构造或析构函数就行。如果违反这条规则会在运行时产生异常。


        in
	inout

	int

	interface

	invariant
	ireal
	is

	lazy
	long

	macro
	mixin声明：
        mixin ( 赋值表达式 ) ; 
    赋值表达式 必须在编译时求值成一个常量字符串。该字符串的文本内容必须要可编译成一个有效的多个声明定义，而且同样地被编译。

	module  模块同源文件是一一对应的。模块名就是去掉路径和扩展名的文件名。
       模块自动为它的内容提供一个名字空间。模块跟类有一点相像，不同之处是：
       • 每个模块只有一个实例，并且它是静态分配的。
       • 模块没有虚函数表。
       • 模块不能继承，它们没有父模块，等等。
       • 每个文件只有一个模块。
       • 模块的符号可以导入。
       • 模块总是在全局作用域内编译，并且不受周围的特征或其它修饰符影响。
       多个模块可以组织成一个结构，叫做“包(packages)”。

	new
	nothrow  2.0
	null

	out

        override
        用于虚函数。即表示该函数一定会重写

	package
	pragma
	private
	protected
	public
	pure  2.0 

	real
	ref
	return ：  在函数实际返回之前，任何带有 auto 存储特性的对象都会被破坏掉，所有的封闭 finally 子句会被执行，所有的 scope(exit) 语句会被执行，所有的 scope(success) 语句会被执行，并且所有的封闭 synchronization 对象会被释放。


     scope   ？？？？？
    用于局部变量和类声明。对于类声明，scope 属性会创建一个 scope 类。对于局部变  量，scope 实现RAII（资源获得即初始化）协议。即表示对象的析构函数自动被调用。

作用域守护语句：（参见书p92）
scope(exit) 非空或无作用域块语句
scope(success) 非空或无作用域块语句
scope(failure) 非空或无作用域块语句
作用域守护语句 在当前作用域的结束处执行 非空或无作用域块语句，而不是在 作用域守
护语句 所在的那个地方执行。scope(exit) 会在正常退出该作用域时或在由于异常展开而退
出时执行 非空或无作用域块语句。scope(failure) 会在由于异常展开退出该作用域时执行
非空或无作用域块语句。scope(success) 则会在正常退出该作用域时执行 非空或无作用域块
语句。
如果在一个作用域内有多重 作用域守护语句，那么它们执行的顺序则跟它们在词法上出现
的顺序相反。如果有 auto 实例在访作用域结束处被析构，那么它们也以跟词法上相反的顺
序跟 作用域守护语句 交叉在一起。

scope(exit) 或 scope(success) 语句不可能由于 throw、goto、break、continue 或 return 退出；也不可能由于 goto 而进入。

	short
        static
        用于函数和数据，静态函数决不能是虚的(vitual)。 

	struct
	super
	switch
	synchronized

	template
	this
	throw
	true
	try


隐式类型接口
自动声明：
多个存储类别 标识符 = 赋值表达式 ;

如果一个声明由“存储类别”起始，并且有“非空初始值”（由这可以推断类型），则在声
明里的类型可以被忽略。

static x = 3; // x 的类型是 int
auto y = 4u; // y 的类型是 uint
auto s = "string"; // s 是类型 char[6]
class C { ... }
auto c = new C(); // c 是类 C 实例的手柄

“非空初始值”不能包含向前引用（在将来这个限制可能被移除）。隐式推断的类型是在编
译时，而在非运行时静态绑定到该声明。


	typedef  类型定义
    强类型可以通过 typedef 引入。对于函数重载和调试器来说，在语义上，强类型是类型检查系统可以将其同其他类型区分的类型。
typedef int myint;
void foo(int x) { . }
void foo(myint m) { . }
.
myint b;
foo(b); // 调用 foo(myint)

Typedef 可以指定一个不同于其底层类型（underlying type）的初始值：
typedef int myint = 7;
myint m; // 初始化为 7

typedef T U; // T 就是 U 的 基类型


	typeid

	typeof
          typeof ( 表达式 )
          typeof ( return )
          Typeof 用来获得一个表达式的类型。例如：
         void func(int i)
         {
           typeof(i) j; // j 的类型是 int
           typeof(3 + 6.0) x; // x 是 double 型
           typeof(1)* p; // p 是指向 int 型的指针
           int[typeof(p)] a; // a 的类型是 int[int*]
           writefln("%d", typeof('c').sizeof); // 输出 1
           double c = cast(typeof(1.0))j; // 将 j 转换为 double 型
         }


          表达式 不会被计算，只会生成它的类型：
           void func()
           {   int i = 1;
               typeof(++i) j; // j 被声明为 int ，i 不会自增
                writefln("%d", i); // 输出 1
           }


          有两种特殊情况：
          1. 就算不在成员函数中，typeof(this) 也将生成 this 在非静态成员函数中的类型。
          2. 类似的，typeof(super) 也将生成 super 在非静态成员函数中的类型。

          class A { }

          class B : A
          {
             typeof(this) x; // x 被声明为 B 型
             typeof(super) y; // y 被声明为 A 型
          }

         struct C
         {
             typeof(this) z; // z 被声明为 C* 型
             typeof(super) q; // 错误，C 没有父结构
         }

         typeof(this) r; // 错误，没有包含在类或者结构中

*******  Typeof 是最有用的的地方就是在于编写泛型模板代码。


	ubyte
	ucent
	uint
	ulong
	union
	unittest
	ushort

	version
	void  
        Void 初始化
          VoidInitializer:
          void
        通常，变量初始化可以使用一个显式的 初始值，也可以设置成变量类型的默认值。 如果 初始化值 为 void，实际上变量并没有被初始化。如果它的值在被设置前使用了，则会导致未定义的程序行为。
void foo()
{
int x = void;
writefln(x); // 会输出“垃圾”信息
}
因此，我们应该只使用 void 初始值，做为在优化关键代码时的最后的手段。


	volatile：没有什么代码活动能跨越 volatile 语句的边界。
            volatile 语句
            volatile ;
        语句 会被计算。在 语句 之前的所有内存写操作都保证在 语句 中或其后的内存读 操作之前完成。在 语句 之后的所有内存读操作都保证在 语句 中或其前的所有内存写完成之后执行。
volatile 语句不能保证原子性。为了该目的，应该使用 synchronized 语句。

	wchar
	while
	with

	__FILE__  2.0 
	__LINE__  2.0 
	__traits  2.0