Operatori logici e bit per bit in Visual Basic

2025-06-17

Gli operatori logici confrontano Boolean le espressioni e restituiscono un Boolean risultato. Gli Andoperatori , Or, AndAlsoOrElse, 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 su un'espressioneBoolean. Restituisce l'opposto logico dell'operando. Se l'espressione restituisce True, Not restituisce False; se l'espressione restituisce False, Not restituisce True. Nell'esempio seguente viene illustrato questo.

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 congiunzione logica su due Boolean espressioni. Se entrambe le espressioni restituiscono True, And restituisce True. Se almeno una delle espressioni restituisce False, And restituisce False.

L'operatore Or esegue la disgiunzione logica o l'inclusione in due Boolean espressioni. Se una delle due espressioni restituisce True, oppure entrambe restituiscono True, allora Or restituisce True. Se nessuna delle due espressioni restituisce True, Or restituisce False.

L'operatore Xor esegue l'esclusione logica su due Boolean espressioni. Se esattamente un'espressione valuta a True, ma non entrambe, Xor restituisce True. Se entrambe le espressioni restituiscono True o entrambe restituiscono False, 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.

Short-Circuiting operazioni logiche

L'operatore AndAlso è molto simile all'operatore And , in quanto esegue anche la congiunzione logica su due Boolean espressioni. La differenza principale tra i due è che AndAlso presenta un 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 routine non viene chiamata se l'espressione è corto circuito e non viene eseguito alcun codice aggiuntivo contenuto in Function . Pertanto, la funzione potrebbe essere eseguita solo occasionalmente e potrebbe non essere testata correttamente. In alternativa, la logica del programma potrebbe 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 un codice importante all'interno checkIfValid() non viene eseguito quando la chiamata è in corto circuito. La prima If istruzione chiama checkIfValid() anche se 12 > 45 restituisce False, perché And non causa un'uscita anticipata. La seconda If istruzione non chiama checkIfValid(), perché quando 12 > 45 restituisce False, AndAlso esegue il corto circuito della seconda espressione. La terza If istruzione chiama checkIfValid() anche se 12 < 45 restituisce True, perché Or non provoca un corto circuito. La quarta If istruzione non chiama checkIfValid(), perché quando 12 < 45 restituisce True, OrElse esegue il corto circuito della seconda espressione.

Operazioni bit per bit

Le operazioni bit per bit valutano due valori integrali in formato binario (base 2). Confrontano i bit in corrispondenza delle 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

Nell'esempio precedente il valore di x viene impostato su 1. Ciò si verifica per i motivi seguenti:

I valori vengono considerati come 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 valore 1 viene posizionato in tale posizione nel risultato. Se uno dei due bit è 0, un valore 0 viene posizionato in tale posizione nel risultato. Nell'esempio precedente questa operazione funziona come segue:

011 (3 in formato binario)

101 (5 in formato binario)

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

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

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

Annotazioni

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.

Condividi tramite