Arrays and Slices in D

D provides three closely related but distinct sequence abstractions: static arrays, dynamic arrays, and slices. A static array such as int[5] has its length baked into the type itself and is typically allocated inline — on the stack for a local variable, or inside the containing struct or class for a member. A dynamic array such as int[] is a length-and-pointer pair whose backing storage lives on the garbage-collected heap and can grow. A slice is not really a fourth type at all — int[] is itself a slice: a view made of a pointer and a length over some underlying memory, whether that memory belongs to a static array, a dynamic array, or a string literal. Knowing which of these three you are holding at any point in a program is essential to reasoning about ownership, mutation, and performance in D.

A static array is declared with the length as part of the type, for example int[5] scores;, and its size is fixed at compile time and cannot change. Because the length is part of the type, int[5] and int[10] are different, incompatible types. Static arrays have value semantics: assigning one static array to another copies every element, and passing one to a function by value copies the whole thing onto the callee's stack frame unless you pass by ref. This makes small static arrays cheap and predictable — no heap allocation, no garbage collector involvement — but it also means copying a large static array is an O(n) operation that can silently hurt performance if you are not paying attention. Static arrays default-initialize their elements using the element type's .init value, so int[5] arr; gives you five zeros without any extra code.

A dynamic array such as int[] values declares only the element type, not a fixed length, and its storage is allocated on the garbage-collected heap. You can grow it with the append operator, values ~= 42;, or by directly setting values.length = 10;, both of which may trigger a reallocation if the current backing block does not have enough spare capacity. D dynamic arrays expose a .capacity property that tells you how many elements can be appended before a reallocation is needed, and std.array's reserve function lets you pre-grow the backing store to avoid repeated reallocations in a tight loop. Because the array reference — pointer plus length — is itself passed by value, two dynamic array variables can point at the same underlying memory; mutating an element through one is visible through the other until one of them is reassigned to a different length or a fresh allocation.

Slicing an existing array with arr[1 .. 3] does not copy any elements; it produces a new (pointer, length) pair that views the same memory as arr, starting at index 1 and stopping before index 3. Inside a slicing expression, the special $ symbol means the length of the array being sliced, so arr[$-1] refers to the last element and arr[0 .. $] is a full-array slice. Because slices are views, mutating slice[0] = 99; after auto slice = arr[1 .. 3]; also changes arr[1], since both refer to the same backing storage — this aliasing is powerful for avoiding copies but is a common source of bugs when a function silently mutates data the caller expected to be read-only. To get an independent copy instead of a view, call .dup for a mutable copy or .idup for an immutable copy, both of which allocate fresh backing memory.

The ~ operator concatenates two arrays and always allocates a brand-new array for the result, so a ~ b never mutates either operand. The ~= operator appends in place and reuses the existing backing memory when there is spare .capacity, but silently falls back to allocating a new block and copying everything over when there isn't — this is why appending to two slices that alias the same array can suddenly stop aliasing partway through a loop. Bounds checking is enabled by default: indexing or slicing out of range throws a core.exception.RangeError in a normal debug build, though this check is stripped out under the -release compiler flag for maximum performance, so code that relies on bounds errors for correctness must not be shipped with -release unless the invariant is guaranteed some other way. Multidimensional arrays follow the same rules: int[3][4] is a static array of 4 static arrays of 3 ints each, while int[][] is a dynamic array of dynamic arrays, letting each row have an independent, jagged length.