std.array

Функции и типы, которые манипулируют встроенными массивами и ассоциативными массивами.

Этот модуль предоставляет все виды функций для создания, манипулирования или преобразования массивов.

Лицензия:

Boost License 1.0.

Авторы:

Андрей Александреску и Джованни М. Дэвис

Исходный код

std/array.d

ForeachType!Range[] array(Range)(Range r)
Constraints: if (isIterable!Range && !isAutodecodableString!Range && !isInfinite!Range);

ForeachType!(PointerTarget!Range)[] array(Range)(Range r)
Constraints: if (isPointer!Range && isIterable!(PointerTarget!Range) && !isAutodecodableString!Range && !isInfinite!Range);

Создаёт массив и инициализирует его копиями элементов диапазона r.

Узкие строки обрабатываются следующим образом:

• Если включена автоматическая декодировка (по умолчанию), то они обрабатываются как отдельный перегруз.
• Если автоматическая декодировка выключена, то это эквивалентно дублированию массива.

Параметры:

Range r

диапазон (или агрегат с функцией opApply ), чьи элементы копируются в выделенный массив

Возвращает:

выделенный и инициализированный массив

Примеры:

auto a = array([1, 2, 3, 4, 5][]);
writeln(a); // [1, 2, 3, 4, 5]

CopyTypeQualifiers!(ElementType!String, dchar)[] array(String)(scope String str)
Constraints: if (isAutodecodableString!String);

Преобразует узкую строку с автоматической декодировкой в тип массива, который полностью поддерживает произвольный доступ. Это обрабатывается как особый случай и всегда возвращает массив dchar

ПРИМЕЧАНИЕ

Эта функция никогда не используется, когда автоматическая декодировка выключена.

Параметры:

String str

isNarrowString для преобразования в массив dchar

Возвращает:

массив dchar[], const(dchar)[], или immutable(dchar)[] в зависимости от константности входных данных.

Примеры:

import std.range.primitives : isRandomAccessRange;
import std.traits : isAutodecodableString;

// note that if autodecoding is turned off, `array` will not transcode these.
static if (isAutodecodableString!string)
    writeln("Hello D".array); // "Hello D"d
else
    writeln("Hello D".array); // "Hello D"

static if (isAutodecodableString!wstring)
    writeln("Hello D"w.array); // "Hello D"d
else
    writeln("Hello D"w.array); // "Hello D"w

static assert(isRandomAccessRange!dstring == true);

auto assocArray(Range)(Range r)
Constraints: if (isInputRange!Range);

auto assocArray(Keys, Values)(Keys keys, Values values)
Constraints: if (isInputRange!Values && isInputRange!Keys);

Возвращает новый ассоциативный массив из диапазона пар ключ/значение или из диапазона ключей и диапазона значений.

Параметры:

Range r	Диапазон кортежей ключей и значений.
Keys keys	Диапазон ключей
Values values	Диапазон значений

Возвращает:

Новый ассоциативный массив из элементов входного диапазона, который должен быть диапазоном кортежей (Ключ, Значение) или диапазоном ключей и диапазоном значений. Если заданы два диапазона разной длины, после исчерпания элементов более короткого, оставшиеся элементы более длинного не будут учтены. Возвращает пустую ссылку на ассоциативный массив при передаче пустого диапазона.

Дубликаты

Ассоциативные массивы имеют уникальные ключи. Если r содержит дублирующиеся ключи, то результат будет содержать значение последней пары для этого ключа в r.

См. также:

std.typecons.Tuple, std.range.zip

Примеры:

import std.range : repeat, zip;
import std.typecons : tuple;
import std.range.primitives : autodecodeStrings;
auto a = assocArray(zip([0, 1, 2], ["a", "b", "c"])); // aka zipMap
static assert(is(typeof(a) == string[int]));
writeln(a); // [0:"a", 1:"b", 2:"c"]

auto b = assocArray([ tuple("foo", "bar"), tuple("baz", "quux") ]);
static assert(is(typeof(b) == string[string]));
writeln(b); // ["foo":"bar", "baz":"quux"]

