View source code
Display the source code in std/array.d from which this page was generated on github.
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using local clone.

Module std.array

Functions and types that manipulate built-in arrays and associative arrays.

This module provides all kinds of functions to create, manipulate or convert arrays:

Function Name Description
array Returns a copy of the input in a newly allocated dynamic array.
appender Returns a new Appender or RefAppender initialized with a given array.
assocArray Returns a newly allocated associative array from a range of key/value tuples.
byPair Construct a range iterating over an associative array by key/value tuples.
insertInPlace Inserts into an existing array at a given position.
join Concatenates a range of ranges into one array.
minimallyInitializedArray Returns a new array of type T.
replace Returns a new array with all occurrences of a certain subrange replaced.
replaceFirst Returns a new array with the first occurrence of a certain subrange replaced.
replaceInPlace Replaces all occurrences of a certain subrange and puts the result into a given array.
replaceInto Replaces all occurrences of a certain subrange and puts the result into an output range.
replaceLast Returns a new array with the last occurrence of a certain subrange replaced.
replaceSlice Returns a new array with a given slice replaced.
replicate Creates a new array out of several copies of an input array or range.
sameHead Checks if the initial segments of two arrays refer to the same place in memory.
sameTail Checks if the final segments of two arrays refer to the same place in memory.
split Eagerly split a range or string into an array.
staticArray Creates a new static array from given data.
uninitializedArray Returns a new array of type T without initializing its elements.

Functions

NameDescription
appender() Convenience function that returns an Appender instance, optionally initialized with array.
appender(arrayPtr) Convenience function that returns a RefAppender instance initialized with arrayPtr. Don't use null for the array pointer, use the other version of appender instead.
array(r) Allocates an array and initializes it with copies of the elements of range r.
array(str) Convert a narrow autodecoding string to an array type that fully supports random access. This is handled as a special case and always returns an array of dchar
assocArray(r) Returns a newly allocated associative array from a range of key/value tuples or from a range of keys and a range of values.
byPair(aa) Construct a range iterating over an associative array by key/value tuples.
insertInPlace(array, pos, stuff) Inserts stuff (which must be an input range or any number of implicitly convertible items) in array at position pos.
join(ror, sep) Eagerly concatenates all of the ranges in ror together (with the GC) into one array using sep as the separator if present.
minimallyInitializedArray(sizes) Returns a new array of type T allocated on the garbage collected heap.
overlap(a, b) Returns the overlapping portion, if any, of two arrays. Unlike equal, overlap only compares the pointers and lengths in the ranges, not the values referred by them. If r1 and r2 have an overlapping slice, returns that slice. Otherwise, returns the null slice.
replace(subject, from, to) Replace occurrences of from with to in subject in a new array.
replace(subject, from, to, stuff) Replaces elements from array with indices ranging from from (inclusive) to to (exclusive) with the range stuff.
replaceFirst(subject, from, to) Replaces the first occurrence of from with to in subject.
replaceInPlace(array, from, to, stuff) Replaces elements from array with indices ranging from from (inclusive) to to (exclusive) with the range stuff. Expands or shrinks the array as needed.
replaceInto(sink, subject, from, to) Replace occurrences of from with to in subject and output the result into sink.
replaceLast(subject, from, to) Replaces the last occurrence of from with to in subject.
replaceSlice(s, slice, replacement) Creates a new array such that the items in slice are replaced with the items in replacement. slice and replacement do not need to be the same length. The result will grow or shrink based on the items given.
replicate(s, n)
sameHead(lhs, rhs) Returns whether the fronts of lhs and rhs both refer to the same place in memory, making one of the arrays a slice of the other which starts at index 0.
sameTail(lhs, rhs) Returns whether the backs of lhs and rhs both refer to the same place in memory, making one of the arrays a slice of the other which end at index $.
split(s) Eagerly splits range into an array, using sep as the delimiter.
staticArray(a) Constructs a static array from a. The type of elements can be specified implicitly so that [1, 2].staticArray results in int[2], or explicitly, e.g. [1, 2].staticArray!float returns float[2]. When a is a range whose length is not known at compile time, the number of elements must be given as template argument (e.g. myrange.staticArray!2). Size and type can be combined, if the source range elements are implicitly convertible to the requested element type (eg: 2.iota.staticArray!(long[2])). When the range a is known at compile time, it can also be specified as a template argument to avoid having to specify the number of elements (e.g.: staticArray!(2.iota) or staticArray!(double, 2.iota)).
uninitializedArray(sizes) Returns a new array of type T allocated on the garbage collected heap without initializing its elements. This can be a useful optimization if every element will be immediately initialized. T may be a multidimensional array. In this case sizes may be specified for any number of dimensions from 0 to the number in T.

Structs

NameDescription
Appender Implements an output range that appends data to an array. This is recommended over array ~= data when appending many elements because it is more efficient. Appender maintains its own array metadata locally, so it can avoid the performance hit of looking up slice capacity for each append.
RefAppender A version of Appender that can update an array in-place. It forwards all calls to an underlying appender implementation. Any calls made to the appender also update the pointer to the original array passed in.

Authors

Andrei Alexandrescu and Jonathan M Davis

License

Boost License 1.0.