Classes in D

A class in D is a reference type: instances are created with new and allocated on the garbage-collected heap, and every class variable is really a reference to that heap object rather than the object itself. Every class implicitly derives from the root class Object, either directly or through its base class chain, which is why every class instance automatically has toString, opEquals, toHash, and opCmp methods available to override. D supports single inheritance — a class can extend exactly one base class with class Dog : Animal { ... } — but a class can additionally implement any number of interfaces, giving you multiple-interface polymorphism without the diamond-inheritance complexity of multiple class inheritance. Because assignment copies the reference and not the object, Dog a = new Dog(); Dog b = a; makes a and b point at the very same heap object, so mutating a field through b is visible through a as well.

Member functions in D classes are virtual by default, meaning a call through a base-class reference dispatches to the most-derived override at runtime; you opt out of this with the final keyword when you want to forbid further overriding, and you must mark an overriding method explicitly with override so the compiler can catch typos in the method signature instead of silently creating an unrelated new method. An abstract class, declared with abstract class Shape { abstract double area(); }, cannot be instantiated directly and exists purely to define a common interface and possibly some shared implementation for its subclasses. Interfaces, declared with interface Drawable { void draw(); }, define a pure contract with no state and no implementation (D does support default method bodies in interfaces in limited cases, but the common idiom is a pure abstract contract); a class can implement several interfaces at once with class Circle : Shape, Drawable { ... }, and any Drawable-typed reference can then hold a Circle, a Square, or anything else implementing that interface.

Class constructors use this(...) exactly like structs, and a derived class constructor must call super(...) — explicitly or implicitly, if the base has a compatible default constructor — before accessing this, since the base portion of the object must be initialized first. Destructors are declared with ~this() and, critically, are called by the garbage collector during a collection cycle whenever it determines the object is unreachable — this timing is nondeterministic, meaning you cannot rely on a class destructor running promptly, or even at all, before the program exits. When deterministic cleanup is needed — closing a file handle, releasing a lock — call the standard library function destroy(obj), which runs the destructor immediately and resets the object's fields to their .init state, after which the reference should be treated as no longer usable (though the memory itself is only reclaimed later by the GC).

Because two class references can point at the same object, D distinguishes identity from equality: the is operator, a is b, tests whether two references point at the exact same object (or compares to null), while the == operator calls opEquals and tests for logical equality as defined by the class, which by default falls back to Object's identity-based comparison unless overridden. Every class inherits toString() from Object, which writeln and format use automatically to produce a readable representation, so overriding toString is the idiomatic way to make a custom class print meaningfully; similarly, overriding toHash() alongside opEquals is required if instances of the class will be used as associative array keys, since the two must remain consistent with each other. Casting between related class types uses cast(Derived) baseRef, which performs a runtime check and yields null if the actual object is not in fact an instance of Derived, giving you a safe way to do type-narrowing similar to a dynamic_cast in other languages.