std.array

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

ForeachType!(typeof((*Range).init))[] array(Range)(Range r)
if (is(Range == U*, U) && isIterable!U && !isAutodecodableString!Range && !isInfinite!Range);

配列を確保し、要素のコピーで初期化する。 の要素のコピーで初期化する。 r.

狭い文字列は以下のように扱われる:

• オートデコードがオンになっている場合(デフォルト)、別のオーバーロードとして扱われる。
• オートデコードがオフの場合、これは配列を複製することと同じである。

Parameters:

Range r

opApply その要素が確保された配列にコピーされる。

Returns:

確保され、初期化された配列

Examples:

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

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

狭いオートデコード文字列を、ランダムアクセスを完全にサポートする配列型に変換する。 型に変換する。 これは特殊なケースとして扱われ、常に配列 を返す。dchar

の配列を返す。 この関数は、オートデコードがオフになっている場合には使用されない。

Parameters:

String str

isNarrowString の配列に変換される。dchar

Returns:

dchar[] const(dchar)[] immutable(dchar)[] の配列に変換される。 の配列に変換される。

Examples:

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

// 自動デコードがオフの場合、`array`はこれらをトランスコードしないことに注意。
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)
if (isInputRange!Range);

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

キーと値のタプルの範囲から、あるいはキーと値の範囲から、新しく割り当てられた連想配列を返す。 またはキーと値の範囲から新しく確保された連想配列を返す。

Parameters:

Range r	入力範囲 キーと値のタプルの入力範囲。
Keys keys	キーの入力範囲
Values values	値の入力範囲

Returns:

入力範囲の要素から新しく割り当てられた連想配列。 タプルの範囲(キー、値)またはキーと値の範囲でなければならない。 キーと値の範囲でなければならない。長さが等しくない2つの範囲が与えられた場合 が与えられた場合、短い方の範囲の要素を使い果たした後は、長い方の残りの要素は考慮されない。 の要素は考慮されない。 空の範囲が指定された場合は、NULL連想配列参照を返す。

重複 連想配列は一意なキーを持つ。rに重複したキーが含まれている場合、結果はr内のそのキーの最後のペアの値を含む、 が重複している場合、結果にはr内のキーの最後のペアの値が含まれる。

See Also:

std.typecons.Tuple, std.range.zip

Examples:

import std.range : repeat, zip;
import std.typecons : tuple;
import std.range.primitives : autodecodeStrings;
auto a = assocArray(zip([0, 1, 2], ["a", "b", "c"])); // 別名 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)
if (isAssociativeArray!AA);

連想配列をキー/値タプルで反復する範囲を構築する。

Parameters:

AA aa

反復処理する連想配列。

Returns:

前方範囲 与えられた連想配列のキーと値のペアのタプルの前方範囲。各ペアのメンバ 各ペアのメンバには、名前(.key と.value)、または整数 インデックス(それぞれ0と1)でアクセスできる。

Examples:

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

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

// キーと値のペアの反復処理。
foreach (pair; aa.byPair)
{
    if (pair.key == "b")
        pairs ~= tuple("B", pair.value);
    else
        pairs ~= pair;
}

// 反復の順序は実装に依存するので、固定順序になるように
// ソートする必要がある。
pairs.sort();
assert(pairs == [
    tuple("B", 2),
    tuple("a", 1),
    tuple("c", 3)
]);

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

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

ガベージコレクションされたヒープ上に確保されたT 型の新しい配列を返す。 型の新しい配列を返す。すべての 要素が即座に初期化される場合、これは有用な最適化である。T は多次元配列であってもよい。 配列かもしれない。この場合、サイズは0から の数までの任意の次元数を指定することができる。 からT の数までの任意の次元数を指定することができる。

uninitializedArrayはnothrow 、弱くpure 。

uninitializedArrayは、初期化されていない要素型がポインタを持つ場合、@system 。

Parameters:

T	結果として得られる配列要素の型。
I sizes	結果の配列の長さ寸法。

Returns:

I.length 次元のT の配列。

Examples:

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)
if (isDynamicArray!T && allSatisfy!(isIntegral, I));

ガベージコレクションされたヒープ上に確保されたT 型の新しい配列を返す。

部分的な初期化は、メモリ安全性を保つために、間接関数を持つ型に対して行われる。 メモリ安全性を保つためである。要素は0に初期化されるだけで、要素の型の初期化が行われるとは限らない。 必ずしも要素型の.init 。

