通过

SafeInt 类

  • 项目

扩展整数原始帮助防止整数溢出并进行比较整数具有不同的类型。

template<typename T, typename E = _SAFEINT_DEFAULT_ERROR_POLICY>
class SafeInt;

参数

模板

说明

T

SafeInt 替换整数或布尔值参数的类型。

E

定义错误处理策略的一个枚举数据类型。

U

整数或布尔值参数的类型的辅助操作数。

Parameter

说明

[] rhs

在多个独立功能的运算符右边表示值的输入参数。

[in] i

在多个独立功能的运算符右边表示值的输入参数。

[in] 位

在多个独立功能的运算符右边表示值的输入参数。

成员

Dd570021.collapse_all(zh-cn,VS.110).gif公共构造函数

名称

说明

SafeInt::SafeInt

默认构造函数。

Dd570021.collapse_all(zh-cn,VS.110).gif赋值运算符

名称

语法

=

template<typename U>

SafeInt<T,E>& operator= (const U& rhs)

=

SafeInt<T,E>& operator= (const T& rhs) throw()

=

template<typename U>

SafeInt<T,E>& operator= (const SafeInt<U, E>& rhs)

=

SafeInt<T,E>& operator= (const SafeInt<T,E>& rhs) throw()

Dd570021.collapse_all(zh-cn,VS.110).gif转换运算符

名称

语法

bool

operator bool() throw()

char

operator char() const

signed char

operator signed char() const

unsigned char

operator unsigned char() const

__int16

operator __int16() const

unsigned __int16

operator unsigned __int16() const

__int32

operator __int32() const

unsigned __int32

operator unsigned __int32() const

long

operator long() const

unsigned long

operator unsigned long() const

__int64

operator __int64() const

unsigned __int64

operator unsigned __int64() const

wchar_t

operator wchar_t() const

Dd570021.collapse_all(zh-cn,VS.110).gif比较运算符

名称

语法

<

template<typename U>

bool operator< (U rhs) const throw()

<

bool operator< (SafeInt<T,E> rhs) const throw()

>=

template<typename U>

bool operator>= (U rhs) const throw()

>=

Bool operator>= (SafeInt<T,E> rhs) const throw()

>

template<typename U>

bool operator> (U rhs) const throw()

>

Bool operator> (SafeInt<T,E> rhs) const throw()

<=

template<typename U>

bool operator<= (U rhs) const throw()

<=

bool operator<= (SafeInt<T,E> rhs) const throw()

==

template<typename U>

bool operator== (U rhs) const throw()

==

bool operator== (bool rhs) const throw()

==

bool operator== (SafeInt<T,E> rhs) const throw()

!=

template<typename U>

bool operator!= (U rhs) const throw()

!=

bool operator!= (bool b) const throw()

!=

bool operator!= (SafeInt<T,E> rhs) const throw()

Dd570021.collapse_all(zh-cn,VS.110).gif算术运算符

名称

语法

+

const SafeInt<T,E>& operator+ () const throw()

-

SafeInt<T,E> operator- () const

++

SafeInt<T,E>& operator++ ()

--

SafeInt<T,E>& operator-- ()

%

template<typename U>

SafeInt<T,E> operator% (U rhs) const

%

SafeInt<T,E> operator% (SafeInt<T,E> rhs) const

%=

template<typename U>

SafeInt<T,E>& operator%= (U rhs)

%=

template<typename U>

SafeInt<T,E>& operator%= (SafeInt<U, E> rhs)

*

template<typename U>

SafeInt<T,E> operator* (U rhs) const

*

SafeInt<T,E> operator* (SafeInt<T,E> rhs) const

*=

SafeInt<T,E>& operator*= (SafeInt<T,E> rhs)

*=

template<typename U>

SafeInt<T,E>& operator*= (U rhs)

*=

template<typename U>

SafeInt<T,E>& operator*= (SafeInt<U, E> rhs)

/

template<typename U>

SafeInt<T,E> operator/ (U rhs) const

/

SafeInt<T,E> operator/ (SafeInt<T,E> rhs ) const

