Classes - D Programming Language (original) (raw)

Contents

Overview
Class Declarations
Class Properties
Member Functions (a.k.a. Methods)
1. Objective-C linkage
Synchronized Method Calls
1. Synchronized Classes
Class Instantiation
Destructors
Static Constructors and Destructors
Class Invariants
Scope Classes
Abstract Classes
Final Classes
Nested Classes
Static Nested Classes
Context Pointer
Explicit Instantiation
outer Property
Anonymous Nested Classes
Const, Immutable and Shared Classes

Overview

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.

Class Declarations

A class declaration is defined:

ClassDeclaration: class Identifier ; class Identifier BaseClassListopt AggregateBody ClassTemplateDeclaration

BaseClassList: : SuperClassOrInterface : SuperClassOrInterface , Interfaces

SuperClassOrInterface: BasicType

Interfaces: Interface Interface , Interfaces

Interface: BasicType

A class consists of:

a super class
interfaces
dynamic fields
static fields
nested classes
member functions
- static member functions
- Virtual Functions
- Constructors
- Destructors
- Class Invariants
- Operator Overloading
other declarations (see DeclDef)

A class is defined:

class Foo { ... members ... }

Note: Unlike C++, there is no trailing ; after the closing } of the class definition. It is also not possible to declare a variable var inline:

class Foo { } var;

Instead, use:

class Foo { } Foo var;

Access Control

Access to class members is controlled using visibility attributes. The default visibility attribute is public.

Super Class

All classes inherit from a super class. If one is not specified, a class inherits from Object. Object forms the root of the D class inheritance hierarchy.

class A { } class B : A { }

Multiple class inheritance is not supported, however a class can inherit from multiple interfaces. If a super class is declared, it must come before any interfaces. Commas are used to separate inherited types.

Fields

Class members are always 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; b.a2 = 4; b.A.a = 5; }

Implementation Defined: The D compiler is free to rearrange the order of fields in a class to optimally pack them. Consider the fields much like the local variables in a function - the compiler assigns some to registers and shuffles others around all to get the optimal stack frame layout. This frees the code designer to organize the fields in a manner that makes the code more readable rather than being forced to organize it according to machine optimization rules. Explicit control of field layout is provided by struct/union types, not classes.

Fields of extern(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.

Class Properties

Class Properties

Property	Description
.tupleof	Symbol sequence of fields in the class.

Class Instance Properties

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.

.tupleof

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.

Note: .tupleof is not available for extern(Objective-C) classes due to their fields having a dynamic offset.

class Foo { int x; long y; }

static assert(__traits(identifier, Foo.tupleof[0]) == "x"); static assert(is(typeof(Foo.tupleof)[1] == long));

void main() { import std.stdio;

auto foo = new Foo;
foo.tupleof[0] = 1;     foo.tupleof[1] = 2;     foreach (ref x; foo.tupleof)
    x++;
assert(foo.x == 2);
assert(foo.y == 3);

auto bar = new Foo;
bar.tupleof = foo.tupleof;     assert(bar.x == 2);
assert(bar.y == 3);

}

Accessing Hidden Fields

The properties .__vptr and .__monitor give access to the class object's vtbl[] and monitor, respectively, but should not be used in user code. See the ABI for details.

Field Properties

The .offsetof property gives the offset in bytes of the field from the beginning of the class instantiation. Note that the compiler can rearrange class field offsets. See the align attribute for a struct-based example.

Note: .offsetof is not available for fields of extern(Objective-C) classes due to their fields having a dynamic offset.

Member Functions (a.k.a. Methods)

Non-static member functions have an extra hidden parameter called this through which the class object's other members can be accessed.

Non-static member functions can have, in addition to the usualFunctionAttributes, the attributesconst, immutable, shared, inout, scope or return scope. These attributes apply to the hidden this parameter.

class C { int a; void foo() const { a = 3; } void foo() immutable { a = 3; } C bar() @safe scope { return this; } }

Objective-C linkage

Static member functions withObjective-C linkage also have an extra hidden parameter called this 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.

Synchronized Method Calls

Member functions of a (non-synchronized) class can be individually marked as synchronized. 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(); synchronized int bar(); }

void test(C c) { c.foo;
shared C sc = new shared C; sc.bar; }

Synchronized Classes

Each member function of a synchronized class is implicitly synchronized. A static member function is synchronized on the classinfo 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:

synchronized class Foo { void bar() { ...statements... } }

is equivalent to (as far as the monitors go):

synchronized class Foo { void bar() { synchronized (this) { ...statements... } } }

Member fields of a synchronized class cannot be public:

synchronized class Foo { int foo; }

synchronized class Bar { private int bar; }

Note: struct types cannot be marked synchronized.

Class Instantiation

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 optional Initializer that will be used instead of the default.

class Abc { int a; long b = 7; float f; }

void main() { Abc obj = new Abc; assert(obj.b == 7); }

The Initializer is evaluated at compile time.

This initialization is done before anyconstructors are called.

Instances of class objects are created with a NewExpression.

A class C without a constructor (or with a nullary constructor) is instantiated using new C, without passing any arguments.
Otherwise, a class can be instantiated with an argument list, e.g.new C(arguments). The arguments are passed to a constructor with a matching parameter list (and resolved like overloaded methods).

By default, a class instance is allocated on the garbage-collected heap. A scope class instance is allocated on the stack.

Constructors

Constructor: this Parameters MemberFunctionAttributesopt FunctionBody this Parameters MemberFunctionAttributesopt MissingFunctionBody ConstructorTemplate

Constructors are defined with a function name of this and have no return value:

class A { int i;

this(int i)     {
    this.i = i;     }

}

void main() { A a = new A(3); assert(a.i == 3); }

Base Class Construction

Base class construction is done by calling the base class constructor by the name super:

class A { this(int y) { } }

class B : A { int j; this() { ... super(3); ... } }

Delegating Constructors

A constructor can call another constructor for the same class in order to share common initializations. This is called a delegating constructor:

class C { int j; this() { ... } this(int i) { this(); j = i; } }

The following restrictions apply:

It is illegal for constructors to mutually call each other.
this() { this(1); }
this(int i) { this(); }
Implementation Defined: The compiler is not required to detect cyclic constructor calls.
Undefined Behavior: If the program executes with cyclic constructor calls.
If a constructor's code contains a delegating constructor call, all possible execution paths through the constructor must make exactly one delegating constructor call:
this() { a || super(); }
this() { (a) ? this(1) : super(); }
this()
{
for (...)
{
super(); }

} 3. It is illegal to refer to this implicitly or explicitly prior to making a delegating constructor call. 4. Delegating constructor calls cannot appear after labels.

Implicit Base Class Construction

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 or super 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 to super is required.

Instantiation Process

The following steps happen:

Storage is allocated for the object. If this fails, rather than return null, anOutOfMemoryError is thrown. Thus, tedious checks for null references are unnecessary.
The raw data is statically initialized using the values provided in the class definition. The pointer to the vtbl[] (the array of pointers to virtual functions) is assigned. Constructors are passed fully formed objects for which virtual functions can be called. This operation is equivalent to doing a memory copy of a static version of the object onto the newly allocated one.
If there is a constructor defined for the class, the constructor matching the argument list is called.
If a delegating constructor is not called, a call to the base class's default constructor is issued.
The body of the constructor is executed.
If class invariant checking is turned on, theclass invariant is called at the end of the constructor.

Constructor Attributes

Constructors can have one of these member function attributes:const, immutable, and shared. Construction of qualified objects will then be restricted to the implemented qualified constructors.

class C { this(); }

C m = new C();

const C c2 = new const C();

Constructors can be overloaded with different attributes.

class C { this(); this() shared; this() immutable; }

C m = new C(); shared s = new shared C(); immutable i = new immutable C();

Pure Constructors

If the constructor can create a unique object (e.g. if it is pure), the object can be implicitly convertible to any qualifiers.

class C { this() pure;

this(int[] arr) immutable pure;
                }

immutable i = new immutable C(); shared s = new shared C(); C m = new C([1,2,3]);

Field initialization inside a constructor

In a constructor body, the first instance of field assignment is its initialization.

class C { int num; this() { num = 1; num = 2; } }

If the field type has an opAssign method, it will not be used for initialization.

struct A { this(int n) {} void opAssign(A rhs) {} } class C { A val; this() { val = A(1); val = A(2); } }

If the field type is not mutable, multiple initialization will be rejected.

class C { immutable int num; this() { num = 1; num = 2; } }

If the field is initialized on one path, it must be initialized on all paths.

class C { immutable int num; immutable int ber; this(int i) { if (i) num = 3; else num = 4; } this(long j) { j ? (num = 3) : (num = 4); j || (ber = 3); j && (ber = 3); } }