static if (autodecodeStrings)
    alias achar = dchar;
else
    alias achar = immutable(char);
auto c = assocArray("ABCD", true.repeat);
static assert(is(typeof(c) == bool[achar]));
bool[achar] expected = ['D':true, 'A':true, 'B':true, 'C':true];
writeln(c); // expected

auto byPair(AA)(AA aa)
Constraints: if (isAssociativeArray!AA);

Создаёт диапазон, итерирующийся по ассоциативному массиву с помощью кортежей ключ/значение.

Параметры:

AA aa

Ассоциативный массив для итерации.

Возвращает:

A последовательный диапазон кортежей пар ключ-значение из данного ассоциативного массива. Члены каждой пары могут быть доступны по имени (.key и .value). или по целочисленному индексу (0 и 1 соответственно).

Примеры:

import std.algorithm.sorting : sort;
import std.typecons : tuple, Tuple;

auto aa = ["a": 1, "b": 2, "c": 3];
Tuple!(string, int)[] pairs;

// Iteration over key/value pairs.
foreach (pair; aa.byPair)
{
    if (pair.key == "b")
        pairs ~= tuple("B", pair.value);
    else
        pairs ~= pair;
}

// Iteration order is implementation-dependent, so we should sort it to get
// a fixed order.
pairs.sort();
assert(pairs == [
    tuple("B", 2),
    tuple("a", 1),
    tuple("c", 3)
]);

nothrow @system auto uninitializedArray(T, I...)(I sizes)
Constraints: if (isDynamicArray!T && allSatisfy!(isIntegral, I) && hasIndirections!(ElementEncodingType!T));

nothrow @trusted auto uninitializedArray(T, I...)(I sizes)
Constraints: if (isDynamicArray!T && allSatisfy!(isIntegral, I) && !hasIndirections!(ElementEncodingType!T));

Возвращает новый массив типа T , выделенный в куче с сборкой мусора без инициализации его элементов. Это может быть полезной оптимизацией, если каждый элемент будет немедленно инициализирован. T может быть многомерным массивом. В этом случае размеры могут быть указаны для любого количества измерений от 0 до числа в T.

uninitializedArray является nothrow и слабо pure.

uninitializedArray является @system если тип неинициализированного элемента имеет указатели.

Параметры:

T	Тип элементов результирующего массива
I sizes	Размерность(и) результирующего массива

Возвращает:

Массив T с I.length измерениями.

Примеры:

double[] arr = uninitializedArray!(double[])(100);
writeln(arr.length); // 100

double[][] matrix = uninitializedArray!(double[][])(42, 31);
writeln(matrix.length); // 42
writeln(matrix[0].length); // 31

char*[] ptrs = uninitializedArray!(char*[])(100);
writeln(ptrs.length); // 100

nothrow @trusted auto minimallyInitializedArray(T, I...)(I sizes)
Constraints: if (isDynamicArray!T && allSatisfy!(isIntegral, I));

Возвращает новый массив типа T , выделенный в куче с сборкой мусора.

Частичная инициализация выполняется для типов с косвенными ссылками для сохранения безопасности памяти. Обратите внимание, что элементы будут инициализированы только до 0, но не обязательно до .init типа элемента.

minimallyInitializedArray является nothrow и слабо pure.

Параметры:

T	Тип элементов массива
I sizes	Размерность(и) результирующего массива

Возвращает:

Массив T с I.length измерениями.

Примеры:

import std.algorithm.comparison : equal;
import std.range : repeat;

auto arr = minimallyInitializedArray!(int[])(42);
writeln(arr.length); // 42

// Elements aren't necessarily initialized to 0, so don't do this:
// assert(arr.equal(0.repeat(42)));
// If that is needed, initialize the array normally instead:
auto arr2 = new int[42];
assert(arr2.equal(0.repeat(42)));

@trusted CommonType!(T[], U[]) overlap(T, U)(T[] a, U[] b)
Constraints: if (is(typeof(a.ptr < b.ptr) == bool));

