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

2025-06-28

Les opérateurs logiques comparent les Boolean expressions et retournent un Boolean résultat. Les opérateurs And, Or, AndAlso, OrElse, et Xor sont binaires, car ils prennent deux opérandes, tandis que l’opérateur Not est unaire, car il prend un opérande unique. Certains de ces opérateurs peuvent également effectuer des opérations logiques au niveau du bit sur des valeurs intégrales.

Opérateur logique unaire

L’opérateur Not effectue une négation logique sur une Boolean expression. Elle génère l’inverse logique de son opérande. Si l’expression prend Truela valeur , Not retourne False; si l’expression prend Falsela valeur , Not retourne True. L’exemple suivant illustre cela.

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’opérateur And effectue une combinaison logique sur deux Boolean expressions. Si les deux expressions évaluent à True, alors And retourne True. Si au moins une des expressions prend la valeur False, And retourne False.

L’opérateur Or effectue une disjonction ou une inclusion logiques sur deux Boolean expressions. Si l'une des expressions prend la valeur True, ou si les deux prennent la valeur True, alors Or retourne True. Si ni l'une ni l'autre des expressions n'évalue à True, Or retourne False.

L’opérateur Xor effectue une exclusion logique sur deux Boolean expressions. Si exactement une expression prend la valeur True, mais pas les deux, Xor retourne True. Si les deux expressions sont évaluées à True ou si les deux sont évaluées à 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 Short-Circuiting

L’opérateur AndAlso est très similaire à l’opérateurAnd, car il effectue également une combinaison logique sur deux Boolean expressions. La principale différence entre les deux est que AndAlso présente un comportement de court-circuitage. Si la première expression d’une AndAlso expression prend la Falsevaleur , 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'opérateur OrElse effectue une disjonction logique de court-circuit sur deux expressions Boolean. Si la première expression d’une OrElse expression prend la Truevaleur , la deuxième expression n’est pas évaluée, car elle ne peut pas modifier le résultat final et OrElse retourne True.

Compromis en matière de court-circuit

Le 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 effectue des actions supplémentaires, le court-circuit ignore ces actions. Par exemple, si l’expression inclut un appel à une Function procédure, cette procédure n’est pas appelée si l’expression est court-circuitée, et tout code supplémentaire contenu dans le Function fichier ne s’exécute pas. Par conséquent, la fonction peut s’exécuter uniquement occasionnellement et ne peut pas être testée correctement. Ou la logique du programme peut dépendre du code dans le Function.

L’exemple suivant illustre la différence entre And, Oret 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 le code important à l’intérieur checkIfValid() ne s’exécute pas lorsque l’appel est court-circuité. La première If instruction appelle checkIfValid() même si 12 > 45 retourne False, car And ne court-circuite pas. La deuxième If instruction n’appelle pas checkIfValid(), car lorsque 12 > 45 retourne False, AndAlso court-circuite la deuxième expression. La troisième If instruction appelle checkIfValid() même si 12 < 45 retourne True, car Or ne court-circuite pas. La quatrième If instruction n’appelle pas checkIfValid(), car quand 12 < 45 retourne True, OrElse court-circuite la deuxième expression.

Opérations au niveau du bit

Les opérations au niveau du bit évaluent deux valeurs intégrales sous forme binaire (base 2). Ils comparent les bits aux positions correspondantes, puis attribuent 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 définit la valeur x 1. Cela se produit pour les raisons suivantes :

Les valeurs sont traitées comme binaires :

3 sous forme binaire = 011

5 sous forme binaire = 101
L’opérateur And compare les représentations binaires, une position binaire (bit) à la fois. Si les deux bits à une position donnée sont 1, un 1 est placé dans cette position dans le résultat. Si l’un ou l’autre bit est 0, un 0 est placé dans cette position dans le résultat. Dans l’exemple précédent, cela fonctionne comme suit :

011 (3 sous forme binaire)

101 (5 sous forme binaire)

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

L’opération au niveau Or du bit est similaire, sauf qu’un 1 est affecté au bit de résultat si les deux bits comparés sont 1. Xor affecte un 1 au bit de résultat si exactement l’un des bits comparés (pas les deux) est 1. Not prend un opérande unique et inverse tous les bits, y compris le bit de signe, et affecte cette valeur au résultat. Cela signifie que 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 au niveau du bit.

Remarque

Les opérations au niveau du bit peuvent être effectuées uniquement sur les types intégraux. Les valeurs à virgule flottante doivent être converties en types intégraux avant que l’opération au niveau du bit puisse continuer.

Partager via