Operatori logici e bit per bit in Visual Basic

Articolo
04/07/2023

Gli operatori logici confrontano Boolean le espressioni e restituiscono un Boolean risultato. Gli Andoperatori , Or, OrElseAndAlso, e Xor sono binari perché accettano due operandi, mentre l'operatore Not è unario perché accetta un singolo operando. Alcuni di questi operatori possono anche eseguire operazioni logiche bit per bit sui valori integrali.

Operatore logico unario

L'operatore Not esegue la negazione logica in un'espressioneBoolean. Restituisce l'opposto logico del suo operando. Se l'espressione restituisce True, Not restituisce False; se l'espressione Falserestituisce , Not restituisce True. Questa condizione è illustrata nell'esempio seguente.

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 esegue una combinazione logica su due Boolean espressioni. Se entrambe le espressioni valutano True, restituisce AndTrue. Se almeno una delle espressioni restituisce , And restituisce .FalseFalse

L'operatore Or esegue la disgiunzione logica o l'inclusione in due Boolean espressioni. Se un'espressione restituisce , o entrambi restituisce TrueOrTrueTrue. Se nessuna espressione restituisce , Or restituisce TrueFalse.

L'operatore Xor esegue l'esclusione logica su due Boolean espressioni. Se un'espressione restituisce Trueesattamente , ma non entrambe, Xor restituisce True. Se entrambe le espressioni valutano o entrambe valutano TrueFalse, Xor restituisce False.

Nell'esempio seguente vengono illustrati gli Andoperatori , Ore 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.

operazioni logiche Short-Circuiting

L'operatore AndAlso è molto simile all'operatoreAnd, in quanto esegue anche una combinazione logica su due Boolean espressioni. La differenza chiave tra i due è che AndAlso mostra il comportamento di corto circuito . Se la prima espressione in un'espressione AndAlso restituisce False, la seconda espressione non viene valutata perché non può modificare il risultato finale e AndAlso restituisce False.

Analogamente, l'operatore OrElse esegue la disgiunzione logica a corto circuito su due Boolean espressioni. Se la prima espressione in un'espressione OrElse restituisce True, la seconda espressione non viene valutata perché non può modificare il risultato finale e OrElse restituisce True.

Short-Circuiting Trade-Offs

Il corto circuito può migliorare le prestazioni non valutando un'espressione che non può modificare il risultato dell'operazione logica. Tuttavia, se tale espressione esegue azioni aggiuntive, il corto circuito ignora tali azioni. Ad esempio, se l'espressione include una chiamata a una Function routine, tale procedura non viene chiamata se l'espressione è corto circuito e qualsiasi codice aggiuntivo contenuto nell'oggetto Function non viene eseguito. Pertanto, la funzione potrebbe essere eseguita solo occasionalmente e potrebbe non essere testata correttamente. In alternativa, la logica del programma può dipendere dal codice in Function.

Nell'esempio seguente viene illustrata la differenza tra And, Ore le relative controparti a 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 precedente si noti che alcuni codici importanti all'interno checkIfValid() non vengono eseguiti quando la chiamata è a corto circuito. La prima If istruzione chiama checkIfValid() anche se 12 > 45 restituisce False, perché And non è corto circuito. La seconda If istruzione non chiama checkIfValid(), perché quando 12 > 45 restituisce False, AndAlso short-circuits la seconda espressione. La terza If istruzione chiama checkIfValid() anche se 12 < 45 restituisce True, perché Or non è corto circuito. La quarta If istruzione non chiama checkIfValid(), perché quando 12 < 45 restituisce True, OrElse short-circuits la seconda espressione.

Operazioni bit per bit

Le operazioni bit per bit valutano due valori integrali nel formato binario (base 2). Confrontano i bit in posizioni corrispondenti e quindi assegnano valori in base al confronto. Nell'esempio seguente viene illustrato l'operatore And .

Dim x As Integer
x = 3 And 5

L'esempio precedente imposta il valore di x su 1. Ciò accade per i motivi seguenti:

I valori vengono considerati binari:

3 in formato binario = 011

5 in formato binario = 101
L'operatore And confronta le rappresentazioni binarie, una posizione binaria (bit) alla volta. Se entrambi i bit in una determinata posizione sono 1, un 1 viene posizionato in tale posizione nel risultato. Se entrambi i bit sono 0, un 0 viene posizionato in tale posizione nel risultato. Nell'esempio precedente questa operazione viene eseguita come indicato di seguito:

011 (3 in formato binario)

101 (5 in formato binario)

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

L'operazione bit per Or bit è simile, ad eccezione del fatto che un 1 viene assegnato al bit di risultato se uno o entrambi i bit confrontati sono 1. Xor assegna un bit a 1 al risultato se esattamente uno dei bit confrontati (non entrambi) è 1. Not accetta un singolo operando e inverte tutti i bit, incluso il bit di segno, e assegna tale 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 zero.

Gli AndAlso operatori e OrElse non supportano 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 l'operazione bit per bit possa procedere.