SafeInt, classe

Étend les primitifs entiers afin d’éviter les débordements d’entiers et permet de comparer les différents types d’entiers.

Syntaxe

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

Paramètres

T
Le type d’entier ou de paramètre booléen remplacé par SafeInt.

E
Un type de données énumérées qui définit la stratégie de gestion des erreurs.

U
Le type d’entier ou de paramètre booléen pour l’opérande secondaire.

rhs
[in] Un paramètre d’entrée qui représente la valeur à droite de l’opérateur dans plusieurs fonctions autonomes.

i
[in] Un paramètre d’entrée qui représente la valeur à droite de l’opérateur dans plusieurs fonctions autonomes.

bits
[in] Un paramètre d’entrée qui représente la valeur à droite de l’opérateur dans plusieurs fonctions autonomes.

Membres

Constructeurs publics

Opérateurs d’assignation

Opérateurs de casting

Opérateurs de comparaison

Opérateurs arithmétiques

Opérateurs logiques

Notes

La classe SafeInt protège contre les dépassements sur les entiers dans les opérations mathématiques. Par exemple, vous pouvez ajouter deux entiers 8 bits, l’un avec une valeur de 200 et l’autre avec une valeur de 100. L’opération mathématique correcte serait 100 + 200 = 300. Toutefois, en raison de la limitation de l’entier 8 bits, le bit supérieur sera perdu et le compilateur retournera 44 (300 - 2⁸) comme résultat. Toute opération dépendant de cette équation mathématique générera un comportement inattendu.

La classe SafeInt vérifie si un débordement arithmétique se produit ou si le code tente de diviser par zéro. Dans les deux cas, la classe appelle le gestionnaire d’erreurs pour avertir le programme de ce problème potentiel.

Cette classe vous permet également de comparer deux différents types d’entiers, dès lors qu’il s’agit d’objets SafeInt. En règle générale, lorsque vous effectuez une comparaison, vous devez d’abord convertir les nombres en le même type. La conversion d’un nombre à un autre type requiert généralement des vérifications pour s’assurer qu’aucune perte de données ne s’est produite.

La table des opérateurs dans cette rubrique répertorie les opérateurs mathématiques et de comparaison pris en charge par la classe SafeInt. La plupart des opérateurs mathématiques retournent un objet SafeInt de type T.

Des opérations de comparaison entre un SafeInt et un type intégral peuvent être réalisées dans les deux sens. 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 SafeInt . L’opérateur & en est un exemple. SafeInt<T, E> & int est pris en charge, mais SafeInt<T, E> & SafeInt<U, E> ce n’est pas le cas. Dans ce dernier exemple, le compilateur ne sait pas quel type de paramètre retourner. L’une des solutions à ce problème consiste à effectuer un cast en retour du deuxième paramètre vers le type de base. En utilisant les mêmes paramètres, cela peut être effectué avec SafeInt<T, E> & (U)SafeInt<U, E>.

Pour les opérateurs de décalage, le décalage d’un plus grand nombre de bits qu’il en existe pour le type de modèle lève une exception ASSERT. Cela n’aura aucun effet en mode Release. Les opérateurs de décalage peuvent mélanger deux types de paramètres SafeInt, car le type de retour est identique au type d’origine. Le nombre situé à droite de l’opérateur indique uniquement le nombre de bits à décaler.

Lorsque vous effectuez une comparaison logique avec un objet SafeInt, la comparaison est strictement arithmétique. Prenons par exemple ces expressions :

• SafeInt<uint>((uint)~0) > -1

• ((uint)~0) > -1

La première instruction est truerésolue en , mais la deuxième instruction est résolue en false. La négation d’opération de bits de 0 est 0xFFFFFFFF. Dans la deuxième instruction, l’opérateur de comparaison par défaut compare 0xFFFFFFFF à 0xFFFFFFFF et les considère comme égaux. L’opérateur de comparaison de la classe SafeInt se rend compte que le deuxième paramètre est négatif, tandis que le premier paramètre n’est pas signé. Par conséquent, bien que la représentation binaire soit identique, l’opérateur logique SafeInt se rend compte que l’entier non signé est supérieur à -1.

Soyez prudent lorsque vous utilisez la classe SafeInt avec l’opérateur ternaire ?:. Examinez la ligne de code suivante.

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

Le compilateur la convertit ainsi :

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

Si flag est false, le compilateur lève une exception au lieu d’affecter la valeur -1 à x. Par conséquent, pour éviter ce comportement, le code approprié à utiliser est la ligne suivante.

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

T et U peuvent avoir un type booléen, un type de caractère ou un type entier. Les types d’entier peuvent être signés ou non signés et de toutes tailles, comprises entre 8 bits et 64 bits.

E est le mécanisme de gestion des erreurs utilisé par SafeInt. Deux mécanismes de gestion des erreurs sont fournis avec la bibliothèque SafeInt. La stratégie par défaut est SafeIntErrorPolicy_SafeIntException, qui lève une exception SafeIntException Class lorsqu’une erreur se produit. L’autre stratégie est SafeIntErrorPolicy_InvalidParameter, qui arrête le programme si une erreur se produit.

Deux options sont disponibles pour personnaliser la stratégie d’erreur. La première option consiste à définir le paramètre E lorsque vous créez un 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 comme votre classe de gestion des erreurs personnalisée avant d’inclure la bibliothèque SafeInt. Utilisez cette option pour modifier la stratégie par défaut de gestion des erreurs pour toutes les instances de la classe SafeInt de votre code.

Hiérarchie d'héritage

SafeInt

Spécifications

En-tête : SafeInt.hpp

Exemple

#include "SafeInt.hpp" // set path to your clone of the SafeInt GitHub repo (https://github.com/dcleblanc/SafeInt)

int main()
{
    int divisor = 3;
    int dividend = 6;
    int result;

    bool success = SafeDivide(dividend, divisor, result); // result = 2
    success = SafeDivide(dividend, 0, result); // expect fail. result isn't modified.
}

Namespace : aucun

SafeInt::SafeInt

Construit un objet SafeInt.

SafeInt() throw

SafeInt (const T& i) throw ()

SafeInt (bool b) throw ()

template <typename U>
SafeInt (const SafeInt <U, E>& u)

I template <typename U>
SafeInt (const U& i)

Paramètres

i
[in] La valeur du nouvel objet SafeInt. Il doit s’agir d’un paramètre de type T ou U, en fonction du constructeur.

b
[in] La valeur booléenne du nouvel objet SafeInt.

u
[in] Un SafeInt de type U. Le nouvel objet SafeInt aura la même valeur que le type U, mais sera de type T.

U Type de données stockées dans le SafeInt. Il peut s’agit d’un type booléen, d’un type de caractère ou d’un type entier. S’il s’agit d’un type entier, il peut être signé ou non signé et être compris entre 8 et 64 bits.

Notes

Le paramètre d’entrée pour le constructeur, i ou u, doit être un type booléen, de caractère ou entier. S’il s’agit d’un autre type de paramètre, la SafeInt classe appelle static_assert pour indiquer un paramètre d’entrée non valide.

Les constructeurs qui utilisent le type de modèle U convertissent automatiquement le paramètre d’entrée du type spécifié par T. La classe SafeInt convertit les données sans aucune perte de données. Il signale au gestionnaire E d’erreurs s’il ne peut pas convertir les données en type T sans perte de données.

Si vous créez un SafeInt à partir d’un paramètre booléen, vous devez initialiser la valeur immédiatement. Vous ne pouvez pas construire d’utilisation SafeInt du code SafeInt<bool> sb;. Cela générera une erreur de compilation.