通过

SafeInt 函数

SafeInt 库提供了多个无需创建 SafeInt 类实例即可使用的函数。 若要防止一个数学运算出现整数溢出，可使用这些函数。 若要保护多个数学运算，应创建 SafeInt 对象。 创建 SafeInt 对象比多次使用这些函数更高效。

使用这些函数，可以对两个不同类型的参数进行比较或执行数学运算，无需先将它们转换为相同类型。

所有这些函数都有两种模板类型：T 和 U。 每种模板类型都可以是布尔类型、字符类型或整型类型。 整型类型可以有符号，也可以无符号，且大小介于 8 位和 64 位之间。

注意

有关此库的最新版本，请访问 https://github.com/dcleblanc/SafeInt。

本节内容

函数 说明
SafeAdd 将两个数字相加，并防止溢出。
SafeCast 将一种类型的参数强制转换为另一种类型。
SafeDivide 将两个数字相除，并防止除以零。
SafeEquals、SafeGreaterThan、SafeGreaterThanEquals、SafeLessThan、SafeLessThanEquals、SafeNotEquals 比较两个数字。 使用这些函数，可以比较两个不同类型的数字，而不更改它们的类型。
SafeModulus 对两个数字执行取模运算。
SafeMultiply 将两个数字相乘，并防止溢出。
SafeSubtract 将两个数字相减，并防止溢出。
部分 说明
SafeInt SafeInt 类。
SafeIntException SafeInt 库专用的异常类。

SafeAdd

以防止溢出的方式将两个数字相加。

template<typename T, typename U>
inline bool SafeAdd (
   T t,
   U u,
   T& result
) throw ();

参数

t
[输入] 要相加的第一个数字。 其类型必须为 T。

u
[输入] 要相加的第二个数字。 其类型必须为 U。

result
[输出] SafeAdd 在其中存储结果的参数。

返回值

如果未出错，返回 true；否则，返回 false。

SafeCast

将一种类型的数字转换为另一种类型。

template<typename T, typename U>
inline bool SafeCast (
   const T From,
   U& To
);

参数

From
[输入] 要转换的源数字。 这必须是 T 类型。

操作
[输出] 对新数字类型的引用。 这必须是 U 类型。

返回值

如果未出错，返回 true；否则，返回 false。

SafeDivide

以防止除以零的方式将两个数字相除。

template<typename T, typename U>
inline bool SafeDivide (
   T t,
   U u,
   T& result
) throw ();

参数

t
[输入] 被除数。 其类型必须为 T。

u
[输入] 除数。 其类型必须为 U。

result
[输出] SafeDivide 在其中存储结果的参数。

返回值

如果未出错，返回 true；否则，返回 false。

SafeEquals

比较两个数字，以确定它们是否相等。

template<typename T, typename U>
inline bool SafeEquals (
   const T t,
   const U u
) throw ();

参数

t
[输入] 要比较的第一个数字。 其类型必须为 T。

u
[输入] 要比较的第二个数字。 其类型必须为 U。

返回值

如果 t 和 u 相等，返回 true；否则，返回 false。

注解

该方法增强了 ==，因为 SafeEquals 使您能够将两个不同类型的数字作比较。

SafeGreaterThan

比较两个数字。

template<typename T, typename U>
inline bool SafeGreaterThan (
   const T t,
   const U u
) throw ();

参数

t
[输入] 要比较的第一个数字。 这必须是 T 类型。

u
[输入] 要比较的第二个数字。 这必须是 U 类型。

返回值

如果 t 大于 u，返回 true；否则，返回 false。

备注

SafeGreaterThan 扩展了常规比较运算符，因为它可便于比较两个不同类型的数字。

SafeGreaterThanEquals

比较两个数字。

template <typename T, typename U>
inline bool SafeGreaterThanEquals (
   const T t,
   const U u
) throw ();

参数

t
[输入] 要比较的第一个数字。 这必须是 T 类型。

u
[输入] 要比较的第二个数字。 这必须是 U 类型。

返回值

如果 t 大于或等于 u，返回 true；否则，返回 false。

备注

SafeGreaterThanEquals 增强了标准比较运算符，因为它可便于比较两个不同类型的数字。

SafeLessThan

确定一个数字是否小于另一个数字。

template<typename T, typename U>
inline bool SafeLessThan (
   const T t,
   const U u
) throw ();

参数

t
[输入] 第一个数字。 这必须是 T 类型。

u
[输入] 第二个数字。 这必须是 U 类型。

返回值

如果 t 小于 u，返回 true；否则，返回 false。

备注

这种方法增强了标准比较运算符，因为 SafeLessThan 可便于比较两个不同类型的数字。

SafeLessThanEquals

比较两个数字。

template <typename T, typename U>
inline bool SafeLessThanEquals (
   const T t,
   const U u
) throw ();

参数

t
[输入] 要比较的第一个数字。 这必须是 T 类型。

u
[输入] 要比较的第二个数字。 这必须是 U 类型。

返回值

如果 t 小于或等于 u，返回 true；否则，返回 false。

备注

SafeLessThanEquals 扩展了常规比较运算符，因为它可便于比较两个不同类型的数字。

SafeModulus

对两个数字执行取模运算。

template<typename T, typename U>
inline bool SafeModulus (
   const T t,
   const U u,
   T& result
) throw ();

参数

t
[输入] 除数。 这必须是 T 类型。

u
[输入] 被除数。 这必须是 U 类型。

result
[输出] SafeModulus 在其中存储结果的参数。

返回值

如果未出错，返回 true；否则，返回 false。

SafeMultiply

以防止溢出的方式将两个数字相乘。

template<typename T, typename U>
inline bool SafeMultiply (
   T t,
   U u,
   T& result
) throw ();

参数

t
[输入] 要相乘的第一个数字。 这必须是 T 类型。

u
[输入] 要相乘的第二个数字。 这必须是 U 类型。

result
[输出] SafeMultiply 在其中存储结果的参数。

返回值

如果未出错，返回 true；否则，返回 false。

SafeNotEquals

确定两个数字不相等。

template<typename T, typename U>
inline bool SafeNotEquals (
   const T t,
   const U u
) throw ();

参数

t
[输入] 要比较的第一个数字。 这必须是 T 类型。

u
[输入] 要比较的第二个数字。 这必须是 U 类型。

返回值

如果 t 和 u 不相等，返回 true；否则，返回 false。

注解

该方法增强了 !=，因为 SafeNotEquals 使您能够将两个不同类型的数字作比较。

SafeSubtract

以防止溢出的方式将两个数字相减。

template<typename T, typename U>
inline bool SafeSubtract (
   T t,
   U u,
   T& result
) throw ();

参数

t
[输入] 减法运算中的第一个数字。 这必须是 T 类型。

u
[输入] 要从 t 中减去的数字。 这必须是 U 类型。

result
[输出] SafeSubtract 在其中存储结果的参数。

返回值

如果未出错，返回 true；否则，返回 false。