/=

SafeInt<T,E>& operator/= (SafeInt<T,E> i)

/=

template<typename U>

SafeInt<T,E>& operator/= (U i)

/=

template<typename U>

SafeInt<T,E>& operator/= (SafeInt<U, E> i)

+

SafeInt<T,E> operator+ (SafeInt<T,E> rhs) const

+

template<typename U>

SafeInt<T,E> operator+ (U rhs) const

+=

SafeInt<T,E>& operator+= (SafeInt<T,E> rhs)

+=

template<typename U>

SafeInt<T,E>& operator+= (U rhs)

+=

template<typename U>

SafeInt<T,E>& operator+= (SafeInt<U, E> rhs)

-

template<typename U>

SafeInt<T,E> operator- (U rhs) const

-

SafeInt<T,E> operator- (SafeInt<T,E> rhs) const

-=

SafeInt<T,E>& operator-= (SafeInt<T,E> rhs)

-=

template<typename U>

SafeInt<T,E>& operator-= (U rhs)

-=

template<typename U>

SafeInt<T,E>& operator-= (SafeInt<U, E> rhs)

Dd570021.collapse_all(zh-cn,VS.110).gif逻辑运算符

名称

语法

!

bool operator !() const throw()

~

SafeInt<T,E> operator~ () const throw()

<<

template<typename U>

SafeInt<T,E> operator<< (U bits) const throw()

<<

template<typename U>

SafeInt<T,E> operator<< (SafeInt<U, E> bits) const throw()

<<=

template<typename U>

SafeInt<T,E>& operator<<= (U bits) throw()

<<=

template<typename U>

SafeInt<T,E>& operator<<= (SafeInt<U, E> bits) throw()

>>

template<typename U>

SafeInt<T,E> operator>> (U bits) const throw()

>>

template<typename U>

SafeInt<T,E> operator>> (SafeInt<U, E> bits) const throw()

>>=

template<typename U>

SafeInt<T,E>& operator>>= (U bits) throw()

>>=

template<typename U>

SafeInt<T,E>& operator>>= (SafeInt<U, E> bits) throw()

&

SafeInt<T,E> operator& (SafeInt<T,E> rhs) const throw()

&

template<typename U>

SafeInt<T,E> operator& (U rhs) const throw()

&=

SafeInt<T,E>& operator&= (SafeInt<T,E> rhs) throw()

&=

template<typename U>

SafeInt<T,E>& operator&= (U rhs) throw()

&=

template<typename U>

SafeInt<T,E>& operator&= (SafeInt<U, E> rhs) throw()

^

SafeInt<T,E> operator^ (SafeInt<T,E> rhs) const throw()

^

template<typename U>

SafeInt<T,E> operator^ (U rhs) const throw()

^=

SafeInt<T,E>& operator^= (SafeInt<T,E> rhs) throw()

^=

template<typename U>

SafeInt<T,E>& operator^= (U rhs) throw()

^=

template<typename U>

SafeInt<T,E>& operator^= (SafeInt<U, E> rhs) throw()

|

SafeInt<T,E> operator| (SafeInt<T,E> rhs) const throw()

|

template<typename U>

SafeInt<T,E> operator| (U rhs) const throw()

|=

SafeInt<T,E>& operator|= (SafeInt<T,E> rhs) throw()

|=

template<typename U>

SafeInt<T,E>& operator|= (U rhs) throw()

|=

template<typename U>

SafeInt<T,E>& operator|= (SafeInt<U, E> rhs) throw()

备注

SafeInt 类可防止在数学运算的整数溢出。 例如，请考虑将两个 8 位整数:具有值为 200，第二个具有值 100。 正确的数学运算是 200 + 100 = 300。 但是，由于 8 位整数限制，，以上的位将丢失，编译器将返回 44 (300 - 2)8作为结果。 依赖于此数学公式的所有操作将生成意外行为。

SafeInt 类来检查算术溢出是否发生或代码尝试被零除)。 在这两种情况下，类调用错误处理程序警告的潜在问题的过程。