Возвращает перекрывающуюся часть, если таковая имеется, двух массивов. В отличие от equal, overlap сравнивает только указатели и длины в диапазонах, а не значения, на которые они ссылаются. Если r1 и r2 имеют перекрываемый фрагмент, возвращает этот фрагмент. В противном случае возвращает нулевой фрагмент.

Параметры:

T[] a	Первый сравниваемый массив
U[] b	Второй сравниваемый массив

Возвращает:

Перекрывающуюся часть двух массивов.

Примеры:

int[] a = [ 10, 11, 12, 13, 14 ];
int[] b = a[1 .. 3];
writeln(overlap(a, b)); // [11, 12]
b = b.dup;
// overlap disappears even though the content is the same
assert(overlap(a, b).empty);

static test()() @nogc
{
    auto a = "It's three o'clock"d;
    auto b = a[5 .. 10];
    return b.overlap(a);
}

//works at compile-time
static assert(test == "three"d);

void insertInPlace(T, U...)(ref T[] array, size_t pos, U stuff)
Constraints: if (!isSomeString!(T[]) && allSatisfy!(isInputRangeOrConvertible!T, U) && (U.length > 0));

void insertInPlace(T, U...)(ref T[] array, size_t pos, U stuff)
Constraints: if (isSomeString!(T[]) && allSatisfy!(isCharOrStringOrDcharRange, U));

Вставляет stuff (которое должно быть диапазоном входных данных или любым количеством неявно преобразуемых элементов) в array в позиции pos.

Параметры:

T[] array	Массив, в который будет вставлено stuff .
size_t pos	Позиция в array для вставки stuff.
U stuff	Диапазон входных данных или любое количество неявно преобразуемых элементов для вставки в array.

Примеры:

int[] a = [ 1, 2, 3, 4 ];
a.insertInPlace(2, [ 1, 2 ]);
writeln(a); // [1, 2, 1, 2, 3, 4]
a.insertInPlace(3, 10u, 11);
writeln(a); // [1, 2, 1, 10, 11, 2, 3, 4]

pure nothrow @safe bool sameHead(T)(in T[] lhs, in T[] rhs);

Возвращает, ссылаются ли начала front массивов lhs и rhs на одно и то же место в памяти, делая один из массивов фрагментом другого, начинающегося с индекса 0.

Параметры:

T[] lhs	Первый сравниваемый массив
T[] rhs	Второй сравниваемый массив

Возвращает:

true если lhs.ptr == rhs.ptr, false в противном случае.

Примеры:

auto a = [1, 2, 3, 4, 5];
auto b = a[0 .. 2];

assert(a.sameHead(b));

pure nothrow @trusted bool sameTail(T)(in T[] lhs, in T[] rhs);

Возвращает, ссылаются ли хвосты back массивов lhs и rhs на одно и то же место в памяти, делая один из массивов фрагментом другого, заканчивающегося в индексе $.

Параметры:

T[] lhs	Первый сравниваемый массив
T[] rhs	Второй сравниваемый массив

Возвращает:

true если оба массива одинаковой длины и lhs.ptr == rhs.ptr, false в противном случае.

Примеры:

auto a = [1, 2, 3, 4, 5];
auto b = a[3..$];

assert(a.sameTail(b));

ElementEncodingType!S[] replicate(S)(S s, size_t n)
Constraints: if (isDynamicArray!S);

ElementType!S[] replicate(S)(S s, size_t n)
Constraints: if (isInputRange!S && !isDynamicArray!S);

Параметры:

S s	диапазон ввода input range или динамический массив
size_t n	число повторений s

Возвращаемое значение:

Массив, состоящий из s повторяющегося n раз. Эта функция выделяет, заполняет и возвращает новый массив.

См. также:

Для ленивой версии обратитесь к std.range.repeat.

Примеры:

auto a = "abc";
auto s = replicate(a, 3);

writeln(s); // "abcabcabc"

auto b = [1, 2, 3];
auto c = replicate(b, 3);

