Improve this page
Quickly fork, edit online, and submit a pull request for this page.
Requires a signed-in GitHub account. This works well for small changes.
If you'd like to make larger changes you may want to consider using
local clone.
Page wiki
View or edit the community-maintained wiki page associated with this page.

# core.checkedint

This module implements integral arithmetic primitives that check
for out-of-range results.

Integral arithmetic operators operate on fixed width types.
Results that are not representable in those fixed widths are silently
truncated to fit.
This module offers integral arithmetic primitives that produce the
same results, but set an 'overflow' flag when such truncation occurs.
The setting is sticky, meaning that numerous operations can be cascaded
and then the flag need only be checked at the end.
Whether the operation is signed or unsigned is indicated by an 's' or 'u'
suffix, respectively. While this could be achieved without such suffixes by
using overloading on the signedness of the types, the suffix makes it clear
which is happening without needing to examine the types.
While the generic versions of these functions are computationally expensive
relative to the cost of the operation itself, compiler implementations are free
to recognize them and generate equivalent and faster code.

References: Fast Integer Overflow Checks

License:

Authors:

Walter Bright

Source: core/checkedint.d

- pure nothrow @nogc @safe int adds(int
*x*, int*y*, ref bool*overflow*);

pure nothrow @nogc @safe long adds(long*x*, long*y*, ref bool*overflow*); - Add two signed integers, checking for
*overflow*.The*overflow*is sticky, meaning a sequence of operations can be done and*overflow*need only be checked at the end.Parameters:int *x*left operand int *y*right operand bool *overflow*set if an *overflow*occurs, is not affected otherwiseReturns:the sum - pure nothrow @nogc @safe uint addu(uint
*x*, uint*y*, ref bool*overflow*);

pure nothrow @nogc @safe ulong addu(ulong*x*, ulong*y*, ref bool*overflow*); - Add two unsigned integers, checking for
*overflow*(aka carry).The*overflow*is sticky, meaning a sequence of operations can be done and*overflow*need only be checked at the end.Parameters:uint *x*left operand uint *y*right operand bool *overflow*set if an *overflow*occurs, is not affected otherwiseReturns:the sum - pure nothrow @nogc @safe int subs(int
*x*, int*y*, ref bool*overflow*);

pure nothrow @nogc @safe long subs(long*x*, long*y*, ref bool*overflow*); - Subtract two signed integers, checking for
*overflow*.The*overflow*is sticky, meaning a sequence of operations can be done and*overflow*need only be checked at the end.Parameters:int *x*left operand int *y*right operand bool *overflow*set if an *overflow*occurs, is not affected otherwiseReturns:the sum - pure nothrow @nogc @safe uint subu(uint
*x*, uint*y*, ref bool*overflow*);

pure nothrow @nogc @safe ulong subu(ulong*x*, ulong*y*, ref bool*overflow*); - Subtract two unsigned integers, checking for
*overflow*(aka borrow).*overflow*is sticky, meaning a sequence of operations can be done and*overflow*need only be checked at the end.Parameters:uint *x*left operand uint *y*right operand bool *overflow*set if an *overflow*occurs, is not affected otherwiseReturns:the sum - pure nothrow @nogc @safe int negs(int
*x*, ref bool*overflow*);

pure nothrow @nogc @safe long negs(long*x*, ref bool*overflow*); - Negate an integer.Parameters:
int *x*operand bool *overflow*set if *x*cannot be negated, is not affected otherwiseReturns:the negation of*x* - pure nothrow @nogc @safe int muls(int
*x*, int*y*, ref bool*overflow*);

pure nothrow @nogc @safe long muls(long*x*, long*y*, ref bool*overflow*); - Multiply two signed integers, checking for
*overflow*.*overflow*is sticky, meaning a sequence of operations can be done and*overflow*need only be checked at the end.Parameters:int *x*left operand int *y*right operand bool *overflow*set if an *overflow*occurs, is not affected otherwiseReturns:the sum - pure nothrow @nogc @safe uint mulu(uint
*x*, uint*y*, ref bool*overflow*);

pure nothrow @nogc @safe ulong mulu(ulong*x*, ulong*y*, ref bool*overflow*); - Multiply two unsigned integers, checking for
*overflow*(aka carry).*overflow*is sticky, meaning a sequence of operations can be done and*overflow*need only be checked at the end.Parameters:uint *x*left operand uint *y*right operand bool *overflow*set if an *overflow*occurs, is not affected otherwiseReturns:the sum