，前提是 SafeInt 对象，此类也可以比较整数的两种不同类型。 通常，那么，当您执行一次比较时，必须先将数字是同一类型。 转换到另一个类型的数字通常需要检查，以确保不会丢失数据。

本主题中的运算符表列出了 SafeInt 类支持的数学和比较运算符。 大多数数学运算符返回类型 TSafeInt 对象。

在 SafeInt 和一个整数类型之间的比较操作可以在任一方向执行。 例如， SafeInt<int>(x) < y 和 y > SafeInt<int>(x) 有效，并返回相同的结果。

使用两个不同 SafeInt 类型，许多二元运算符不支持。 此的一个示例是 & 运算符。 SafeInt<T, E> & int 支持，但是， SafeInt<T, E> & SafeInt<U, E> 不是。 在后一个示例中，编译器不知道返回什么类型的参数。 此问题的解决方案会将第二个参数返回给基础。 使用相同的参数，这可以通过 SafeInt<T, E> & (U)SafeInt<U, E>。

备注

任何按位运算，两个不同参数应大小相同。如果范围不同，则编译器将引发 ASSERT (MFC) 异常。此操作的结果不能保证是否准确。若要解决此问题，请将较小的参数，直到大小相同。更大的参数。

对于置换运算符，即将多位比为模板类型存在断言将引发异常。 这在发布模式将不起作用。 ，因为返回类型为与原始类型，组合 SafeInt 两种参数为置换运算符是可能的。 在运算符的右侧数字只是指示个数。是。

当您执行一个逻辑比较与 SafeInt 对象时，该比较强是算术的。 例如，请考虑以下表达式:

  • SafeInt<uint>((uint)~0) > -1

  • ((uint)~0) > -1

第一个语句解析为 true，不过，第二个语句引用解析为 false。 按位 " 非 0 是 0xFFFFFFFF。 在第二个语句，默认比较运算符与 0xFFFFFFFF 比较 0xFFFFFFFF 并且认为它们相等。 SafeInt 类的比较运算符意识到第二个参数为负，而第一个参数是无符号。 因此，不过，个表示相同， SafeInt 逻辑运算符意识到无符号整数大于 -1。

，当您使用 ?: 三元运算符一起时，使用 SafeInt 类小心。 请看下列代码行。

Int x = flag ? SafeInt<unsigned int>(y) : -1;

编译器将其转换为示:

Int x = flag ? SafeInt<unsigned int>(y) : SafeInt<unsigned int>(-1);

如果 flag 是 false，编译器引发异常而不是赋值为 -1 到 x。 因此，避免此行为，正确的代码使用是以下行。

Int x = flag ? (int) SafeInt<unsigned int>(y) : -1;

T 和 U 可分配布尔值类型、 char 类型或 integer 类型。 整数类型可以是签名或未签名和从 8 位的任何范围为 64 位。

备注

虽然 SafeInt 类接受任意整数，更加有效地执行与无符号类型。

E 是 SafeInt 使用的错误处理机制。 两个错误处理 framework 提供 SafeInt 库。 默认策略是 SafeIntErrorPolicy_SafeIntException， SafeIntException 类 引发异常，则错误时。 另一种策略是 SafeIntErrorPolicy_InvalidParameter，停止程序，如果错误。

具有自定义错误策略的两个选项。 ，在创建 SafeInt时，第一个选项是将参数 E 。 ，在要更改一 SafeInt时，错误处理策略请使用此选项。 ，在包括 SafeInt 库之前，另一种选择是定义 _SAFEINT_DEFAULT_ERROR_POLICY 是您的自定义错误处理的类。 ，在要更改 SafeInt 类的所有实例的默认错误处理策略在代码中，则使用此选项。

备注

自定义的类从 SafeInt 库的错误不应将控制权返回给调用错误处理程序的代码。在错误处理程序调用之后， SafeInt 操作的结果无法信任。

要求

标题: safeint.h

命名空间: msl::utilities

请参见

参考

SafeIntException 类

其他资源

其他支持库类

SafeInt库