int* p;
int[3] s;
int[] a;

p.length; // error, length not known for pointer
s.length; // compile time constant 3
a.length; // runtime value

p.dup;    // error, length not known
s.dup;    // creates an array of 3 elements, copies
          // elements of s into it
a.dup;    // creates an array of a.length elements, copies
          // elements of a into it

Setting Dynamic Array Length

The .length property of a dynamic array can be set as the left-hand side of an = operator:

array.length = 7;

This causes the array to be reallocated in place, and the existing contents copied over to the new array. If the new array length is shorter, the array is not reallocated, and no data is copied. It is equivalent to slicing the array:

array = array[0..7];

If the new array length is longer, the array is reallocated if necessary, preserving the existing elements. The new elements are filled out with the default initializer.

Growing an Array

To maximize efficiency, the runtime always tries to resize the array in place to avoid extra copying. It will do a copy if the new size is larger and either:

• The array was not allocated by the GC.
• There is no spare capacity for the array.
• Resizing in place would overwrite valid data still accessible in another slice.

char[] a = new char[20];
char[] b = a[0..10];
char[] c = a[10..20];
char[] d = a;

b.length = 15; // always reallocates because extending in place would
               // overwrite other data in a.
b[11] = 'x';   // a[11] and c[1] are not affected
assert(a[11] == char.init);

d.length = 1;
assert(d.ptr == a.ptr); // unchanged

d.length = 20; // also reallocates, because doing this will overwrite a and c
assert(d.ptr != a.ptr);

c.length = 12; // may reallocate in place if space allows, because nothing
               // was allocated after c.
c[5] = 'y';    // may affect contents of a, but not b or d because those
               // were reallocated.

a.length = 25; // This always reallocates because if c extended in place,
               // then extending a would overwrite c.  If c didn't
               // reallocate in place, it means there was not enough space,
               // which will still be true for a.
a[15] = 'z';   // does not affect c, because either a or c has reallocated.

To guarantee copying behavior, use the .dup property to ensure a unique array that can be resized.

Note: These issues also apply to appending arrays with the ~= operator. Concatenation using the ~ operator is not affected since it always reallocates.

Resizing a dynamic array is a relatively expensive operation. So, while the following method of filling an array:

void fun()
{
    int[] array;
    while (1)
    {
        import core.stdc.stdio : getchar;
        auto c = getchar;
        if (!c)
            break;
        ++array.length;
        array[array.length - 1] = c;
    }
}

will work, it will be inefficient. A more practical approach would be to minimize the number of resizes:

void fun()
{
    int[] array;
    array.length = 100;        // guess
    int i;
    for (i = 0; ; i++)
    {
        import core.stdc.stdio : getchar;
        auto c = getchar;
        if (!c)
            break;
        if (i == array.length)
            array.length *= 2;
        array[i] = c;
    }
    array.length = i;
}

Base selection of the initial size on expected common use cases, which can be determined by instrumenting the code, or simply using good judgement. For example, when gathering user input from the console - it's unlikely to be longer than 80.

capacity and reserve

The capacity property gives the maximum length a dynamic array can grow to without reallocating. If the array does not point to GC-allocated memory, the capacity will be zero. The spare capacity for an array <em>a</em> is a.capacity - a.length.

By default, capacity will be zero if an element has been stored after the slice.

int[] a;
assert(a.capacity == 0);
a.length = 3; // may allocate spare capacity too
assert(a.capacity >= 3);
auto b = a[1..3];
assert(b.capacity >= 2); // either a or b can append into any spare capacity
b = a[0..2];
assert(b.capacity == 0);

Rationale: This behaviour helps prevent accidental overwriting of elements in another slice. It is also necessary to protect immutable elements from being overwritten.

The reserve function expands an array's capacity for use by the append operator or .length assignment.

int[] array;
const size_t cap = array.reserve(10); // request
assert(cap >= 10); // allocated may be more than request
assert(array.ptr != null);

