このページの英語版を見る

object


カテゴリー	記号
配列	assumeSafeAppend capacity dup idup reserve
連想配列	byKey byKeyValue byValue clear dup get keys rehash require update values
一般	destroy hashOf imported noreturn
クラス	Error Exception Object opEquals Throwable
型情報	Interface ModuleInfo OffsetTypeInfo RTInfoImpl rtinfoNoPointers TypeInfo TypeInfo_Class

すべてのDプログラムで使用可能なシンボルを形成する。オブジェクトを含む。を含む。このモジュールは暗黙的にインポートされる。

License:

Boost License 1.0.

Authors:

Walter Bright, Sean Kelly

ソースオブジェクト.d

alias noreturn = noreturn;

ボトム型。参照 noreturn.

class Object;

すべてのDクラス・オブジェクトはObjectを継承する。

string toString();

Object を人間が読める文字列に変換する。

nothrow @trusted size_t toHash();

Objectのハッシュ関数を計算する。

int opCmp(Object o);

別の Object obj と比較する。

Returns:


この < obj	< 0
this == obj	0
this > obj	> 0

bool opEquals(Object o);

this がo と等しいかどうかをテストする。デフォルトの実装では、(is 演算子を使用した)同一性による比較のみが行われる。一般に、opEquals のオーバーライドやオーバーロードは、オブジェクトをその内容で比較しようとするはずだ。クラスは、引数として特定の型を取り、内容比較を行うオーバーロードを追加したいと思うだろう。を引数として取り、内容の比較を行うオーバーロードを追加したいと思うだろう。そして、これをオーバーライドして、特定の型のオーバーロードに転送することができる。型付きオーバーロードのnull 。

Examples:

class Child {
   int contents;
   // 最初に型付きオーバーロード。必要な属性をすべて使用できる
   bool opEquals(const Child c) const @safe pure nothrow @nogc
   {
       if (c is null)
           return false;
       return this.contents == c.contents;
   }

   // そして、一般的なオーバーライドはキャストで転送される
   override bool opEquals(Object o)
   {
       return this.opEquals(cast(Child) o);
   }
}

static Object factory(string classname);

で指定されたクラスのインスタンスを作成する。のインスタンスを生成する。クラスはコンストラクタを持たないか、デフォルトのコンストラクタを持たなければならない。デフォルトのコンストラクタを持っていなければならない。

Returns:

失敗した場合は null

例:

module foo.bar;

class C
{
    this() { x = 10; }
    int x;
}

void main()
{
    auto c = cast(C)Object.factory("foo.bar.C");
    assert(c !is null && c.x == 10);
}

bool opEquals(LHS, RHS)(LHS lhs, RHS rhs) if ((is(LHS : const(Object)) || is(LHS : shared(const(Object)))) && (is(RHS : const(Object)) || is(RHS : shared(const(Object)))));

クラス opEquals オーバーライドの実装。NULLチェック後にクラス定義のメソッドを呼び出す。実装がnogcであっても、これはnogcではないことに注意。なぜなら、typeinfoの名前文字列を比較するからである。これはdmdのdll実装のためである。しかしであれば、@safeに推論することができる。

Examples:

同じオブジェクトにエイリアスされた場合、または両方がnullの場合、=>等しい。

class F { int flag; this(int flag) { this.flag = flag; } }

F f;
assert(f == f); // どちらもnull
f = new F(1);
assert(f == f); // どちらも同じオブジェクトにエイリアスされている

Examples:

どちらかがNULLの場合 => 等しくない

class F { int flag; this(int flag) { this.flag = flag; } }
F f;
assert(!(new F(0) == f));
assert(!(f == new F(0)));

Examples:

まったく同じ型の場合 => メソッドopEqualsを1回呼び出す。このテストは@safe 。@safe

class F
{
    int flag;

    this(int flag)
    {
        this.flag = flag;
    }

    bool opEquals(const F o) const @safe nothrow pure
    {
        return flag == o.flag;
    }
}

F f;
assert(new F(0) == new F(0));
assert(!(new F(0) == new F(1)));

Examples:

一般的な場合=>メソッドopEqualsへの対称的な呼び出し

int fEquals, gEquals;

class Base
{
    int flag;
    this(int flag)
    {
        this.flag = flag;
    }
}

class F : Base
{
    this(int flag) { super(flag); }

    bool opEquals(const Base o) @safe
    {
        fEquals++;
        return flag == o.flag;
    }
}

class G : Base
{
    this(int flag) { super(flag); }

    bool opEquals(const Base o) @safe
    {
        gEquals++;
        return flag == o.flag;
    }
}

assert(new F(1) == new G(1));
assert(fEquals == 1);
assert(gEquals == 1);

Examples:

このテストは、包括的な継承イコールチェーンの例も示している。

static class Base
{
    int member;

    this(int member) pure @safe nothrow @nogc
    {
        this.member = member;
    }

    override bool opEquals(Object rhs) const
    {
        return this.opEquals(cast(Base) rhs);
    }