A field initialization may not appear in a loop or after a label.

class C { immutable int num; immutable string str; this() { foreach (i; 0..2) { num = 1; } size_t i = 0; Label: str = "hello"; if (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; @disable this(); }

class C { S s; this(S t) { s = t; } this(int i) { this(); } this() { } }

Destructors

Destructor: ~ this ( ) MemberFunctionAttributesopt FunctionBody ~ this ( ) MemberFunctionAttributesopt MissingFunctionBody

The destructor function is called when:

A live object is deleted by the garbage collector
A live scope class instance goes out of scope
destroy is called on the object

Example:

import std.stdio;

class Foo { ~this() { writeln("dtor"); } }

void main() { auto foo = new Foo; destroy(foo); writeln("end"); }

Only one destructor can be declared per class, although other destructors can be mixed in.
A destructor does not have any parameters or attributes.
A destructor is always virtual.

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 with destroy. The runtime marks the object so the destructor is never called twice.

The destructor for the super class automatically gets called when the destructor ends. There is no way to call the super class destructor explicitly.

Implementation Defined: The garbage collector is not guaranteed to run the destructor for all unreferenced objects.

Important: The order in which the garbage collector calls destructors for unreferenced objects is not specified. This means that when the garbage collector calls a destructor for an object of a class that has members which are references to garbage collected objects, those references may no longer be valid. This means that destructors cannot reference sub objects.

Note: This rule does not apply to a scope class instance or an object destructed with destroy, as the destructor is not being run during a garbage collection cycle, meaning all references are valid.

Objects referenced from the static data segment never get collected by the GC.

Static Constructors and Destructors

Static Constructors

StaticConstructor: static this ( ) MemberFunctionAttributesopt FunctionBody static this ( ) MemberFunctionAttributesopt MissingFunctionBody

A static constructor is a function that performs initializations of thread local data before the main() 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.

Static constructors in other languages are built implicitly by using member initializers that can't be computed at compile time. The trouble with this stems from not having good control over exactly when the code is executed, for example:

class Foo { static int a = b + 1; static int b = a * 2; }

What values do a and b end up with, what order are the initializations executed in, what are the values of a and b 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 syntax static this().

class Foo { static int a; static int b = 1; static int c = b + a; static this() { a = b + 1; b = a * 2; } }

If main() or the thread returns normally, (does not throw an exception), the static destructor is added to the list of functions to be called on 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.

The static in the static constructor declaration is not an attribute, it must appear immediately before the this:

class Foo { static this() { ... } static private this() { ... } static { this() { ... } } static: this() { ... } }

Static Destructors

StaticDestructor: static ~ this ( ) MemberFunctionAttributesopt FunctionBody

A static destructor is defined as a special static function with the syntax static ~this().

class Foo { static ~this() { } }

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.

The static in the static destructor declaration is not an attribute, it must appear immediately before the ~this:

class Foo { static ~this() { ... } static private ~this() { ... } static { ~this() { ... } } static: ~this() { ... } }

Shared Static Constructors

SharedStaticConstructor: shared static this ( ) MemberFunctionAttributesopt FunctionBody shared static this ( ) MemberFunctionAttributesopt MissingFunctionBody

Shared static constructors are executed before any StaticConstructors, and are intended for initializing any shared global data.

Shared Static Destructors

SharedStaticDestructor: shared static ~ this ( ) MemberFunctionAttributesopt FunctionBody shared static ~ this ( ) MemberFunctionAttributesopt MissingFunctionBody

Shared static destructors are executed at program termination in the reverse order thatSharedStaticConstructors were executed.

Class Invariants

Invariant: invariant ( ) BlockStatement invariant BlockStatement invariant ( AssertArguments ) ;

Class _Invariant_s 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 a const member function. The invariant is defined to hold if all the AssertExpressions within the invariant that are executed succeed.

class Date { this(int d, int h) { day = d; hour = h; }

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.

Class _Invariant_s must hold at the exit of the class constructor (if any), and at the entry of the class destructor (if any).

Class _Invariant_s must hold at the entry and exit of all public or exported non-static member functions. The order of application of invariants is:

preconditions
invariant
function body
invariant
postconditions

If the invariant does not hold, then the program enters an invalid state.

Implementation Defined:

Whether the class Invariant is executed at runtime or not. This is typically controlled with a compiler switch.
The behavior when the invariant does not hold is typically the same as for when AssertExpressions fail.

Undefined Behavior: happens if the invariant does not hold and execution continues.

Public or exported non-static member functions cannot be called from within an invariant.

class Foo { public void f() { } private void g() { }

invariant
{
    f();          g();      }

}

Best Practices:

Do not indirectly call exported or public member functions within a class invariant, as this can result in infinite recursion.
Avoid reliance on side effects in the invariant. as the invariant may or may not be executed.
Avoid having mutable public fields of classes with invariants, as then the invariant cannot verify the public interface.

Scope Classes

A scope class is a class with the scope attribute, as in:

scope class Foo { ... }

The scope characteristic is inherited, so any classes derived from a scope class are also scope.

A scope class reference can only appear as a function local variable. It must be declared as being scope:

scope class Foo { ... }

void func() { Foo f; scope Foo g = new Foo(); }

When a scope class reference goes out of scope, the destructor (if any) for it is automatically called. This holds true even if the scope was exited via a thrown exception.

Abstract Classes

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 { abstract void f(); }

auto c = new C; class D : C {}

auto d = new D; class E : C { override void f() {} }

auto e = new E;

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. through super.foo() in a derived class. Note that the class is still abstract and cannot be instantiated directly.

A class can be declared abstract:

abstract class A { }

auto a = new A; class B : A {}

auto b = new B;

Final Classes

Final classes cannot be subclassed:

final class A { } class B : A { }

Methods of a final class are alwaysfinal.

Nested Classes

A nested class is a class that is declared inside the scope of a function or another class. A nested class has access to the variables and other symbols of the classes and functions it is nested inside:

class Outer { int m;

class Inner
{
    int foo()
    {
        return m;           }
}

}

void func() { int m;

class Inner
{
    int foo()
    {
        return m;         }
}

}

Static Nested Classes

If a nested class has the static attribute, then it can not access variables of the enclosing scope that are local to the stack or need athis reference:

class Outer { int m; static int n;

static class Inner
{
    int foo()
    {
        return m;               return n;           }
}

}

void func() { int m; static int n;

static class Inner
{
    int foo()
    {
        return m;               return n;           }
}

}

Context Pointer

Non-static nested classes work by containing an extra hidden member (called the context pointer) that is the frame pointer of the enclosing function if it is nested inside a function, or the this reference of the enclosing class's instance if 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 { }

static class SInner { }

}

void main() { Outer o = new Outer; Outer.SInner os = new Outer.SInner; }

void main() { class Nested { }

Nested n = new Nested;      
static f()
{
        }

}

Explicit Instantiation

A this reference can be supplied to the creation of an inner class instance by prefixing it to the NewExpression:

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); }

