std.container.array

auto arr = Array!int(0, 2, 3);
writeln(arr[0]); // 0
writeln(arr.front); // 0
writeln(arr.back); // 3

// 予備スペース
arr.reserve(1000);
writeln(arr.length); // 3
assert(arr.capacity >= 1000);

// 挿入
arr.insertBefore(arr[1..$], 1);
writeln(arr.front); // 0
writeln(arr.length); // 4

arr.insertBack(4);
writeln(arr.back); // 4
writeln(arr.length); // 5

// 要素を設定する
arr[1] *= 42;
writeln(arr[1]); // 42

import std.algorithm.comparison : equal;
auto arr = Array!int(1, 2, 3);

// concat
auto b = Array!int(11, 12, 13);
arr ~= b;
writeln(arr.length); // 6

// スライス
assert(arr[1 .. 3].equal([2, 3]));

// 除去
arr.linearRemove(arr[1 .. 3]);
assert(arr[0 .. 2].equal([1, 11]));

auto arr = Array!bool([true, true, false, true, false]);
writeln(arr.length); // 5

struct Array(T) if (!is(immutable(T) == immutable(bool)));

メモリを決定論的に制御する配列型。 配列に割り当てられたメモリはできるだけ早く回収され、 ガベージコレクタに依存することはない。 Arraymalloc 、realloc 、freeを 独自のメモリの管理に使用している。

つまり、要素へのポインタは、 Array要素が削除されるとすぐに、 ポインタが宙に浮いた状態になる Array。一方、 によって割り当てられたメモリは ArrayGCによってスキャンされ、 GC管理オブジェクトが参照する Array生存状態が維持されます。

注釈 xml-ph-0000@deepl.internalのような範囲ベースの関数と併用する場合は、 Arraystd.algorithm のような範囲ベースの関数を使用する場合は、 Array範囲を取得するにはスライスする必要があります(例えば、array.map! の代わりにarray[].map!を使用します )。コンテナ自体は範囲ではありません。

this(U)(U[] values...)
if (isImplicitlyConvertible!(U, T));

this(T single);

複数のアイテムを受け取るコンストラクタ。

this(Range)(Range r)
if (isInputRange!Range && isImplicitlyConvertible!(ElementType!Range, T) && !is(Range == T[]));

入力範囲を受け取るコンストラクタ

const bool opEquals(const Array rhs);

const bool opEquals(const ref Array rhs);

等価比較。

alias Range = RangeT!Array;

alias ConstRange = RangeT!(const(Array));

alias ImmutableRange = RangeT!(immutable(Array));

配列の主レンジを定義する。これはランダムアクセス可能なレンジである。

ConstRangeconst 個の要素を持つバリアントである。 ImmutableRangeimmutable 個の要素を持つバリアントである。

@property Array dup();

配列を複製する。要素自体は間接的に複製されない。

複雑さ Ο(length)。

const @property bool empty();

Returns: 配列に要素が含まれていない場合、およびその場合のみ。

true 配列に要素が含まれていない場合、およびその場合のみ。

複雑さ Ο(1)

const @property size_t length();

const size_t opDollar();

Returns: 配列の要素数。

配列の要素数。

複雑さ Ο(1)

@property size_t capacity();

Returns: 配列が挿入時にメモリを再割り当てすることなく、また、イテレータを無効にすることなく格納できる要素の最大数。

配列が挿入時にメモリの再割り当てやイテレータの無効化を行わずに格納できる要素の最大数。

複雑さ Ο(1)

inout @system inout(T)[] data();

Returns: 配列の内部表現。

配列の内部表現。

Complexity Ο(1)。

void reserve(size_t elements);

e 要素を収容するのに十分な容量を確保する。e < capacity の場合、このメソッドは何もしない。

事後条件capacity >= e

注釈 要素の容量が増加した場合、 要素へのすべてのイテレータが無効になることを前提とすべきである。

複雑性 最大でΟ(length) e > capacity の場合は、それ以外はΟ(1)。

Range opSlice();

Returns:

配列の要素を順に繰り返す範囲。

複雑さ Ο(1)

Range opSlice(size_t i, size_t j);

Returns: 配列の要素を順に繰り返し処理する範囲

配列の要素を インデックス i最大(除く)インデックスまで j。

前提条件 i <= j && j <= length