minimallyInitializedArrayはnothrow 、弱くpure 。

Parameters:

T	配列要素の型。
I sizes	結果として得られる配列の長さ寸法。

Returns:

I.length 次元のT の配列。

Examples:

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

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

// 要素は必ずしも0に初期化されるとは限らないので、これはしないこと:
// assert(arr.equal(0.repeat(42)));
// 必要であれば、代わりに通常通り配列を初期化する:
auto arr2 = new int[42];
assert(arr2.equal(0.repeat(42)));

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

2つの配列の重なり部分があればそれを返す。equal とは異なる、 overlapとは異なり のポインタと長さを比較するだけであり、それらが参照する値を比較するわけではない。r1 とr2 に重複するスライスがあれば、そのスライスを返す。 スライスが重なっていれば、そのスライスを返す。そうでなければ、NULLの スライスを返す。

Parameters:

T[] a	比較する最初の配列
U[] b	比較する2番目の配列

Returns:

2つの配列の重なり部分。

Examples:

int[] a = [ 10, 11, 12, 13, 14 ];
int[] b = a[1 .. 3];
writeln(overlap(a, b)); // [11, 12]
b = b.dup;
// 内容が同じでも重なりが消える
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);
}

// コンパイル時に動作する
static assert(test == "three"d);

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

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

挿入 stuff(を挿入する。 を挿入する。 arrayを挿入する。 pos.

Parameters:

T[] array	に挿入される stuffに挿入される。
size_t pos	挿入する arrayを挿入する。 stuff.
U stuff	入力範囲、 に挿入する暗黙的に変換可能な項目の数。 array.

Examples:

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]

union U
{
    float a = 3.0;
    int b;
}

U u1 = { b : 3 };
U u2 = { b : 4 };
U u3 = { b : 5 };
U[] unionArr = [u2, u3];
unionArr.insertInPlace(2, [u1]);
writeln(unionArr); // [u2, u3, u1]
unionArr.insertInPlace(0, [u3, u2]);
writeln(unionArr); // [u3, u2, u2, u3, u1]

static class C
{
    int a;
    float b;

    this(int a, float b) { this.a = a; this.b = b; }
}

C c1 = new C(42, 1.0);
C c2 = new C(0, 0.0);
C c3 = new C(int.max, float.init);

C[] classArr = [c1, c2, c3];
insertInPlace(classArr, 3, [c2, c3]);
C[5] classArr1 = classArr;
writeln(classArr1); // [c1, c2, c3, c2, c3]
insertInPlace(classArr, 0, c3, c1);
C[7] classArr2 = classArr;
writeln(classArr2); // [c3, c1, c1, c2, c3, c2, c3]

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

のfrontsかどうかを返す。 lhsと rhsの両方がメモリ上の の両方がメモリ上の同じ場所を参照しているかどうかを返す。 0 のスライスである。

Parameters:

T[] lhs	比較する最初の配列
T[] rhs	比較する2番目の配列

Returns:

true もし 、そうでなければ 。lhs.ptr == rhs.ptr false

Examples:

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

assert(a.sameHead(b));

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

のbacksかどうかを返す。 lhsと rhsの両方がメモリ上の の両方がメモリ上の同じ場所を参照しているかどうかを返す。 $ のスライスである。

Parameters:

T[] lhs	比較する最初の配列
T[] rhs	比較する2番目の配列

Returns:

true 両配列が同じ長さの場合、 、 そうでない場合はlhs.ptr == rhs.ptr false

Examples:

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

assert(a.sameTail(b));

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

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

Parameters:

S s	入力範囲 または動的配列
size_t n	繰り返し回数 s

Returns:

で構成される配列。 s繰り返し n回繰り返される。この関数は新しい配列を確保し、満たし、返す。 を返す。

See Also:

手抜きバージョンについては、以下を参照のこと。 std.range.repeat.

Examples:

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)
if (isSomeString!S);

auto split(Range, Separator)(Range range, Separator sep)
if (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)
if (isForwardRange!Range && is(typeof(unaryFun!isTerminator(range.front))));

を配列に分割する。 rangeを配列に分割する。 sepを区切り文字として使用する。

区切り文字を指定しない場合は、文字列は単語の配列に分割される、 に分割される。 空白を含む文字列はマージされる(空の単語は生成されない)。

区切り文字は rangeは前方範囲でなければならない。 の要素と同じ型の値である。 range の要素と同じ型の値であってもよいし、別の前方 range.