    bool opEquals(const Base rhs) const @nogc pure nothrow @safe
    {
        if (rhs is null)
            return false;
        return this.member == rhs.member;
    }
}

// 現在のTypeInfoの実装では、pureとnogcを除いて、属性が有効な直接クラスを通じて動作する
bool testThroughBase() nothrow @safe
{
    Base b1 = new Base(0);
    Base b2 = new Base(0);
    assert(b1 == b2);
    Base b3 = new Base(1);
    assert(b1 != b3);
    return true;
}

static assert(testThroughBase());

// また、オーバーライドのおかげで基本のクラスインターフェースを通じて動作するが、これ以上の属性はない
bool testThroughObject()
{
    Object o1 = new Base(0);
    Object o2 = new Base(0);
    assert(o1 == o2);
    Object o3 = new Base(1);
    assert(o1 != o3);
    return true;
}

static assert(testThroughObject());

// 子を生成するたびに、古いopEqualsをすべて上書きし、
// 新しい子に対して新しいオーバーロードを追加したい。
static class Child : Base
{
    int member2;

    this(int member, int member2) pure @safe nothrow @nogc
    {
        super(member);
        this.member2 = member2;
    }

    // どんなベースでも一貫して動作するように、チェーン全体を上書きする
    override bool opEquals(Object rhs) const
    {
        return this.opEquals(cast(Child) rhs);
    }
    override bool opEquals(const Base rhs) const
    {
        return this.opEquals(cast(const Child) rhs);
    }
    // そして、必要に応じて新しいメンバーを処理するための新しいオーバーロードを追加する
    bool opEquals(const Child rhs) const @nogc pure nothrow @safe
    {
        if (rhs is null)
            return false;
        // 暗黙の変換で非仮想化ベーステストにコールバックし、
        // 新しいメンバーも比較できる。あるいは、ここでもベースメンバーを
        // 直接比較することもできた。
        return Base.opEquals(rhs) && this.member2 == rhs.member2;
    }

    // もちろん、ミックスインテンプレートでこれを自動化できる。
}

bool testThroughChild()
{
    Child a = new Child(0, 0);
    Child b = new Child(0, 1);
    assert(a != b);

    Base ba = a;
    Base bb = b;
    assert(ba != bb);

    Object oa = a;
    Object ob = b;
    assert(oa != ob);

    return true;
}

static assert(testThroughChild());

void setSameMutex(shared Object ownee, shared Object owner);

ownee にオーナーのミューテックスを使わせる。オーナーのミューテックスがまだ設定されていない場合は、これを初期化する。

Parameters:

Object `ownee`	変更するオブジェクト
Object `owner`	ソースオブジェクト

struct Interface;

インターフェースに関する情報。オブジェクトがインターフェースを介してアクセスされると、そのvtblの最初の項目としてInterface*が表示される。が表示される。

TypeInfo_Class classinfo;: typeid によって返される、このインタフェースのクラス情報 (クラスを含むものではない)
size_t offset;: オブジェクト 'this' からインターフェース 'this' へのオフセット。

struct OffsetTypeInfo;

集合体の各メンバーのオフセットと型情報を与えるペアの配列。集約内の各メンバーのオフセットと型情報を与えるペアの配列。

size_t offset;: オブジェクトの先頭からのメンバのオフセット
TypeInfo ti;: このメンバの型情報

abstract class TypeInfo;

型に関するランタイム型情報。任意の型に対して型のインスタンスのハッシュを計算する。

const nothrow @trusted size_t getHash(scope const void* p);

型のインスタンスのハッシュを計算する。

Parameters:

void* p 型のインスタンスの開始点へのポインタ。

Returns:

ハッシュ

Bugs:

https://issues.dlang.org/show_bug.cgi?id=12516を修正する。例えば、これを本当に安全なインターフェイスに変更する。

const bool equals(in void* p1, in void* p2);

2つのインスタンスを等しいかどうか比較する。

const int compare(in void* p1, in void* p2);

2つのインスタンスを<, ==, >で比較する。

const pure nothrow @nogc @property @safe size_t tsize();

型のサイズを返す。

const void swap(void* p1, void* p2);

2つの型のインスタンスを交換する。

inout pure nothrow @nogc @property inout(TypeInfo) next();

どのような型であるかによって定義される "next"型のTypeInfoを取得する、ない場合はnullを返す。

abstract const pure nothrow @nogc @safe const(void)[] initializer();

デフォルトのイニシャライザを返す。型がすべてゼロで初期化される場合は、NULLの配列が返される。型がすべて0に初期化される場合は、NULLのptrと型サイズに等しい長さの配列が返される。が返される。静的配列の場合，これは配列の単一の要素に対するデフォルトのイニシャライザを返す。正しいサイズを得るにはtsize を使用する。

const pure nothrow @nogc @property @safe uint flags();

型のフラグを取得する:1は、GCがポインタをスキャンすることを意味する、 2 は、この型の arg が SIMD レジスタで渡されることを意味する。

const const(OffsetTypeInfo)[] offTi();

