SafeInt, classe
Étend les primitives entiers pour empêcher le dépassement sur les entiers et vous permet de comparer différents types d'entiers.
template<typename T, typename E = _SAFEINT_DEFAULT_ERROR_POLICY>
class SafeInt;
Paramètres
Modèle |
Description |
|---|---|
T |
Le type de paramètre entier ou booléen qu' SafeInt remplace. |
E |
Un type de données énuméré qui définit la stratégie de gestion des erreurs. |
U |
Le type de paramètre entier ou booléen pour l'opérande secondaire. |
Paramètre |
Description |
|---|---|
[in] rhs |
Un paramètre d'entrée qui représente la valeur située à droite de l'opérateur dans plusieurs fonctions autonomes. |
[in] i |
Un paramètre d'entrée qui représente la valeur située à droite de l'opérateur dans plusieurs fonctions autonomes. |
[in] bits |
Un paramètre d'entrée qui représente la valeur située à droite de l'opérateur dans plusieurs fonctions autonomes. |
Membres
.gif "Dd570021.collapse_all(fr-fr,VS.110).gif")
Constructeurs publics
Nom |
Description |
|---|---|
Constructeur par défaut. |
Opérateurs d'assignation
Nom |
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() |
Opérateurs de cast
Nom |
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 |
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 |
Opérateurs de comparaison
Nom |
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() |
Opérateurs arithmétiques
Nom |
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) |
Opérateurs logiques
Nom |
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() |
Notes
La classe d' SafeInt protège contre le dépassement sur les entiers dans des opérations mathématiques.Par exemple, envisagez d'ajouter deux entiers de 8 bits : il a une valeur de 200 et le deuxième a la valeur 100.L'opération mathématique correcte est 200 + 100 = 300.Toutefois, en raison de la limite entière à 8 bits, le bit supérieur sera perdu et le compilateur retourne 44 (300 - 28) comme résultat.Toute opération qui dépend de cette équation mathématique génère un comportement inattendu.
La classe d' SafeInt vérifie si un dépassement de capacité arithmétiques se produit ou si les tests de code division par zéro.Dans les deux cas, la classe appelle le gestionnaire d'erreurs pour informer le programme du problème potentiel.
Cette classe vous permet également de comparer deux types d'entiers à condition que ils sont des objets d' SafeInt .En général, lorsque vous exécutez une comparaison, vous devez d'abord convertir les nombres pour être du même type.Cast d'un nombre à un autre type requiert souvent des contrôles pour vous assurer qu'il n'y a aucune perte de données.
La table d'opérateurs dans cette rubrique présente le mathématiques et les opérateurs de comparaison pris en charge par la classe d' SafeInt .La plupart des opérateurs mathématiques retournent un objet d' SafeInt de type T.
Les opérations de comparaison entre SafeInt et un type intégral peuvent être exécutées dans l'un ou l'autre direction.Par exemple, SafeInt<int>(x) < y et y > SafeInt<int>(x) sont valides et retournent le même résultat.
De nombreux opérateurs binaires ne prennent pas en charge l'utilisation de deux types différents d' SafeInt .Un exemple de ce est l'opérateur d' & .SafeInt<T, E> & int est pris en charge, mais SafeInt<T, E> & SafeInt<U, E> n'est pas.Dans le dernier exemple, le compilateur ne connaît pas quel type de paramètre à retourner.Une solution à ce problème consiste à effectuer un cast du deuxième paramètre vers le type de base.À l'aide de les mêmes paramètres, cette opération peut être effectuée à SafeInt<T, E> & (U)SafeInt<U, E>.
[!REMARQUE]
Pour toutes les opérations de bits, les deux paramètres différents doivent être de la même taille.Si les tailles différentes, le compilateur lève une exception d' ASSERT (MFC) .Les résultats de cette opération ne peuvent pas être garantie précis.Pour résoudre ce problème, effectuez un cast du paramètre plus petit jusqu'à ce qu'il soit la même taille qu'un paramètre plus grand.
Pour les opérateurs de décalage, le déplacement plus de bits qui existent pour le type de modèle lèveront une exception ASSERT.Cela n'aura aucun effet en mode release.Combiner deux types de paramètres SafeInt est possible que les opérateurs de décalage car le type de retour est identique au type d'origine.Le nombre à droite de l'opérateur indique que le nombre de bits pour déplacer.
Lorsque vous exécutez une comparaison logique à un objet SafeInt, la comparaison est strictement arithmétique.Par exemple, considérez ces expressions :
SafeInt<uint>((uint)~0) > -1
((uint)~0) > -1
La première instruction se résout à true, avec deuxième résolutions d'instruction à false.La négation de bits 0 est 0xFFFFFFFF.Dans la deuxième instruction, l'opérateur de comparaison par défaut compare 0xFFFFFFFF à 0xFFFFFFFF et les considère comme étant égal.L'opérateur de comparaison pour la classe d' SafeInt s'aperçoit que le deuxième paramètre est négatif alors que le premier paramètre est non signé.Par conséquent, bien que la représentation binaire est identique, l'opérateur logique d' SafeInt s'aperçoit que l'entier non signé est supérieur à -1.
Soyez prudent lorsque vous utilisez la classe d' SafeInt avec l'opérateur conditionnel ternaire d' ?: .Considérez la ligne de code suivante.
Int x = flag ? SafeInt<unsigned int>(y) : -1;
Le compilateur convertit la manière suivante :
Int x = flag ? SafeInt<unsigned int>(y) : SafeInt<unsigned int>(-1);
Si flag est false, le compilateur lève une exception au lieu d'assigner la valeur -1 à x.Par conséquent, pour éviter ce comportement, le code correct à utiliser est la ligne suivante.
Int x = flag ? (int) SafeInt<unsigned int>(y) : -1;
T et U peuvent être assignés un type boolean, un type de caractère, ou le type entier.Les types entiers peuvent être signés ou non signés et toute taille de 8 bits et 64 bits.
[!REMARQUE]
Bien que la classe d' SafeInt accepte tout type d'entier, elle exécute plus efficacement avec les types non signés.
E est le mécanisme de gestion des erreurs qu' SafeInt utilise.Deux mécanismes de gestion des erreurs disposent de bibliothèque SafeInt.La stratégie par défaut est SafeIntErrorPolicy_SafeIntException, qui lève une exception de SafeIntException, classe lorsqu'une erreur se produit.L'autre stratégie est SafeIntErrorPolicy_InvalidParameter, qui arrête le programme si une erreur se produit.
Il existe deux options de personnaliser la stratégie d'erreur.La première option est de définir le paramètre E lorsque vous créez SafeInt.Utilisez cette option lorsque vous souhaitez modifier la stratégie de gestion des erreurs pour un seul SafeInt.L'autre option consiste à définir _SAFEINT_DEFAULT_ERROR_POLICY pour être votre cours personnalisé de gestion des erreurs avant que nous vous conseillons d'inclure la bibliothèque d' SafeInt .Utilisez cette option lorsque vous souhaitez modifier la stratégie par défaut de gestion des erreurs pour toutes les instances de la classe d' SafeInt dans votre code.
[!REMARQUE]
Une classe personnalisée qui gère les erreurs de la bibliothèque SafeInt ne doit pas retourner le contrôle au code qui a appelé le gestionnaire d'erreur.Une fois le gestionnaire d'erreurs est appelé, le résultat de l'opération d' SafeInt ne peut pas être approuvé.
Configuration requise
en-tête : safeint.h
Msl::utilities del'espace de noms :