Parameters:

S s	区切り文字が指定されない場合は、単語で分割する文字列
Range range	分割する範囲
Separator sep	の要素と同じ型の値。 rangeまたは別の
isTerminator	true を返した場合に、その範囲を分割する述語。

Returns:

の分割された部分を含む配列。 range(または s).

See Also:

std.algorithm.iteration.splitterを使えば、メモリを割り当てずに遅延バージョンを作ることができる。

std.regex.splitter正規表現で定義された 式で定義されたセパレータを使って分割する。

Examples:

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"]

Examples:

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

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

Examples:

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, R sep)
if (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)
if (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)
if (isInputRange!RoR && isInputRange!(Unqual!(ElementType!RoR)));

のすべての範囲を(GCと一緒に)熱心に連結する。 rorを1つの配列に連結する。 を使って1つの配列に連結する。 sepをセパレーターとして使用する。

Parameters:

RoR ror	入力範囲 入力範囲の
R sep	入力範囲、または単一の要素。

Returns:

要素の配列

See Also:

手抜きバージョンについては、以下を参照のこと。 std.algorithm.iteration.joiner

Examples:

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)
if (isForwardRange!R1 && isForwardRange!R2 && (hasLength!R2 || isSomeString!R2) || is(Unqual!E : Unqual!R1));

の出現箇所を置き換える。 fromを toを置き換える。 subjectを新しい配列に置き換える。

Parameters:

E[] subject	スキャンする配列
R1 from	置換する項目
R2 to	のすべてのインスタンスを置き換える fromで置き換える。

Returns:

の中身を変えずに新しい配列に置き換える。 subjectの内容を変更しない新しい配列。 の中身を変えずに新しい配列を返す。

See Also:

std.algorithm.iteration.substitute手抜きのリプレースだ。

Examples:

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

E[] replace(E, R1, R2)(E[] subject, R1 from, R2 to, ref size_t changed)
if (isForwardRange!R1 && isForwardRange!R2 && (hasLength!R2 || isSomeString!R2) || is(Unqual!E : Unqual!R1));

の出現箇所を置き換える。 fromを toを置き換える。 subjectを新しい配列に置き換える。 changed置換が何回行われたかをカウントする。

Parameters:

E[] subject	スキャンする配列
R1 from	置換する項目
R2 to	のすべてのインスタンスを置き換える fromで置き換える。
size_t changed	置換の数

Returns:

の中身を変えずに新しい配列を作る。 subjectの内容を変更しない新しい配列、あるいは の中身を変えずに新しい配列を返す。

Examples:

size_t changed = 0;
writeln("Hello Wörld".replace("o Wö", "o Wo", changed)); // "Hello World"
writeln(changed); // 1

changed = 0;
writeln("Hello Wörld".replace("l", "h", changed)); // "Hehho Wörhd"
import std.stdio : writeln;
writeln(changed);
writeln(changed); // 3

void replaceInto(E, Sink, R1, R2)(Sink sink, E[] subject, R1 from, R2 to)
if (isOutputRange!(Sink, E) && (isForwardRange!R1 && isForwardRange!R2 && (hasLength!R2 || isSomeString!R2) || is(Unqual!E : Unqual!R1)));

の出現箇所を置き換える。 fromを toで置換する。 subjectに置換し、その結果を sink.

Parameters:

Sink sink	出力範囲
E[] subject	スキャンする配列
R1 from	置換する項目
R2 to	のすべてのインスタンスを置き換える fromを

See Also:

std.algorithm.iteration.substituteに置き換える。

Examples:

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]

void replaceInto(E, Sink, R1, R2)(Sink sink, E[] subject, R1 from, R2 to, ref size_t changed)
if (isOutputRange!(Sink, E) && (isForwardRange!R1 && isForwardRange!R2 && (hasLength!R2 || isSomeString!R2) || is(Unqual!E : Unqual!R1)));

の出現箇所を置き換える。 fromを toで置換する。 subjectに置換し、その結果を sink. changedに出力する。

Parameters:

Sink sink	出力範囲
E[] subject	スキャンする配列
R1 from	置換する項目
R2 to	のすべてのインスタンスを置き換える fromを含む
size_t changed	置換の数

Examples:

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

size_t changed = 0;
replaceInto(sink, arr, from, to, changed);

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