int[] copy = array;
assert(copy.capacity == cap); // array and copy have same capacity
array ~= [1, 2, 3, 4, 5]; // grow in place
assert(cap == array.capacity); // array memory was not reallocated
assert(copy.ptr == array.ptr);
assert(copy.capacity == 0);
copy ~= 0; // new allocation
assert(copy.ptr != array.ptr);

Above, copy's length remains zero but it points to the same memory allocated by the reserve call. Because array is then appended to, copy.ptr + 0 no longer points to unused memory - instead that is the address of array[0]. So copy.capacity will be zero to prevent any appending to copy from overwriting elements in array.

Note: The runtime uses the number of appended elements to track the start of the spare capacity for the memory allocation.

When an array with spare capacity has its length reduced, or is assigned a slice of itself that ends before the previous last element, the capacity will be zero.

The @system function assumeSafeAppend allows the capacity to be regained, but care must be taken not to overwrite immutable elements that may exist in a longer slice.

int[] a = [1, 2, 3];
a.length--;
assert(a.capacity == 0);
a.assumeSafeAppend();
assert(a.capacity >= 3);

Note: Accessing .capacity may require the runtime to acquire a global lock and perform a cache lookup.

Functions as Array Properties

See Uniform Function Call Syntax (UFCS).

Array Bounds Checking

It is an error to index an array with an index that is less than 0 or greater than or equal to the array length. If an index is out of bounds, an ArrayIndexError is thrown if detected at runtime, and an error is raised if detected at compile time. A program may not rely on array bounds checking happening, for example, the following program is incorrect:

void main()
{
    import core.exception;
    try
    {
        auto array = [1, 2];
        for (auto i = 0; ; i++)
        {
            array[i] = 5;
        }
    }
    catch (ArrayIndexError)
    {
        // terminate loop
    }
}

The loop is correctly written:

void main()
{
    auto array = [1, 2];
    for (auto i = 0; i < array.length; i++)
    {
        array[i] = 5;
    }
}

Implementation Note: Compilers should attempt to detect array bounds errors at compile time, for example:

int[3] foo;
int x = foo[3]; // error, out of bounds

Insertion of array bounds checking code at runtime should be turned on and off with a compile time switch.

See also Safe Functions.

Disabling Array Bounds Checking

Insertion of array bounds checking code at runtime may be turned off with a compiler switch -boundscheck.

If the bounds check in @system or @trusted code is disabled, the code correctness must still be guaranteed by the code author.

On the other hand, disabling the bounds check in @safe code will break the guaranteed memory safety by compiler. It's not recommended unless motivated by speed measurements.

Array Initialization

Default Initialization

• Pointers are initialized to null.
• Static array contents are initialized to the default initializer for the array element type.
• Dynamic arrays are initialized to having 0 elements.
• Associative arrays are initialized to having 0 elements.

Length Initialization

The new expression can be used to allocate a dynamic array with a specified length by specifying its type and then using the (size) syntax:

int[] i = new int[](5); //i.length == 5
int[][] j = new int[][](10, 5); //j.length == 10, j[0].length == 5

Void Initialization

Void initialization happens when the Initializer for an array is void. What it means is that no initialization is done, i.e. the contents of the array will be undefined. This is most useful as an efficiency optimization. Void initializations are an advanced technique and should only be used when profiling indicates that it matters.

To void initialise the <em>elements</em> of a dynamic array use std.array.uninitializedArray.

Static Initialization of Statically Allocated Arrays

Static initalizations are supplied by a list of array element values enclosed in [ ]. The values can be optionally preceded by an index and a :. If an index is not supplied, it is set to the previous index plus 1, or 0 if it is the first value.

int[3] a = [ 1:2, 3 ]; // a[0] = 0, a[1] = 2, a[2] = 3

assert(a == [0, 2, 3]);

This is most handy when the array indices are given by Enums:

