SafeInt-Klasse
Erweitert die ganzzahligen Primitive, um zu verhindern, dass Ganzzahlüberlauf und ermöglicht Ihnen verschiedene Typen von ganzen Zahlen vergleichen.
template<typename T, typename E = _SAFEINT_DEFAULT_ERROR_POLICY>
class SafeInt;
Parameter
Vorlage |
Beschreibung |
|---|---|
T |
Der Typ der ganze Zahl oder eines booleschen Parameters, den SafeInt ersetzt. |
E |
Ein aufgelisteter Datentyp, der die Richtlinie zur Fehlerbehandlung definiert. |
U |
Der Typ der ganze Zahl oder eines booleschen Parameters für den sekundären Operanden. |
Parameter |
Beschreibung |
|---|---|
[in] rechte Seite |
Ein Eingabeparameter, der den Wert rechts vom Operator in einigen eigenständigen Funktionen darstellt. |
[in] i |
Ein Eingabeparameter, der den Wert rechts vom Operator in einigen eigenständigen Funktionen darstellt. |
[in] Bits |
Ein Eingabeparameter, der den Wert rechts vom Operator in einigen eigenständigen Funktionen darstellt. |
Mitglieder
.gif "Dd570021.collapse_all(de-de,VS.110).gif")
Öffentliche Konstruktoren
Name |
Beschreibung |
|---|---|
Standardkonstruktor. |
Zuweisungsoperatoren
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() |
Umwandlungs-Operatoren
Name |
Syntax |
|---|---|
bool |
operator bool() throw() |
char |
operator char() const |
char mit Vorzeichen |
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 |
Vergleichsoperatoren
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() |
Arithmetische Operatoren
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) |
Logische Operatoren
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() |
Hinweise
Die SafeInt-Klasse schützt vor Ganzzahlüberlauf in mathematischen Operationen.Beispielsweise sollten Sie zwei 8-Bit-Ganzzahlen hinzuzufügen: Ein verfügt über einen Wert von 200, und das zweite Element verfügt über einen Wert von 100.Der richtige mathematische Operation würde 200 + 100 = 300 sein.Aufgrund der 8-Bit-Ganzzahl-Grenze, ist das oberste Bit verloren, und der Compiler gibt 44 zurück (300 bis 28) als Ergebnis.Jeder Vorgang, der von dieser mathematischen Formel abhängig ist, generiert ein unerwartetes Verhalten.
Die SafeInt-Klasse wird überprüft, ob ein arithmetischer Überlauf auftritt, oder ob der Code versucht, durch null zu teilen.In beiden Fällen ruft die Klasse den Fehlerhandler auf, um das Programm des potenziellen Problem zu warnen.
Diese Klasse ermöglicht Ihnen außerdem zwei unterschiedliche Typen von ganzen Zahlen vergleichen, solange sie SafeInt-Objekte sind.Normalerweise wenn Sie einen Vergleich durchführen, müssen Sie zuerst die Zahlen konvertiert, um vom selben Typ sein.Die Umwandlung aus einer Zahl in einen anderen Typ erfordert häufig Überprüfungen sichergestellt, dass kein Datenverlust vorhanden ist.
Die Tabelle Operator in diesem Thema wird das mathematische und Vergleichsoperatoren unterstützt über die SafeInt-Klasse auf.Die meisten mathematischen Operatoren geben ein SafeInt-Objekt vom Typ T zurück.
Vergleichsvorgänge zwischen SafeInt und einen ganzzahligen Typ können in jeder Richtung ausgeführt werden.Beispielsweise sind SafeInt<int>(x) < y und y > SafeInt<int>(x) gültig und werden so lange dasselbe Ergebnis zurückgeben.
Viele binären Operatoren unterstützen keine mit zwei verschiedenen SafeInt-Typen.Ein Beispiel hierfür ist der &-Operator.SafeInt<T, E> & int wird unterstützt, SafeInt<T, E> & SafeInt<U, E> jedoch nicht.Im letzten Beispiel weiß der Compiler nicht, welcher Typ des Parameters, das zurückgegeben werden soll.Eine Lösung für dieses Problem besteht darin, den zweiten Parameter an den Basistyp umgewandelt werden.Mit den gleichen Parameter verwendet, kann dies mit SafeInt<T, E> & (U)SafeInt<U, E> erfolgen.
.gif "Hinweis") Hinweis |
|---|
Für alle bitweisen Operationen sollten die zwei verschiedenen Parametern dieselbe Größe haben.Wenn die Größe unterscheiden, löst der Compiler eine ASSERT (MFC) Ausnahme aus.Die Ergebnisse dieses Vorgangs kann nicht garantiert werden, um genau zu sein.Um dieses Problem zu beheben, kleinerer Parameter der Umwandlung je, bis sie dieselbe Größe als desto größer Parameter ist. |
Für die Schiebeoperatoren mehr Bits, als Verschieben der vorhandenen Sie für den Vorlagentyp aus einer ASSERTIONS ausnahme.Dies wirkt sich nicht im Releasemodus.Zwei Typen SafeInt-Parameter zu kombinieren, ist für die Schiebeoperatoren möglich, da der Rückgabetyp der gleiche wie der ursprüngliche Typ ist.Die Zahl rechts vom Operator gibt nur die Anzahl der Bits, um sich selbst zu verschieben.
Wenn Sie einen logischen Vergleich mit einem SafeInt-Objekt ausführen, ist der Vergleich ausgenommen arithmetisch.Betrachten Sie z. B. die folgenden Ausdrücke:
SafeInt<uint>((uint)~0) > -1
((uint)~0) > -1
Die erste Anweisung wird in true auf, aber die zweite Anweisung wird in false auf.Die bitweise Negation von 0 ist 0xFFFFFFFF.In der zweiten Anweisung vergleicht der standardmäßigen Vergleichsoperator 0xFFFFFFFF zu 0xFFFFFFFF und sie als gleich betrachtet werden.Der Vergleichsoperator für die SafeInt-Klasse realisiert, dass der zweite Parameter negativ ist, während der erste Parameter ohne Vorzeichen ist.Daher Bit obwohl die Darstellung der realisiert identisch ist SafeInt logische Operator, dass die ganze Zahl ohne Vorzeichen größer als -1 ist.
Seien Sie vorsichtig, wenn Sie die SafeInt-Klasse zusammen mit dem Operator ternären ?: verwenden.Betrachten Sie die folgende Codezeile.
Int x = flag ? SafeInt<unsigned int>(y) : -1;
Der Compiler konvertiert sie in diesem:
Int x = flag ? SafeInt<unsigned int>(y) : SafeInt<unsigned int>(-1);
Wenn flagfalse ist, löst der Compiler eine Ausnahme aus, anstatt den Wert -1 x zuzuweisen.Daher um dieses Verhalten zu vermeiden, ist der richtige Code zu verwenden, um die nächste Zeile.
Int x = flag ? (int) SafeInt<unsigned int>(y) : -1;
T und U können einen booleschen Typ, einen Zeichentyp oder ganzzahligen Typ zugewiesen werden.Die ganzzahligen Typen können mit oder ohne Vorzeichen und eine Größe von 8 Bits auf 64 Bits sein.
| Hinweis |
|---|
Obwohl die SafeInt-Klasse eine beliebige Art von integer zulässt, führt sie effizienter mit Typen ohne Vorzeichen aus. |
E ist der Mechanismus zur Fehlerbehandlung von SafeInt verwendet.Es werden zwei Mechanismen zur Fehlerbehandlung mit der SafeInt-Bibliothek bereitgestellt.Die Standardrichtlinie SafeIntErrorPolicy_SafeIntException, die eine SafeIntException-Klasse Ausnahme ausgelöst werden soll, wenn ein Fehler auftritt.Die andere Richtlinie ist SafeIntErrorPolicy_InvalidParameter, die das Programm beendet, wenn ein Fehler auftritt.
Es gibt zwei Möglichkeiten, die Fehler der Richtlinien anzupassen.Die erste Möglichkeit besteht darin, den Parameter E festzulegen, wenn Sie SafeInt erstellen.Verwenden Sie diese Option, wenn Sie die Richtlinie zur Fehlerbehandlung für nur ein SafeInt ändern möchten.Die andere Möglichkeit besteht darin, _SAFEINT_DEFAULT_ERROR_POLICY zu definieren, um die benutzerdefinierte Fehlerbehandlung Klasse sein, bevor Sie die SafeInt Bibliothek einschließen.Verwenden Sie diese Option, wenn Sie die Richtlinie zur Fehlerbehandlung für alle Instanzen der SafeInt-Klasse im Code ändern möchten.
| Hinweis |
|---|
Eine benutzerdefinierte Klasse, die von der SafeInt-Bibliothek behandelt, sollte Steuerelement nicht an den Code zurückgegeben, der den Fehlerhandler aufgerufen hat.Nachdem der Fehlerhandler aufgerufen wurde, kann das Ergebnis des Vorgangs SafeInt nicht vertrauenswürdig sein. |
Anforderungen
Header: safeint.h
Namespace: msl::utilities