Opérateurs de bits et opérateurs logiques en Visual Basic

Article
09/12/2008

Mise à jour : novembre 2007

Les opérateurs logiques comparent des expressions Boolean et retournent un résultat Boolean. Les opérateurs And, Or, AndAlso, OrElse et Xor sont binaires parce qu'ils prennent deux opérandes, tandis que l'opérateur Not est unaire parce qu'il prend un seul opérande. Certains de ces opérateurs peuvent également exécuter des opérations logiques de bits sur des valeurs intégrales.

Opérateur logique unaire

L'Not, opérateur (Visual Basic) effectue une négation logique sur une expression Boolean. Il retourne l'opposé logique de son opérande. Si l'expression a la valeur True, Not retourne False ; si elle a la valeur False, Not retourne True. L'exemple suivant illustre ce comportement :

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

Opérateurs logiques binaires

L'And, opérateur (Visual Basic) effectue une conjonction logique sur deux expressions Boolean. Si les deux expressions ont la valeur True, And retourne True. Si au moins l'une des expressions a la valeur False, And retourne False.

L'Or, opérateur (Visual Basic) effectue une disjonction ou une inclusion logique sur deux expressions Boolean. Si l'une des deux expressions a la valeur True, ou encore si elles ont toutes les deux la valeur True, Or retourne True. Si aucune expression n'a la valeur True, Or retourne False.

L'Xor, opérateur (Visual Basic) effectue une exclusion logique sur deux expressions Boolean. Si une seule expression a la valeur True, Xor retourne True. Si les deux expressions ont la valeur True ou la valeur False, Xor retourne False.

L'exemple suivant illustre les opérateurs And, Or et 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.

Opérations logiques de court-circuit

L'AndAlso, opérateur est très similaire à l'opérateur And, car il effectue également une conjonction logique sur deux expressions Boolean. La différence principale entre les deux est que AndAlso se comporte comme un court-circuit. Si la première expression d'une expression AndAlso a la valeur False, la deuxième expression n'est pas évaluée, car elle ne peut pas modifier le résultat final et AndAlso retourne False.

De même, l'OrElse, opérateur effectue une disjonction logique de court-circuit sur deux expressions Boolean. Si la première expression d'une expression OrElse a la valeur True, la deuxième expression n'est pas évaluée, car elle ne peut pas modifier le résultat final et OrElse retourne True.

Compromis de court-circuit

Un court-circuit peut améliorer les performances en n'évaluant pas une expression qui ne peut pas modifier le résultat de l'opération logique. Toutefois, si cette expression exécute des actions supplémentaires, le court-circuit les ignore. Par exemple, si l'expression inclut un appel à une procédure Function, cette procédure n'est pas appelée si l'expression est court-circuitée, et le code supplémentaire contenu dans la Function ne s'exécute pas. Si votre logique de programme dépend de l'un de ces codes supplémentaires, vous devez probablement éviter de court-circuiter les opérateurs.

L'exemple suivant illustre la différence entre And, Or et leurs équivalents de court-circuit.

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

Dans l'exemple précédent, notez que du code important dans checkIfValid() ne s'exécute pas lorsque l'appel est court-circuité. La première instruction If appelle checkIfValid() bien que 12 > 45 retourne False, parce que And n'effectue pas de court-circuit. La deuxième instruction If n'appelle pas checkIfValid() parce que si 12 > 45 retourne False, AndAlso court-circuite la deuxième expression. La troisième instruction If appelle checkIfValid() bien que 12 < 45 retourne True, parce que Or n'effectue pas de court-circuit. La quatrième instruction If n'appelle pas checkIfValid() parce que si 12 < 45 retourne True, OrElse court-circuite la deuxième expression.

Opérateurs de bits

Les opérations de bits évaluent deux valeurs intégrales sous forme binaire (base 2). Elles comparent les bits à des positions correspondantes, puis assignent des valeurs en fonction de la comparaison. L'exemple suivant illustre l'opérateur And.

Dim x As Integer
x = 3 And 5

L'exemple précédent affecte à x la valeur 1. Cela est dû aux raisons suivantes :

Les valeurs sont traitées comme des valeurs binaires :

3 sous forme binaire = 011

5 sous forme binaire = 101
L'opérateur And compare les représentations binaires par position binaire (bit). Si les deux bits d'une position donnée correspondent à 1, une valeur égale à 1 est placée à cette position dans le résultat. Si l'un des deux bits est 0, une valeur égale à 0 est placée à cette position dans le résultat. Dans l'exemple précédent, cette procédure fonctionne comme suit :

011 (3 sous forme binaire)

101 (5 sous forme binaire)

001 (le résultat sous forme binaire)
Le résultat est traité comme une valeur décimale. La valeur 001 est la représentation binaire de 1, donc x = 1.

L'opération Or au niveau des bits est similaire, excepté que 1 est assigné au bit de résultat si l'un des deux bits comparés est égal à 1. Xor assigne 1 au bit de résultat si un seul des bits comparés est égal à 1. Not accepte un opérande simple, inverse tous les bits (y compris le bit de signe) et assigne la valeur au résultat. Ainsi, pour les nombres positifs signés, Not retourne toujours une valeur négative, et pour les nombres négatifs, Not retourne toujours une valeur positive ou nulle.

Les opérateurs AndAlso et OrElse ne prennent pas en charge les opérations de bits.

Remarque :
Les opérations de bits ne peuvent être effectuées que sur des types intégraux. Les valeurs de virgule flottante doivent être converties en types intégraux avant de poursuivre une opération de bits.