Compartilhar via

Operadores lógicos e bit a bit no Visual Basic

Operadores lógicos comparam Boolean expressões e retornam um Boolean resultado. Os Andoperadores , Or, AndAlsoe OrElseXor, são binários porque eles tomam dois operandos, enquanto o Not operador é unário porque ele usa um único operando. 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 negação lógica em uma expressão Boolean. Ele produz o oposto lógico do 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 essa situação.

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 expressões Boolean. Se ambas as expressões forem avaliadas como True, então And retornará True. Se pelo menos uma das expressões for avaliada como False, então And retornará False.

O Operador Or executa a disjunção lógica ou inclusão em duas expressões Boolean. Se uma das expressões for avaliada como True, ou se ambas forem avaliadas como True, então Or retornará True. 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 forem avaliadas como True ou como False, Xor retornará False.

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

Short-Circuiting Operações Lógicas

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

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

Compensações de curto-circuito

O curto-circuito pode melhorar o desempenho não avaliando 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 seus equivalentes 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 algumas partes importantes do código dentro de checkIfValid() não são executadas quando a chamada é curto-circuitada. A primeira instrução If chama checkIfValid(), embora 12 > 45 retorne False, porque And não faz curto-circuito. A segunda If instrução não chama checkIfValid(), porque quando 12 > 45 retorna False, AndAlso curto-circuita a segunda expressão. A terceira instrução If chama checkIfValid(), embora 12 < 45 retorne True, porque Or não faz curto-circuito. A quarta If instrução não chama checkIfValid(), porque quando 12 < 45 retorna True, OrElse curto-circuita a segunda expressão.

Operações bit a bit

As operações bit a bit avaliam dois valores integrais no formato binário (base 2). Eles comparam os bits em 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 como x 1. Isso acontece pelos seguintes motivos:

  • Os valores são tratados como binários:

    3 no formato binário = 011

    5 em 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 forem 1, um 1 será colocado nessa posição no resultado. Se qualquer um dos bits for 0, então um 0 será colocado naquela posição no resultado. No exemplo anterior, isso funciona da seguinte maneira:

    011 (3 no formato binário)

    101 (5 em 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 bit Or é semelhante, exceto que um 1 é atribuído ao bit de resultado se um ou ambos os bits comparados forem 1. Xor atribui 1 ao bit de resultado se exatamente um dos bits comparados (não ambos) for 1. Not usa 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 operadores AndAlso e OrElse não dão suporte a operações bitwise.

Observação

As operações bit a bit só podem ser executadas em tipos integrais. Os valores de ponto flutuante devem ser convertidos em tipos integrais antes que a operação bit a bit possa continuar.

Consulte também