enum Color { red, blue, green }

int[Color.max + 1] value =
  [ Color.blue :6,
    Color.green:2,
    Color.red  :5 ];

assert(value == [5, 6, 2]);

All elements of a static array can be initialized to a specific value with:

int[4] a = 42; // set all elements of a to 42

assert(a == [42, 42, 42, 42]);

These arrays are statically allocated when they appear in global scope. Otherwise, they need to be marked with const or static storage classes to make them statically allocated arrays.

Special Array Types

Strings

A string is an array of immutable (read-only) characters. String literals essentially are an easy way to write character array literals.

char[] arr;
//arr = "abc";          // error, cannot implicitly convert expression `"abc"` of type `string` to `char[]`
arr = "abc".dup;        // ok, allocates mutable copy

string str1 = "abc";    // ok, same types
//str1 = arr;           // error, cannot implicitly convert expression `arr` of type `char[]` to `string`
str1 = arr.idup;        // ok, allocates an immutable copy of elements
assert(str1 == "abc");

string str2 = str1;     // ok, mutable slice of same immutable array contents

The name string is aliased to immutable(char)[]. The type immutable(char)[] represents an array of immutable chars. However, the reference to the string is mutable.

immutable(char)[] s = "foo";
s[0] = 'a';  // error, s[0] is immutable
s = "bar";   // ok, s itself is not immutable

If the reference to the string needs to be immutable as well, it can be declared immutable char[] or immutable string:

immutable char[] s = "foo";
s[0] = 'a';  // error, s refers to immutable data
s = "bar";   // error, s is immutable

Strings can be copied, compared, concatenated, and appended:

string s1;
immutable s2 = "ello";
s1 = s2;
s1 = "h" ~ s1;
if (s1 > "farro")
    s1 ~= " there";

assert(s1 == "hello there");

with array semantics. Any generated temporaries get cleaned up by the garbage collector (or by using alloca()). Not only that, this works with any array not just a special String array.

String Literal Types

The type of a string literal is determined by the semantic phase of compilation. The type is determined by implicit conversion rules. If there are two equally applicable implicit conversions, the result is an error. To disambiguate these cases, a cast or a postfix of c, w or d can be used:

cast(immutable(wchar)[]) "abc" // this is an array of wchar characters
"abc"w                         // so is this

String literals that do not have a postfix character and that have not been cast can be implicitly converted between string, wstring, and dstring (see below) as necessary.

void fun()
{
    char c;
    wchar w;
    dchar d;

    c = 'b';     // c is assigned the character 'b'
    w = 'b';     // w is assigned the wchar character 'b'
    //w = 'bc';  // error - only one wchar character at a time
    w = "b"[0];  // w is assigned the wchar character 'b'
    w = "\r"[0]; // w is assigned the carriage return wchar character
    d = 'd';     // d is assigned the character 'd'
}

Strings and Unicode

String data is encoded as follows:

Note that built-in comparison operators operate on a code unit basis. The end result for valid strings is the same as that of code point for code point comparison as long as both strings are in the same normalization form. Since normalization is a costly operation not suitable for language primitives it's assumed to be enforced by the user.

The standard library lends a hand for comparing strings with mixed encodings (by transparently decoding, see std.algorithm.cmp), case-insensitive comparison and normalization.

Last but not least, a desired string sorting order differs by culture and language and is usually nothing like code point for code point comparison. The natural order of strings is obtained by applying http://www.unicode.org/reports/tr10/, the Unicode collation algorithm

that should be implemented in the standard library.

Character Pointers and C strings

A pointer to a character can be generated:

string str = "abcd";
immutable(char)* p = &str[3]; // pointer to 4th element
assert(*p == 'd');
p = str.ptr; // pointer to 1st element
assert(*p == 'a');

Only string <em>literals</em> are zero-terminated in D. In general, when transferring a pointer to string data to C, append a terminating '\0':

