Operadores lógicos e bitwise no Visual Basic

Artigo
03/05/2024

Os operadores lógicos comparam Boolean expressões e retornam um Boolean resultado. Os Andoperadores , , , , e Xor são binários porque usam dois operandos, enquanto o Not operador é unário porque usa um único operando. OrElseAndAlsoOr Alguns desses operadores também podem executar operações lógicas bit a bit em valores integrais.

Operador lógico unário

O operador Not executa a negação lógica em uma Boolean expressão. Ele produz o oposto lógico de seu operando. Se a expressão for avaliada como True, então Not retornará False; se a expressão for avaliada como False, então Not retornará True. O exemplo a seguir ilustra isso.

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

Operadores lógicos binários

O operador And executa a conjunção lógica em duas Boolean expressões. Se ambas as expressões avaliarem para True, retornará AndTrue. Se pelo menos uma das expressões for avaliada como False, retornará AndFalse.

O operador Or executa disjunção lógica ou inclusão em duas Boolean expressões. Se uma das expressões for avaliada como True, ou ambas avaliarem como True, retornará OrTrue. Se nenhuma das expressões for avaliada como True, Or retornará False.

O Operador Xor executa a exclusão lógica em duas Boolean expressões. Se exatamente uma expressão for avaliada como True, mas não ambas, Xor retornará True. Se ambas as expressões avaliarem para True ou ambas avaliarem para False, Xor retornará False.

O exemplo a seguir ilustra os Andoperadores , 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.

Operações lógicas de curto-circuito

O operador AndAlso é muito semelhante ao And operador, na medida em que também executa conjunção lógica em duas Boolean expressões. A principal diferença entre os dois é que AndAlso exibe um comportamento de curto-circuito . Se a primeira expressão de uma AndAlso expressão for avaliada como False, então a segunda expressão não será avaliada porque não pode alterar o resultado final e AndAlso retornará False.

Da mesma forma, o operador OrElse executa disjunção lógica de curto-circuito em duas Boolean expressões. Se a primeira expressão de uma OrElse expressão for avaliada como True, então a segunda expressão não será avaliada porque não pode alterar o resultado final e OrElse retornará True.

Compensações de curto-circuito

O curto-circuito pode melhorar o desempenho ao não avaliar uma expressão que não pode alterar o resultado da operação lógica. No entanto, se essa expressão executar ações adicionais, o curto-circuito ignorará essas ações. Por exemplo, se a expressão incluir uma chamada para um Function procedimento, esse procedimento não será chamado se a expressão estiver em curto-circuito e qualquer código adicional contido no Function não for executado. Portanto, a função pode ser executada apenas ocasionalmente e pode não ser testada corretamente. Ou a lógica do programa pode depender do código no Function.

O exemplo a seguir ilustra a diferença entre And, Or, e suas contrapartes de curto-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

No exemplo anterior, observe que algum código importante dentro checkIfValid() não é executado quando a chamada está em curto-circuito. A primeira If instrução chama checkIfValid() mesmo que 12 > 45 retorna False, porque And não curto-circuito. A segunda If instrução não chama checkIfValid(), porque quando 12 > 45 retorna False, AndAlso curto-circuito a segunda expressão. A terceira If afirmação chama checkIfValid() mesmo que 12 < 45 retorna True, porque Or não curto-circuito. A quarta If instrução não chama checkIfValid(), porque quando 12 < 45 retorna True, OrElse curto-circuito a segunda expressão.

Operações Bitwise

As operações Bitwise avaliam dois valores integrais na forma binária (base 2). Eles comparam os bits nas posições correspondentes e, em seguida, atribuem valores com base na comparação. O exemplo a seguir ilustra o And operador.

Dim x As Integer
x = 3 And 5

O exemplo anterior define o valor de x 1. Isso acontece pelos seguintes motivos:

Os valores são tratados como binários:

3 na forma binária = 011

5 na forma binária = 101
O And operador compara as representações binárias, uma posição binária (bit) de cada vez. Se ambos os bits em uma determinada posição são 1, então um 1 é colocado nessa posição no resultado. Se qualquer bit for 0, então um 0 é colocado nessa posição no resultado. No exemplo anterior, isso funciona da seguinte maneira:

011 (3 na forma binária)

101 (5 na forma binária)

001 (O resultado, em forma binária)
O resultado é tratado como decimal. O valor 001 é a representação binária de 1, portanto x = 1.

A operação bit a Or bit é semelhante, exceto que um 1 é atribuído ao bit de resultado se um ou ambos os bits comparados forem 1. Xor atribui um 1 ao bit de resultado se exatamente um dos bits comparados (não ambos) for 1. Not pega um único operando e inverte todos os bits, incluindo o bit de sinal, e atribui esse valor ao resultado. Isso significa que, para números positivos assinados, Not sempre retorna um valor negativo e, para números negativos, Not sempre retorna um valor positivo ou zero.

Os AndAlso operadores e OrElse não suportam operações bitwise.

Nota

As operações Bitwise podem ser executadas apenas em tipos integrais. Os valores de vírgula flutuante devem ser convertidos em tipos integrais antes que a operação bit a bit possa prosseguir.

Partilhar via