型の内容に関する型情報を取得する。

const void destroy(void* p);

オブジェクトとそのすべてのサブオブジェクトに対してデストラクタを実行する。

const void postblit(void* p);

オブジェクトとそのすべてのサブオブジェクトに対してポストブリットを実行する

const pure nothrow @nogc @property @safe size_t talign();

型のアライメントを返す。

nothrow @safe int argTypes(out TypeInfo arg1, out TypeInfo arg2);

8バイトに収まる引数の内部情報を返す。 X86-64 ABI 3.2.3を参照のこと。

const pure nothrow @nogc @property @trusted immutable(void)* rtInfo();

ガベージコレクタが正確なコレクションを行うために使用する情報を返す。

class TypeInfo_Class: object.TypeInfo;

クラスに関するランタイム型情報。オブジェクトのインスタンスから typeid式を使ってオブジェクト・インスタンスから取得できる。

byte[] m_init;

クラス静的イニシャライザ (init.lengthはクラスのサイズをバイト単位で与える)

string name;

クラス名

void*[] vtbl;

仮想関数ポインタ・テーブル

Interface[] interfaces;

このクラスが実装するインターフェース

TypeInfo_Class base;

基底クラス

ushort depth;

Objectからの継承距離

uint[4] nameSig;

に対する一意なシグネチャname

static const(TypeInfo_Class) find(scope const char[] classname);

クラス名に対応するTypeInfo_Classをすべてのモジュールから検索する。

Returns:

見つからなければnull

const Object create();

this'で表されるObjectのインスタンスを生成する。

final const pure nothrow @nogc @trusted bool isBaseOf(scope const TypeInfo_Class child);

で表されるオブジェクトのインスタンスを生成する。 childに由来するか TypeInfo_Class である場合に真を返す。引数が null の場合は常に false を返す。を返す。

Parameters:

TypeInfo_Class child あるクラスのTypeInfo

Returns:

で記述されたクラスが childによって記述されているクラスが TypeInfo_Class である。

struct ModuleInfo;

ModuleInfoのインスタンスは、コンパイルされたモジュールごとにオブジェクト・ファイルに生成される。

これはモジュールの様々な側面へのアクセスを提供する。 BetterCでは生成されない。

const pure nothrow @nogc @property void function() tlsctor();: Returns:
スレッドローカル用のモジュールコンストラクタがない場合はnull
const pure nothrow @nogc @property void function() tlsdtor();: Returns:
スレッドローカルのモジュールデストラクタ、null 。
const pure nothrow @nogc @property void* xgetMembers();: Returns:
モジュールのconst(MemberInfo)[] getMembers(string) 関数のアドレス、null が1つもない場合は、。
const pure nothrow @nogc @property void function() ctor();: Returns:
モジュールのコンストラクタ、null 。
const pure nothrow @nogc @property void function() dtor();: Returns:
モジュールのデストラクタ、null 。
const pure nothrow @nogc @property void function() ictor();: Returns:
モジュールの順序に依存しないコンストラクタが1つもない場合はnull
const pure nothrow @nogc @property void function() unitTest();: Returns:
モジュールのunittestを実行する関数のアドレス、null 。
const pure nothrow @nogc @property immutable(ModuleInfo*)[] importedModules() return;: Returns:
このモジュールがインポートしたモジュールの ModuleInfo へのポインタの配列がある。
const pure nothrow @nogc @property TypeInfo_Class[] localClasses() return;: Returns:
このモジュールで定義されたクラスの TypeInfo_Classへのポインタの配列
const pure nothrow @nogc @property string name() return;: Returns:
モジュール名、無ければnull

class Throwable;

すべてのスローオブジェクトの基底クラス。

すべてのスローオブジェクトは Throwable を継承しなければならない。このクラスから派生するクラスException このクラスから派生したクラスは、キャッチして安全に処理できるスローオブジェクトのカテゴリを表す。を表す。原則として、から派生していない Throwable Exception オブジェクトをキャッチしてはならない。回復不能な実行時エラーを表すからである。これらのエラーがスローされた場合、特定の実行時保証が保持されない可能性がある。このようなエラーがスローされた場合、特定の実行時保証が保持されない可能性がある。キャッチした後に実行を継続するのは危険である。

string msg;

エラーを説明するメッセージ。

string file;

エラーがスローされた場所に対応するDソースコードのファイル名。エラーがスローされたDソースコードのファイル名。

size_t line;

エラーがスローされた場所に対応するDソースコードの行番号。エラーがスローされた場所に対応するDソースコードの行番号。

TraceInfo info;

エラーが発生した場所のスタック・トレース。これは不透明なオブジェクトである。これは、string に変換されるか、 foreach で反復処理され、(文字列として)スタック・トレースの項目を取り出すことができる。

TraceDeallocator infoDeallocator;

セットされている場合、これは破壊時にTraceInfoをデアロケートするために使用される。

inout pure nothrow @nogc @property scope @safe inout(Throwable) next() return;

Returns:

リストの次のエラーへの参照。これは、新しい Throwable がcatch ブロックの内部からスローされたときに使用される。最初にキャッチされた Throwable キャッチされたException は、このフィールドを経由する。

pure nothrow @nogc @property scope @safe void next(Throwable tail);

チェインのnextを tail. 可能であれば、chainTogether を代わりに使う。

final pure nothrow @nogc ref scope @system uint refcount() return;

Returns:

参照カウントへの変更可能な参照。 0 - GCによって割り当てられ、1 - d_newThrowable()によって割り当てられる、そして>=2は参照カウント+1である。

注釈: 参照カウントは、GCによって確保された0、d_newThrowable()によって確保された1、そして参照カウント+1である>=2である。カジュアルな使用を避けるため、@system 。

int opApply(scope int delegate(Throwable) dg);

Throwableのチェーンをループする。

static pure nothrow @nogc @system Throwable chainTogether(return scope Throwable e1, return scope Throwable e2);

を追加する。 e2で始まる例外の連鎖に追加する。 e1.

Parameters:

Throwable `e1`	チェーンの先頭(NULLでもよい)
Throwable `e2`	チェーンの2番目の部分(nullでもよい)

Returns:

連鎖の開始点にあるthrowable。 e1と e2の両方がNULLの場合はNULL

string toString();

Object.toString をオーバーライドし、エラーメッセージを返す。内部的には、これはtoString オーバーロードに転送される。シンクデリゲートを取る。

const void toString(scope void delegate(in char[]) sink);

Throwable階層は、GCアロケーションを避けるために、sinkデリゲートを取るtoStringオーバーロードを使用している。シンクデリゲートを取るtoStringオーバーロードを使用する。シンクデリゲートを取るtoStringオーバーロードを使用する。エラーメッセージをカスタマイズするには、この toString メソッドをオーバーライドする。

const nothrow @safe const(char)[] message();

エラーメッセージを取得する。

このゲッターは、Exceptionのメッセージにアクセスする別の方法である、サブクラスでオーバーライドできるという利点もある。そのため、サブクラスは独自のメモリ管理を自由に行うことができる。フィールドでstring 。

デフォルトの動作は、Throwable.msg フィールドを返す。

Returns:

の原因を表すメッセージが返される。Throwable

class Exception: object.Throwable;

キャッチして処理しても安全なすべてのエラーの基本クラス。

原則的に、このクラスから派生したスローオブジェクトだけがキャッチして安全である。 catch することができる。Exceptionから派生していないスローオブジェクトから派生しないスローオブジェクトは、キャッチすべきでない実行時エラーを表す。保証が保持されず、プログラムの実行を続行することが安全でなくなる可能性があるからである。

Examples:

bool gotCaught;
try
{
    throw new Exception("msg");
}
catch (Exception e)
{
    gotCaught = true;
    assert(e.msg == "msg");
}
assert(gotCaught);

pure nothrow @nogc @safe this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable nextInChain = null);: Exceptionの新しいインスタンスを作成する。nextInChainパラメータは内部的に使用される。は内部的に使用され、ユーザーコードから渡される場合は常にnull でなければならない。このコンストラクタは、新しく生成されたExceptionを自動的にスローしない。そのためにはthrow 式を使うべきである。

class Error: object.Throwable;

すべての回復不能な実行時エラーの基本クラスである。

これは、Throwable オブジェクトのカテゴリーを表す。なオブジェクトのカテゴリを表す。原則として、Error オブジェクトは回復不可能なランタイム・エラーを表すからである。これらのエラーがスローされると、ある種の実行時保証が保持されないことがある。をキャッチした後に実行を続行するのは危険である。

Examples:

bool gotCaught;
try
{
    throw new Error("msg");
}
catch (Error e)
{
    gotCaught = true;
    assert(e.msg == "msg");
}
assert(gotCaught);

pure nothrow @nogc @safe this(string msg, Throwable nextInChain = null);: Errorの新しいインスタンスを作成する。nextInChainパラメータは内部的に使用される。は内部的に使用され、ユーザーコードから渡される場合は常にnull でなければならない。このコンストラクタは、新しく生成された "Error"を自動的にスローしない。 Errorは自動的にスローされない。そのためにはthrow 。
Throwable bypassedException;: このErrorがスローされたときにバイパスされた最初のException 、または、Exceptionが保留されていない場合は、null 。

@trusted void clear(Value, Key)(Value[Key] aa); @trusted void clear(Value, Key)(Value[Key]* aa);

連想配列から残りのすべてのキーと値を削除する。

Parameters:

Value[Key] aa 連想配列。

Examples:

auto aa = ["k1": 2];
aa.clear;
assert("k1" !in aa);

T rehash(T : Value[Key], Value, Key)(T aa); T rehash(T : Value[Key], Value, Key)(T* aa); T rehash(T : shared(Value[Key]), Value, Key)(T aa); T rehash(T : shared(Value[Key]), Value, Key)(T* aa);

ルックアップがより効率的になるように、連想配列を再編成する。より効率的になるようにする。

Parameters:

T aa 連想配列。

Returns:

リハッシュ連想配列。

V[K] dup(T : V[K], K, V)(T aa); V[K] dup(T : V[K], K, V)(T* aa);

同じサイズの新しい連想配列を作成し、連想配列の内容をそこにコピーする。の内容をコピーする。

Parameters:

T aa 連想配列。

Examples:

auto aa = ["k1": 2];
auto a2 = aa.dup;
aa["k2"] = 3;
assert("k2" !in a2);

pure nothrow @nogc @safe auto byKey(T : V[K], K, V)(T aa); pure nothrow @nogc auto byKey(T : V[K], K, V)(T* aa);

前方範囲を返し、連想配列のキーを反復処理する。キーはは参照で返される。

配列に構造的な変更(キーの削除や追加)が加えられた場合、この関数で以前に取得したすべてのこの関数で取得したすべての範囲は無効になる。以下のプログラム例では以下のプログラム例では、NULLポインタをデリファレンスする:

 import std.stdio : writeln;

 auto dict = ["k1": 1, "k2": 2];
 auto keyRange = dict.byKey;
 dict.clear;
 writeln(keyRange.front);    // セグメンテーション違反

Parameters:

T aa 連想配列。

Returns:

連想配列のキーを参照する前方範囲。

Examples:

auto dict = [1: "v1", 2: "v2"];
int sum;
foreach (v; dict.byKey)
    sum += v;

assert(sum == 3);

pure nothrow @nogc @safe auto byValue(T : V[K], K, V)(T aa); pure nothrow @nogc auto byValue(T : V[K], K, V)(T* aa);

前方範囲を返し、連想配列の値を反復処理する。値は参照で返される。参照で返される。

配列に構造的な変更(キーの削除や追加)が行われた場合、この関数で以前に取得したすべてのこの関数によって取得されたすべての範囲は無効になる。以下のプログラム例では以下のプログラム例では、NULLポインタをデリファレンスする:

 import std.stdio : writeln;

 auto dict = ["k1": 1, "k2": 2];
 auto valueRange = dict.byValue;
 dict.clear;
 writeln(valueRange.front);    // セグメンテーション違反

Parameters:

T aa 連想配列。

Returns:

連想配列の値を参照する前方範囲。

Examples:

auto dict = ["k1": 1, "k2": 2];
int sum;
foreach (v; dict.byValue)
    sum += v;

assert(sum == 3);

pure nothrow @nogc @safe auto byKeyValue(T : V[K], K, V)(T aa); pure nothrow @nogc auto byKeyValue(T : V[K], K, V)(T* aa);

連想配列のキーと値のペアを繰り返し処理するを返し、連想配列のキーと値のペアを繰り返し処理する。返される返されるペアは、.key と.value プロパティで表現される、で表現される。

配列に構造的な変更(キーの削除や追加)が加えられた場合、この関数によって以前に取得された範囲はすべて無効になる。この関数で取得したすべての範囲は無効になる。以下の例では以下のプログラム例では、NULLポインタをデリファレンスする:

 import std.stdio : writeln;

 auto dict = ["k1": 1, "k2": 2];
 auto kvRange = dict.byKeyValue;
 dict.clear;
 writeln(kvRange.front.key, ": ", kvRange.front.value);    // セグメンテーション違反

注釈:これは連想配列を反復処理するための低レベルのインターフェイスである。とは互換性がない。 Tuple型とは互換性がない。 Tuple との互換性のために、代わりに std.array.byPairを使用すること。

Parameters:

T aa 連想配列。

Returns:

連想配列のペアを参照する前方範囲。

Examples:

auto dict = ["k1": 1, "k2": 2];
int sum;
foreach (e; dict.byKeyValue)
{
    assert(e.key[1] == e.value + '0');
    sum += e.value;
}

assert(sum == 3);

@property Key[] keys(T : Value[Key], Value, Key)(T aa); @property Key[] keys(T : Value[Key], Value, Key)(T* aa);

連想配列のキーのコピーを含む、新しく確保された動的配列を返す。連想配列のキーのコピーを含む

Parameters:

T aa 連想配列。

Returns:

キーのコピーを含む動的配列。

Examples:

auto aa = [1: "v1", 2: "v2"];
int sum;
foreach (k; aa.keys)
    sum += k;

assert(sum == 3);

@property Value[] values(T : Value[Key], Value, Key)(T aa); @property Value[] values(T : Value[Key], Value, Key)(T* aa);

連想配列の値のコピーを含む、新しく確保された動的配列を返す。からの値のコピーを含む

Parameters:

T aa 連想配列。

Returns:

値のコピーを含む動的配列。

Examples:

auto aa = ["k1": 1, "k2": 2];
int sum;
foreach (e; aa.values)
    sum += e;

assert(sum == 3);

inout(V) get(K, V)(inout(V[K]) aa, K key, lazy inout(V) defaultValue); inout(V) get(K, V)(inout(V[K])* aa, K key, lazy inout(V) defaultValue);

