Declaration: typedef Decl alias Decl Decl Decl: const Decl static Decl final Decl synchronized Decl deprecated Decl BasicType BasicType2 Declarators ; BasicType BasicType2 FunctionDeclarator Declarators: Declarator Declarator , Declarators BasicType: bit byte ubyte short ushort int uint long ulong char wchar dchar float double real ifloat idouble ireal cfloat cdouble creal void .IdentifierList IdentifierList Typeof Typeof . IdentifierList TemplateInstance TemplateInstance . IdentifierList IdentifierList Identifier Identifier . IdentifierList Typeof typeof ( Expression )
int x; // x is an int int* x; // x is a pointer to int int** x; // x is a pointer to a pointer to int int[] x; // x is an array of ints int*[] x; // x is an array of pointers to ints int[]* x; // x is a pointer to an array of intsArrays, read left to right:
int[3] x; // x is an array of 3 ints int[3][5] x; // x is an array of 5 arrays of 3 ints int[3]*[5] x; // x is an array of 5 pointers to arrays of 3 intsPointers to functions are declared as subdeclarations:
int (*x)(char); // x is a pointer to a function taking a char argument // and returning an int int (*[] x)(char); // x is an array of pointers to functions // taking a char argument and returning an intC-style array declarations, where the [] appear to the right of the identifier, may be used as an alternative:
int x[3]; // x is an array of 3 ints int x[3][5]; // x is an array of 3 arrays of 5 ints int (*x[5])[3]; // x is an array of 5 pointers to arrays of 3 intsIn a declaration declaring multiple declarations, all the declarations must be of the same type:
int x,y; // x and y are ints int* x,y; // x and y are pointers to ints int x,*y; // error, multiple types int[] x,y; // x and y are arrays of ints int x[],y; // error, multiple types
typedef int myint; void foo(int x) { . } void foo(myint m) { . } . myint b; foo(b); // calls foo(myint)Typedefs can specify a default initializer different from the default initializer of the underlying type:
typedef int myint = 7; myint m; // initialized to 7
alias abc.Foo.bar myint;Aliased types are semantically identical to the types they are aliased to. The debugger cannot distinguish between them, and there is no difference as far as function overloading is concerned. For example:
alias int myint; void foo(int x) { . } void foo(myint m) { . } error, multiply defined function fooType aliases are equivalent to the C typedef.
import string; alias string.strlen mylen; ... int len = mylen("hello"); // actually calls string.strlen()The following alias declarations are valid:
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 is type int t2 v2; // v2 is type int t3 v3; // v3 is type int t4 v4; // v4 is type intAliased symbols are useful as a shorthand for a long qualified symbol name, or as a way to redirect references from one symbol to another:
version (Win32) { alias win32.foo myfoo; } version (linux) { alias linux.bar myfoo; }Aliasing can be used to 'import' a symbol from an import into the current scope:
alias string.strlen strlen;Aliases can also 'import' a set of overloaded functions, that can be overloaded with functions in the current scope:
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); // calls B.foo i = b.foo(1); // calls C.foo }Note: Type aliases can sometimes look indistinguishable from alias declarations:
alias foo.bar abc; // is it a type or a symbol?The distinction is made in the semantic analysis pass.
void func(int i) { typeof(i) j; // j is of type int typeof(3 + 6.0) x; // x is of type double typeof(1)* p; // p is of type pointer to int int[typeof[p]] a; // a is of type int[int*] printf("%d\n", typeof('c').size); // prints 1 double c = cast(typeof(1.0))j; // cast j to double }Where Typeof is most useful is in writing generic template code.