声 明 2.014

单个声明：
typedef 声明
alias 声明
声明

声明：
存储类别 声明
基本类型 多个声明符 ;
基本类型 单个声明符 函数体
自动声明

多个声明符：
声明符初始值
声明符初始值 , 声明符标志符列表

声明符初始值：
声明符
声明符 = 初始值

声明符 标志符 列表：
声明符标志符
声明符标志符 , 声明符标志符列表

声明符标志符：
标识符
标识符 = 初始值

基本类型：
bool
byte
ubyte
short
ushort
int
uint
long
ulong
char
wchar
dchar
float
double
real
ifloat
idouble
ireal
cfloat
cdouble
creal
void

.标识符列表

标识符列表：
Typeof
Typeof .标识符列表

基本类型2：
*
[ ]
[ 表达式 ]
[ 类型 ]
delegate 多个形参 FunctionAttributes  opt   2.014

function 多个形参 FunctionAttributes  opt   2.014

声明符：
基本类型2 声明符
标识符
() 声明符
标识符 多个声明符后缀
() 声明符 多个声明符后缀

多个声明符后缀：
单个声明符后缀
单个声明符后缀 多个声明符后缀

单个声明符后缀：
[ ]
[ 表达式 ]
[ 类型 ]
形式参数  FunctionAttributes  opt  2.014
 

标志符列表：
标识符
标识符 .标识符列表
模板实例
模板实例 .标识符列表

多个存储类别：
单个存储类别
单个存储类别 多个存储类别

单个存储类别：
abstract
auto
const
deprecated
extern
final
invariant

nothrow  2.014 
override

pure     2.014
scope
static
synchronized

类型：
基本类型
基本类型 声明符2

声明符2：
基本类型2 声明符2
( 声明符2 )
( 声明符2 ) 多个声明符后缀

多个形参:
( 形参列表 )
( )

形参列表：
单个形参
单个形参 , 形参列表
单个形参 ...
...

单个形参:
声明符
声明符 = 赋值表达式 
(声明符 = DefaultInitializerExpression 2.014 写法)

InOut 声明符
InOut 声明符 = 赋值表达式
(InOut 声明符 = DefaultInitializerExpression  2.014 写法)

InOut:
in
out
ref
lazy

2.014
FunctionAttributes:
FunctionAttribute
FunctionAttribute FunctionAttributes

FunctionAttribute:
pure
nothrow


DefaultInitializerExpression:
AssignExpression
__FILE__
__LINE__




初始值：
VoidInitializer
非空初始值

非空初始值：
赋值表达式
数组初始值
结构初始值

数组初始值：
[ ]
[ 多个数组成员初始化 ]

多个数组成员初始化：
单个数组成员初始化
单个数组成员初始化 ,
单个数组成员初始化 , 多个数组成员初始化

单个数组成员初始化：
非空初始值
赋值表达式 :非空初始值

结构初始值：
{ }
{ 多个结构成员初始值 }

多个结构成员初始值:
单个结构成员初始值
单个结构成员初始值 ,
单个结构成员初始值 , 多个结构成员初始值

单个结构成员初始值：
非空初始值
标识符 :非空初始值


1 声明语法

声明语法通常从右向左读：
int x; // x 是一个 int
int* x; // x 是指向 int 的指针
int** x; // x 是一个指向指针的指针，而被指向的指针又指向 int
int[] x; // x 是 int 型的数组
int*[] x; // x 是一个指针数组，该指针指向 int
int[]* x; // x 是指向 int 型数组的指针

数组读法也是从右至左：
int[3] x; // x 是有3 个 int 型元素的数组
int[3][5] x; // x 是有5个元素的数组，每个元素是有3个元素的 int 数组
int[3]*[5] x; // x 是有5个元素的数组，每个元素是指向有3个元素的 int 的数组的指针

指向 函数的指针 用关键字 function 声明：
int function(char) x; // x is a pointer to a function taking a char argument
// 返回值类型是 int
i
nt function(char)[] x; // x 是指向函数的指针数组，
// 此函数有一个 char 的参数，返回值类型是 int