Here o supplies the this reference to the inner class instance of Outer.

outer Property

For a nested class instance, the .outer property provides the this reference of the enclosing class's instance. If there is no accessible parent class instance, the property provides a void* to the enclosing function frame.

class Outer { class Inner1 { Outer getOuter() { return this.outer; } }

void foo()
{
    Inner1 i = new Inner1;
    assert(i.getOuter() is this);
}

}

class Outer { void bar() { int x = 1;

    class Inner2
    {
        Outer getOuter()
        {
            x = 2;
                                                            return this.**_outer_**;
        }
    }

    Inner2 i = new Inner2;
    assert(i.getOuter() is this);
}

}

class Outer { static void baz() { int x = 1;

    class Inner3
    {
        void* getOuter()
        {
            x = 2;
                                            return this.**_outer_**;
        }
    }

    Inner3 i = new Inner3;
    assert(i.getOuter() !is null);
}

}

Anonymous Nested Classes

An anonymous nested class is both defined and instantiated with a NewAnonClassExpression:

NewAnonClassExpression: new class ConstructorArgsopt AnonBaseClassListopt AggregateBody

ConstructorArgs: ( NamedArgumentListopt )

AnonBaseClassList: SuperClassOrInterface SuperClassOrInterface , Interfaces

which is equivalent to:

class Identifier : AnonBaseClassList AggregateBody // ... new Identifier ConstructorArgs

where Identifier is the name generated for the anonymous nested class.

interface I { void foo(); }

auto obj = new class I { void foo() { writeln("foo"); } }; obj.foo();

Const, Immutable and Shared Classes

If a ClassDeclaration has a const, immutable or shared 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.