複雑性 Ο(1)

inout @property ref inout(T) front();

Returns: 配列の最初の要素。

配列の最初の要素。

前提条件empty == false

複雑さ Ο(1)

inout @property ref inout(T) back();

Returns: 配列の最後の要素。

配列の最後の要素。

前提条件 empty == false

複雑さ Ο(1)

inout ref inout(T) opIndex(size_t i);

Returns: 指定されたインデックスの要素、またはその要素への参照。

指定されたインデックスの要素、またはその要素への参照。

前提条件 i < length

複雑性 Ο(1)

void opSliceAssign(T value);

void opSliceAssign(T value, size_t i, size_t j);

void opSliceUnary(string op)()
if (op == "++" || op == "--");

void opSliceUnary(string op)(size_t i, size_t j)
if (op == "++" || op == "--");

void opSliceOpAssign(string op)(T value);

void opSliceOpAssign(string op)(T value, size_t i, size_t j);

スライス全体に対して指定の操作を実行するスライス演算子。

前提条件i < j && j < length

複雑さ Ο(slice.length)

Array opBinary(string op, Stuff)(Stuff stuff)
if (op == "~");

Returns: xml-ph-0000@deepl.internal とその引数を結合した新しい配列。

this とその引数を結合した新しい配列。

複雑性 Ο(length + m) ここで、m は stuff。

void opOpAssign(string op, Stuff)(auto ref Stuff stuff)
if (op == "~");

insertBack に転送する。

void clear();

配列からすべての要素を削除し、割り当てられたメモリを解放する。

事後条件empty == true && capacity == 0

複雑さ Ο(length)

@property void length(size_t newLength);

配列の要素数を設定する。 newLength。 もし newLength が length場合、新しい要素は配列の最後に追加され、T.init で初期化されます。T がstruct で、そのデフォルト コンストラクタが@disable で注釈されている場合、 newLengthまたはそれ以下でなければならない。 length。

複雑さ 保証Ο(abs(length - newLength)) もし capacity >= newLength。 capacity < newLength最悪の場合、Ο(newLength) である。

前提条件 __traits(compiles, { static T _; }) || newLength <= length

事後条件length == newLength

T removeAny();

alias stableRemoveAny = removeAny;

配列から最後の要素を削除し、それを返す。 安定版と非安定版の両方で動作は同じであり、 配列を反復する範囲が決して無効にならないことを保証する。

前提条件 empty == false

Returns: 削除された要素。

削除された要素。

複雑さ Ο(1).

Throws:

Exception 配列が空の場合。

size_t insertBack(Stuff)(Stuff stuff)
if (isImplicitlyConvertible!(Stuff, T) || isInputRange!Stuff && isImplicitlyConvertible!(ElementType!Stuff, T));

alias insert = insertBack;

指定した要素を配列の末尾に挿入する。 stuffT に変換できる値、またはT に変換できるオブジェクトの範囲を指定できる。

Returns:

挿入された要素の数。

複雑さ Ο(length + m) 再配置が行われた場合、それ以外はΟ(m) ここで、m は要素の数である stuff。

void removeBack();

alias stableRemoveBack = removeBack;

配列の末尾の値を削除する。安定版および非安定版の両方で 同じ動作をし、配列を反復する範囲が 無効になることは決してない。

前提条件 empty == false

複雑さ Ο(1).

Throws:

Exception 配列が空の場合。

size_t removeBack(size_t howMany);

alias stableRemoveBack = removeBack;

配列の末尾から値を削除する。 howMany配列の末尾から値を削除する。 上記のパラメータ化されていないバージョンとは異なり、これらの関数は 要素を削除できなかった場合でも「スロー」しない howMany。代わりに、 もし howMany > nすべての要素が削除されます。返り値は 削除された要素の有効な数です。安定版および非安定版の両方で 同じ動作をし、配列を反復する範囲が 無効になることは決してありません。

Returns: 削除された要素の数。

削除された要素の数。

複雑さ Ο(howMany)。

size_t insertBefore(Stuff)(Range r, Stuff stuff)
if (isImplicitlyConvertible!(Stuff, T));

size_t insertBefore(Stuff)(Range r, Stuff stuff)
if (isInputRange!Stuff && isImplicitlyConvertible!(ElementType!Stuff, T));

alias stableInsertBefore = insertBefore;

