D programming Language
Download 1.66 Mb.
|
- Navigate this page:
- Static Construction and Destruction
- Order of Static Construction
- Order of Static Construction within a Module
ModulesModule: ModuleDeclaration DeclDefs DeclDefs DeclDefs: DeclDef DeclDef DeclDefs DeclDef: AttributeSpecifier ImportDeclaration EnumDeclaration ClassDeclaration InterfaceDeclaration AggregateDeclaration Declaration Constructor Destructor Invariant Unittest StaticConstructor StaticDestructor DebugSpecification VersionSpecification ; Modules have a one-to-one correspondence with source files. The module name is the file name with the path and extension stripped off. Modules automatically provide a namespace scope for their contents. Modules superficially resemble classes, but differ in that:
Module DeclarationThe ModuleDeclaration sets the name of the module and what package it belongs to. If absent, the module name is taken to be the same name (stripped of path and extension) of the source file name. ModuleDeclaration: module ModuleName ; ModuleName: Identifier ModuleName . Identifier The Identifier preceding the rightmost are the packages that the module is in. The packages correspond to directory names in the source file path. If present, the ModuleDeclaration appears syntactically first in the source file, and there can be only one per source file. Example: module c.stdio; // this is module stdio in the c package By convention, package and module names are all lower case. This is because those names have a one-to-one correspondence with the operating system's directory and file names, and many file systems are not case sensitive. All lower case package and module names will minimize problems moving projects between dissimilar file systems. Import DeclarationRather than text include files, D imports symbols symbolically with the import declaration: ImportDeclaration: import ModuleNameList ; ModuleNameList: ModuleName ModuleName , ModuleNameList The rightmost Identifier becomes the module name. The top level scope in the module is merged with the current scope. Example: import c.stdio; // import module stdio from the c package import foo, bar; // import modules foo and bar
Scope and ModulesEach module forms its own namespace. When a module is imported into another module, all its top level declarations are available without qualification. Ambiguities are illegal, and can be resolved by explicitly qualifying the symbol with the module name. For example, assume the following modules: Module foo int x = 1; int y = 2;
int y = 3; int z = 4; then:
import foo; ...
q = y; // sets q to foo.y and:
import foo; int y = 5; q = y; // local y overrides foo.y and:
import foo; import bar; q = y; // error: foo.y or bar.y? and:
import foo; import bar; q = bar.y; // q set to 3
Cycles (circular dependencies) in the import declarations are allowed as long as not both of the modules contain static constructors or static destructors. Violation of this rule will result in a runtime exception. Order of Static Construction within a ModuleWithin a module, the static construction occurs in the lexical order in which they appear. Order of Static DestructionIt is defined to be exactly the reverse order that static construction was performed in. Static destructors for individual modules will only be run if the corresponding static constructor successfully completed. DeclarationsDeclaration: typedef Decl alias Decl
const Decl static Decl final Decl synchronized Decl deprecated Decl BasicType BasicType2 Declarators ; BasicType BasicType2 FunctionDeclarator Declarators: Declarator Declarator , Declarators Declaration SyntaxDeclaration syntax generally reads left to right: 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 ints Arrays, when lexically next to each other, read right to left: int[3] x; // x is an array of 3 ints int[3][5] x; // x is an array of 3 arrays of 5 ints int[3]*[5] x; // x is an array of 5 pointers to arrays of 3 ints Pointers 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 int C-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 ints In 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 Type DefiningStrong types can be introduced with the typedef. Strong types are semantically a distinct type to the type checking system, for function overloading, and for the debugger. 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 Type AliasingIt's sometimes convenient to use an alias for a type, such as a shorthand for typing out a long, complex type like a pointer to a function. In D, this is done with the alias declaration: 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 foo Type aliases are equivalent to the C typedef.
Alias DeclarationsA symbol can be declared as an alias of another symbol. For example: 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; } instance Foo2(int) t1; // a TemplateAliasDeclaration alias instance Foo2(int).t t2; alias t1.t t3; alias t2 t4; alias instance Foo2(int) t5; t1.t v1; // v1 is type int t2 v2; // v2 is type int t3 v3; // v3 is type int t4 v4; // v4 is type int t5.t v5; // v5 is type int Aliased 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;
alias foo.bar abc; // is it a type or a symbol? The distinction is made in the semantic analysis pass. Directory: upload upload -> 587 Return function, r i(X) r i(0) r i(1) r i(2) r i(3) 1 0 2 4 6 Thermal Station, I 2 0 1 5 6 3 0 3 5 6 10 upload -> Department of science and humanities department of mathematics part-a questions and answers upload -> The Case Against the nypd’s Quota-Driven ‘Broken Windows’ Policing What Is It? upload -> For want of a nail upload -> Traditional British values upload -> Tv shows, Made for tv movies, Mini Series & Internet Programs Shot at Paramount Ranch upload -> Ownership Models There are two different types of ownership models upload -> Police Militarization upload -> City of rising star regular meting thursday, july 14, 2016 upload -> Township of winfield Download 1.66 Mb. Share with your friends:
|