T[] replace(T, Range)(T[] subject, size_t from, size_t to, Range stuff)
if (isInputRange!Range && (is(ElementType!Range : T) || isSomeString!(T[]) && is(ElementType!Range : dchar)));

array の要素を以下の範囲のインデックスで置き換える。 from から to(排他的)の範囲の要素を stuff.

Parameters:

T[] subject	スキャンする配列
size_t from	開始インデックス
size_t to	終了インデックス
Range stuff	その間の置換する項目 fromそして to

Returns:

の中身を変えずに新しい配列を作る。 subject.

See Also:

std.algorithm.iteration.substitute手抜きのリプレースだ。

Examples:

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)
if (is(typeof(replace(array, from, to, stuff))));

の要素を arrayの要素を from から to(排他的)の範囲のインデックスに置き換える。 stuff.必要に応じて配列を展開または縮小する。 は，必要に応じて配列を拡張または縮小する。

Parameters:

T[] array	スキャンする配列
size_t from	開始インデックス
size_t to	終了インデックス
Range stuff	その間の置換する項目 fromそして to

Examples:

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)
if (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.

Parameters:

E[] subject	スキャンする配列
R1 from	置換する項目
R2 to	置換する項目 fromで置き換える。

Returns:

の中身を変えずに新しい配列に置き換える。 subjectの内容を変更しない新しい配列。 の中身を変えずに新しい配列を返す。

Examples:

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)
if (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.

Parameters:

E[] subject	スキャンする配列
R1 from	置換する項目
R2 to	置換する項目 fromで置き換える。

Returns:

の中身を変えずに新しい配列に置き換える。 subjectの内容を変更しない新しい配列。 の中身を変えずに新しい配列を返す。

Examples:

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は同じ長さである必要はない。 に置き換えられる。結果は、与えられた項目に基づいて大きくなったり小さくなったりする。

Parameters:

inout(T)[] s	新しい配列の底辺
T[] slice	のスライス s置換される
T[] replacement	置換する項目 sliceで置き換える。

Returns:

新しい配列は sである。 sliceで置き換えられている。 replacement[].

See Also:

std.algorithm.iteration.substitute手抜きのリプレースだ。

Examples:

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 を探すことによるパフォーマンスの低下を避けることができる。

Parameters:

A	シミュレートする配列の型を指定する。

See Also:

appender

Examples:

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]

@trusted this(A arr);

与えられた配列でAppender を構築する。 これはデータをコピーしないことに注意。 データをコピーしないことに注意。 配列の容量が arr.capacity, によって決定されるように、配列がより大きな容量を持つ場合、それはアペンダによって使用される。 アペンダーを配列上で初期化した後、元の配列にアペンドすると再割り当てされる、 元の配列にアペンドすると再割り当てされる。

void reserve(size_t newCapacity);

少なくともnewCapacityの要素をアペンド用に確保する。 要求されたよりも多くの要素が予約される可能性がある。 より多くの要素が予約されることに注意すること。もし newCapacity <= capacityの場合、何もしない。 が実行される。

Parameters:

size_t newCapacity

Appender が持つべき容量

const @property size_t capacity();

Returns:

アレイの容量 (再割り当てのトリガーとなるまでに管理アレイが収容できる要素の最大数)。 を持つべきである。)もし 追加によって再割り当てが行われる場合は、0 が返される。

inout @property @trusted inout(T)[] data();

今後はopSlice()を使おう。

Returns:

管理配列。

inout @property @trusted inout(T)[] opSlice();

Returns:

管理配列。

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

管理配列に item管理配列に追加する。のエンコーディングを行う。 char A 、型が異なるchar 配列の場合、型に対するエンコーディングを行う。

Parameters:

U item

追加する単一の項目

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

範囲全体を管理配列に追加する。要素のエンコーディングを行う。 char A 、型が異なるchar 配列の場合は、要素のエンコーディングを行う。

Parameters:

Range items

追加する項目の範囲

template opOpAssign(string op : "~")

管理配列に追加する。

See Also:

Appender.put

pure nothrow @trusted void clear();

管理配列をクリアする。 これにより、配列の要素を再利用できるようになる。 を再利用できるようになる。

注釈 clearは、"@disable型"では無効である。 Appender 、不変のデータを上書きしてしまう可能性があるためである。

pure @trusted void shrinkTo(size_t newlength);

管理配列を指定された長さに縮小する。

Throws:

Exception newlengthが現在の配列の長さより大きい場合。

注釈 shrinkToは、不変要素型またはconst要素型に対しては無効である。