size_t insertAfter(Stuff)(Range r, Stuff stuff)
if (isImplicitlyConvertible!(Stuff, T) || isInputRange!Stuff && isImplicitlyConvertible!(ElementType!Stuff, T));

size_t replace(Stuff)(Range r, Stuff stuff)
if (isInputRange!Stuff && isImplicitlyConvertible!(ElementType!Stuff, T));

size_t replace(Stuff)(Range r, Stuff stuff)
if (isImplicitlyConvertible!(Stuff, T));

stuff範囲の前、後、またはその代わりに挿入する r。 これは、この配列から事前に抽出された有効な範囲でなければならない。 stuff T に変換できる値、またはT に変換できるオブジェクトの範囲である。 安定版と非安定版の両方で動作は同じであり、 配列を反復する範囲が決して無効にならないことを保証する。

Returns:

挿入された値の数。

複雑さ Ο(length + m) ここで、m は長さである stuff。

Throws:

Exceptionrこの配列から抽出された範囲ではない場合。

Range linearRemove(Range r);

に属するすべての要素を削除する。 r。これは、 もともとこの配列から取得された範囲でなければなりません。

Returns: 配列の残りの要素にまたがる範囲で、当初は配列の直後にあったもの

配列の残りの要素にまたがる範囲で、 最初は r。

複雑さ Ο(length)

Throws:

Exceptionrこの配列から抽出された有効な範囲ではない。

struct Array(T) if (is(immutable(T) == immutable(bool)));

bool に特化した配列。 各要素に1ビットを割り当てることで、値を効率的にまとめる。

struct Range;

配列の主要な範囲を定義する。

@property Range save();

@property bool empty();

@property T front();

@property void front(bool value);

T moveFront();

void popFront();

@property T back();

@property void back(bool value);

T moveBack();

void popBack();

T opIndex(size_t i);

void opIndexAssign(T value, size_t i);

T moveAt(size_t i);

const @property size_t length();

Range opSlice(size_t low, size_t high);

範囲のプリミティブ

this(U)(U[] values...)
if (isImplicitlyConvertible!(U, T));

複数の項目を指定するコンストラクタ。

this(Range)(Range r)
if (isInputRange!Range && isImplicitlyConvertible!(ElementType!Range, T) && !is(Range == T[]));

入力範囲を受け取るコンストラクタ

@property bool empty();

配列に要素が存在しない場合にのみtrue を返すプロパティ。

複雑さ Ο(1)

@property Array dup();

Returns: 配列の複製。

配列の複製。

複雑性 Ο(length)。

const @property size_t length();

配列の要素数を返す。

複雑性 Ο(1).

@property size_t capacity();

Returns: 配列が挿入時にメモリを再割り当てすることなく、またイテレータを無効にすることなく格納できる要素の最大数。

配列が挿入時にメモリを再割り当てすることなく、またイテレータを無効にすることなく格納できる要素の最大数。

複雑性 Ο(1)。

void reserve(size_t e);

要素を格納するのに十分な容量を確保する e。 もし e < capacityこのメソッドは何もしない。

事後条件 capacity >= e 注意 容量を増やした場合、 要素へのすべての反復子は無効になる。

注釈 要素の容量を増やした場合、 要素へのすべてのイテレータが無効になるものと想定すべきである。

複雑さ 最大でΟ(length)e > capacity、そうでない場合はΟ(1)。

Range opSlice();

Returns: 配列のすべての要素を順に繰り返す範囲。

配列のすべての要素を順に繰り返す範囲。

複雑さ Ο(1)

Range opSlice(size_t a, size_t b);

Returns: 配列を2つの指定した位置の間で反復する範囲。

指定した2つの位置の間で配列を反復する範囲。

複雑性 Ο(1)

@property bool front();

@property void front(bool value);

Returns: 配列の最初の要素。

配列の最初の要素。

前提条件empty == false

複雑さ Ο(1)

Throws:

Exception 配列が空の場合。

@property bool back();

@property void back(bool value);

Returns: 配列の最後の要素。

配列の最後の要素。

前提条件empty == false

複雑さ Ο(1)

Throws:

Exception 配列が空の場合。

bool opIndex(size_t i);

void opIndexAssign(bool value, size_t i);

void opIndexOpAssign(string op)(bool value, size_t i);

