Classe SafeInt

Estende le primitive Integer per impedire l'overflow di Integer e consente di confrontare tipi Integer diversi.

Sintassi

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

Parametri

T
Tipo Integer o parametro booleano sostituito da SafeInt.

E
Tipo di dati enumerato che definisce i criteri di gestione degli errori.

U
Tipo Integer o parametro booleano per il secondo operando.

rhs
[in] Parametro di input che rappresenta il valore sul lato destro dell'operatore in numerose funzioni autonome.

i
[in] Parametro di input che rappresenta il valore sul lato destro dell'operatore in numerose funzioni autonome.

bits
[in] Parametro di input che rappresenta il valore sul lato destro dell'operatore in numerose funzioni autonome.

Membri

Costruttori pubblici

Operatori di assegnazione

Operatori di cast

Operatori di confronto

Operatori aritmetici

Operatori logici

Osservazioni:

La classe SafeInt protegge dall'overflow di Integer nelle operazioni matematiche. Si consideri, ad esempio, la somma di due Integer a 8 bit: uno ha un valore pari a 200 e il secondo un valore pari a 100. L'operazione matematica corretta sarebbe 200 + 100 = 300. Tuttavia, a causa del limite di 8 bit per gli Integer, il bit superiore andrà perso e il compilatore restituirà 44 (300 - 2⁸) come risultato. Qualsiasi operazione che dipende da questa equazione matematica genererà un comportamento imprevisto.

La classe SafeInt controlla se si verifica un overflow aritmetico o se il codice prova a eseguire una divisione per zero. In entrambi i casi la classe chiama il gestore degli errori per informare il programma del potenziale problema.

Questa classe consente anche di confrontare due tipi Integer diversi, a condizione che siano oggetti SafeInt. In genere, quando si esegue un confronto, è necessario prima convertire i numeri in modo che siano dello stesso tipo. Il cast di un numero in un altro tipo spesso richiede controlli per assicurarsi che non vi sia alcuna perdita di dati.

La tabella relativa agli operatori in questo argomento elenca gli operatori matematici e di confronto supportati dalla classe SafeInt. La maggior parte degli operatori matematici restituisce un oggetto SafeInt di tipo T.

Le operazioni di confronto tra un oggetto SafeInt e un tipo di dati integrale possono essere eseguite in entrambe le direzioni. Ad esempio, entrambe le operazioni SafeInt<int>(x) < y e y> SafeInt<int>(x) sono valide e restituiscono lo stesso risultato.

Molti operatori binari non supportano l'uso di due tipi diversi SafeInt . Un esempio è costituito dall'operatore &. SafeInt<T, E> & int è supportato, ma SafeInt<T, E> & SafeInt<U, E> non lo è. Nell'ultimo esempio, il compilatore non sa quale tipo di parametro restituire. Per risolvere questo problema è possibile eseguire il cast del secondo parametro nel tipo di base. Usando gli stessi parametri, questa operazione può essere eseguita con SafeInt<T, E> & (U)SafeInt<U, E>.

Per gli operatori shift, lo spostamento di un numero di bit maggiore di quelli esistenti per il tipo di modello genera un'eccezione ASSERT. Ciò non ha alcun effetto nella modalità di rilascio. La combinazione di due tipi di parametri SafeInt è possibile per gli operatori shift perché il tipo restituito è identico al tipo originale. Il numero a destra dell'operatore indica solo il numero di bit da spostare.

Quando si esegue un confronto logico con un oggetto SafeInt, il confronto è strettamente aritmetico. Prendere ad esempio in considerazione queste espressioni:

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

• ((uint)~0) > -1

La prima istruzione viene risolta in true, ma la seconda istruzione viene risolta in false. La negazione bit per bit di 0 è 0xFFFFFFFF. Nella seconda istruzione l'operatore di confronto predefinito confronta 0xFFFFFFFF e 0xFFFFFFFF e li considera uguali. L'operatore di confronto per la classe SafeInt rileva che il secondo parametro è negativo, mentre il primo parametro è senza segno. Di conseguenza, anche se la rappresentazione in bit è identica, l'operatore logico SafeInt determina che il valore intero senza segno è maggiore di -1.

Fare attenzione quando si usa la classe SafeInt insieme all'operatore ternario ?:. Considerare la riga di codice seguente.

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

Il compilatore la converte in quanto segue:

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

Se flag è false, il compilatore genera un'eccezione invece di assegnare il valore -1 a x. Pertanto, per evitare questo comportamento, il codice corretto da usare è la riga seguente.

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

È possibile assegnare a T e U un tipo booleano, un tipo di carattere o un tipo Integer. I tipi Integer possono essere con o senza segno e avere qualsiasi dimensione tra 8 bit e 64 bit.

E è il meccanismo di gestione degli errori usato da SafeInt. Con la libreria SafeInt vengono forniti due meccanismi di gestione degli errori. Il criterio predefinito è SafeIntErrorPolicy_SafeIntException, che genera un'eccezione della classe SafeIntException quando si verifica un errore. L'altro criterio è SafeIntErrorPolicy_InvalidParameter, che arresta il programma se si verifica un errore.

Ci sono due opzioni per personalizzare i criteri di gestione degli errori. La prima opzione consiste nell'impostare il parametro E quando si crea un oggetto SafeInt. Usare questa opzione quando si vuole modificare il criterio di gestione degli errori per un solo oggetto SafeInt. L'altra opzione consiste nel definire _SAFEINT_DEFAULT_ERROR_POLICY come classe personalizzata di gestione degli errori prima di includere la libreria SafeInt. Usare questa opzione quando si vuole modificare il criterio predefinito di gestione degli errori per tutte le istanze della classe SafeInt nel codice.

Gerarchia di ereditarietà

SafeInt

Requisiti

Intestazione: SafeInt.hpp

Esempio

#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.
}

Spazio dei nomi: nessuno

SafeInt::SafeInt

Costruisce un oggetto 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)

Parametri

i
[in] Valore per il nuovo oggetto SafeInt. Deve trattarsi di un parametro di tipo T o U, a seconda del costruttore.

b
[in] Valore booleano per il nuovo oggetto SafeInt.

u
[in] Oggetto SafeInt di tipo U. Il nuovo oggetto SafeInt avrà lo stesso valore di u, ma sarà di tipo T.

U Tipo di dati archiviati in SafeInt. Può trattarsi di un tipo booleano, carattere o Integer. Se si tratta di un tipo integer, può essere firmato o senza segno e può essere compreso tra 8 e 64 bit.

Osservazioni:

Il parametro di input per il costruttore, i o u, deve essere un tipo booleano, carattere o Integer. Se si tratta di un altro tipo di parametro, la SafeInt classe chiama static_assert per indicare un parametro di input non valido.

I costruttori che usano il tipo di modello U convertono automaticamente il parametro di input nel tipo specificato da T. La classe SafeInt converte i dati senza alcuna perdita di dati. Segnala al gestore E errori se non riesce a convertire i dati in un tipo T senza perdita di dati.

Se si crea un oggetto SafeInt da un parametro booleano, è necessario inizializzare il valore immediatamente. Non è possibile costruire un SafeInt oggetto usando il codice SafeInt<bool> sb;. In questo caso, verrà generato un errore di compilazione.