writeln(c); // [1, 2, 3, 1, 2, 3, 1, 2, 3]

auto d = replicate(b, 0);

writeln(d); // []

pure @safe S[] split(S)(S s)
Ограничения: если (isSomeString!S);

auto split(Range, Separator)(Range range, Separator sep)
Ограничения: если (isForwardRange!Range && (is(typeof(ElementType!Range.init == Separator.init)) || is(typeof(ElementType!Range.init == ElementType!Separator.init)) && isForwardRange!Separator));

auto split(alias isTerminator, Range)(Range range)
Ограничения: если (isForwardRange!Range && is(typeof(unaryFun!isTerminator(range.front))));

Жадно разбивает range на массив, используя sep в качестве разделителя.

Если разделитель не указан, строки разбиваются на массив слов, используя пробелы в качестве разделителей. Пробелы объединяются (пустых слов не создается).

range должен быть forward range. Разделитель может быть значением того же типа, что и элементы в range, или это может быть другой forward range.

Параметры:

S s	строка для разделения по словам, если разделитель не указан
Range range	диапазон для разделения
Separator sep	значение того же типа, что и элементы в range или другой
isTerminator	предикат, который разделяет диапазон, когда возвращает true.

Возвращаемое значение:

Массив, содержащий разделенные части range (или слова из s).

См. также:

std.algorithm.iteration.splitter для ленивой версии без выделения памяти. std.regex.splitter для версии, которая разделяет используя разделитель, определённый регулярным выражением.

Примеры:

import std.uni : isWhite;
writeln("Learning,D,is,fun".split(",")); // ["Learning", "D", "is", "fun"]
writeln("Learning D is fun".split!isWhite); // ["Learning", "D", "is", "fun"]
writeln("Learning D is fun".split(" D ")); // ["Learning", "is fun"]

Примеры:

string str = "Hello World!";
writeln(str.split); // ["Hello", "World!"]

string str2 = "Hello\t\tWorld\t!";
writeln(str2.split); // ["Hello", "World", "!"]

Примеры:

writeln(split("hello world")); // ["hello", "world"]
writeln(split("192.168.0.1", ".")); // ["192", "168", "0", "1"]

auto a = split([1, 2, 3, 4, 5, 1, 2, 3, 4, 5], [2, 3]);
writeln(a); // [[1], [4, 5, 1], [4, 5]]

ElementEncodingType!(ElementType!RoR)[] join(RoR, R)(RoR ror, scope R sep)
Ограничения: если (isInputRange!RoR && isInputRange!(Unqual!(ElementType!RoR)) && isInputRange!R && (is(immutable(ElementType!(ElementType!RoR)) == immutable(ElementType!R)) || isSomeChar!(ElementType!(ElementType!RoR)) && isSomeChar!(ElementType!R)));

ElementEncodingType!(ElementType!RoR)[] join(RoR, E)(RoR ror, scope E sep)
Ограничения: если (isInputRange!RoR && isInputRange!(Unqual!(ElementType!RoR)) && (is(E : ElementType!(ElementType!RoR)) || !autodecodeStrings && isSomeChar!(ElementType!(ElementType!RoR)) && isSomeChar!E));

ElementEncodingType!(ElementType!RoR)[] join(RoR)(RoR ror)
Ограничения: если (isInputRange!RoR && isInputRange!(Unqual!(ElementType!RoR)));

Жадно объединяет все диапазоны в ror вместе (с GC) в один массив, используя sep в качестве разделителя, если он присутствует.

Параметры:

RoR ror	Диапазон ввода input range диапазонов ввода
R sep	Диапазон ввода или единственный элемент для объединения диапазонов

Возвращаемое значение:

Массив элементов

См. также:

Для ленивой версии см. std.algorithm.iteration.joiner

Примеры:

writeln(join(["hello", "silly", "world"], " ")); // "hello silly world"
writeln(join(["hello", "silly", "world"])); // "hellosillyworld"

