• Introduction
• Lexical
• Interpolation Expression Sequence
• Grammar
• Modules
• Declarations
• Types
• Properties
• Attributes
• Pragmas
• Expressions
• Statements
• Arrays
• Associative Arrays
• Structs and Unions
• Classes
• Interfaces
• Enums
• Type Qualifiers
• Functions
• Operator Overloading
• Templates
• Template Mixins
• Contract Programming
• Conditional Compilation
• Traits
• Error Handling
• Unit Tests
• Garbage Collection
• Floating Point
• D x86 Inline Assembler
• Embedded Documentation
• Interfacing to C
• Interfacing to C++
• Interfacing to Objective-C
• Portability Guide
• Named Character Entities
• Memory Safety
• Application Binary Interface
• Vector Extensions
• Better C
• ImportC
• Live Functions
• Windows Programming
• Glossary
• Legacy Code
• Editions

Properties

Common Properties

Every symbol, type, and expression has properties that can be queried:

Type Properties

Every type has properties that can be queried. Every expression also has these properties, which are equivalent to the properties of the expression's type. These properties are:

Numeric Properties

Derived Type Properties

See:

• Array Properties
• Associative Array Properties
• Vector Properties

User-Defined Type Properties

See:

• Class Properties
• Enum Properties
• Struct Properties

.init Property

.init produces a constant expression that is the default initializer. If applied to a type, it is the default initializer for that type. If applied to a variable or field, it is the default initializer for that variable or field's type. The default values for different kinds of types are described below:

int a;
int b = 1;

static assert(int.init == 0);
static assert(a.init == 0);
static assert(b.init == 0);

struct Foo
{
    int a;
    int b = 7;
}

static assert(Foo.init.a == 0);
static assert(Foo.init.b == 7);

.init vs Default Initialization

Note that .init produces a statically initialized object, which may be different from default initialization for value types:

1. For a nested struct S, the context pointer in S.init is null:

void main()
{
    int x;
    struct S
    {
        void foo() { x = 1; }  // access x in enclosing scope via context pointer
    }
    S s1;           // OK, s1 correctly initializes its context pointer
    S s2 = S();     // OK, same as s1
    s1.foo();       // OK

    S s3 = S.init;  // Beware, the context pointer in s3 is null
    s3.foo();       // Access violation
}

2. If a struct S has @disable this();, T.init might return a logically incorrect object:

struct S
{
    int x;
    @disable this();
    this(int n) { x = n; }
    invariant { assert(x > 0); }
    void check() {}
}

void main()
{
  //S s1;           // Error: variable s1 initializer required for type S
  //S s2 = S();     // Error: constructor S.this is not callable
                    // because it is annotated with @disable
    S s3 = S.init;  // Bad. s3.x == 0, and it violates the invariant of S
    s3.check();     // Assertion failure
}

Similarly, a static array of structs may have different behaviour for .init vs default initialization.

.stringof Property

.stringof produces a constant string that is the source representation of its prefix. If applied to a type, it is the string for that type. If applied to an expression, it is the source representation of that expression. The expression will not be evaluated.

module test;
import std.stdio;

struct Dog { }

enum Color { Red }

int i = 4;

void main()
{
    writeln((1+2).stringof);       // "1 + 2"
    writeln(test.stringof);        // "module test"
    writeln(Dog.stringof);         // "Dog"
    writeln(int.stringof);         // "int"
    writeln((int*[5][]).stringof); // "int*[5][]"
    writeln(Color.Red.stringof);   // "Red"
    writeln((5).stringof);         // "5"

    writeln((++i).stringof);       // "i += 1"
    assert(i == 4);                // `++i` was not evaluated
}

.sizeof Property

e.sizeof gives the size in bytes of the expression e.

When getting the size of a member, it is not necessary for there to be a this object:

struct S
{
    int a;
}

static assert(S.a.sizeof == 4);
static assert(Object.sizeof == (void*).sizeof);

.sizeof applied to a class object returns the size of the class reference, not the class instantiation.

See also: __traits(classInstanceSize).

.alignof Property

.alignof gives the aligned size of an expression or type. For example, an aligned size of 1 means that it is aligned on a byte boundary, 4 means it is aligned on a 32 bit boundary.

See the align attribute for an example.

.mangleof Property

Mangling refers to how a symbol is represented in text form in the generated object file. .mangleof returns a string literal of the representation of the type or symbol it is applied to. The mangling of types and symbols with D linkage is defined by Name Mangling.

.classinfo Property

.classinfo provides information about the dynamic type of a class object. It returns a reference to type object.TypeInfo_Class.

.classinfo applied to an interface gives the information for the interface, not the class it might be an instance of.

.tupleof Property

.tupleof provides a symbol sequence of all the non-static fields in a struct or class. The order of the fields in the tuple matches the order in which the fields are declared.

struct Vector3
{
    int x, y, z;
}

void test()
{
    Vector3 v = Vector3(5, 10, 15);
    float sum = 0;
    foreach(num; v.tupleof)
    {
        sum+= num;
    }
    writeln(sum); //30
}

User-Defined Properties

User-defined properties can be created using Property Functions.