The object-oriented features of D all come from classes. The class hierarchy has as its root the class Object. Object defines a minimum level of functionality that each derived class has, and a default implementation for that functionality.
Classes are programmer defined types. Support for classes are what make D an object oriented language, giving it encapsulation, inheritance, and polymorphism. D classes support the single inheritance paradigm, extended by adding support for interfaces. Class objects are instantiated by reference only.
A class can be exported, which means its name and all its non-private members are exposed externally to the DLL or EXE.
A class declaration is defined:
ClassDeclaration:classIdentifier;classIdentifierBaseClassListoptAggregateBodyClassTemplateDeclarationBaseClassList::SuperClassOrInterface:SuperClassOrInterface,InterfacesSuperClassOrInterface:BasicTypeInterfaces:InterfaceInterface,InterfacesInterface:BasicType
A class consists of:
A class is defined:
class Foo{ ... members ...}class Foo { } var; Instead, use:class Foo { }Foo var;Access to class members is controlled using visibility attributes. The default visibility attribute ispublic.
All classes inherit from a super class. If one is not specified, a class inherits fromObject.Object forms the root of the D class inheritance hierarchy.
class A { }// A inherits from Objectclass B : A { }// B inherits from A
Multiple class inheritance is not supported, however a class can inherit from multipleinterfaces. If a super class is declared, it must come before any interfaces. Commas are used to separate inherited types.
Non-static member variables are called fields. Members of a class instance are accessed with the. operator.
Members of a base class can be accessed by prepending the name of the base class followed by a dot:
class A {int a;int a2;}class B : A {int a; }void foo(B b){ b.a = 3;// accesses field B.a b.a2 = 4;// accesses field A.a2 b.A.a = 5;// accesses field A.a}
Fields ofextern(Objective-C) classes have a dynamic offset. That means that the base class can change (add or remove instance variables) without the subclasses needing to recompile or relink.
| Property | Description |
|---|---|
| .tupleof | Symbol sequence of fields in the class. |
| Property | Description |
|---|---|
| .classinfo | Information about the dynamic type of the class. |
| .outer | For a nested class instance, provides either the parent class instance, or the parent function's context pointer when there is no parent class. |
The.tupleof property provides a symbol sequence of all the non-static fields in the class, excluding the initialhidden fields and the fields in the base class. When used on an instance,.tupleof gives anlvalue sequence.
The order of the fields in the tuple matches the order in which the fields are declared.
class Foo {int x;long y; }staticassert(__traits(identifier, Foo.tupleof[0]) =="x");staticassert(is(typeof(Foo.tupleof)[1] ==long));void main(){import std.stdio;auto foo =new Foo; foo.tupleof[0] = 1;// set foo.x to 1 foo.tupleof[1] = 2;// set foo.y to 2foreach (ref x; foo.tupleof) x++;assert(foo.x == 2);assert(foo.y == 3);auto bar =new Foo; bar.tupleof = foo.tupleof;// copy fieldsassert(bar.x == 2);assert(bar.y == 3);}
The properties.__vptr and.__monitor give access to the class object's vtbl[] and monitor, respectively, but should not be used in user code. Seethe ABI for details.
See also:Context Pointer.
The.offsetof property gives the offset in bytes of the field from the beginning of the class instantiation. Note that the compiler canrearrange class field offsets. Seethealign attribute for a struct-based example.
Non-static member functions must be called on an instance of their class. They have an extra hidden parameter calledthis through which the class object's other members can be accessed. Inside the function body, the class instance members are in scope.
class C{int a;void foo() { a = 3;// assign to `this.a` }}auto c =new C;c.foo();assert(c.a == 3);
Non-static member functions can have, in addition to the usualFunctionAttributes, the attributesconst,immutable,shared,inout,scope orreturn scope. These attributes apply to the hiddenthis parameter.
class C{int a;void foo()const { a = 3;// error, 'this' is const }void foo()immutable { a = 3;// error, 'this' is immutable } C bar() @safescope {returnthis;// error, 'this' is scope }}
Static member functions withObjective-C linkage also have an extra hidden parameter calledthis through which the class object's other members can be accessed.
Member functions with Objective-C linkage have an additional hidden, anonymous, parameter which is the selector the function was called with.
Static member functions with Objective-C linkage are placed in a hidden nested metaclass as non-static member functions.
Member functions of a (non-synchronized) class can be individually marked assynchronized. The class instance's monitor object will be locked when the method is called and unlocked when the call terminates.
A synchronized method can only be called on ashared class instance.
class C{void foo();synchronizedint bar();}void test(C c){ c.foo;// OK//c.bar; // Error, `c` is not `shared`shared C sc =newshared C;//sc.foo; // Error, `foo` not callable using a `shared` object sc.bar;// OK}
See alsoSynchronizedStatement.
Each member function of asynchronized class is implicitlysynchronized. A static member function is synchronized on theclassinfo object for the class, which means that one monitor is used for all static member functions for that synchronized class. For non-static functions of a synchronized class, the monitor used is part of the class object. For example:
synchronizedclass Foo{void bar() { ...statements... }}
is equivalent to (as far as the monitors go):
synchronizedclass Foo{void bar() {synchronized (this) { ...statements... } }}
Member fields of a synchronized class cannot be public:
synchronizedclass Foo{int foo;// Error: public field}synchronizedclass Bar{privateint bar;// ok}
Fields are by default initialized to thedefault initializer for their type (usually 0 for integer types and NaN for floating point types). If the field declaration has an optionalInitializer that will be used instead of the default.
class Abc{int a;// default initializer for a is 0long b = 7;// default initializer for b is 7float f;// default initializer for f is NAN}void main(){ Abc obj =new Abc;assert(obj.b == 7);}
TheInitializer is evaluated at compile time.
This initialization is done before anyconstructors are called.
Instances of class objects are created with aNewExpression.
By default, a class instance is allocated on the garbage-collected heap. Ascope class instance is allocated on the stack.
A constructor is a specialmember function which is normallyinvoked by the compiler when the class instance is created.
Constructor:thisParametersMemberFunctionAttributesoptFunctionBodythisParametersMemberFunctionAttributesoptMissingFunctionBodyConstructorTemplate
A constructor is declared with a function name ofthis and no return type:
class A{int i;this()// constructor taking no arguments { i = 2;// initialize `this.i` }this(int i)// constructor taking an int argument {this.i = i;// initialize field `i` from parameter `i` }}void main(){ A a =new A;// instantiate A and call `A.this()`assert(a.i == 2); a =new A(3);// instantiate A and call `A.this(3)`assert(a.i == 3);}
Explicitly returning a value in a constructor is not allowed, howeverreturn; may be used to exit the function early.
Base class construction is done by calling the base class constructor by the namesuper:
class A {this(int y) { } }class B : A{int j;this() { ...super(3);// call base constructor A.this(3) ... }}
A constructor can call another constructor for the same class in order to share common initializations. This is called adelegating constructor:
class C{int j;this() { ... }this(int i) {this();// delegating constructor call j = i; }}
The following restrictions apply:
this() {this(1); }this(int i) {this(); }// illegal, cyclic constructor calls
this() { a ||super(); }// illegal, 0 or 1 callthis() { (a) ?this(1) :super(); }// OKthis() {super();this(1); }// illegal, 2 callsthis(){for (...) {super();// illegal, inside loop }}
See also:field initialization.
If there is no constructor for a class, but there is a constructor for the base class, a default constructor is implicitly generated with the form:
this() { }If no calls to a delegating constructor orsuper appear in a constructor, and the base class has a nullary constructor, a call tosuper() is inserted at the beginning of the constructor. If that base class has a constructor that requires arguments and no nullary constructor, a matching call tosuper is required.
The following steps happen:
Constructors can have one of these member function attributes:const,immutable, andshared. Construction of qualified objects will then be restricted to the implemented qualified constructors.
class C{this();// non-shared mutable constructor}// create mutable objectC m =new C();// create const object using mutable constructorconst C c2 =newconst C();// a mutable constructor cannot create an immutable object// immutable C i = new immutable C();// a mutable constructor cannot create a shared object// shared C s = new shared C();
Constructors can be overloaded with different attributes.
class C{this();// non-shared mutable constructorthis()shared;// shared mutable constructorthis()immutable;// immutable constructor}C m =new C();shared s =newshared C();immutable i =newimmutable C();
If the constructor can create a unique object (e.g. if it ispure), the object can be implicitly convertible to any qualifiers.
class C{this()pure;// Based on the definition, this creates a mutable object. But the// created object cannot contain any mutable global data.// Therefore the created object is unique.this(int[] arr)immutablepure;// Based on the definition, this creates an immutable object. But// the argument int[] never appears in the created object so it// isn't implicitly convertible to immutable. Also, it cannot store// any immutable global data.// Therefore the created object is unique.}immutable i =newimmutable C();// this() pure is calledshared s =newshared C();// this() pure is calledC m =new C([1,2,3]);// this(int[]) immutable pure is called
In a constructor body, the first instance of field assignment is its initialization.
class C{int num;this() { num = 1;// initialization num = 2;// assignment }}
If the field type has anopAssign method, it will not be used for initialization.
struct A{this(int n) {}voidopAssign(A rhs) {}}class C{ A val;this() { val = A(1);// val is initialized to the value of A(1) val = A(2);// rewritten to val.opAssign(A(2)) }}
If the field type is not mutable, multiple initialization will be rejected.
class C{immutableint num;this() { num = 1;// OK num = 2;// Error: multiple field initialization }}
If the field is initialized on one path, it must be initialized on all paths.
class C{immutableint num;immutableint ber;this(int i) {if (i) num = 3;// initializationelse num = 4;// initialization }this(long j) { j ? (num = 3) : (num = 4);// ok j || (ber = 3);// error, intialized on only one path j && (ber = 3);// error, intialized on only one path }}
A field initialization may not appear in a loop or after a label.
class C{immutableint num;immutable string str;this() {foreach (i; 0..2) { num = 1;// Error: field initialization not allowed in loops } size_t i = 0; Label: str ="hello";// Error: field initialization not allowed after labelsif (i++ < 2)goto Label; }}
If a field's type has disabled default construction, then it must be initialized in the constructor.
struct S {int y; @disablethis(); }class C{ S s;this(S t) { s = t; }// okthis(int i) {this(); }// okthis() { }// error, s not initialized}
Destructor:~ this ( )MemberFunctionAttributesoptFunctionBody~ this ( )MemberFunctionAttributesoptMissingFunctionBody
The destructor function is called when:
Example:
import std.stdio;class Foo{ ~this()// destructor for Foo { writeln("dtor"); }}void main(){auto foo =new Foo; destroy(foo); writeln("end");}
The destructor is expected to release any non-GC resources held by the object.
The program can explicitly call the destructor of a live object immediately withdestroy. The runtime marks the object so the destructor is never called twice.
The destructor for thesuper class automatically gets called when the destructor ends. There is no way to call the super class destructor explicitly.
Objects referenced from the static data segment never get collected by the GC.
StaticConstructor:static this ( )MemberFunctionAttributesoptFunctionBodystatic this ( )MemberFunctionAttributesoptMissingFunctionBody
A static constructor is a function that performs initializations of thread local data before themain() function gets control for the main thread, and upon thread startup.
Static constructors are used to initialize static class members with values that cannot be computed at compile time.
class Foo{staticint a = b + 1;staticint b = a * 2;}What values doa andb end up with, what order are the initializations executed in, what are the values ofa andb before the initializations are run, is this a compile error, or is this a runtime error? Additional confusion comes from it not being obvious if an initializer is static or dynamic.
D makes this simple. All member initializations must be determinable by the compiler at compile time, hence there is no order-of-evaluation dependency for member initializations, and it is not possible to read a value that has not been initialized. Dynamic initialization is performed by a static constructor, defined with a special syntaxstatic this().
class Foo{staticint a;// default initialized to 0staticint b = 1;staticint c = b + a;// error, not a constant initializerstaticthis()// static constructor { a = b + 1;// a is set to 2 b = a * 2;// b is set to 4 }}
Ifmain() or the thread returns normally, (does not throw anexception), the static destructor is added to the list of functions to be calledon thread termination.
Static constructors have empty parameter lists.
Static constructors within a module are executed in the lexical order in which they appear. All the static constructors for modules that are directly or indirectly imported are executed before the static constructors for the importer.
Thestatic in the static constructor declaration is not an attribute, it must appear immediately before thethis:
class Foo{staticthis() { ... }// a static constructorstaticprivatethis() { ... }// Error: not a static constructorstatic {this() { ... }// not a static constructor }static:this() { ... }// not a static constructor}
StaticDestructor:static ~ this ( )MemberFunctionAttributesoptFunctionBodyA static destructor is defined as a special static function with the syntaxstatic ~this().
class Foo{static ~this()// static destructor { }}
A static destructor gets called on thread termination, but only if the static constructor completed successfully. Static destructors have empty parameter lists. Static destructors get called in the reverse order that the static constructors were called in.
Thestatic in the static destructor declaration is not an attribute, it must appear immediately before the~this:
class Foo{static ~this() { ... }// a static destructorstaticprivate ~this() { ... }// Error: not a static destructorstatic { ~this() { ... }// not a static destructor }static: ~this() { ... }// not a static destructor}
SharedStaticConstructor:shared static this ( )MemberFunctionAttributesoptFunctionBodyshared static this ( )MemberFunctionAttributesoptMissingFunctionBody
Shared static constructors are executed before anyStaticConstructors, and are intended for initializing any shared global data.
SharedStaticDestructor:shared static ~ this ( )MemberFunctionAttributesoptFunctionBodyshared static ~ this ( )MemberFunctionAttributesoptMissingFunctionBody
Shared static destructors are executed at program termination in the reverse order thatSharedStaticConstructors were executed.
Invariant:invariant ( )BlockStatementinvariantBlockStatementinvariant (AssertArguments) ;
ClassInvariants specify the relationships among the members of a class instance. Those relationships must hold for any interactions with the instance from its public interface.
The invariant is in the form of aconst member function. The invariant is defined tohold if all theAssertExpressions within the invariant that are executed succeed.
class Date{this(int d,int h) { day = d;// days are 1..31 hour = h;// hours are 0..23 }invariant {assert(1 <= day && day <= 31);assert(0 <= hour && hour < 24); }private:int day;int hour;}
Any class invariants for base classes are applied before the class invariant for the derived class.
There may be multiple invariants in a class. They are applied in lexical order.
ClassInvariants must hold at the exit of the class constructor (if any), and at the entry of the class destructor (if any).
ClassInvariants must hold at the entry and exit of all public or exported non-static member functions. The order of application of invariants is:
If the invariant does not hold, then the program enters an invalid state.
Public or exported non-static member functions cannot be called from within an invariant.
class Foo{publicvoid f() { }privatevoid g() { }invariant { f();// error, cannot call public member function from invariant g();// ok, g() is not public }}
A scope class is a class with thescope attribute, as in:
scopeclass Foo { ... }
The scope characteristic is inherited, so any classes derived from a scopeclass are also scope.
A scope class reference can only appear as a function local variable. It must be declared as beingscope:
scopeclass Foo { ... }void func(){ Foo f;// error, reference to scope class must be scopescope Foo g =new Foo();// correct}
When a scope class reference goes out of scope, the destructor (if any) forit is automatically called. This holds true even if the scope was exited via athrown exception.
An abstract member function must be overridden by a derived class. Only virtual member functions may be declared abstract; non-virtual member functions and free-standing functions cannot be declared abstract.
A class is abstract if any of its virtual member functions are declared abstract or if they are defined within an abstract attribute. Note that an abstract class may also contain non-virtual member functions. Abstract classes cannot be instantiated directly. They can only be instantiated as a base class of another, non-abstract, class.
class C{abstractvoid f();}auto c =new C;// error, C is abstractclass D : C {}auto d =new D;// error, D is abstractclass E : C{overridevoid f() {}}auto e =new E;// OK
Member functions declared as abstract can still have function bodies. This is so that even though they must be overridden, they can still provide ‘base class functionality’, e.g. throughsuper.foo() in a derived class. Note that the class is still abstract and cannot be instantiated directly.
A class can be declared abstract:
abstractclass A{// ...}auto a =new A;// error, A is abstractclass B : A {}auto b =new B;// OK
Final classes cannot be subclassed:
finalclass A { }class B : A { }// error, class A is final
Methods of a final class are alwaysfinal.
Anested class is a class that is declared inside the scope of afunction or another class. A nested class has access to the variables and othersymbols of the classes and functions it is nested inside:
class Outer{int m;class Inner {int foo() {return m;// Ok to access member of Outer } }}
void func(){int m;class Inner {int foo() {return m;// Ok to access local variable m of func() } }}
If a nested class has thestatic attribute, then it can not accessvariables of the enclosing scope that are local to the stack or need athis reference:
class Outer{int m;staticint n;staticclass Inner {int foo() {return m;// Error, Inner is static and m needs a thisreturn n;// Ok, n is static } }}
void func(){int m;staticint n;staticclass Inner {int foo() {return m;// Error, Inner is static and m is local to the stackreturn n;// Ok, n is static } }}
Non-static nested classes work by containing an extra hidden member (calledthe context pointer) that is the frame pointer of the enclosing function if itis nested inside a function, or thethis reference of the enclosing class's instanceif it is nested inside a class.
When a non-static nested class is instantiated, the context pointer is assigned before the class's constructor is called, therefore the constructor has full access to the enclosing variables. A non-static nested class can only be instantiated when the necessary context pointer information is available:
class Outer{class Inner { }staticclass SInner { }}void main(){ Outer o =new Outer;// Ok//Outer.Inner oi = new Outer.Inner; // Error, no 'this' for Outer Outer.SInner os =new Outer.SInner;// Ok}
void main(){class Nested { } Nested n =new Nested;// Okstatic f() {//Nested sn = new Nested; // Error, no 'this' for Nested }}
Athis reference can be supplied to the creation of an inner class instance by prefixing it to theNewExpression:
class Outer{int a;class Inner {int foo() {return a; } }}void main(){ Outer o =new Outer; o.a = 3; Outer.Inner oi = o.new Inner;assert(oi.foo() == 3);}
Hereo supplies thethis reference to the inner class instance ofOuter.
For a nested class instance, the.outer property provides thethis reference of the enclosing class's instance. If there is no accessible parent class instance, the property provides avoid* to the enclosing function frame.
class Outer{class Inner1 { Outer getOuter() {returnthis.outer; } }void foo() { Inner1 i =new Inner1;assert(i.getOuter()isthis); }}
class Outer{void bar() {// x is referenced from nested scope, so// bar makes a closure environment.int x = 1;class Inner2 { Outer getOuter() { x = 2;// The Inner2 instance has access to the function frame// of bar as a static frame pointer, but .outer returns// the enclosing Outer class instance property.returnthis.outer; } } Inner2 i =new Inner2;assert(i.getOuter()isthis); }}
class Outer{// baz cannot access an instance of Outerstaticvoid baz() {// make a closure environmentint x = 1;class Inner3 {void* getOuter() { x = 2;// There's no accessible enclosing class instance, so the// .outer property returns the function frame of baz.returnthis.outer; } } Inner3 i =new Inner3;assert(i.getOuter() !isnull); }}
An anonymous nested class is both defined and instantiated with aNewAnonClassExpression:
NewAnonClassExpression:newPlacementExpressionoptclassConstructorArgsoptAnonBaseClassListoptAggregateBodyConstructorArgs:(NamedArgumentListopt)AnonBaseClassList:SuperClassOrInterfaceSuperClassOrInterface,Interfaceswhich is equivalent to:
classIdentifier:AnonBaseClassListAggregateBody// ...newIdentifierConstructorArgswhereIdentifier is the name generated for the anonymous nested class.
interface I{void foo();}auto obj =newclass I{void foo() { writeln("foo"); }};obj.foo();
If aClassDeclaration has aconst,immutable orshared storage class, then it is as if each member of the class was declared with that storage class. If a base class is const, immutable or shared, then all classes derived from it are also const, immutable or shared.