writeln(join([[1, 2, 3], [4, 5]], [72, 73])); // [1, 2, 3, 72, 73, 4, 5]
writeln(join([[1, 2, 3], [4, 5]])); // [1, 2, 3, 4, 5]

const string[] arr = ["apple", "banana"];
writeln(arr.join(",")); // "apple,banana"
writeln(arr.join()); // "applebanana"

E[] replace(E, R1, R2)(E[] subject, R1 from, R2 to)
Ограничения: если (isForwardRange!R1 && isForwardRange!R2 && (hasLength!R2 || isSomeString!R2) || is(Unqual!E : Unqual!R1));

Заменяет вхождения from на to в subject в новом массиве.

Параметры:

E[] subject	массив для сканирования
R1 from	элемент для замены
R2 to	элемент для замены всех вхождений from

Возвращаемое значение:

Новый массив без изменения содержимого subject, или исходный массив, если совпадений не найдено.

См. также:

std.algorithm.iteration.substitute для ленивой замены.

Примеры:

writeln("Hello Wörld".replace("o Wö", "o Wo")); // "Hello World"
writeln("Hello Wörld".replace("l", "h")); // "Hehho Wörhd"

void replaceInto(E, Sink, R1, R2)(Sink sink, E[] subject, R1 from, R2 to)
Ограничения: если (isOutputRange!(Sink, E) && (isForwardRange!R1 && isForwardRange!R2 && (hasLength!R2 || isSomeString!R2) || is(Unqual!E : Unqual!R1)));

Заменяет вхождения from на to в subject и выводит результат в sink.

Параметры:

Sink sink	output range
E[] subject	массив для сканирования
R1 from	элемент для замены
R2 to	элемент для замены всех вхождений from

См. также:

std.algorithm.iteration.substitute для ленивой замены.

Примеры:

auto arr = [1, 2, 3, 4, 5];
auto from = [2, 3];
auto to = [4, 6];
auto sink = appender!(int[])();

replaceInto(sink, arr, from, to);

writeln(sink.data); // [1, 4, 6, 4, 5]

T[] replace(T, Range)(T[] subject, size_t from, size_t to, Range stuff)
Ограничения: если (isInputRange!Range && (is(ElementType!Range : T) || isSomeString!(T[]) && is(ElementType!Range : dchar)));

Заменяет элементы с индексами от array (включительно) до from (исключительно) на диапазон stuff.

Параметры:

T[] subject	массив для сканирования
size_t from	начальный индекс
size_t to	конечный индекс
Range stuff	элементы для замены между from и to

Возвращаемое значение:

Новый массив без изменения содержимого subject.

См. также:

std.algorithm.iteration.substitute для ленивой замены.

Примеры:

auto a = [ 1, 2, 3, 4 ];
auto b = a.replace(1, 3, [ 9, 9, 9 ]);
writeln(a); // [1, 2, 3, 4]
writeln(b); // [1, 9, 9, 9, 4]

void replaceInPlace(T, Range)(ref T[] array, size_t from, size_t to, Range stuff)
Ограничения: если (is(typeof(replace(array, from, to, stuff))));

Заменяет элементы с индексами от array (включительно) до to (исключительно) на диапазон stuff. Расширяет или сокращает массив по мере необходимости.

Параметры:

T[] array	массив для сканирования
size_t from	начальный индекс
size_t to	конечный индекс
Range stuff	элементы для замены между from и to

Примеры:

int[] a = [1, 4, 5];
replaceInPlace(a, 1u, 2u, [2, 3, 4]);
writeln(a); // [1, 2, 3, 4, 5]
replaceInPlace(a, 1u, 2u, cast(int[])[]);
writeln(a); // [1, 3, 4, 5]
replaceInPlace(a, 1u, 3u, a[2 .. 4]);
writeln(a); // [1, 4, 5, 5]

E[] replaceFirst(E, R1, R2)(E[] subject, R1 from, R2 to)
Ограничения: если (isDynamicArray!(E[]) && isForwardRange!R1 && is(typeof(appender!(E[])().put(from[0..1]))) && isForwardRange!R2 && is(typeof(appender!(E[])().put(to[0..1]))));