string str = "ab";
assert(str.ptr[2] == '\0'); // OK
str ~= "cd";
// str is no longer zero-terminated
str ~= "\0";
assert(str[4] == '\0'); // OK
str.length = 2;
// str is no longer correctly zero-terminated
assert(str.ptr[2] != '\0');

The function std.string.toStringz can also be used.

Example: printf

core.stdc.stdio.printf is a C function and is not part of D. printf() will print C strings, which are 0 terminated. There are two ways to use printf() with D strings. The first is to add a terminating 0:

str ~= "\0";
printf("the string is '%s'\n", str.ptr);

or:

import std.string;
printf("the string is '%s'\n", std.string.toStringz(str));

String literals already have a 0 appended to them, so can be used directly:

printf("the string is '%s'\n", "string literal".ptr);

So, why does the first string literal to printf not need the .ptr? The first parameter is prototyped as a const(char)*, and a string literal can be implicitly converted to a const(char)*. The rest of the arguments to printf, however, are variadic (specified by ...), and a string literal typed immutable(char)[] cannot be passed to variadic parameters.

The second way is to use the precision specifier. The length comes first, followed by the pointer:

printf("the string is '%.*s'\n", cast(int)str.length, str.ptr);

The best way is to use std.stdio.writefln, which can handle D strings:

import std.stdio;
writefln("the string is '%s'", str);

Void Arrays

There is a special type of array which acts as a wildcard that can hold arrays of any kind, declared as void[]. Void arrays are used for low-level operations where some kind of array data is being handled, but the exact type of the array elements are unimportant. The .length of a void array is the length of the data in bytes, rather than the number of elements in its original type. Array indices in indexing and slicing operations are interpreted as byte indices.

Arrays of any type can be implicitly converted to a void array; the compiler inserts the appropriate calculations so that the .length of the resulting array's size is in bytes rather than number of elements. Void arrays cannot be converted back to the original type without using a cast, and it is an error to convert to an array type whose element size does not evenly divide the length of the void array.

void main()
{
    int[] data1 = [1,2,3];
    long[] data2;

    void[] arr = data1;            // OK, int[] implicit converts to void[].
    assert(data1.length == 3);
    assert(arr.length == 12);      // length is implicitly converted to bytes.

    //data1 = arr;                 // Illegal: void[] does not implicitly
                                   // convert to int[].
    int[] data3 = cast(int[]) arr; // OK, can convert with explicit cast.
    data2 = cast(long[]) arr;      // Runtime error: long.sizeof == 8, which
                                   // does not divide arr.length, which is 12
                                   // bytes.
}

Void arrays can also be static if their length is known at compile-time. The length is specified in bytes:

void main()
{
    byte[2] x;
    int[2] y;

    void[2] a = x; // OK, lengths match
    void[2] b = y; // Error: int[2] is 8 bytes long, doesn't fit in 2 bytes.
}

While it may seem that void arrays are just fancy syntax for ubyte[], there is a subtle distinction. The garbage collector generally will not scan ubyte[] arrays for pointers, ubyte[] being presumed to contain only pure byte data, not pointers. However, it will scan void[] arrays for pointers, since such an array may have been implicitly converted from an array of pointers or an array of elements that contain pointers. Allocating an array that contains pointers as ubyte[] may run the risk of the GC collecting live memory if these pointers are the only remaining references to their targets.

Implicit Conversions

A pointer T* can be implicitly converted to one of the following:

• void*

A static array T[dim] can be implicitly converted to one of the following (U is a base class of T):

• T[]
• const(U)[]
• const(U[])
• void[]

A dynamic array T[] can be implicitly converted to one of the following (U is a base class of T):

• const(U)[]
• const(U[])
• void[]

Array literals can also be implicitly converted to static array types. See Array Literals for details.

String literals can also be implicitly converted to static array types and character pointer types. See String Literals for details.

statement, Statements, hash-map, Associative Arrays