キーが存在すれば対応する値を返す。 defaultValueを返す。

Parameters:

inout(V[K]) `aa`	連想配列。
K `key`	キー。
inout(V) `defaultValue`	デフォルト値。

Returns:

値。

Examples:

auto aa = ["k1": 1];
assert(aa.get("k1", 0) == 1);
assert(aa.get("k2", 0) == 0);

ref V require(K, V)(ref V[K] aa, K key, lazy V value = V.init);

キーを検索し、存在すれば対応する値を返す。値を評価し、連想配列に追加して返す。

Parameters:

V[K] `aa`	連想配列。
K `key`	キー。
V `value`	必要な値。

Returns:

値。

Examples:

auto aa = ["k1": 1];
assert(aa.require("k1", 0) == 1);
assert(aa.require("k2", 0) == 0);
assert(aa["k2"] == 0);

void update(K, V, C, U)(ref V[K] aa, K key, scope C create, scope U update) if (is(typeof(create()) : V) && (is(typeof(update(aa[K.init])) : V) || is(typeof(update(aa[K.init])) == void)));

コール createもし keyが連想配列に存在しない場合に呼び出す、そうでなければ update. createに対応する値を返す。 key. updateはキー・パラメータを受け付ける。値を返す場合、その値はに設定される。 key.

Parameters:

V[K] `aa`	連想配列。
K `key`	キー。
C `create`	の値を作成する callable。 `key`. Vを返さなければならない。
U `update`	が存在する場合に呼び出す callable。 `key`が存在する場合に呼び出す callable。 K引数を取り、Vまたはvoidを返す。

Examples:

int[string] aa;

// 作成
aa.update("key",
    () => 1,
    (int) {} // 実行されない
    );
assert(aa["key"] == 1);

// refによる値の更新
aa.update("key",
    () => 0, // 実行されない
    (ref int v) {
        v += 1;
    });
assert(aa["key"] == 2);

// 戻り値から更新する
aa.update("key",
    () => 0, // 実行されない
    (int v) => v * 2
    );
assert(aa["key"] == 4);

// 値を変更せずに'update'する
aa.update("key",
    () => 0, // 実行されない
    (int) {
        // 何か他のことをする
    });
assert(aa["key"] == 4);

size_t hashOf(T)(auto ref T arg, size_t seed); size_t hashOf(T)(auto ref T arg);

のハッシュ値を計算する。 argのハッシュ値を計算する。 seedのハッシュ値を計算する。結果は typeid(T).getHash(&arg).

Parameters:

T `arg`	のハッシュ値を計算する。
size_t `seed`	オプション `seed`値のハッシュ値を計算する。

戻り値の計算されたハッシュ値。 arg

Examples:

class MyObject
{
    size_t myMegaHash() const @safe pure nothrow
    {
        return 42;
    }
}
struct Test
{
    int a;
    string b;
    MyObject c;
    size_t toHash() const pure nothrow
    {
        size_t hash = a.hashOf();
        hash = b.hashOf(hash);
        size_t h1 = c.myMegaHash();
        hash = h1.hashOf(hash); //2つのハッシュ値を混ぜる
        return hash;
    }
}

immutable size_t[pointerBitmap.length] RTInfoImpl(size_t[] pointerBitmap);

T型のRTInfoを作成する。

enum immutable(void)* rtinfoNoPointers;

正確なGCのためのショートカット。実際のポインタ・ビットマップの代わりに使用される

@property auto dup(T)(T[] a) if (!is(const(T) : T)); @property T[] dup(T)(const(T)[] a) if (is(const(T) : T));

.dup配列プロパティを提供する。

Examples:

auto arr = [1, 2];
auto arr2 = arr.dup;
arr[0] = 0;
assert(arr == [0, 2]);
assert(arr2 == [1, 2]);

@property immutable(T)[] idup(T)(T[] a); @property immutable(T)[] idup(T : void)(const(T)[] a);

.idup 配列プロパティを指定する。

Examples:

char[] arr = ['a', 'b', 'c'];
string s = arr.idup;
arr[0] = '.';
assert(s == "abc");

pure nothrow @property @trusted size_t capacity(T)(T[] arr);

(プロパティ)スライスの現在の容量を取得する。容量とはスライスの現在の容量を取得する。スライスの現在の容量を取得する。

追記がスライスを再割り当てしなければならず、拡張の可能性がない場合は 0 が返される。これは、スライスが静的な配列を参照している場合や別のスライスが現在のスライスの末尾を過ぎた要素を参照している場合などである。

注釈: スライスの容量は、他のスライスに対する操作によって影響を受けることがある。スライスの容量は、他のスライスに対する操作の影響を受けることがある。

Examples:

//静的配列のスライス: 容量なし
int[4] sarray = [1, 2, 3, 4];
int[]  slice  = sarray[];
assert(sarray.capacity == 0);
//スライスに追加すると、新しい配列に再割り当てされる
slice ~= 5;
assert(slice.capacity >= 5);

