Operatori logici e bit per bit in Visual Basic

Articolo
08/11/2011

Gli operatori logici confrontano le espressioni Boolean e restituiscono il risultato Boolean. Gli operatori And, Or, AndAlso, OrElse e Xor sono binari in quanto prendono due operandi, mentre l'operatore Not è unario in quanto prende un unico operando. Alcuni di questi operatori possono inoltre eseguire operazioni logiche bit per bit sui valori integrali.

Operatore logico unario

L'Operatore Not (Visual Basic) esegue una negazione logica su un'espressione Boolean. Viene generato il risultato contrario logico del suo operando. Se l'espressione restituisce True, Not restituirà False; se l'espressione restituisce False, Not restituirà True. Questa condizione è illustrata nell'esempio che segue.

Dim x, y As Boolean
x = Not 23 > 14
y = Not 23 > 67
' The preceding statements set x to False and y to True.

Operatori logici binari

L'Operatore And (Visual Basic) esegue una congiunzione logica su due espressioni Boolean. Se entrambe le espressioni restituiscono True, And restituirà True. Se almeno una delle espressioni restituisce False, And restituirà False.

L'Operatore Or (Visual Basic) esegue una disgiunzione logica o un'inclusione su due espressioni Boolean. Se una delle espressioni restituisce True o se entrambe restituiscono True, Or restituirà True. Se una delle espressioni restituisce True, Or restituisce False.

L'Operatore Xor (Visual Basic) esegue un' esclusione logica su due espressioni Boolean. Se esattamente un'espressione restituisce True, ma non entrambe, Xor restituirà True. Se entrambe le espressioni restituiscono True o entrambe restituiscono False, Xor restituirà False.

Nell'esempio illustrato vengono illustrati gli operatori And, Or e Xor.

Dim a, b, c, d, e, f, g As Boolean

a = 23 > 14 And 11 > 8
b = 14 > 23 And 11 > 8
' The preceding statements set a to True and b to False.

c = 23 > 14 Or 8 > 11
d = 23 > 67 Or 8 > 11
' The preceding statements set c to True and d to False.

e = 23 > 67 Xor 11 > 8
f = 23 > 14 Xor 11 > 8
g = 14 > 23 Xor 8 > 11
' The preceding statements set e to True, f to False, and g to False.

Operatori logici di corto circuito

L'Operatore AndAlso (Visual Basic) è molto simile all'operatore And, in quanto anch'esso esegue una congiunzione logica tra due espressioni Boolean. La differenza fondamentale tra le due consiste nel fatto che AndAlso mostra un comportamento di tipo short circuit. Se la prima espressione in un'espressione AndAlso restituisce False, la seconda espressione non verrà valutata in quanto non può alterare il risultato finale e AndAlso restituisce False.

Analogamente, l'Operatore OrElse (Visual Basic) esegue una disgiunzione logica short circuit tra due espressioni Boolean. Se la prima espressione in un'espressione OrElse restituisce True, la seconda espressione non verrà valutata in quanto non può alterare il risultato finale e OrElse restituisce True.

Vantaggi e svantaggi dello short-circuit

Lo short-circuit può migliorare le prestazioni non valutando un'espressione che non può alterare il risultato dell'operazione logica. Tuttavia se tale espressione esegue operazioni aggiuntive, lo short-circuit ignorerà quelle azioni. Se l'espressione include una chiamata a una procedura Function ad esempio, quella procedura non verrà chiamata se si esegue un corto circuito dell'espressione e se qualsiasi codice aggiuntivo contenuto nella Function non viene eseguito. Pertanto, la funzione potrebbe venire eseguita solo occasionalmente e potrebbe non venire testata correttamente. In alternativa la logica di programma potrebbe dipendere dal codice nella Function.

Nell'esempio seguente viene illustrata la differenza tra And, Or e le loro controparti di corto circuito.

Dim amount As Integer = 12
Dim highestAllowed As Integer = 45
Dim grandTotal As Integer

If amount > highestAllowed And checkIfValid(amount) Then
    ' The preceding statement calls checkIfValid().
End If
If amount > highestAllowed AndAlso checkIfValid(amount) Then
    ' The preceding statement does not call checkIfValid().
End If
If amount < highestAllowed Or checkIfValid(amount) Then
    ' The preceding statement calls checkIfValid().
End If
If amount < highestAllowed OrElse checkIfValid(amount) Then
    ' The preceding statement does not call checkIfValid().
End If

Function checkIfValid(ByVal checkValue As Integer) As Boolean
    If checkValue > 15 Then
        MsgBox(CStr(checkValue) & " is not a valid value.")
        ' The MsgBox warning is not displayed if the call to
        ' checkIfValid() is part of a short-circuited expression.
        Return False
    Else
        grandTotal += checkValue
        ' The grandTotal value is not updated if the call to
        ' checkIfValid() is part of a short-circuited expression.
        Return True
    End If
End Function

Nell'esempio illustrato in precedenza, si noti che una parte del codice importante in checkIfValid() non viene eseguita quando viene eseguito un "corto circuito" della chiamata. La prima istruzione If chiama checkIfValid() anche se 12 > 45 restituisce False, in quanto non viene eseguito il corto circuito di And. La seconda istruzione If non chiama checkIfValid(), in quanto quando 12 > 45 restituisce False, AndAlso provoca un corto circuito della seconda espressione. La terza istruzione If chiama checkIfValid() anche se 12 < 45 restituisce True, in quando non viene eseguito il corto circuito di Or. La quarta istruzione If non chiama checkIfValid(), in quanto quando 12 < 45 restituisce True, OrElse provoca un corto circuito della seconda espressione.

Operazioni bit per bit

Le operazioni bit per bit valutano due valori integrali nella forma binaria (base 2). Esse confrontano i bit in posizioni corrispondenti quindi assegnare i valori in base al confronto. Nell'esempio riportato di seguito viene illustrato l'operatore And.

Dim x As Integer
x = 3 And 5

Nell'esempio precedente il valore x viene impostato su 1. Questa situazione si verifica per i seguenti motivi:

I valori vengono considerati come binari:

3 in forma binaria = 011

5 in forma binaria = 101
L'operatore And confronta le rappresentazioni binarie, una posizione binaria (bit) alla volta. Se entrambi i bit in una determinata posizione sono 1, nel risultato viene inserito 1 in quella posizione. Se uno dei bit è 0, nel risultato viene inserito 0 in quella posizione. Nell'esempio illustrato in precedenza si ottiene il seguente risultato:

011 (3 in forma binaria)

101 (5 in forma binaria)

001 (il risultato, in forma binaria)
Il risultato viene considerato come decimale. Il valore 001 è la rappresentazione binaria di 1, quindi x = 1.

L'operazione Or bit per bit è simile, tranne per il fatto che viene assegnato un 1 al bit risultante se uno o entrambi i bit paragonati corrisponde a 1. Xor assegna un 1 al bit risultante se esattamente uno dei bit paragonati (non entrambi) corrisponde a 1. Not accetta un operando singolo e inverte tutti i bit, incluso il bit del segno e assegna il valore al risultato. Ciò significa che per i numeri positivi firmati, Not restituisce sempre un valore negativo e per i numeri negativi Not restituisce sempre un valore positivo o pari a zero.

Gli operatori AndAlso e OrElse non supportano le operazioni bit per bit.

Nota

Le operazioni bit per bit possono essere eseguite solo sui tipi integrali. I valori a virgola mobile devono essere convertiti in tipi integrali prima che possa proseguire l'operazione bit per bit.