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

std.checkedint

このモジュールは積分演算を効率的にチェックする機能を定義する。オーバーフロー、精度を失ったキャスト、予期せぬ符号の変更などに対する効率的なチェック機能を定義する、などに対する効率的なチェック機能を定義する。チェック(および場合によっては修正)は演算レベルで行うことができる。例: opChecked!"+"(x, y, overflow) は2つの積分とを加算し、オーバーフローが発生した場合はをにセットする。フラグ (参照渡しの )は、演算が成功すれば触れない。同じフラグを一連の操作に再利用し、最後にテストすることができる。個々のチェックされたオペレーションを発行することは、柔軟で効率的だが、しばしば面倒である。面倒である。このxy overflow true overflow bool

Checked機能は、カプセル化されたインテグラル・ラッパーを提供する。を提供する。を提供する。例えば、Checked!int は、int のような振る舞いをする型であるが、を生成する演算に関与すると、即座に実行を中止する。のような振る舞いをするが、算術的に誤った結果を生成する演算に関与した場合は即座に実行を中止する。算術的に誤った結果を生成する演算に関与すると、即座に実行を中止する。付属の便利関数 checkedは型推論を使用して、積分型T の値x をに変換する。 Checked!T checked(x) に変換する:

void main()
{
    import std.checkedint, std.stdio;
    writeln((checked(5) + 7).get); // 12
    writeln((checked(10) * 1000 * 1000 * 1000).get); // オーバーフロー
}

同様に、checked(-1) > uint(0) は実行を中止する(組み込みの比較int(-1) > uint(0) は、C言語に倣った変換ルールにより、驚くほど真である。変換ルールはCをモデルにしている)。従って、Checked!int は事実上ドロップインである。デバッグビルドではint 、リリースモードではint に置き換えられる。リリース・モードでは、効率が要求されれば。

Checked は、2番目の型パラメーターの助けを借りて、動作をカスタマイズできる、 Hook.Hook 、どのメソッドを定義するかによって、積分のコア演算はオーバーフローを検証されたり、完全に再定義されたりする。のコア演算は、オーバーフローを検証されたり、完全に再定義されたりする。もし Hook が全くメソッドを定義せず、状態も持たない場合、動作に変化はない。つまり、Checked!(int, void) は、int のラッパーであり、カスタマイズはまったく加えられていない。のラッパーである。

このモジュールは、いくつかの定義済みフック(下記)を提供する。 Checked:


Abort	にメッセージを送り、その後にを呼び出す。 std.stdio. stderrassert(0)これはデフォルトの第2パラメータである。つまり、Checked!short は Checked!(short, Abort).
Throw	は例外をスローして、不正な操作をすべて失敗させる。
Warn	不正な操作を std.stdio.stderr に表示するが、それ以外は組み込みの動作を維持する。
ProperCompare	は、比較演算子==,!=,<,<=,>, および>= を修正した、を修正した。例: Checked!(uint, ProperCompare)(1) > -1 はtrue 、であるが、組み込みの比較の場合はそうではない。またまた、浮動小数点数と等しいかどうかの比較はを正確に浮動小数点数に変換できる場合のみ成立する、等号の推移性を保つためである。
WithNaN	は、浮動小数点値に予約された同音異義語のような特別な "Not a Number"(NaN)値を予約する。のような特別な "Not a Number"(NaN)値を予約する。いったんChecked!(X, WithNaN) がこの特別な値を得ると、その値は再割り当てされるまで保持され、伝播する。再割り当てされる。 isNaNはオブジェクトが数値でないかどうかを問い合わせることができる。
Saturate	飽和演算を実装している。Checked!(int, Saturate) int.max int 「すなわち、飽和演算を実装している。を無限大にオーバーフローさせるような演算はすべてint.min で "停止"する。で停止する。

これらのポリシーは単独で使用されることもある。例えば、Checked!(uint, WithNaN) は以下のようなポリシーを定義している。 uint-のような型を定義している。この型は、すべての誤操作に対して安定したNaN状態になる。チェックされた積分は実際の積分をエミュレートする。チェックされた積分は実際の積分をエミュレートする。つまり、その上に別のチェック済み積分を重ねることができる。いくつかの興味深い組み合わせがある:


Checked!(Checked!int, ProperCompare)
int 。オーバーフロー時にassert(0) 。(を定義する。 Abort はデフォルト・ポリシーである)。ポリシーが組み合わされる順番は重要である。なぜなら一番外側のポリシー(この場合はProperCompare )が演算子を最初にインターセプトするからである。演算子を最初にインターセプトする。Abort 逆の組み合わせChecked!(Checked!(int, ProperCompare)) は意味がない。は比較をインターセプトし、ProperCompare に介入する機会を与えることなく失敗するからである。を与えることなく失敗するからだ。

Checked!(Checked!(int, ProperCompare), WithNaN)
はNaN値をサポートするint 型はNaN値をサポートする。NaNでない値に対しては、比較は正しく機能する。は適切に機能する。ここでも構成順序が重要である。Checked!(Checked!(int, WithNaN), ProperCompare) はセマンティクスが良くない。ProperCompare なぜなら、は、関係する数値がNaNかどうかテストされる前に比較を遮るからである。

フックのメンバは、Design by Introspectionの方法で静的に検索される。で静的に検索される。以下の表は、フック型が定義できるメンバと、そのメンバを使用する型の動作に与える影響を示している。フック型が定義できるメンバと、それを使用するChecked 型の動作に対するそれらの影響力を示している。表中、Hook 型が状態を導入しない場合、hook はHook のエイリアスである。のエイリアスであり、そうでなければHook のオブジェクトである。