T moveAt(size_t i);

指定したインデックスの値を返す、または変更するインデックス演算子。

前提条件 i < length

複雑さ Ο(1)

Array!bool opBinary(string op, Stuff)(Stuff rhs)
if (op == "~");

Returns: xml-ph-0000@deepl.internal とその引数を結合した新しい配列。

this とその引数を結合した新しい配列。

複雑性 Ο(length + m) ここで、m はstuff の要素数である。

Array!bool opOpAssign(string op, Stuff)(Stuff stuff)
if (op == "~");

insertBack に転送する。

void clear();

配列からすべての要素を削除し、割り当てられたメモリを解放する。

事後条件 empty == true && capacity == 0

複雑さ Ο(length)

@property void length(size_t newLength);

配列の要素数を設定する。 newLength。 もし newLength が length、新しい要素は配列の末尾に追加され、false で初期化される。

複雑性 が保証される。Ο(abs(length - newLength)) capacity >= newLength。 もし capacity < newLength最悪の場合、Ο(newLength) となる。

事後条件length == newLength

T removeAny();

alias stableRemoveAny = removeAny;

配列から最後の要素を削除し、それを返す。 安定版と非安定版の両方で動作は同じであり、 配列を反復する範囲が決して無効にならないことを保証する。

前提条件 empty == false

Returns: 削除された要素。

削除された要素。

複雑さ Ο(1).

Throws:

Exception 配列が空の場合。

size_t insertBack(Stuff)(Stuff stuff)
if (is(Stuff : bool));

size_t insertBack(Stuff)(Stuff stuff)
if (isInputRange!Stuff && is(ElementType!Stuff : bool));

alias stableInsertBack = insertBack;

alias insert = insertBack;

alias stableInsert = insertBack;

alias linearInsert = insertBack;

alias stableLinearInsert = insertBack;

指定した要素を配列の末尾に挿入する。 stuffbool に変換できる値、またはbool に変換できるオブジェクトの範囲を指定できる。

Returns:

挿入された要素の数。

複雑さ Ο(length + m) 再配置が行われた場合、それ以外はΟ(m) ここで、m は要素の数である stuff。

void removeBack();

alias stableRemoveBack = removeBack;

配列の末尾の値を削除する。安定版および非安定版の両方で 同じ動作をし、配列を反復する範囲が 無効になることは決してない。

前提条件 empty == false

複雑さ Ο(1).

Throws:

Exception 配列が空の場合。

size_t removeBack(size_t howMany);

alias stableRemoveBack = removeBack;

配列の末尾から値を削除する。 howMany配列の末尾から値を削除する。 上記のパラメータ化されていないバージョンとは異なり、これらの関数は 要素を削除できなかった場合に"スロー"しない howMany。代わりに、 howMany > n、 すべての要素が削除されます。返される値は、実際に削除された要素の数です。 安定版および非安定版の両方で動作は同じであり、 配列を反復する範囲が決して無効にならないことが保証されています。

Returns: 削除された要素の数。

削除された要素の数。

複雑さ Ο(howMany)。

size_t insertBefore(Stuff)(Range r, Stuff stuff);

alias stableInsertBefore = insertBefore;

size_t insertAfter(Stuff)(Range r, Stuff stuff)
if (isImplicitlyConvertible!(Stuff, T) || isInputRange!Stuff && isImplicitlyConvertible!(ElementType!Stuff, T));

alias stableInsertAfter = insertAfter;

size_t replace(Stuff)(Range r, Stuff stuff)
if (is(Stuff : bool));

alias stableReplace = replace;

stuff範囲の前、後、またはその代わりに挿入する r。 これは、この配列から事前に抽出された有効な範囲でなければならない。 stuff bool に変換できる値、またはbool に変換できるオブジェクトの範囲である。 安定版と非安定版の両方で動作は同じであり、 配列を反復する範囲が決して無効にならないことを保証する。

Returns:

挿入された値の数。

複雑さ Ο(length + m) ここで、m は長さである stuff。

Range linearRemove(Range r);

に属するすべての要素を削除する。 r。これは、 この配列から最初に取得した範囲でなければならない。

Returns: 配列の残りの要素にまたがる範囲で、当初は配列の直後にあったもの

配列の残りの要素にまたがる範囲で、 最初は r。

複雑さ Ο(length)