Заменяет первое вхождение from на to в subject.

Параметры:

E[] subject	массив для сканирования
R1 from	элемент для замены
R2 to	элемент для замены from

Возвращаемое значение:

Новый массив без изменения содержимого subject, или исходный массив, если совпадений не найдено.

Примеры:

auto a = [1, 2, 2, 3, 4, 5];
auto b = a.replaceFirst([2], [1337]);
writeln(b); // [1, 1337, 2, 3, 4, 5]

auto s = "This is a foo foo list";
auto r = s.replaceFirst("foo", "silly");
writeln(r); // "This is a silly foo list"

E[] replaceLast(E, R1, R2)(E[] subject, R1 from, R2 to)
Ограничения: если (isDynamicArray!(E[]) && isForwardRange!R1 && is(typeof(appender!(E[])().put(from[0..1]))) && isForwardRange!R2 && is(typeof(appender!(E[])().put(to[0..1]))));

Заменяет последнее вхождение from на to в subject.

Параметры:

E[] subject	массив для сканирования
R1 from	элемент для замены
R2 to	элемент для замены from

Возвращаемое значение:

Новый массив без изменения содержимого subject, или исходный массив, если совпадений не найдено.

Примеры:

auto a = [1, 2, 2, 3, 4, 5];
auto b = a.replaceLast([2], [1337]);
writeln(b); // [1, 2, 1337, 3, 4, 5]

auto s = "This is a foo foo list";
auto r = s.replaceLast("foo", "silly");
writeln(r); // "This is a foo silly list"

inout(T)[] replaceSlice(T)(inout(T)[] s, in T[] slice, in T[] replacement);

Создает новый массив, в котором элементы в slice заменяются элементами в replacement. slice и replacement не обязательно должны иметь одинаковую длину. Результат будет увеличиваться или уменьшаться в зависимости от предоставленных элементов.

Параметры:

inout(T)[] s	основание нового массива
T[] slice	срез s для замены
T[] replacement	элементы для замены slice

Возвращает:

Новый массив, в котором s заменены на slice.

См. также:

std.algorithm.iteration.substitute для ленивой замены.

Примеры:

auto a = [1, 2, 3, 4, 5];
auto b = replaceSlice(a, a[1 .. 4], [0, 0, 0]);

writeln(b); // [1, 0, 0, 0, 5]

struct Appender(A) if (isDynamicArray!A);

Реализует диапазон вывода, добавляющий данные в массив. Это рекомендуется вместо array ~= data при добавлении многих элементов, так как это более эффективно. Appender сохраняет свои метаданные массива локально, поэтому может избежать глобальной блокировки для каждого добавления, где capacity не равно нулю.

Параметры:

A	тип массива для моделирования.

См. также:

appender

Примеры:

auto app = appender!string();
string b = "abcdefg";
foreach (char c; b)
    app.put(c);
writeln(app[]); // "abcdefg"

int[] a = [ 1, 2 ];
auto app2 = appender(a);
app2.put(3);
app2.put([ 4, 5, 6 ]);
writeln(app2[]); // [1, 2, 3, 4, 5, 6]

pure nothrow @trusted this(A arr);

Конструирует Appender с заданным массивом. Обратите внимание, что это не копирует данные. Если массив имеет большую емкость, как определено arr.capacity, она будет использоваться аппендером. После инициализации аппендера в массиве, добавление в исходный массив приведет к перераспределению.

void reserve(size_t newCapacity);

Зарезервировать как минимум newCapacity элементов для добавления. Обратите внимание, что может быть зарезервировано больше элементов, чем запрошено. Если newCapacity <= capacity, то ничего не делается.

Параметры:

size_t newCapacity

емкость, которую должен иметь Appender

const pure nothrow @property @safe size_t capacity();

Возвращает:

емкость массива (максимальное количество элементов, которые может вместить управляемый массив, прежде чем произойдет перераспределение). Если любое добавление приведет к перераспределению, будет возвращено 0.

inout pure nothrow @property @trusted inout(ElementEncodingType!A)[] data();