Hook メンバ	におけるセマンティクス。Checked!(T, Hook)
defaultValue	定義されていれば、Hook.defaultValue!T がペイロードのデフォルト・イニシャライザとして使われる。ペイロードのデフォルト初期化子として使われる。
min	定義されている場合、Hook.min!T がペイロードの最小値として使用される。の最小値として使用される。
max	定義されている場合、Hook.max!T がペイロードの最大値として使用される。ペイロードの最大値として使用される。
hookOpCast	定義されている場合、hook.hookOpCast!U(get) がペイロードの最大値として使用される。 Uに無条件に転送される。
onBadCast	定義されており、hookOpCast が定義されていない場合、 onBadCast!U(get) に転送される。U にキャストされ、キャストが情報を失うか、符号の変更を余儀なくされる場合に転送される。
hookOpEquals	定義されている場合、hook.hookOpEquals(get, rhs) 。に無条件に転送される。ペイロードが、積分、浮動小数点、またはブール型の値rhs と等しいかどうか比較されるとき、は無条件に転送される。
hookOpCmp	定義されている場合、hook.hookOpCmp(get, rhs) は無条件に転送される。に対して順序が比較されるとき、無条件に転送される。ペイロードが、積分、浮動小数点、またはブール型の値rhs と比較されるとき、は無条件に転送される。
hookOpUnary	定義されている場合、hook.hookOpUnary!op(get) (ここでop は演算子シンボル)は、単項演算子- および~ に転送される。さらに、単項演算子++ および-- については、hook.hookOpUnary!op(payload) が呼び出される。が呼び出される。payload は、Checked によってラップされた値への参照である。フックで変更できる。
hookOpBinary	定義されている場合hook.hookOpBinary!op(get, rhs) (ここで、op は演算子シンボルで、rhs は右辺オペランドである) は、二項演算子の場合、無条件に次のように転送される。二項演算子+ 、- 、* 、/ 、% については無条件に転送される、 ^^ &,\|,^,<<,>>, および>>> 。
hookOpBinaryRight	定義されている場合、hook.hookOpBinaryRight!op(lhs, get) (op は演算子記号で lhs は左辺オペランド)は、二項演算子に対して無条件に転送される。演算子+,-,*,/,%,^^,&,\|,^,<<,>>, および>>> 。
onOverflow	定義されている場合、hook.onOverflow!op(get) に転送される。に転送される。オーバーフローする単項演算子については、hookOpUnary が定義されていない場合にのみオーバーフローする。単項演算子~ はオーバーフローしない。単項演算子- は、符号付き型の最も負の値が否定されたときのみオーバーフローする。符号付き型の最も負の値が否定され、フック呼び出しの結果が返されるときのみ、オーバーフローする。インクリメントまたはデクリメント演算子がオーバーフローすると、ペイロードにはの結果が割り当てられる。の結果が割り当てられる。二項演算子がオーバーフローすると、hook.onOverflow!op(get) の結果が返されるが、フック呼び出しの結果は返されない。 hook.onOverflow!op(get, rhs) の結果が返される。ただし、Hook がを定義していない場合に限る。がhookOpBinary を定義していない場合に限る。
hookOpOpAssign	定義されている場合、hook.hookOpOpAssign!op(payload, rhs) (ここで、op は演算子シンボル、rhs は右辺オペランドである。オペランド)は、二項演算子+=,-=,*=,/=,%= 、 ^^= &=,\|=,^=,<<=,>>=, および>>>= 。
onLowerBound	定義されている場合、hook.onLowerBound(value, bound) (value は代入される値)の結果が転送される。二項演算子+=,-=,*=,/=,%=,^^=,&=,\|=,^=,<<=,>>= 、および>>>= の結果が、T で表現可能な最小値より小さい場合に転送される。
onUpperBound	定義されている場合、hook.onUpperBound(value, bound) (ここで、value は代入される値である) は、二項演算子、、、、、の結果が、で表現可能な最小の値よりも小さい場合に転送される。二項演算子+=,-=,*=,/=,%=,^^=,&=,\|=,^=,<<=,>>= 、および>>>= の結果が、T で表現可能な最大の値よりも大きい場合に転送される。
hookToHash	定義されている場合、hook.hookToHash(payload) (ここで、payload はCheckedによってラップされた値への参照である) が転送される。 toHash に転送される。カスタムハッシュは Hookで実装できる。そうでない場合は、組み込みのハッシュが使用される。

ソース std/checkedint.d

Examples:

int[] concatAndAdd(int[] a, int[] b, int offset)
{
    // サイズ計算のオーバーフローでアボートする
    auto r = new int[(checked(a.length) + b.length).get];
    // 要素計算のオーバーフローでアボートする
    foreach (i; 0 .. a.length)
        r[i] = (a[i] + checked(offset)).get;
    foreach (i; 0 .. b.length)
        r[i + a.length] = (b[i] + checked(offset)).get;
    return r;
}
writeln(concatAndAdd([1, 2, 3], [4, 5], -1)); // [0, 1, 2, 3, 4]

Examples:

Saturate オーバーフローで止まる

auto x = (cast(byte) 127).checked!Saturate;
writeln(x); // 127
x++;
writeln(x); // 127

Examples:

WithNaN には、浮動小数点値に予約された同音異義語のような特別な "Not a Number"(NaN)値がある。

auto x = 100.checked!WithNaN;
writeln(x); // 100
x /= 0;
assert(x.isNaN);

Examples:

ProperCompare 比較演算子 ==, !=, <, <=, >, >= が正しい結果を返すように修正された。

uint x = 1;
auto y = x.checked!ProperCompare;
assert(x < -1); // 組み込み比較
assert(y > -1); // プロパー比較

Examples:

Throw 不正な操作は例外をスローして失敗する。

import std.exception : assertThrown;
auto x = -1.checked!Throw;
assertThrown(x / 0);
assertThrown(x + int.min);
assertThrown(x == uint.max);

struct Checked(T, Hook = Abort) if (isIntegral!T || is(T == Checked!(U, H), U, H));

チェックされた積分型は、積分T をラップし、その振る舞いをカスタマイズする。 Hook の助けを借りてその振る舞いをカスタマイズする。ラップされる型は、定義済みの積分の1つでなければならない。 (のインスタンスでなければならない。 Checked.

Parameters:

T	型にラップされたものでなければならない。 `Checked`型にラップされる。
Hook	の振る舞いをカスタマイズするフック型である。 `Checked`型である。

Examples:

// すべての問題を無視するフック。
static struct Ignore
{
    @nogc nothrow pure @safe static:
    Dst onBadCast(Dst, Src)(Src src) { return cast(Dst) src; }
    Lhs onLowerBound(Rhs, T)(Rhs rhs, T bound) { return cast(T) rhs; }
    T onUpperBound(Rhs, T)(Rhs rhs, T bound) { return cast(T) rhs; }
    bool hookOpEquals(Lhs, Rhs)(Lhs lhs, Rhs rhs) { return lhs == rhs; }
    int hookOpCmp(Lhs, Rhs)(Lhs lhs, Rhs rhs) { return (lhs > rhs) - (lhs < rhs); }
    typeof(~Lhs()) onOverflow(string x, Lhs)(ref Lhs lhs) { return mixin(x ~ "lhs"); }
    typeof(Lhs() + Rhs()) onOverflow(string x, Lhs, Rhs)(Lhs lhs, Rhs rhs)
    {
        static if (x == "/")
            return typeof(lhs / rhs).min;
        else
            return mixin("lhs" ~ x ~ "rhs");
    }
}

auto x = Checked!(int, Ignore)(5) + 7;

alias Representation = T;

チェックの対象となる積分の型。

Hook hook;

hookは、状態を持つ場合はメンバ変数であり、そうでない場合はHook のエイリアスである。

inout auto get();

Returns:

基礎となる値のコピー。

Examples:

auto x = checked(ubyte(42));
static assert(is(typeof(x.get()) == ubyte));
writeln(x.get); // 42
const y = checked(ubyte(42));
static assert(is(typeof(y.get()) == const ubyte));
writeln(y.get); // 42

enum Checked!(T, Hook) min; enum Checked!(T, Hook) max;

最小値と最大値を定義する。これらの値は、以下の定義によってフックすることができる。 Hook.min またはHook.max 。

Examples:

最小値と最大値を定義する。これらの値は、以下の定義によってフック可能である。または。 Hook.min Hook.max

writeln(Checked!short.min); // -32768
writeln(Checked!(short, WithNaN).min); // -32767
writeln(Checked!(uint, WithNaN).max); // uint.max - 1

this(U)(U rhs) if (valueConvertible!(U, T) || !isIntegral!T && is(typeof(T(rhs))) || is(U == Checked!(V, W), V, W) && is(typeof(Checked!(T, Hook)(rhs.get))));

基礎となる型に適切に変換可能な値を取るコンストラクタ。U は、損なわれることなくT に変換できる積分か、あるいはに変換できる別のChecked インスタンスのいずれかである。 T に変換できる別のインスタンスである。

Examples:

auto a = checked(42L);
writeln(a); // 42
auto b = Checked!long(4242); // 4242をlongに変換する
writeln(b); // 4242

ref Checked opAssign(U)(U rhs) return if (is(typeof(Checked!(T, Hook)(rhs))));

代入演算子。コンストラクタと同じ制約を持つ。

Parameters:

U rhs 代入する値

Returns:

への参照。

this

Examples:

Checked!long a;
a = 42L;
writeln(a); // 42
a = 4242;
writeln(a); // 4242

Examples:

Checked!long a, b;
a = b = 3;
assert(a == 3 && b == 3);

this(Range)(Range str) if (isInputRange!Range && isSomeChar!(ElementType!Range));

10進文字列から構築する。変換は std.conv.to 文字列をラップされたT 型に変換するのと同じ規則に従う。

Parameters:

Range str 入力範囲文字

Examples:

std.conv.to は、文字列をに変換Checked!T

できる:

import std.conv : to;

const a = to!long("1234");
const b = to!(Checked!long)("1234");
writeln(a); // b

U opCast(U, this _)() if (isIntegral!U || isFloatingPoint!U || is(U == bool));

積分、bool 、または浮動小数点型へのキャスト演算子。

浮動小数点型へのキャストが要求され、Hook 定義

されている場合、を確認することによってキャストが検証される。

onBadCast を定義している場合、get == cast(T) U(get) を確認することでキャストが検証される。それがtrue でない場合、hook.onBadCast!U(get) が返される。

積分型へのキャストが要求され、Hook がonBadCast を定義している、を定義している場合、キャストはget とcast(U) get が同じ算術数であることを確認することで検証される。(ただし、int(-1) と uint(1) は算術的には異なる値であることに注意されたい。は算術的には異なる値であることに注意されたい)。もしが算術的に等しくない場合、hook.onBadCast!U(get) が返される。が返される。

Parameters:

以下の通りである。

にキャストする型は

Returns:

Hook がhookOpCast を定義している場合、呼び出しは即座に以下を返す。 hook.hookOpCast!U(get).そうでない場合は、bool にキャストすると get != 0 が返され、のすべての値を表すことができる別の積分にキャストすると、に昇格したが返される。 T get がU に昇格して返される。

Examples:

writeln(cast(uint)checked(42)); // 42
writeln(cast(uint)checked!WithNaN(-42)); // uint.max

bool opEquals(U, this _)(U rhs) if (isIntegral!U || isFloatingPoint!U || is(U == bool) || is(U == Checked!(V, W), V, W) && is(typeof(this == rhs.payload)));

this とrhs が等しいかどう

かを比較する。 U がChecked のインスタンスでもある場合、両方のフッ

ク(左辺と右辺)がメソッドに対してイントロスペクトされる。

)は、hookOpEquals メソッドに対してイントロスペクトされる。両方が定義している場合が優先される。

