Třída SafeInt
Rozšiřuje primitiv celé zabránit přetečení celého čísla a umožňuje porovnat různé typy celá čísla.
template<typename T, typename E = _SAFEINT_DEFAULT_ERROR_POLICY>
class SafeInt;
Parametry
Šablona |
Description |
|---|---|
T |
Zadejte celé číslo nebo logický parametr, SafeInt nahradí. |
E |
Typ dat výčet definující zásady pro zpracování chyb. |
U |
Typ integer nebo booleovský parametr pro sekundární operand. |
Parametr |
Description |
|---|---|
[rhs v] |
Vstupní parametr, který představuje hodnotu na pravé straně operátoru v samostatné několik funkcí. |
[v] i |
Vstupní parametr, který představuje hodnotu na pravé straně operátoru v samostatné několik funkcí. |
[Služba bits v] |
Vstupní parametr, který představuje hodnotu na pravé straně operátoru v samostatné několik funkcí. |
Členy
.gif "Dd570021.collapse_all(cs-cz,VS.110).gif")
Veřejné konstruktory
Název |
Description |
|---|---|
Výchozí konstruktor. |
Operátory přiřazení
Název |
Syntaxe |
|---|---|
= |
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() |
Obsazení operátory
Název |
Syntaxe |
|---|---|
bool |
operator bool() throw() |
char |
operator char() const |
signed char |
operator signed char() const |
unsigned char |
operator unsigned char() const |
__int16 |
operator __int16() const |
Nepodepsaný __int16 |
operator unsigned __int16() const |
__int32 |
operator __int32() const |
Nepodepsaný __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 |
Relační operátory
Název |
Syntaxe |
|---|---|
< |
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() |
Aritmetické operátory
Název |
Syntaxe |
|---|---|
+ |
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) |
Logické operátory
Název |
Syntaxe |
|---|---|
! |
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() |
Poznámky
SafeInt Třídy chrání proti přetečení celého čísla v matematických operací.Například zvažte přidání dvou celých čísel 8 bit: jeden má hodnotu 200 a druhá hodnota 100.Správné matematické operace by 200 + 100 = 300.Však z důvodu omezení 8bitové celé číslo horní bit ztraceny a kompilátor vrátí 44 (300 28) jako výsledek.Jakoukoli operaci, která závisí na matematické rovnice vygeneruje neočekávané chování.
SafeInt Třídy zkontroluje, zda dojde k přetečení aritmetické nebo zda se pokusí kód dělení nulou.V obou případech volání třídy popisovač chyb programu potenciální problém upozornit.
Tato třída také umožňuje porovnat dva různé typy celá čísla, jako jsou SafeInt objektů.Obvykle při srovnání, je nutné nejprve převést čísla být stejného typu.Kontroly zkontrolujte, zda nedochází ke ztrátě dat, jedno číslo jinému typu obsazení často vyžaduje.
Tabulka operátory v tomto tématu jsou uvedeny matematické a relační operátory podporován SafeInt třídy.Většina matematických operátorů vrátit SafeInt objekt typu T.
Operace porovnání mezi SafeInt a integrálního typu lze provést v obou směrech.Například SafeInt<int>(x) < y a y > SafeInt<int>(x) jsou platné a vrátí stejný výsledek.
Mnoho binární operátory nepodporují pomocí dvou různých SafeInt typy.Jedním příkladem je & operátor.SafeInt<T, E> & intje podporován, ale SafeInt<T, E> & SafeInt<U, E> není.V druhém příkladu kompilátor neví, jaký typ parametru vrátit.Jedním z řešení tohoto problému je druhý parametr zpět na základní typ nádech.Pomocí stejných parametrů lze to s SafeInt<T, E> & (U)SafeInt<U, E>.
[!POZNÁMKA]
Bitové operace mělo být dva různé parametry stejné velikosti.Pokud se liší velikostí, kompilátor vyvolají ASSERT (MFC) výjimku.Výsledky této operace nelze zaručit, přesný.Chcete-li tento problém vyřešit, odevzdaných dokud stejnou velikost jako parametr větší menší parametr.
Pro operátory posunutí posunutí bitů více než neexistuje pro typ šablony vyvolají výjimku výrazu.V režimu release to nebude mít žádný vliv.Dva typy parametrů SafeInt míchání je možné operátory posunutí návratový typ je stejný jako původní typ.Číslo na pravé straně operátoru pouze označuje počet bitů shift.
Při provádění logických porovnání s SafeInt objektu je přísně aritmetické porovnání.Zvažte například tyto výrazy:
SafeInt<uint>((uint)~0) > -1
((uint)~0) > -1
První příkaz převede na true, ale druhý příkaz převede na false.Bitový operátor negace 0 je 0xFFFFFFFF.V druhém příkazu výchozí operátor porovnání porovná 0xFFFFFFFF až 0xFFFFFFFF a je rovna považuje za.Pro operátor porovnání SafeInt třídy realizuje druhý parametr je negativní, vzhledem k tomu, že první parametr je bez znaménka.Proto, i když bitová reprezentace stejná, SafeInt provádí logický operátor, celé číslo bez znaménka je větší než -1.
Buďte opatrní při použití SafeInt třídy spolu ?: Ternární operátor.Zvažte následující řádek kódu.
Int x = flag ? SafeInt<unsigned int>(y) : -1;
Kompilátor převede na tento:
Int x = flag ? SafeInt<unsigned int>(y) : SafeInt<unsigned int>(-1);
Pokud flag je false, kompilátor výjimku namísto přiřazení hodnoty-1 do x.Chcete-li předejít tomuto chování, správný kód tedy následující řádek.
Int x = flag ? (int) SafeInt<unsigned int>(y) : -1;
Ta U lze přiřadit typu Boolean, zadejte znak nebo typ integer.Celočíselné typy můžete podepsaná nebo nepodepsaná a libovolné velikosti z 8 bitů 64 bitů.
[!POZNÁMKA]
Přestože SafeInt třídy přijímá jakéhokoli typu integer, provede efektivněji s typy nepodepsaný.
Eje mechanismus pro zpracování chyb, SafeInt používá.Jsou k dispozici dva mechanismy pro zpracování chyb pomocí knihovny SafeInt.Výchozí zásada SafeIntErrorPolicy_SafeIntException, které vyvolá Třída SafeIntException výjimku při výskytu chyby.Druhá zásada je SafeIntErrorPolicy_InvalidParameter, který ukončí program, dojde k chybě.
Existují dvě možnosti přizpůsobení zásad chyba.První možností je nastavit parametr E při vytváření SafeInt.Tuto možnost použijte, pokud chcete změnit při zpracování zásad pro právě jeden SafeInt.Další možností je definovat _SAFEINT_DEFAULT_ERROR_POLICY se svou vlastní zpracování chyb třídu než SafeInt knihovny.Tuto možnost použijte, pokud chcete změnit výchozí chybu při zpracování zásad pro všechny instance SafeInt třídy v kódu.
[!POZNÁMKA]
Vlastní třídy, která zpracovává chyby z knihovny SafeInt ovládací prvek není zpět na kód, který se nazývá popisovač chyb.Po chybě obslužná rutina, výsledek SafeInt operaci nelze důvěřovat.
Požadavky
Záhlaví: safeint.h
Obor názvů: msl::utilities