Используйте opSlice() отныне.

Возвращает:

Управляемый массив.

inout pure nothrow @property @trusted inout(ElementEncodingType!A)[] opSlice();

Возвращает:

Управляемый массив.

void put(U)(U item)
Constraints: if (canPutItem!U);

Добавляет item в управляемый массив. Выполняет кодирование для char типов, если A является массивом char другого типа.

Параметры:

U item

одиночный элемент для добавления

void put(Range)(Range items)
Constraints: if (canPutRange!Range);

Добавляет весь диапазон в управляемый массив. Выполняет кодирование для char элементов, если A — это массив char другого типа.

Параметры:

Range items

диапазон элементов для добавления

template opOpAssign(string op : "~")

Добавляет в управляемый массив.

См. также:

Appender.put

pure nothrow @trusted void clear();

Очищает управляемый массив. Это позволяет повторно использовать элементы массива для добавления.

Примечание

clear отключен для неизменяемых или константных типов элементов, из-за возможности, что Appender может перезаписать неизменяемые данные.

pure @trusted void shrinkTo(size_t newlength);

Уменьшает управляемый массив до заданной длины.

Исключения:

Exception если newlength больше текущей длины массива.

Примечание

shrinkTo отключен для неизменяемых или константных типов элементов.

const string toString()();

const void toString(Writer)(ref Writer w, ref scope const std.format.FormatSpec!char fmt)
Constraints: if (isOutputRange!(Writer, char));

Возвращает строку в формате Appender!(A)(data).

Параметры:

Writer w	Диапазон вывода, принимающий диапазон вывода.
std.format.FormatSpec!char fmt	std.format.FormatSpec, определяющий, как форматируется массив.

Возвращает:

Строку string если writer не установлено; void в противном случае.

struct RefAppender(A) if (isDynamicArray!A);

Версия Appender, которая может обновлять массив непосредственно. Пересылает все вызовы базовой реализации аппендера. Любые вызовы, сделанные аппендеру, также обновляют указатель на исходный массив, переданный в него.

Совет

Используйте перегрузку arrayPtr appender для создания с выводом типа.

Параметры:

A	тип массива для моделирования

Примеры:

int[] a = [1, 2];
auto app2 = appender(&a);
writeln(app2[]); // [1, 2]
writeln(a); // [1, 2]
app2 ~= 3;
app2 ~= [4, 5, 6];
writeln(app2[]); // [1, 2, 3, 4, 5, 6]
writeln(a); // [1, 2, 3, 4, 5, 6]

app2.reserve(5);
assert(app2.capacity >= 5);

this(A* arr);

Конструирует RefAppender с заданной ссылкой на массив. Это не копирует данные. Если массив имеет большую емкость, как определено arr.capacity, она будет использоваться аппендером.

Примечание

Не используйте встроенное добавление (например, ~=) к исходному массиву, пока не закончите работу с аппендером, так как последующие вызовы аппендера перераспределят данные массива без этих добавлений.

Параметры:

A* arr

Указатель на массив. Не должен быть null.

void opDispatch(string fn, Args...)(Args args)
Constraints: if (__traits(compiles, (Appender!A a) => mixin("a." ~ fn ~ "(args)")));

Оборачивает оставшиеся Appender методы, такие как put.

Параметры:

fn	Имя метода для вызова.
Args args	Аргументы для передачи методу.

void opOpAssign(string op : "~", U)(U rhs)
Constraints: if (__traits(compiles, (Appender!A a) { a.put(rhs); } ));

Добавляет rhs в управляемый массив.

Параметры:

U rhs

Элемент или диапазон.

const @property size_t capacity();

Возвращает емкость массива (максимальное количество элементов, которые может вместить управляемый массив, прежде чем произойдет перераспределение). Если любое добавление приведет к перераспределению, capacity вернет 0.

inout @property inout(ElementEncodingType!A)[] opSlice();

Возвращает:

управляемый массив.

Appender!A appender(A)()
Constraints: if (isDynamicArray!A);