Parameters:

する

U rhs 右辺が等しいかどうかを比較

Returns:

Hook がhookOpEquals を定義する場合、"関数"は hook.hookOpEquals(get, rhs) に進む

。

そうでなければ get == rhs の結果が返される。

Examples:

import std.traits : isUnsigned;

static struct MyHook
{
    static bool thereWereErrors;
    static bool hookOpEquals(L, R)(L lhs, R rhs)
    {
        if (lhs != rhs) return false;
        static if (isUnsigned!L && !isUnsigned!R)
        {
            if (lhs > 0 && rhs < 0) thereWereErrors = true;
        }
        else static if (isUnsigned!R && !isUnsigned!L)
            if (lhs < 0 && rhs > 0) thereWereErrors = true;
        // ビルトインの動作を維持する。
        return true;
    }
}
auto a = checked!MyHook(-42);
writeln(a); // uint(-42)
assert(MyHook.thereWereErrors);
MyHook.thereWereErrors = false;
writeln(checked!MyHook(uint(-42))); // -42
assert(MyHook.thereWereErrors);
static struct MyHook2
{
    static bool hookOpEquals(L, R)(L lhs, R rhs)
    {
        return lhs == rhs;
    }
}
MyHook.thereWereErrors = false;
writeln(checked!MyHook2(uint(-42))); // a
// 左側のフックが優先されるため、エラーは発生しない
assert(!MyHook.thereWereErrors);

const nothrow @safe size_t toHash(); shared const nothrow @safe size_t toHash(this _)();

this のハッシュを生成する。Hook がhookToHash を定義している場合、呼び出しは直ちにを返す。は直ちにhook.hookToHash(payload) を返す。Hook 。を実装していないが状態を持っている場合、組み込み関数を使用してhookToHash のハッシュが生成される。 Hook のハッシュとxoredされる。 payload のハッシュとxoredされる。

Returns:

this インスタンスのハッシュ。

const void toString(Writer, Char)(ref scope Writer sink, ref scope const FormatSpec!Char fmt);

この文字列表現をsink に書き込む。

Parameters:

Writer `sink`	Char 。出力範囲。
FormatSpec!Char `fmt`	std.format.FormatSpec 。を制御する。

Examples:

toString が直接呼び出されることはほとんどない。 : std.format.format

import std.format;

writeln(format("%04d", checked(15))); // "0015"
writeln(format("0x%02x", checked(15))); // "0x0f"

auto opCmp(U, this _)(const U rhs) if (isIntegral!U || isFloatingPoint!U || is(U == bool)); auto opCmp(U, Hook1, this _)(Checked!(U, Hook1) rhs);

this とrhs を比較して順序を決める。Hook がhookOpCmp を定義している場合、を定義している場合、関数はhook.hookOpCmp(get, rhs) に転送する。そうでなければの結

果が返される。 U がChecked のインスタンスでもある場合、両方のフッ

ク(左辺と右辺)がメソッドに対してイントロスペクトされる。

のインスタンスでもある場合、両方のフック(左側と右側)がメソッドhookOpCmp に対してイントロスペクトされる。両方が定義している場合が優先される。

Parameters:

である。

U `rhs`	右辺オペランド
U	`rhs` 、またはその下の型のいずれか	`rhs` がChecked インスタンスである場合
Hook1	`rhs` がChecked インスタンスである場合、Hook1 はインスタンスの振る舞いフックを表すインスタンスのビヘイビアフック

Returns:

hook がhookOpCmp を定義する場合、hookOpCmp の結果

である。

もし U がChecked のインスタンスであり、hook がを定義していない場合、の結果が返される。 hookOpCmp を定義していない場合、rhs.hook.hookOpCmp の結果が返される。どのインスタンスもhookOpCmp を介して動作を定義していない場合、の結果が返される、 -1 は、lhs がrhs より小さければ返され、1 がより大きければ返される。lhs がrhs よりも大きく、0 が等しい場合に返される。

Examples:

import std.traits : isUnsigned;

static struct MyHook
{
    static bool thereWereErrors;
    static int hookOpCmp(L, R)(L lhs, R rhs)
    {
        static if (isUnsigned!L && !isUnsigned!R)
        {
            if (rhs < 0 && rhs >= lhs)
                thereWereErrors = true;
        }
        else static if (isUnsigned!R && !isUnsigned!L)
        {
            if (lhs < 0 && lhs >= rhs)
                thereWereErrors = true;
        }
        // ビルトインの動作を維持する。
        return lhs < rhs ? -1 : lhs > rhs;
    }
}
auto a = checked!MyHook(-42);
assert(a > uint(42));
assert(MyHook.thereWereErrors);
static struct MyHook2
{
    static int hookOpCmp(L, R)(L lhs, R rhs)
    {
        // デフォルトの動作
        return lhs < rhs ? -1 : lhs > rhs;
    }
}
MyHook.thereWereErrors = false;
assert(Checked!(uint, MyHook2)(uint(-42)) <= a);
//assert(Checked!(uint, MyHook2)(uint(-42)) >= a);
// 左側のフックが優先されるため、エラーは発生しない
assert(!MyHook.thereWereErrors);
assert(a <= Checked!(uint, MyHook2)(uint(-42)));
assert(MyHook.thereWereErrors);

