Поделиться через

Класс SafeInt

  • Статья

Расширяет примитивов целого числа, чтобы предотвратить переполнение целых числа и позволяет сравнивать различные типы целых чисел.

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

Параметры

Шаблон

Описание

T

Тип целого числа или логического параметра, который SafeInt заменяет.

E

Перечислимые типы данных, который определяет политику обработки ошибок.

U

Тип целого числа или логического параметра для вторичного операнда.

Параметр

Описание

[in] rhs

Входной параметр, представляющий значение в правой части оператора в нескольких отдельных функций.

[in] I

Входной параметр, представляющий значение в правой части оператора в нескольких отдельных функций.

[in] биты

Входной параметр, представляющий значение в правой части оператора в нескольких отдельных функций.

Члены

Dd570021.collapse_all(ru-ru,VS.110).gifОткрытые конструкторы

Имя

Описание

SafeInt::SafeInt

Конструктор по умолчанию.

Dd570021.collapse_all(ru-ru,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(ru-ru,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(ru-ru,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(ru-ru,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(ru-ru,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 защищает от переполнения целого числа в математических операциях.Рассмотрим, например, чтобы добавить 2 8 разрядных целого числа. один из них имеет значение 200, а второй - имеет значение 100.Математическая операция будет правильной 200 + 100 = 300.Однако из-за 8 разрядного ограничения целого числа, и компилятор будет потерян верхний бит будет 44 (300 - 2)8 в результат.Любая операция, зависящие от это математическая формула будет непредвиденную расширений функциональности.

Класс SafeInt проверяет, присутствует ли арифметического переполнения или деления на ноль. пытается ли кодВ обоих случаях класс вызывает обработчик ошибок для предупреждения программы прогнозируемой проблемы.

Этот класс также позволяет сравнить 2 различных типа целых чисел, пока они являются объектами SafeInt.Как правило, при выполнении сравнения, сначала необходимо преобразовать числа, чтобы являться одним и тем же типом.Приведение одного числа на другое типу часто требует проверки убеждают, что потери данных.

Таблица операторов в этом разделе перечислены математические операторы и операторы сравнения, поддерживаемые классом SafeInt.Большинство математические операторы возвращают объект SafeInt типа T.

Операции сравнения SafeInt объединенным типом и могут выполняться в любом направлении.Например, а SafeInt<int>(x) < y и y > SafeInt<int>(x) допустимым и возвращают один и тот же результат.

Многие двоичных операторов не поддерживают с помощью 2 различных типа SafeInt.Примером этого оператора &.SafeInt<T, E> & int поддерживается, но не SafeInt<T, E> & SafeInt<U, E>.В последнем примере компилятор не знает, какой тип параметра, который необходимо вернуть.Решением этой проблемы является приведение второй параметр обратно к базовому типу.С помощью тех же вариантов, это можно сделать с SafeInt<T, E> & (U)SafeInt<U, E>.

ПримечаниеПримечание

Для битовых операций: 2 различных параметров должны быть одинаковым размером.Если размеры различаются, то компилятор создает исключение ASSERT (MFC).Результаты данной операции невозможно гарантировать, что были явно заданы.Чтобы разрешить эту проблему, приведение меньший параметр до тех пор, пока не будет тот же размер, как большой параметр.

Для операторов миграции сдвигающ несколько битов не существует для типа шаблона будут вызывать исключение УТВЕРЖДЕНИЯ.Это не оказывает влияния в режиме выпуска.Смешение 2 типа параметров 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);

Если flagfalse, то компилятор создает исключение вместо присвоения значения от -1 до x.Поэтому во избежание этой функциональности, правильный код для использования в следующей линия.

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

T и U можно присвоить логические тип символьный тип или тип integer.Типы целого числа без знака и могут быть подписаны или любы размер от 8 до 64 бит.

ПримечаниеПримечание

Хотя класс SafeInt принимает любой тип целого числа, он выполняет более эффективно с типами без знака.

E механизм обработки ошибок, SafeInt.2 Механизма обработки ошибок, предоставляемых с библиотекой SafeInt.Политика по умолчанию SafeIntErrorPolicy_SafeIntException, которая вызывает исключение Класс SafeIntException при возникновении ошибки.Другая политика SafeIntErrorPolicy_InvalidParameter, программа останавливается при возникновении ошибки.

2 Параметра настраивать политику ошибки.Первый вариант задать параметр E при создании SafeInt.Используйте этот параметр, если нужно, чтобы изменить политику обработки ошибок только для одного SafeInt.Можно также указать _SAFEINT_DEFAULT_ERROR_POLICY для настраиванным быть пользовательским классом обработки ошибок прежде чем включать библиотеку SafeInt.Используйте этот параметр, если нужно, чтобы изменить политику по умолчанию обработки ошибок для всех экземпляров класса SafeInt в коде.

ПримечаниеПримечание

Настраиванный класс, который обрабатывает ошибки из библиотека SafeInt не должен вернуть элемент управления коду, который вызвал обработчика ошибок.После того, как обработчик ошибок называется, результат операции SafeInt нельзя доверять.

Требования

заголовок: safeint.h

Msl::utilities пространство имен:

См. также

Ссылки

Класс SafeIntException

Другие ресурсы

Прочие классы библиотек поддержки

Библиотека SafeInt