Appender!(E[]) appender(A : E[], E)(auto ref A array);

Функция-удобство, которая возвращает экземпляр Appender, необязательно инициализированный array.

Примеры:

auto w = appender!string;
// pre-allocate space for at least 10 elements (this avoids costly reallocations)
w.reserve(10);
assert(w.capacity >= 10);

w.put('a'); // single elements
w.put("bc"); // multiple elements

// use the append syntax
w ~= 'd';
w ~= "ef";

writeln(w[]); // "abcdef"

RefAppender!(E[]) appender(P : E[]*, E)(P arrayPtr);

Функция-удобство, которая возвращает экземпляр RefAppender, инициализированный arrayPtr. Не используйте null для указателя массива, используйте другую версию appender вместо этого.

Примеры:

int[] a = [1, 2];
auto app2 = appender(&a);
writeln(app2[]); // [1, 2]
writeln(a); // [1, 2]
app2 ~= 3;
app2 ~= [4, 5, 6];
writeln(app2[]); // [1, 2, 3, 4, 5, 6]
writeln(a); // [1, 2, 3, 4, 5, 6]

app2.reserve(5);
assert(app2.capacity >= 5);

T[n] staticArray(T, size_t n)(auto ref T[n] a);

auto staticArray(size_t n, T)(scope T a)
Constraints: if (isInputRange!T);

auto staticArray(size_t n, T)(scope T a, out size_t rangeLength)
Constraints: if (isInputRange!T);

auto staticArray(Un : U[n], U, size_t n, T)(scope T a)
Constraints: if (isInputRange!T && is(ElementType!T : U));

auto staticArray(Un : U[n], U, size_t n, T)(scope T a, out size_t rangeLength)
Constraints: if (isInputRange!T && is(ElementType!T : U));

auto staticArray(alias a)()
Constraints: if (isInputRange!(typeof(a)));

auto staticArray(U, alias a)()
Constraints: if (isInputRange!(typeof(a)));

Создаёт статический массив из a. Тип элементов может быть указан неявно, так что [1, 2].staticArray приводит к int[2], или явно, например [1, 2].staticArray!float возвращает float[2]. Когда a представляет собой диапазон, длина которого неизвестна на этапе компиляции, количество элементов должно быть указано как шаблонный аргумент (например, myrange.staticArray!2). Размер и тип могут быть объединены, если элементы исходного диапазона неявно преобразуются в требуемый тип элемента (например, 2.iota.staticArray!(long[2])). Когда диапазон a известен на этапе компиляции, его также можно указать как шаблонный аргумент, чтобы избежать необходимости указывать количество элементов (например: staticArray!(2.iota) или staticArray!(double, 2.iota)).

Примечание

staticArray возвращается по значению, поэтому выражения, включающие большие массивы, могут быть неэффективными.

Параметры:

T[n] a	Входные элементы. Если элементов меньше, чем указанная длина статического массива, оставшаяся часть инициализируется по умолчанию. Если элементов больше, чем указано, используются первые элементы до указанной длины.
size_t rangeLength	Выводит количество элементов, используемых из a в него. Необязательно.

Возвращает:

Статический массив, созданный из a.

Примеры:

статический массив из литерала массива

auto a = [0, 1].staticArray;
static assert(is(typeof(a) == int[2]));
writeln(a); // [0, 1]

Примеры:

статический массив из диапазона + размера

import std.range : iota;

auto input = 3.iota;
auto a = input.staticArray!2;
static assert(is(typeof(a) == int[2]));
writeln(a); // [0, 1]
auto b = input.staticArray!(long[4]);
static assert(is(typeof(b) == long[4]));
writeln(b); // [0, 1, 2, 0]

Примеры:

статический массив из диапазона времени компиляции

import std.range : iota;

enum a = staticArray!(2.iota);
static assert(is(typeof(a) == int[2]));
writeln(a); // [0, 1]

enum b = staticArray!(long, 2.iota);
static assert(is(typeof(b) == long[2]));
writeln(b); // [0, 1]