auto opUnary(string op, this _)() if (op == "+" || op == "-" || op == "~"); ref Checked opUnary(string op)() return if (op == "++" || op == "--");

単項演算子+ 、- 、~ 、++ 、-- を定義する。単項演算子+ はオーバーライドはできず、常に組み込みの動作をする(this を返す)。その他の演算子 Hook がhookOpUnary を定義している場合、opUnary は Checked!(typeof(hook.hookOpUnary!op(get)), Hook)(hook.hookOpUnary!op(get)) に転送される。

Hook がhookOpUnary を定義せず、onOverflow を定義し

ている場合、にフォワードする、

opUnary は、オーバーフローが発生した場合にhook.onOverflow!op(get) に転送する。 ++ および-- の場合、ペイロードは onOverflow.

T が32ビットまたは64ビットの符号付き積分であり、かつ最も負の値に等しい場合、単項式- はオーバーフローすると見なされることに注釈する。 32ビットまたは64ビットの符号付き積分であり、最も負の値に等しい場合、単項式はオーバーフローすると見なされることに注意されたい。これは値には正の否定がないからである。

Parameters:

単項演算子

Returns:

単項演算の結果を表すChecked インスタンス

。

演算子の結果を表すインスタンス。

Examples:

static struct MyHook
{
    static bool thereWereErrors;
    static L hookOpUnary(string x, L)(L lhs)
    {
        if (x == "-" && lhs == -lhs) thereWereErrors = true;
        return -lhs;
    }
}
auto a = checked!MyHook(long.min);
writeln(a); // -a
assert(MyHook.thereWereErrors);
auto b = checked!void(42);
writeln(++b); // 43

auto opBinary(string op, Rhs)(const Rhs rhs) if (isIntegral!Rhs || isFloatingPoint!Rhs || is(Rhs == bool)); const auto opBinary(string op, Rhs)(const Rhs rhs) if (isIntegral!Rhs || isFloatingPoint!Rhs || is(Rhs == bool)); auto opBinary(string op, U, Hook1)(Checked!(U, Hook1) rhs); const auto opBinary(string op, U, Hook1)(Checked!(U, Hook1) rhs);

二項演算子+,-,*,/,%,^^,&,|,^,<<,>> を定義する、および>>> を定義する。Hook がhookOpBinary 、 opBinaryを Checked!(typeof(hook.hookOpBinary!op(get, rhs)), Hook)(hook.hookOpBinary!op(get, rhs)) に転送する。

Hook がhookOpBinary を定義せず、onOverflow を定義している場合、 opBinaryに転送する。 hook.onOverflow!op(get, rhs)に転送する。に転送する。

2つのChecked インスタンスがバイナリ操作に関与し、両方がを定義している場合、左側のフックが優先される。 hookOpBinary を定義している場合、左側のフックが優先される。もし両方が onOverflow を定義している場合、コンパイル時エラーが発生する。

Parameters:

op	二項演算子
Rhs `rhs`	右辺オペランド
U	もし `rhs`がChecked インスタンスの場合、U はインスタンス型を表す。
Hook1	もし `rhs`がChecked インスタンスなら、Hook1 はインスタンスのビヘイビアフック

Returns:

の結果を表すChecked インスタンスである。操作の結果を表すインスタンス。

auto opBinaryRight(string op, Lhs)(const Lhs lhs) if (isIntegral!Lhs || isFloatingPoint!Lhs || is(Lhs == bool)); const auto opBinaryRight(string op, Lhs)(const Lhs lhs) if (isIntegral!Lhs || isFloatingPoint!Lhs || is(Lhs == bool));

二項演算子+,-,*,/,%,^^,&,|,^,<< を定義する、 >> および>>> は、組み込みの数値型またはブール型が左辺にあり、インスタンスが右辺にある場合に使用する。が左辺にあり、Checked インスタンスが右辺にある場合である。

Parameters:

op	二項演算子
Lhs `lhs`	左辺オペランド

Returns:

二項演算の結果を表すChecked インスタンス。演算

ref Checked opOpAssign(string op, Rhs)(const Rhs rhs) return if (isIntegral!Rhs || isFloatingPoint!Rhs || is(Rhs == bool)); ref Checked opOpAssign(string op, Rhs)(const Rhs rhs) return if (is(Rhs == Checked!(RhsT, RhsHook), RhsT, RhsHook));

演算子+=,-=,*=,/=,%=,^^=,&=,|=,^= を定義する、 <<= >>= 、および>>>= 。

Hook がhookOpOpAssign を定義する場合、opOpAssign は次のように転送

する。

hook.hookOpOpAssign!op(payload, rhs) ここで、payload はへの参照である。

そうでない場合、演算子はまずauto result = opBinary!op(payload, rhs).payload を評価する。 opBinary.次に、result がChecked!(T, Hook).min より小さく、かつ Hook onLowerBound hook.onLowerBound(result, min) result がChecked!(T, Hook).max より大きく、Hook がonUpperBound を定義している場合、ペイロードはから割り当てられる。 hook.onUpperBound(result, min) から割り当てられる。

右辺もCheckedであるが、フックや基礎となる型が異なる場合、そのフックと基礎となる型は、から割り当てられる。右辺もCheckedであるが、フックや基礎となる型が異なる場合、このCheckedのフックと基礎となる型が優先される。が優先される。

それ以外の場合は、組み込みの動作が実行される。

Parameters:

。

op	関係する演算子("=" を除いたもの、例えば"+" は"+=" など)
Rhs `rhs`	演算子の右辺(左辺はthis )。

Returns:

this への参照。

Examples:

static struct MyHook
{
    static bool thereWereErrors;
    static T onLowerBound(Rhs, T)(Rhs rhs, T bound)
    {
        thereWereErrors = true;
        return bound;
    }
    static T onUpperBound(Rhs, T)(Rhs rhs, T bound)
    {
        thereWereErrors = true;
        return bound;
    }
}
auto x = checked!MyHook(byte.min);
x -= 1;
assert(MyHook.thereWereErrors);
MyHook.thereWereErrors = false;
x = byte.max;
x += 1;
assert(MyHook.thereWereErrors);

Checked!(T, Hook) checked(Hook = Abort, T)(const T value) if (is(typeof(Checked!(T, Hook)(value))));

積分を対応するインスタンスに変換する便利な関数である。Checked に変換する便利な関数である。フック型を指定することができる。 (デフォルトはAbort )。

Parameters:

ルトでは

Hook	動作をカスタマイズする型、デフォ

Abort

である。

T	Checked 、インスタンスの基礎となるレプリゼンテーションを表す型
T `value`	表現の実際の値。

Returns:

提供されたHook 、カスタマイズされたChecked インスタンス

。

value

Examples:

static assert(is(typeof(checked(42)) == Checked!int));
writeln(checked(42)); // Checked!int(42)
static assert(is(typeof(checked!WithNaN(42)) == Checked!(int, WithNaN)));
writeln(checked!WithNaN(42)); // Checked!(int, WithNaN)(42)

struct Abort;

stderr 、エラーメッセージを表示することで、すべての積分エラーを強制的に失敗させる。 Abort はChecked のデフォルトの第2引数である。

Examples:

void test(T)()
{
    Checked!(int, Abort) x;
    x = 42;
    auto x1 = cast(T) x;
    writeln(x1); // 42
    //x1 += long(int.max);
}
test!short;
test!(const short);
test!(immutable short);

Dst onBadCast(Dst, Src)(Src src);

不正なキャスト(精度を失うか、負の値を符号なし型に変換しようとするもの)が行われたときに自動的に呼び出さ

負の値を符号なし型に変換しようとするもの)に自動的に呼び出される。変換元の型はSrc で、変換先の型はDst である。

Parameters:

Src src 変換元オペランド

Returns:

オペランドは、キャストの結果として転送される

、

これはキャストの結果として転送される。Abort の場合関数はプログラムを中断するので、決して戻らない。

T onLowerBound(Rhs, T)(Rhs rhs, T bound); T onUpperBound(Rhs, T)(Rhs rhs, T bound);

境界エラー時に自動的に呼び出さ

Parameters:

Rhs `rhs`	演算子が評価された後の、代入の右辺値。が評価された後の
T `bound`	違反した境界の値

Returns:

演算子が評価された後の右辺の値。がresultとして転送される。Abort の場合、関数が戻ることはない。プログラムを中断するからである。

bool hookOpEquals(Lhs, Rhs)(Lhs lhs, Rhs rhs);

等しいかどうかの比較時に自動的に呼び出さ

誤った符号付き負の値が符号なし正の値と等しくなるような比較)の場合、このフックはを発行する。このフックはassert(0) を発行し、アプリケーションを終了させる。アプリケーションを終了する。

Parameters:

、。

Lhs lhs 演算子の左辺が符号付き負の値である場合、Checked の第1引数例えばint 演算子の左辺が

Checked!int

Rhs rhs 演算子に関係する右辺型が

Returns:

正しく比較されると、比較結果を返す。そうでない場合、関数はアプリケーションを終了するので、決して戻らない。

int hookOpCmp(Lhs, Rhs)(Lhs lhs, Rhs rhs);

演算子、、、のいずれかを使用した順序の比較時に自動的に呼び出される

演算子< 、<= 、> 、>= のいずれかを使用した順序付けの比較時に自動的に呼び出される。比較に誤りがある場合(符号付き負の値が符号なし正の値より大きいか等しく見える場合)、アプリケーションは終了する。比較に誤りがある場合(つまり、符号付き負の値が符号なし正の値以上となる場合)、assert(0) でアプリケーションを終了する。そうでない場合は、3 状態の結果が返される(lhs > rhs の場合は正、 lhs < rhs なら負、それ以外なら0 ) が返される。

Parameters:

Lhs lhs int の第1引数は、Checked 、例えば演算子の左辺が演算子の左辺が

Checked!int

Rhs rhs 演算子に関係する右辺の型」である。

Returns:

正しい比較の場合、lhs > rhs の場合は正の整数、lhs < rhs の場合は負の整数、0 の場合は両者が等しい整数を返す

。

等しい場合は int(-1) < uint(0) のような間違った比較の場合、関数は決して戻らない。は決して戻らない。

typeof(~Lhs()) onOverflow(string x, Lhs)(Lhs lhs); typeof(Lhs() + Rhs()) onOverflow(string x, Lhs, Rhs)(Lhs lhs, Rhs rhs);

単項演算または二項演算中のオーバーフロー時に自動的に呼び出さ

Parameters:

ば

演算子は、例え

Lhs `lhs`	左辺(または唯一の)引数
Rhs `rhs`	演算子に関係する右辺型

Returns:

演算子で指定された値であり、resultとして転送さ

れる。

がresultとして転送される。Abort の場合、関数が戻ることはない。それはプログラムを中断するからである。

struct Throw;

型の例外をスローすることで、すべての積分エラーを強制的に失敗させる。 Throw.CheckFailure.このエラーで表示されるメッセージは、で表示されるものと似ている。 Warnによって出力される。

Examples:

void test(T)()
{
    Checked!(int, Throw) x;
    x = 42;
    auto x1 = cast(T) x;
    writeln(x1); // 42
    x = T.max + 1;
    import std.exception : assertThrown, assertNotThrown;
    assertThrown(cast(T) x);
    x = x.max;
    assertThrown(x += 42);
    assertThrown(x += 42L);
    x = x.min;
    assertThrown(-x);
    assertThrown(x -= 42);
    assertThrown(x -= 42L);
    x = -1;
    assertNotThrown(x == -1);
    assertThrown(x == uint(-1));
    assertNotThrown(x <= -1);
    assertThrown(x <= uint(-1));
}
test!short;
test!(const short);
test!(immutable short);

class CheckFailure: object.Exception;

例外型" 失敗したときにスローさ

this(T...)(string f, T vals);

Parameters:

。

string `f`	フォーマット指定子
T `vals`	フォーマット指定子の実際の値

Dst onBadCast(Dst, Src)(Src src);

不正なキャスト(精度を落としたり、負の値を符号なし型に変換しようとするもの)が行われたときに自動的に呼び出さ

負の値を符号なし型に変換しようとするもの)の際に自動的に呼び出される。変換元の型はSrc で、変換先の型はDst である。

Parameters:

Src src ソースオペランド

Returns:

の結果は、キャスト操作の希望する値である、これはキャストの結果として転送される。Throw の場合関数は例外をスローするので、決して戻らない。

Throws:

CheckFailure 不正なキャストの場合

T onLowerBound(Rhs, T)(Rhs rhs, T bound); T onUpperBound(Rhs, T)(Rhs rhs, T bound);

境界エラー時に自動的に呼び出される。

Parameters:

Rhs `rhs`	演算子が評価された後の、代入の右辺値。が評価された後の
T `bound`	違反した境界の値

Returns:

演算子が評価された後の右辺の値。がresultとして転送される。Throw の場合、関数は決して戻らない。をスローする。

Throws:

CheckFailure オーバーフロー時

bool hookOpEquals(L, R)(L lhs, R rhs);

等しいかどうかの比較時に自動的に呼び出される。をスローする。をスローする。を符号なし正の値と等しく見せるようなもの)。

Parameters:

。

L lhs 演算子の左辺が等しい場合、Checked の第1引数、例えばint 演算子の左辺が

Checked!int

R rhs 演算子に関係する右辺型が

Returns:

比較の結果。

Throws:

CheckFailure 比較が数学的に間違っている場合。

int hookOpCmp(Lhs, Rhs)(Lhs lhs, Rhs rhs);

演算子、、、のいずれかを使用した順序の比較時に自動的に呼び出される

演算子< 、<= 、> 、>= のいずれかを使用した順序付けの比較時に自動的に呼び出される。比較に誤りがある場合(符号付き負の値が符号なし正の値より大きいか等しく見える場合など)、をスローする。比較に誤りがある場合(符号なし負の値を符号なし正の値以上に見せる場合など)、Throw.CheckFailure 例外をスローする。そうでない場合は、3状態の結果が返される(lhs > rhs の場合は正、 lhs < rhs の場合は負、それ以外の場合は0 ) が返される。