const string toString()();

const void toString(Writer)(ref Writer w, ref scope const FormatSpec!char fmt)
if (isOutputRange!(Writer, char));

Appender!(A)(data) 形式の文字列を返す。

Parameters:

Writer w	char 。 出力範囲。
FormatSpec!char fmt	A std.format.FormatSpec配列 を制御する。

Returns:

writer が設定されていない場合はstring を、そうでない場合はvoid を指定する。

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

のバージョン。 Appenderのバージョンで、配列をインプレースで更新できる。 これは、すべての呼び出しをアペンダ実装に転送する。 アペンダへの呼び出しはすべて、渡された元の配列へのポインタを更新する。 へのポインタも更新する。

ヒント のarrayPtr オーバーロードを使用する。 appenderのオーバーロードを使う。

Parameters:

A	シミュレートする配列の型

Examples:

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によって決定されるように、配列がより大きな容量を持つ場合、それは によって決定されるように、配列がより大きな容量を持つ場合、それはアペンダによって使用される。

注釈 アペンダが終了するまでは、元の配列に対して組み込みのアペンド(すなわち、~= )を使用しないこと。 を使用してはいけない。 を呼び出すと、それらのアペンドなしで配列データを再割り当てするからである。

Parameters:

A* arr

配列へのポインタ。NULLであってはならない。

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

以下のような残りのAppender メソッドをラップする。 put.

Parameters:

fn	呼び出すメソッド名。
Args args	メソッドに渡す引数。

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

管理配列に rhsを管理配列に追加する。

Parameters:

U rhs

要素または範囲。

const @property size_t capacity();

アレイの容量(再割り当てを行う前に管理アレイが収容できる要素の最大数)を返す。 を返す。) もし を追加すると再割り当てされる、 capacityは0 を返す。

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

Returns:

を返す。

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

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

を返す便利な関数である。 Appenderインスタンスを返す便利な関数である、 オプションで array.

Examples:

auto w = appender!string;
// 少なくとも10要素分のスペースを事前に確保する(これにより、コストのかかる再割り当てを回避できる)
w.reserve(10);
assert(w.capacity >= 10);

w.put('a'); // 単一要素
w.put("bc"); // 複数の要素

// 追加構文を使う
w ~= 'd';
w ~= "ef";

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

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

を返す便利な関数である。 RefAppenderインスタンスを返す で初期化されたインスタンスを返す。 arrayPtr.配列ポインタにnullを使わず、他の の他のバージョンを使う。 appenderを使う。

Examples:

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);

U[n] staticArray(U, T, size_t n)(auto ref T[n] a)
if (!is(T == U) && is(T : U));

コンパイル時に長さがわかっている動的配列から静的配列を構築する。 要素の型は推測することも、明示的に指定することもできる:

• [1, 2].staticArray は以下を返す。int[2]
• [1, 2].staticArray!float 戻り値 float[2]

注釈: 注釈: 注釈: 注釈: 注釈: 注釈: 注釈: 注釈: 注釈: 注釈: 注釈: 注釈 staticArrayは値で返すので、大きな配列を含む式は非効率的かもしれない。

Parameters:

T[n] a

入力配列。

Returns:

から構成される静的配列。 a.

Examples:

配列リテラルからの静的配列

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

Examples:

要素の暗黙のキャストによる配列からの静的配列

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

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

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

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

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

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

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

範囲から静的配列を構築する。 コンパイル時に a.lengthがコンパイル時にわからない場合は、要素数を をテンプレート引数として与えなければならない(例えば myrange.staticArray!2). 元範囲の要素が暗黙のうちに要求された要素型に変換可能であれば、サイズと型を組み合わせることができる。 要求された要素型に暗黙のうちに変換可能であれば、サイズと型を組み合わせることができる (例: 2.iota.staticArray!(long[2])).

範囲 aがコンパイル時にわかっている場合、それを テンプレート引数として与えることができる。 (例えば staticArray!(2.iota)または staticArray!(double, 2.iota)).

Parameters:

T a	入力範囲。静的配列の指定した長さよりも要素が少ない場合、 の残りの部分がデフォルトで初期化される。指定された要素数より多い場合は、指定された長さまでの最初の要素 までが使われる。
size_t rangeLength	から使用された要素数を出力する。 a.オプション。

Examples:

範囲 + サイズからの静的配列

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]

Examples:

CTレンジからの静的配列

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]