也可以使用 C 风格的数组声明方式：
int x[3]; // x 是有3 个 int 型元素的数组
int x[3][5]; // x 是有3个元素的数组，每个元素是有5个元素的 int 数组
int (*x[5])[3]; // x 是有5个元素的数组，每个元素是指向有3个元素的 int 的数组的指针
int (*x)(char); // x 是指向函数的指针，函数有一个 char 的参数，
// 返回值类型是 int
int (*[] x)(char); // x 是指向函数的指针数组，
// 此函数有一个 char 的参数，返回值类型是 int

在多重声明中，所有被声明的符号拥有相同的类型：
int x,y; // x 和 y 是 int
int* x,y; // x 和 y 是指向 int 的指针
int x,*y; // 错误，多重类型
int[] x,y; // x 和 y 是 int 数组
int x[],y; // 错误，多重类型


2 隐式类型接口

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

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

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

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


3 类型定义

强类型 可以通过 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


4 类型别名

时为类型起一个别名是很方便的，例如可以作为一个冗长复杂类型（比如一个函数指针）的
简写形式。在 D 中，可以使用别名声明达到这个目的：
alias abc.Foo.bar myint;

别名类型 在语义上等价于 原类型。调试器 无法区分它们，在 函数重载 是也不会区分它们。

例如：
alias int myint;
void foo(int x) { . }
void foo(myint m) { .} // 错误，多次定义了函数 foo

类型别名等价于 C 中的 typedef。


5 别名声明

符号可以被声明为另一个符号的“别名”。例如：
import string;
alias string.strlen mylen;
...
int len = mylen("hello"); // 实际上调用的是 string.strlen()

下面的别名声明是合法的：
template Foo2(T) { alias T t; }
alias Foo2!(int) t1;
alias Foo2!(int).t t2;
alias t1.t t3;
alias t2 t4;
t1.t v1; // v1 的类型是 int
t2 v2; // v2 的类型是 int
t3 v3; // v3 的类型是 int
t4 v4; // v4 的类型是 int

别名符号可以将一个较长的符号简记为一个较短的符号，还可以将一个引用从一个符号重定
位到另一个符号：

version (Win32)
{
alias win32.foo myfoo;
}
version (linux)
{
alias linux.bar myfoo;
}

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

别名还可以‘导入’一系列的重载函数，这样就可以在当前作用域中重载函数：
class A {
int foo(int a) { return 1; }
}

class B : A {
int foo( int a, uint b ) { return 2; }
}

class C : B {
int foo( int a ) { return 3; }
alias B.foo foo;
}

class D : C {
}
void test()
{
D b = new D();
int i;
i = b.foo(1, 2u); // 调用 B.foo
i = b.foo(1); // 调用 C.foo
}

注意： 类型别名有时会同别名声明十分相似：

alias foo.bar abc; // 它是一个类型还是一个符号？

在语义分析是将会区分这两种情况。

别名不能用于表达式：
struct S { static int i; }
S s;
alias s.i a; // 非法，s.i 是一个表达式
alias S.i b; // 正确
b = 4; // 把 S.i 设置为 4


6 Extern 声明

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


7 typeof

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
}

有两种特殊情况：(2.014 有三种)

1. 就算不在成员函数中，typeof(this) 也将生成 this 在非静态成员函数中的类型。
2. 类似的，typeof(super) 也将生成 super 在非静态成员函数中的类型。
3. typeof(return) will, when inside a function scope, give the return type of that function.   2.014

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 是 最有用 的的地方就是在于编写泛型模板代码。


8 Void 初始化

VoidInitializer:
void

通常，变量初始化可以使用一个显式的 初始值，也可以设置成变量类型的默认值。如果 初
始化值 为 void，实际上变量并没有被初始化。如果它的值在被设置前使用了，则会导致未定义的程序行为。

void foo()
{
int x = void;
writefln(x); // 会输出“垃圾”信息
}

因此，我们应该只使用 void 初始值，做为在优化关键代码时的最后的手段。





。。。。。。。