Parameters:

Lhs lhs int の第1引数は、Checked 、例えば、演算子の左辺が演算子の左辺が

Checked!int

Rhs rhs 演算子に関係する右辺の型」である。

Returns:

正しい比較の場合、lhs > rhs の場合は正の整数、lhs < rhs の場合は負の整数、0 の場合は両者が等し

い整数を返す。

Throws:

int(-1) < uint(0) のような誤った比較では、を

投げるため、関数は決して戻らない。

関数はThrow.CheckedFailure 例外がスローされるため、決して戻らない。

typeof(~Lhs()) onOverflow(string x, Lhs)(Lhs lhs); typeof(Lhs() + Rhs()) onOverflow(string x, Lhs, Rhs)(Lhs lhs, Rhs rhs);

単項演算または二項演算中のオーバーフロー時に自動的に呼び出さ

Parameters:

ば

演算子は、例え

Lhs `lhs`	左辺(または唯一の)引数
Rhs `rhs`	演算子に関係する右辺型

Returns:

演算子で指定された値であり、resultとして転送さ

れる。

がresultとして転送される。Throw の場合、関数は例外を投げるので、決して戻らない。例外をスローするからである。

Throws:

CheckFailure オーバーフロー時

struct Warn;

デフォルトの動作に影響を与えることなく、すべての積分エラーのトレースをstderr 。デフォルトの動作に影響を与えない。

Examples:

auto x = checked!Warn(42);
short x1 = cast(short) x;
//x += long(int.max);
auto y = checked!Warn(cast(const int) 42);
short y1 = cast(const byte) y;

Dst onBadCast(Dst, Src)(Src src);

からの不正なキャスト時に自動的に呼び出される。 srcからDst (精度を失ったり精度を失うか、負の値を符号なし型に変換しようとするもの)。型に変換しようとするもの)。

Parameters:

Src `src`	キャスト元
Dst	キャストの対象型

Returns:

cast(Dst) src

T onLowerBound(Rhs, T)(Rhs rhs, T bound); T onUpperBound(Rhs, T)(Rhs rhs, T bound);

不正なopOpAssign 呼び出し(精度を落とすもの、負の値を符号なし型に変換しようとするもの)があった場合に自動的に呼び出される。または負の値を符号なし型に変換しようとするもの)。

Parameters:

Rhs `rhs`	演算子が評価された後、代入の右辺値が評価された後の代入における右辺値である。
T `bound`	違反する境界

Returns:

cast(T) rhs

bool hookOpEquals(Lhs, Rhs)(Lhs lhs, Rhs rhs);

等しいかどうかの比較時に自動的に呼び出される。誤って (符号付き負の値が符号なし正の値と等しくなるような比較)の場合、サイドメニューとしてに警告メッセージを書き込む。符号付き負の値が符号なし正の値と等しくなるような比較)の場合、副作用として警告メッセージをstderr に書き込む。に警告メッセージを書き込む。

Parameters:

、。

Lhs lhs 演算子の左辺が符号付き負の値である場合、Checked の第1引数例えばint 演算子の左辺が

Checked!int

Rhs rhs 演算子に関係する右辺型が

Returns:

すべての場合において、関数はlhs == rhs の組み込み結果を返す

。

Examples:

auto x = checked!Warn(-42);
// パス
writeln(x); // -42
// 合格だが警告が表示される
// assert(x == uint(-42));

int hookOpCmp(Lhs, Rhs)(Lhs lhs, Rhs rhs);

のいずれかを使用して順序を比較するときに自動的に呼び出される。演算子< 、<= 、> 、>= のいずれかを使用した順序比較時に自動的に呼び出される。比較に誤りがあった場合(符号付き負の値が符号なし正の値より大きいか等しいと表示される場合)、自動的に呼び出される。比較に誤りがあった場合(符号付き負の値が符号なし正の値以上となる場合)、stderr に警告メッセージが表示される。

Parameters:

Lhs `lhs`	Checked int の第1引数、例えば演算子の左辺が演算子の左辺がChecked!int
Rhs `rhs`	演算子に関係する右辺型が

Returns:

すべての場合において、lhs < rhs ? -1 : lhs > rhs を返す。結果は自動修正されない。

Examples:

auto x = checked!Warn(-42);
// パス
assert(x <= -42);
// 合格だが警告が表示される
// assert(x <= uint(-42));

typeof(~Lhs()) onOverflow(string x, Lhs)(ref Lhs lhs); typeof(Lhs() + Rhs()) onOverflow(string x, Lhs, Rhs)(Lhs lhs, Rhs rhs);

単項演算中または二項演算中のオーバーフロー時に自動的に呼び出される。

Parameters:

x	関係する演算子
Lhs	演算子の左辺がint の場合、Checked の第1引数。演算子の左辺がChecked!int
Rhs	演算子に関係する右辺型

Returns:

mixin(x ~ "lhs") 単項の場合、二項演算子mixin("lhs" ~ x ~ "rhs")

struct ProperCompare;

等号と順序に対して算術的に正しい比較を提供するフック。 Checked!(X, ProperCompare) "型"のオブジェクトを別の (等号または順序付けのために) 整数型のオブジェクトを別の整数と比較することで、比較の前に符号付き整数から符号なし整数への意外な変換が比較の前に起こらないことを保証する。浮動小数点数に対する等号比較の両側でChecked!(X, ProperCompare) を使用すると浮動小数点数に対する等価比較の両側でを使用することで、その積分が浮動小数点型に適切に変換されることを確認できる。浮動小数点型に適切に変換できることを確認し、等式が推移的であることを確認する。

Examples:

alias opEqualsProper = ProperCompare.hookOpEquals;
assert(opEqualsProper(42, 42));
assert(opEqualsProper(42.0, 42.0));
assert(opEqualsProper(42u, 42));
assert(opEqualsProper(42, 42u));
writeln(-1); // 4294967295u
assert(!opEqualsProper(-1, 4294967295u));
assert(!opEqualsProper(const uint(-1), -1));
assert(!opEqualsProper(uint(-1), -1.0));
writeln(3_000_000_000U); // -1_294_967_296
assert(!opEqualsProper(3_000_000_000U, -1_294_967_296));

bool hookOpEquals(L, R)(L lhs, R rhs);

== 、積分値との比較を確実にする!= 。を保証するフックである。組み込みのセマンティクス組み込みのセマンティクスは、符号付き値を符号なし値と等しく比較するときに、驚くべき動作をもたらす。例えば、uint.max == -1 または-1_294_967_296 == 3_000_000_000u のように、符号なし値と等号を比較する場合、組み込みのセミックは驚くべき動作をもたらす。hookOpEquals(x, y) の呼び出しは、true を返す。 x とy が同じ算術数を表す場合のみである。

一方の数値が積分値で、もう一方の数値が浮動小数点数である場合、はを返す。の場合、hookOpEquals(x, y) はtrue を返す。が浮動小数点数に正確に(近似なしに)変換できる場合にのみ、を返す。を返す。これは、等号の推移性を保持するためである。 hookOpEquals(x, y) とhookOpEquals(y, z) が等号の場合、hookOpEquals(y, z) 、x 、y 、z が積分数と浮動小数点数の混在の場合、が等号の推移性を保持するためである。となる。

Parameters:

L `lhs`	等号の比較の左辺
R `rhs`	等しいかどうかの比較の右辺

Returns:

値が等しい場合の比較結果true

auto hookOpCmp(L, R)(L lhs, R rhs);

積分値に対する比較を確実にする< 、<= 、> 、>= のフック。に対するフックは、通常の算術規則で期待される動作をする。組み込みの組み込みのセマンティクスは、符号付き値と符号なし値を比較する際に驚くべき動作をする。例えば、0u < -1 のような符号なし値との比較では、組み込みのセマンティクスは驚くべき振る舞いをする。例えばhookOpCmp(x, y) 呼び出しは、x が抽象的な算術的意味においてy よりも小さい場合に限り、-1 を返す。を返す。

一方の数値が積分値で、もう一方の数値が浮動小数点数である場合、。 hookOpEquals(x, y) である浮動小数点数を返す。-1 x < y 0 x == y 1 x > y NaN である浮動小数点数を返す。 NaN を返す。

Parameters:

L `lhs`	順序比較の左辺
R `rhs`	順序比較の右辺

Returns:

比較の結果(lhs < rhs の場合は負、 lhs > rhs の場合は正、0 の場合は値が等しい)。

struct WithNaN;

特別な値を "Not a Number"代表として予約するフック。符号付き積分の場合符号付き積分の場合、予約値はT.min である。符号付き積分の場合予約値はT.max である。

Checked!(X, WithNaN) のデフォルト値は NaN 値である。したがって、すべての変数が明示的に初期化されるように注意しなければならない。したがって、すべての変数は明示的に初期化されるよう注意しなければならない。少なくともNaNを含む演算は、NaNそのものになる。a == b,a < b,a > b,a <= b,a >= b のうち少なくとも1つがNaNの場合、false が得られる。 a とb の少なくとも一方がNaNの場合、を返す。

Examples:

auto x1 = Checked!(int, WithNaN)();
assert(x1.isNaN);
writeln(x1.get); // int.min
assert(x1 != x1);
assert(!(x1 < x1));
assert(!(x1 > x1));
assert(!(x1 == x1));
++x1;
assert(x1.isNaN);
writeln(x1.get); // int.min
--x1;
assert(x1.isNaN);
writeln(x1.get); // int.min
x1 = 42;
assert(!x1.isNaN);
writeln(x1); // x1
assert(x1 <= x1);
assert(x1 >= x1);
static assert(x1.min == int.min + 1);
x1 += long(int.max);

enum T defaultValue(T);

明示的に初期化されていない値に使用されるデフォルト値。NaN値である。値、すなわち符号付き積分の場合はT.min であり、符号なし積分の場合はT.max である。

enum T max(T); enum T min(T);

表現可能な最大値は以下の通りである。 T.max符号付き積分の場合は T.max - 1 である。表現可能な最小値は、符号付き積分では T.min + 1 、符号なし積分では0 である。

Lhs hookOpCast(Lhs, Rhs)(Rhs rhs);

もし rhsがWithNaN.defaultValue!Rhs の場合 WithNaN.defaultValue!Lhs.それ以外の場合はcast(Lhs) rhs を返す。

Parameters:

Rhs `rhs`	キャストされる値 (Rhs はChecked の第1引数である)
Lhs	キャストの対象型

Returns:

キャスト操作の結果。

Examples:

auto x = checked!WithNaN(422);
writeln((cast(ubyte)x)); // 255
x = checked!WithNaN(-422);
writeln((cast(byte)x)); // -128
writeln(cast(short)x); // -422
assert(cast(bool) x);
x = x.init; // NaNに戻す
assert(x != true);
assert(x != false);

bool hookOpEquals(Lhs, Rhs)(Lhs lhs, Rhs rhs);

lhs == WithNaN.defaultValue!Lhs の場合はfalse を返す、lhs == rhs それ以外の場合は

Parameters:

Lhs `lhs`	比較の左辺(Lhs は Checked)
Rhs `rhs`	比較の右辺

Returns:

lhs != WithNaN.defaultValue!Lhs && lhs == rhs

double hookOpCmp(Lhs, Rhs)(Lhs lhs, Rhs rhs);

lhs == WithNaN.defaultValue!Lhs の場合、double.init を返す。それ以外の場合ははデフォルトの比較と同じセマンティクスを持つ。

Parameters:

Lhs `lhs`	比較の左辺 (Lhs は Checked)
Rhs `rhs`	比較の右辺

Returns:

double.init もし lhs == WitnNaN.defaultValue!Lhs lhs < rhs の場合は-1.0 、lhs == rhs の場合は0.0 、lhs > rhs の場合は1.0 。

Examples:

Checked!(int, WithNaN) x;
assert(!(x < 0) && !(x > 0) && !(x == 0));
x = 1;
assert(x > 0 && !(x < 0) && !(x == 0));

auto hookOpUnary(string x, T)(ref T v);

単項演算子- 、~ 、++ 、-- のフックを定義する。

- と~ については、v == WithNaN.defaultValue!T の場合、以下を返す。 WithNaN.defaultValue!T.それ以外の場合、セマンティクスは組み込み演算子の場合と同じである。と同じである。

++ および-- の場合、v == WithNaN.defaultValue!Lhs または演算がオーバーフローになる場合は vをWithNaN.defaultValue!T にセットする。それ以外の場合、セマンティクスは組込み演算子と同じである。

Parameters:

x	演算子記号
T `v`	比較の左辺 (T は Checked)

Returns:

x == "-" || x == "~" の場合:v == WithNaN.defaultValue!T の場合、"関数"はWithNaN.defaultValue!T を返す。そうでなければ、演算子の通常の結果を返す。
x == "++" || x == "--" の場合:関数はvoid を返す。

Examples:

Checked!(int, WithNaN) x;
++x;
assert(x.isNaN);
x = 1;
assert(!x.isNaN);
x = -x;
++x;
assert(!x.isNaN);

auto hookOpBinary(string x, L, R)(L lhs, R rhs);

二項演算子+,-,*,/,%,^^,&,| のフックを定義する、 ^ Checked オブジェクトが左辺オペランドである場合、<<,>>,>>> のフックを定義する。を返す。lhs == WithNaN.defaultValue!Lhs の場合は WithNaN.defaultValue!(typeof(lhs + rhs)) を評価せずにオペランドを評価せずに戻る。そうでなければ、オペランドを評価する。評価がオーバーフローしなければは結果を返す。そうでない場合は、WithNaN.defaultValue!(typeof(lhs + rhs)) を返す。

Parameters:

x	演算子記号
L `lhs`	左辺オペランド (Lhs はChecked の第1引数である )。
R `rhs`	右辺オペランド

Returns:

lhs != WithNaN.defaultValue!Lhs 、演算子がオーバーフローしない場合、関数は組み込み演算子と同じ結果を返す。それ以外の場合は WithNaN.defaultValue!(typeof(lhs + rhs)) を返す。

Examples:

Checked!(int, WithNaN) x;
assert((x + 1).isNaN);
x = 100;
assert(!(x + 1).isNaN);

auto hookOpBinaryRight(string x, L, R)(L lhs, R rhs);

二項演算子+,-,*,/,%,^^,&,| のフックを定義する、 ^ Checked オブジェクトが右辺オペランドである場合の<<,>>,>>> のフックを定義する。を返す。rhs == WithNaN.defaultValue!Rhs の場合は WithNaN.defaultValue!(typeof(lhs + rhs)) を評価せずにオペランドを評価せずに戻る。そうでなければ、オペランドを評価する。評価がオーバーフローしなければは結果を返す。そうでない場合は、WithNaN.defaultValue!(typeof(lhs + rhs)) を返す。