//動的配列のスライス
int[] a = [1, 2, 3, 4];
int[] b = a[1 .. $];
int[] c = a[1 .. $ - 1];
debug(SENTINEL) {} else // 非ゼロの容量は、配列とGCの実装に大きく依存する
{
    assert(a.capacity != 0);
    assert(a.capacity == b.capacity + 1); //aもbも同じ尾を共有している
}
assert(c.capacity == 0);              //cへの追加はcを再配置しなければならない。

pure nothrow @trusted size_t reserve(T)(ref T[] arr, size_t newcapacity);

スライスの容量を確保する。容量とはスライスの容量である。スライスの容量である。

Returns:

アレイの新しい容量(要求された容量よりも大きくなる可能性がある)。要求された容量よりも大きくなる可能性がある)。

Examples:

//静的配列のスライス: 容量なし。予約は再配置する。
int[4] sarray = [1, 2, 3, 4];
int[]  slice  = sarray[];
auto u = slice.reserve(8);
assert(u >= 8);
assert(&sarray[0] !is &slice[0]);
assert(slice.capacity == u);

//動的配列のスライス
int[] a = [1, 2, 3, 4];
a.reserve(8); //さらに4つのアイテムを追加する準備をする
auto p = &a[0];
u = a.capacity;
a ~= [5, 6, 7, 8];
assert(p == &a[0]);      //再割り当てされるべきではなかった
assert(u == a.capacity); //延長されるべきではなかった

nothrow ref @system inout(T[]) assumeSafeAppend(T)(auto ref inout(T[]) arr);

この配列への追加が安全であると仮定する。この配列を追加するこの関数を呼び出した後にこの配列に行われた追記は、たとえその配列がもともと大きな配列のスライスであったとしても、その場所に追記される可能性がある。たとえその配列が最初から大きな配列のスライスであったとしてもである。

この関数は、メモリブロック内の配列の先に使用中の要素がないことが確実な場合にのみ使用する。配列の先に使用されている要素がないことが確実な場合にのみ使用する。もしあれば、それらの要素はこの配列に追加することで上書きされる。

警告この関数を呼び出した後、指定された配列の後にあるデータへの参照を使用すると、未定義の動作になる。を使用すると、未定義の動作になる。

Returns:

入力が返される。

Examples:

int[] a = [1, 2, 3, 4];

// assumeSafeAppendなし。追加は再配置する。
int[] b = a [0 .. 3];
b ~= 5;
assert(a.ptr != b.ptr);

debug(SENTINEL) {} else
{
    // assumeSafeAppendあり。追加は上書きする。
    int[] c = a [0 .. 3];
    c.assumeSafeAppend() ~= 5;
    assert(a.ptr == c.ptr);
}

void destroy(bool initialize = true, T)(ref T obj) if (is(T == struct)); void destroy(bool initialize = true, T)(T obj) if (is(T == class)); void destroy(bool initialize = true, T)(T obj) if (is(T == interface)); void destroy(bool initialize = true, T)(ref T obj) if (__traits(isStaticArray, T)); void destroy(bool initialize = true, T)(ref T obj) if (!is(T == struct) && !is(T == interface) && !is(T == class) && !__traits(isStaticArray, T));

与えられたオブジェクトを破棄し、オプションで初期状態にリセットする。これはデストラクタまたはファイナライザを呼び出す。デストラクタまたはファイナライザを呼び出す。GCサイクルを開始したり、GCメモリを解放したりはしない。 GCメモリを解放することはない。 initialize が指定された場合、false 、オブジェクトは破棄後に無効とみなされる。オブジェクトは破壊後は無効とみなされ、参照されるべきではない。

Examples:

参照型のデモ

class C
{
    struct Agg
    {
        static int dtorCount;

        int x = 10;
        ~this() { dtorCount++; }
    }

    static int dtorCount;

    string s = "S";
    Agg a;
    ~this() { dtorCount++; }
}

C c = new C();
assert(c.dtorCount == 0);   // デストラクタはまだ呼び出されていない
assert(c.s == "S");         // 初期状態`c.s`は`"S"`
assert(c.a.dtorCount == 0); // デストラクタはまだ呼び出されていない
assert(c.a.x == 10);        // 初期状態`c.a.x`は`10`
c.s = "T";
c.a.x = 30;
assert(c.s == "T");         // `c.s`は`"T"`である
destroy(c);
assert(c.dtorCount == 1);   // `c`のデストラクタが呼び出された
assert(c.s == "S");         // `c.s`は初期状態に戻り、`"S"`
assert(c.a.dtorCount == 1); // `c.a`のデストラクタが呼び出された
assert(c.a.x == 10);        // `c.a.x`は初期状態に戻り、`10`

Examples:

C++クラスも機能する

extern (C++) class CPP
{
    struct Agg
    {
        __gshared int dtorCount;

        int x = 10;
        ~this() { dtorCount++; }
    }

    __gshared int dtorCount;

    string s = "S";
    Agg a;
    ~this() { dtorCount++; }
}

