C6290C6290

avertissement C6290 : opération de bits sur résultat logique : !warning C6290: Bitwise operation on logical result: ! a une priorité plus élevée que &.has higher precedence than &. Utilisez & & ou ( ! () x & y)) à la placeUse && or (!(x & y)) instead

Cet avertissement indique une confusion possible dans l’utilisation d’un opérateur ou un ordre de priorité.This warning indicates possible confusion in the use of an operator or an operator precedence.

Le ! opérateur génère un résultat booléen, et il a une priorité plus élevée que le &. L’opérateur de bits- et (&) l’opérateur accepte deux arguments arithmétiques.The ! operator yields a Boolean result, and it has higher precedence than the &.The bitwise-and (&) operator takes two arithmetic arguments. Par conséquent, les erreurs suivantes a été détecté :Therefore, one of the following errors has been detected:

  • L’expression est de parenthèses :The expression is mis-parenthesised:

    Étant donné que le résultat de ! est la valeur booléenne (zéro ou 1), une tentative de tester que deux variables ont des bits en commun revient à tester que le bit le plus faible est présent sur le côté droit : ((!8) & 1) == 0.Because the result of ! is Boolean (zero or one), an attempt to test that two variables have bits in common will only end up testing that the lowest bit is present in the right side: ((!8) & 1) == 0.

  • Le ! opérateur est incorrect et doit être un ~ à la place :The ! operator is incorrect, and should be a ~ instead:

    Le ! opérateur a un résultat booléen, tandis que le ~ opérateur a un résultat arithmétique.The ! operator has a Boolean result, while the ~ operator has an arithmetic result. Ces opérateurs ne sont jamais interchangeables, même lorsqu’ils utilisent une valeur Boolean (zéro ou 1) : ((!0x01) & 0x10) == 0x0, tandis que ((~0x01) & 0x10) == 0x10.These operators are never interchangeable, even when operating on a Boolean value (zero or one): ((!0x01) & 0x10) == 0x0, while ((~0x01) & 0x10) == 0x10.

  • L’opérateur binaire & est incorrecte et doit être &&:The binary operator & is incorrect, and should instead be &&:

    Alors que & peut parfois être permuté avec &&, il n’est pas équivalent car il force l’évaluation du côté droit de l’expression.While & can sometimes be interchanged with &&, it is not equivalent because it forces evaluation of the right side of the expression. Certains effets secondaires dans ce type d’expression peuvent être terminaux.Certain side effects in this type of expression can be terminal.

    Il est difficile d’évaluer la gravité de ce problème sans examiner le code.It is difficult to judge the severity of this problem without examining the code. Le code doit être évaluée pour vous assurer que le test prévu est en cours.The code should be inspected to ensure that the intended test is occurring.

ExempleExample

Le code suivant génère cet avertissement :The following code generates this warning:

void f(int x, int y)
{
  if (!x & y)
  {
    // code ..
  }
}

Pour corriger cet avertissement, utilisez l’exemple de code suivant :To correct this warning, use the following sample code:

void f(int x, int y)
{
  /* When testing that x has no bits in common with y. */
  if (!(x & y))
  {
    // code
  }

  /* When testing for the complement of x in y. */
  if ((~x) & y)
  {
    // code ...
  }
}
#include <windows.h>
void fC(int x, BOOL y )
 {
  /* When y is a Boolean or Boolean result. */
  if ((!x) && y)
  {
    // code ...
  }
}

Avertissement C6317 s’affiche si le ! opérateur se trouve sur le côté droit de la & opérateur.Warning C6317 is reported if the ! operator is on the right side of the & operator.

Voir aussiSee Also

C6317C6317