Parameters:

x	演算子記号
L `lhs`	左辺オペランド
R `rhs`	右辺オペランド (Rhs はChecked の第1引数)

Returns:

rhs != WithNaN.defaultValue!Rhs 、演算子がオーバーフローしない場合、関数は組み込み演算子と同じ結果を返す。それ以外の場合は WithNaN.defaultValue!(typeof(lhs + rhs)) を返す。

Examples:

Checked!(int, WithNaN) x;
assert((1 + x).isNaN);
x = 100;
assert(!(1 + x).isNaN);

void hookOpOpAssign(string x, L, R)(ref L lhs, R rhs);

二項演算子+=,-=,*=,/=,%=,^^= のフックを定義する、 &= |= ,^=,<<=,>>=,>>>= 。Checked オブジェクトが左辺オペランドである場合に使用される。lhs == WithNaN.defaultValue!Lhs の場合、アクションは実行されない。そうでなければオペランドを評価する。評価がオーバーフローせず、Lhs に収まる。に収まる場合、結果を lhsを結果にセットする。そうでなければ lhsをWithNaN.defaultValue!Lhs にセットする。

Parameters:

x	演算子記号(= を含まない)
L `lhs`	左辺オペランド (Lhs はChecked の第1引数 )
R `rhs`	右辺オペランド

Returns:

void

Examples:

Checked!(int, WithNaN) x;
x += 4;
assert(x.isNaN);
x = 0;
x += 4;
assert(!x.isNaN);
x += int.max;
assert(x.isNaN);

bool isNaN(T)(const Checked!(T, WithNaN) x);

Checked!(T, WithNaN) オブジェクトが数値(NaN)でないかどうかを問い合わせる。

Parameters:

Checked!(T, WithNaN) x Checked インスタンスを問い合わせる。

Returns:

true もし xがNaNの場合、false 。

Examples:

auto x1 = Checked!(int, WithNaN)();
assert(x1.isNaN);
x1 = 1;
assert(!x1.isNaN);
x1 = x1.init;
assert(x1.isNaN);

struct Saturate;

飽和を実装したフックである。つまり、オーバーフローするような算術演算は、結果をその極値(オーバーフローの方向によってmin またはmax )のままにする。オーバーフローの方向によって異なる)。

ある値が飽和値に達しても、別の演算で通常の範囲に戻すことができる。演算によって通常の範囲に戻ることができる。

Examples:

auto x = checked!Saturate(int.max);
++x;
writeln(x); // int.max
--x;
writeln(x); // int.max - 1
x = int.min;
writeln(-x); // int.max
x -= 42;
writeln(x); // int.min
writeln(x * -2); // int.max

T onLowerBound(Rhs, T)(Rhs, T bound); T onUpperBound(Rhs, T)(Rhs, T bound);

+=,-=,*=,/=,%=,^^=,&=,|=,^=,<<=,>>= 、および>>>= 。このフックは、バイナリ演算の結果がに収まらない場合に呼び出される。 Lhs に収まらない場合、このフックが呼ばれる。

Parameters:

Rhs	演算が計算された後の代入の右辺型は、次のようになる。を計算する。
T `bound`	違反する境界

Returns:

Lhs.max もし、そうでなければ。rhs >= 0 Lhs.min

Examples:

auto x = checked!Saturate(short(100));
x += 33000;
writeln(x); // short.max
x -= 70000;
writeln(x); // short.min

auto onOverflow(string x, Lhs)(Lhs); typeof(Lhs() + Rhs()) onOverflow(string x, Lhs, Rhs)(Lhs lhs, Rhs rhs);

+,- (単項および二項) ,*,/ 、 % ^^ ,&,|,^,<<,>>, および>>> 。

単項の場合、- 、 onOverflowlhs == Lhs.min Lhs が呼び出される。である場合に呼び出される。この関数はLhs.max を返す。

二項演算子の場合、結果は以下のようになる:

Lhs.max 結果は以下のようになる。で除算された場合、または負の値で右シフトされた場合、結果は以下のようになる。負の値で右へシフトする。0
Lhs.min 結果が負の方向にオーバーフローした場合負の方向にオーバーフローした場合
0 もし lhsによって左にシフトされている場合、または負の値で左にシフトされている場合、または大きな正の値で右にシフトされている場合。

Parameters:

x	opAssign 操作に関与する演算子
Lhs	演算子の左辺型(Lhs がその第一引数である。 Checked)
Rhs	演算子の右辺型

Returns:

演算子の飽和結果。

Examples:

writeln(checked!Saturate(int.max) + 1); // int.max
writeln(checked!Saturate(100)^^10); // int.max
writeln(checked!Saturate(-100)^^10); // int.max
writeln(checked!Saturate(100) / 0); // int.max
writeln(checked!Saturate(100) << -1); // 0
writeln(checked!Saturate(100) << 33); // int.max
writeln(checked!Saturate(100) >> -1); // int.max
writeln(checked!Saturate(100) >> 33); // 0

typeof(mixin(x == "cmp" ? "0" : "L() " ~ x ~ " R()")) opChecked(string x, L, R)(const L lhs, const R rhs, ref bool overflow) if (isIntegral!L && isIntegral!R);

任意の2つの積分型に対してオーバーフロー・チェックを行う2項演算を定義する。結果の型は言語規則に従う。に従う。 overflowオーバーフローが発生した場合にセットされる。例えば、-1 がuint に変換された場合など)。概念的な動作は以下の通りである:

無限精度で演算を実行する。
無限精度の結果が結果型に収まる場合、それを返し、次の動作には触れない。に触れない。 overflow
そうでなければ overflowをtrue にセットし、未指定の値を返す。

この実装では、型と操作の特性を利用して、追加作業を最小限に抑えている。追加作業を最小限にする。

Parameters:

x	二項演算子。/
L `lhs`	演算子の左辺
R `rhs`	演算子の右辺
bool `overflow`	オーバーフロー指示子(エラーがあった場合にtrue を代入する)

Returns:

演算の結果。これは組み込み演算子と同じである。

Examples:

bool overflow;
assert(opChecked!"+"(const short(1), short(1), overflow) == 2 && !overflow);
assert(opChecked!"+"(1, 1, overflow) == 2 && !overflow);
assert(opChecked!"+"(1, 1u, overflow) == 2 && !overflow);
assert(opChecked!"+"(-1, 1u, overflow) == 0 && !overflow);
assert(opChecked!"+"(1u, -1, overflow) == 0 && !overflow);

Examples:

bool overflow;
assert(opChecked!"-"(1, 1, overflow) == 0 && !overflow);
assert(opChecked!"-"(1, 1u, overflow) == 0 && !overflow);
assert(opChecked!"-"(1u, -1, overflow) == 2 && !overflow);
assert(opChecked!"-"(-1, 1u, overflow) == 0 && overflow);

DEEPL APIにより翻訳、ところどころ修正。
このページの最新版(英語)
このページの原文(英語)
翻訳時のdmdのバージョン: 2.108.0
ドキュメントのdmdのバージョン: 2.109.1
翻訳日付 :2024-04-15 10:56:22+09:00
HTML生成日時: 2025-01-09 08:11:49+09:00
編集者: dokutoku

言語リファレンス

std.checkedint