SafeInt – třída
Rozšiřuje primitiv celé aby se zabránilo přetečení celých čísel a umožňuje porovnávat různé druhy celých čísel.
template<typename T, typename E = _SAFEINT_DEFAULT_ERROR_POLICY>
class SafeInt;
Parametry
Šablona |
Popis |
|---|---|
T |
Typ celé číslo nebo Boolean parametr, který SafeInt nahradí. |
E |
Výčtový datový typ, který definuje zásady zpracování chyb. |
U |
Typ celé číslo nebo Boolean parametr pro sekundární operand. |
Parametr |
Popis |
|---|---|
[rhs v] |
Vstupní parametr, který představuje hodnotu na pravé straně operátoru v několika samostatných funkcí. |
[v] i |
Vstupní parametr, který představuje hodnotu na pravé straně operátoru v několika samostatných funkcí. |
[Služba bits v] |
Vstupní parametr, který představuje hodnotu na pravé straně operátoru v několika samostatných funkcí. |
Členy
Veřejné konstruktory
Name |
Popis |
|---|---|
Výchozí konstruktor. |
Operátory přiřazení
Name |
Syntax |
|---|---|
= |
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() |
Operátorů přetypování
Name |
Syntax |
|---|---|
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 |
Porovnávací operátory
Name |
Syntax |
|---|---|
< |
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
Name |
Syntax |
|---|---|
+ |
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
Name |
Syntax |
|---|---|
! |
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řída chrání proti celočíselnému přetečení v matematických operacích.Například může být vhodné přidat dvě celá čísla 8 bitů: jeden s hodnotou 200 a druhá hodnota je 100.Správné matematické operace by bylo 200 + 100 = 300.Však z důvodu omezení 8bitové celé číslo, horní bit budou ztraceny a kompilátor vrátí 44 (300-28) jako výsledek.Jakákoli operace, která závisí na matematické rovnice vygeneruje neočekávané chování.
SafeInt Třída zkontroluje, zda dojde k přetečení aritmetické operace nebo zda kód se pokusí dělení nulou.V obou případech volá třídy obslužná rutina chyb upozorní program potenciální problém.
Tato třída také umožňuje porovnat dva různé druhy celých čísel, tak dlouho, dokud se SafeInt objekty.Obvykle se při provedení porovnání je nutné nejprve převést čísla být stejného typu.Obsazení jedno číslo jinému typu často vyžaduje kontroly a ujistěte se, že nedochází ke ztrátě dat.
Tabulka operátorů v tomto tématu jsou uvedeny matematické a porovnání operátory podporován SafeInt třídy.Většina matematické operátory vrací SafeInt objekt typu T.
Operace porovnání mezi SafeInt a integrálního typu lze provádět v obou směrech.Například obě SafeInt<int>(x) < y a y > SafeInt<int>(x) jsou platné a vrátí stejný výsledek.
Mnoho binárních operátorů lze provést pomocí dvou různých SafeInt typy.Příkladem je & operátor.SafeInt<T, E> & intje podporována, 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 přetypovat.Pomocí stejných parametrů se provádí s SafeInt<T, E> & (U)SafeInt<U, E>.
[!POZNÁMKA]
Bitové operace třeba dva různé parametry stejné velikosti.Pokud se velikosti liší, kompilátor vyvolají ASSERT (MFC) výjimku.Výsledky této operace nelze zaručit být přesné.Chcete-li tento problém vyřešit, přetypujte parametr menší, dokud nebude stejné velikosti jako parametr větší.
Pro operátory posunutí tím více bitů, než kolik jich pro typ šablony vyvolá výjimku ASSERT.V režimu vydání to nebude mít žádný vliv.Míchání dva typy parametrů SafeInt je možné pro operátory posunutí, protože návratový typ je shodný s původním typem.Číslo na pravé straně operátoru pouze označuje počet bitů posunutí.
Při provádění logických porovnání s objektem SafeInt 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ý příkaz výchozí porovnávací operátor porovná 0xFFFFFFFF až 0xFFFFFFFF a je rovna považuje za.Pro operátor porovnání SafeInt třídy si uvědomuje, že druhý parametr je negativní, že první parametr je bez znaménka.Proto, i když bitová reprezentace stejná, SafeInt logický operátor si uvědomuje, že je celé číslo bez znaménka větší než -1.
Buďte opatrní při použití SafeInt společně s třídou ?: Ternární operátor.Zvažte následující řádek kódu.
Int x = flag ? SafeInt<unsigned int>(y) : -1;
Kompilátor převádí je toto:
Int x = flag ? SafeInt<unsigned int>(y) : SafeInt<unsigned int>(-1);
Pokud flag je false, kompilátor generuje výjimku namísto přiřazení hodnotu -1 x.Chcete-li se vyhnout tomuto chování, chcete-li použít správný kód tedy následující řádek.
Int x = flag ? (int) SafeInt<unsigned int>(y) : -1;
Ta U může být přiřazen typ Boolean, znak nebo typ integer.A jakékoli velikosti 8 bitů 64 bitů typům podepsané a nepodepsané celé číslo.
[!POZNÁMKA]
I když SafeInt třída přijímá libovolný typ integer, provádí efektivněji s nepodepsané typy.
EChyba zpracování mechanismus, SafeInt používá.Knihovna SafeInt jsou zahrnuty dva mechanismy zpracování chyb.Výchozí zásady jsou SafeIntErrorPolicy_SafeIntException, které vyvolá SafeIntException – třída výjimka při výskytu chyby.Druhá zásada je SafeIntErrorPolicy_InvalidParameter, který ukončuje program v případě, že dojde k chybě.
Chyba zásadu upravit dvěma způsoby.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 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í chyba zpracování zásad pro všechny instance SafeInt třídy v kódu.
[!POZNÁMKA]
Vlastní třídy, která zpracovává chyby z Knihovna SafeInt neměla vrátit ovládací prvek kód, který se nazývá obslužná rutina chyb.Poté, co se nazývá obslužná rutina chyb, výsledek SafeInt operace nelze důvěřovat.
Požadavky
Záhlaví: safeint.h
Obor názvů: msl::utilities