CPP cpp = new CPP();
assert(cpp.dtorCount == 0);   // デストラクタはまだ呼び出されていない
assert(cpp.s == "S");         // 初期状態`cpp.s`は`"S"`
assert(cpp.a.dtorCount == 0); // デストラクタはまだ呼び出されていない
assert(cpp.a.x == 10);        // 初期状態`cpp.a.x`は`10`
cpp.s = "T";
cpp.a.x = 30;
assert(cpp.s == "T");         // `cpp.s`は`"T"`
destroy!false(cpp);           // 初期化せずに破棄する
assert(cpp.dtorCount == 1);   // `cpp`のデストラクタが呼び出された
assert(cpp.s == "T");         // `cpp.s`が初期化されていない
assert(cpp.a.dtorCount == 1); // `cpp.a`のデストラクタが呼び出された
assert(cpp.a.x == 30);        // `cpp.a.x`が初期化されていない
destroy(cpp);
assert(cpp.dtorCount == 2);   // `cpp`のデストラクタが再度呼び出された
assert(cpp.s == "S");         // `cpp.s`は初期状態に戻り、`"S"`
assert(cpp.a.dtorCount == 2); // `cpp.a`のデストラクタが再度呼び出された
assert(cpp.a.x == 10);        // `cpp.a.x`は初期状態に戻り、`10`

Examples:

値型" デモ

int i;
assert(i == 0);           // `i`の初期状態は`0`
i = 1;
assert(i == 1);           // `i`は`1`に変化した
destroy!false(i);
assert(i == 1);           // `i`が初期化されなかった
destroy(i);
assert(i == 0);           // `i`は初期状態`0`に戻る

Examples:

入れ子構造体型

int dtorCount;
struct A
{
    int i;
    ~this()
    {
        dtorCount++; // ローカル変数を捕捉する
    }
}
A a = A(5);
destroy!false(a);
assert(dtorCount == 1);
assert(a.i == 5);

destroy(a);
assert(dtorCount == 2);
assert(a.i == 0);

// コンテキストポインターは現在nullである
// それを復元して、dtorが実行できるようにする
import core.lifetime : emplace;
emplace(&a, A(0));
// dtorもここから呼び出される

template imported(string moduleName)

インライン・インポート」、すなわち、import 。を提供する。例::

void fun(imported!"std.stdio".File input)
{
    ... use File from std.stdio normally ...
}

トップレベルでstd.stdio をインポートする必要はないので、fun はそれ自身の依存関係を持つ。を持つ。同じアプローチをテンプレート制約にも使うことができる:

void fun(T)(imported!"std.stdio".File input, T value)
if (imported!"std.traits".isIntegral!T)
{
    ...
}

インライン・インポートは、with ステートメントと組み合わせて使用することもできる。 with によって制御されるスコープ内では、インポートされたモジュールのすべてのシンボルが利用可能になる。利用可能になる:

void fun()
{
    with (imported!"std.datetime")
    with (imported!"std.stdio")
    {
        Clock.currTime.writeln;
    }
}

インライン・インポートの利点は、import 宣言をトップレベルで使用するよりも優れている点である。インライン・インポートの利点は以下の通りである:

テンプレートは、宣言レベルで依存関係を指定するのではなく、宣言レベルで依存関係を指定する。 importedテンプレートは、モジュール・レベルではなく宣言レベルで依存関係を指定する。モジュール・レベルではない。これにより、モジュール・レベルで集約されるのではなくの依存コストを推論することができる。
を使った宣言は、モジュールレベルで集約されないので、移動が簡単だ。 importedを使った宣言は、トップレベルのコンテキストを必要としないので、移動が簡単だ。トップレベルのコンテキストを必要としないため、リファクタリングがよりシンプルで迅速になる。
を使った宣言は importedを使った宣言は、テンプレートとの相性がいい。なぜならインスタンス化されないテンプレートは、パラメータや制約を持たないからだ。インスタンス化されないテンプレートは、そのパラメータと制約を持たないので、追加のモジュールが必要なしにインポートされることはない。このためにより、未使用のテンプレートのコストは無視できるほど小さくなる。依存関係は必要に応じて取り込まれるクライアントコードで使用される宣言に応じて、必要性に応じて引き出される。

また importedにも欠点がある:

モジュール内のほとんどの宣言が同じインポートを必要とする場合、宣言の外側のトップ・レベルでファクタリングを行う方が、同じインポートを繰り返すよりも簡単である。モジュール内のほとんどの宣言が同じインポートを必要とする場合、トップレベル、宣言の外側でファクタリングする方が、繰り返すよりも簡単である。
makeや他のビルドシステムのような、従来の依存関係追跡ツールは、ファイルレベルの依存関係を想定しており、特別なツール(例えば、runなど)が必要である。のような従来の依存関係追跡ツールは、ファイルレベルの依存関係を想定しており、効率的に動作させるためには(rdmdのような)特別なツールが必要である。を必要とする。
モジュールの先頭にある依存関係は、モジュール全体に広がっている依存関係よりも素早く検査しやすい。モジュール全体に広がっている

言語リファレンス

object