Aller au contenu
Encyclopédie informatique Édition 2026

Les opérateurs

Partie 3 sur 3

Niveau de lecture :

6Les opérateurs bit à bit et de décalage

Ces opérateurs travaillent sur les bits d’un nombre entier, c’est-à-dire sur les 0 et les 1 de son écriture binaire. On pense parfois qu’on s’en passe ; on les rencontre pourtant dans les droits d’accès, les adresses réseau, les couleurs et la cryptographie.

6.1ET, OU, OU exclusif, NON

Chaque opérateur compare les bits de même rang (de même poids) :

  • & (et bit à bit) donne 1 si les deux bits valent 1. 9 & 12, soit 1001 & 1100, donne 1000, c’est-à-dire 8 ;
  • | (ou bit à bit) donne 1 si l’un des deux bits au moins vaut 1. 9 | 12 donne 1101, soit 13 ;
  • ^ (ou exclusif) donne 1 si les deux bits sont différents. 9 ^ 12 donne 0101, soit 5 ;
  • ~ (complément) inverse tous les bits.

Une correction sur ~ : on lit parfois ~9 = 6, ce qui n’est vrai que si l’on raisonne sur 4 bits. Sur un entier de 32 bits signé, ~9 vaut -10, car tous les bits sont inversés, y compris ceux de gauche. La figure 1 montre les trois premières opérations.

LES OPÉRATIONS BIT À BIT : 9 (1001) ET 12 (1100) 9 1 0 0 1 en décimal : 9 12 1 1 0 0 en décimal : 12 9 & 12 (ET) 1 0 0 0 = 8 : 1 seulement si les deux bits valent 1 9 | 12 (OU) 1 1 0 1 = 13 : 1 si au moins un bit vaut 1 9 ^ 12 (OU exclusif) 0 1 0 1 = 5 : 1 si les deux bits sont différents Sur 4 bits, ~9 vaut 0110, soit 6 ; sur 32 bits signés, ~9 vaut -10 : tous les bits de gauche s’inversent aussi.
Figure 1. Les trois opérations bit à bit sur 9 (1001) et 12 (1100).

6.2Les masques

Un masque est un nombre dont les bits sélectionnent ce qu’on veut lire ou changer. Pour savoir si un droit est présent, on utilise & ; pour l’ajouter, | ; pour le retirer, & ~ ; pour l’inverser, ^. C’est le principe des droits d’accès des fichiers Unix (lecture 4, écriture 2, exécution 1) : le droit 6 est lecture plus écriture. L’exercice 2 s’y consacre.

6.3Décaler les bits

Les opérateurs de décalage font glisser les bits vers la gauche (<<) ou la droite (>>). Décaler de un rang à gauche multiplie par 2 : 6 << 1 = 12 (110 devient 1100). Décaler à droite divise par 2, en jetant le reste : 6 >> 1 = 3.

On les appelle parfois « opérateurs de rotation ». C’est une erreur de vocabulaire : dans un décalage, les bits qui sortent sont perdus et remplacés par des zéros (ou par une copie du signe). Dans une vraie rotation, les bits qui sortent à une extrémité réapparaissent à l’autre. Le C n’a pas d’opérateur de rotation.

Autre correction : on présente parfois >>> pour le C++, qui ne l’a pas. Il existe en Java et en JavaScript, où il décale sans conserver le signe. Pour un nombre négatif, >> recopie le bit de signe à gauche (-8 >> 1 vaut -4), alors que >>> le remplit de zéros : en 32 bits, -8 >>> 1 vaut 2 147 483 644. En C et C++, décaler à droite un nombre négatif dépend de la machine ; décaler de plus de bits que la taille du type est indéfini. Enfin, en JavaScript, tous les opérateurs de bits convertissent d’abord leurs opérandes en entiers de 32 bits, d’où l’affirmation, souvent répétée, sur les « 32 bits » : vraie pour JavaScript, pas pour les autres langages.

Pour s’exercer

Exercice 1 : Évaluer à la main

Dans un programme C où toutes les variables sont des entiers, que vaut 7 + 3 * 2 - 8 / 4 % 3 ? Et que valent -7 / 2 et -7 % 2 ?

Voir la réponse

Les opérateurs *, / et % passent avant + et -, et se lisent de gauche à droite. On calcule : 3 × 2 = 6 ; 8 / 4 = 2, puis 2 % 3 = 2 ; il reste 7 + 6 - 2 = 11. En C, la division entière coupe la partie décimale : -7 / 2 vaut -3 (et non -4), et -7 % 2 vaut -1 (le reste garde le signe du premier nombre, car -3 × 2 + (-1) = -7).

Exercice 2 : Les droits avec un masque

On code lecture = 4, écriture = 2, exécution = 1. Un fichier a le droit d = 5. Écrivez les expressions pour : (a) savoir s’il a le droit d’écriture ; (b) lui ajouter ce droit ; (c) retirer le droit de lecture.

Voir la réponse

(a) d & 2 : le résultat est différent de 0 si le droit d’écriture est présent (ici 5 & 2 = 0, donc non). (b) d = d | 2; : le droit est ajouté, d vaut alors 7. (c) d = d & ~4; : ~4 met à 0 le bit de lecture et à 1 tous les autres, donc seul ce droit disparaît ; d vaut alors 1.

Exercice 3 : Trouver l’erreur

Que se passe-t-il dans ces trois morceaux de C ? (a) if (x = 3) { ... } ; (b) if (flags & 4 == 4) { ... } ; (c) if (p->v > 0 && p != NULL) { ... }.

Voir la réponse

(a) Il y a un seul signe = : c’est une affectation, pas une comparaison. x reçoit 3 et la condition est toujours vraie. Il faut écrire x == 3. (b) == passe avant &, donc C calcule flags & (4 == 4), c’est-à-dire flags & 1, ce qui ne teste pas le bon bit. Il faut des parenthèses : (flags & 4) == 4. (c) On lit p->v avant de vérifier que p n’est pas NULL : si p vaut NULL, le programme plante. Il faut inverser : p != NULL && p->v > 0 (le && s’arrête dès que la première partie est fausse).

7La priorité et l’associativité

Quand plusieurs opérateurs se côtoient, le langage applique des règles pour décider de l’ordre. La priorité dit lequel passe en premier : dans 2 + 3 * 4, la multiplication passe avant l’addition, le résultat est 14. L’associativité départage deux opérateurs de même priorité : 10 - 4 - 3 se lit de gauche à droite, soit (10 - 4) - 3 = 3, alors que l’affectation a = b = c se lit de droite à gauche.

On donne souvent un tableau de priorités par langage. Nous retenons l’ordre commun à C, C++ et Java, du plus prioritaire au moins prioritaire (la figure 2 le résume) :

  • les parenthèses, les crochets, le point et les opérateurs postfixes (x++) ;
  • les opérateurs unaires : !, ~, - unaire, ++ préfixe, la conversion de type ;
  • *, /, % ;
  • +, - ;
  • <<, >> (et >>> en Java) ;
  • <, <=, >, >= ;
  • ==, != ;
  • &, puis ^, puis | ;
  • &&, puis || ;
  • l’opérateur ternaire ?: ;
  • les affectations (=, +=, etc.) ;
  • la virgule, en dernier.
LA PRIORITÉ : CE QUI PASSE EN PREMIER (C, C++, JAVA) 1 ( ) [ ] x++ x-- les plus prioritaires 2 ! ~ - unaire ++x opérateurs à un seul opérande 3 * / % multiplier, diviser, reste 4 + - additionner, soustraire 5 << >> décalages 6 < <= > >= ==  != comparaisons 7 & ^ | puis && || bits, puis logique 8 ?: = += ... les moins prioritaires 2 + 3 * 4 = 2 + (3 * 4) = 14 a & b == c = a & (b == c) piège : parenthésez
Figure 2. L’ordre de traitement, du plus prioritaire au moins prioritaire.

7.1Les pièges de la priorité

Deux erreurs reviennent sans cesse. Première erreur : en C, C++, Java, JavaScript et PHP, les opérateurs de comparaison passent avant les opérateurs de bits. a & b == c se lit donc a & (b == c), rarement ce qu’on voulait ; il faut écrire (a & b) == c. Deuxième erreur : a + b << 2 se lit (a + b) << 2, car le plus passe avant le décalage, ce qui surprend ceux qui pensent « décalage » comme une multiplication.

La règle d’or est simple : dès qu’un doute existe, mettez des parenthèses. Elles ne coûtent rien à l’exécution, et le lecteur de votre code (vous, dans six mois) vous en sera reconnaissant. Perl a le même principe, avec en plus une priorité très basse pour and, or et not, qui explique l’usage de la partie 5.

8Les particularités de chaque langage

  • C et C++ : beaucoup de comportements indéfinis (débordement signé, décalage trop grand). En C++, on peut surcharger (redéfinir) les opérateurs pour ses propres types : cout << "texte" fonctionne parce que << y signifie « envoyer vers le flux de sortie ».
  • Java : le + colle aussi du texte, instanceof teste le type d’un objet, >>> existe, le débordement entier boucle sans erreur.
  • JavaScript : tous les nombres sont décimaux, == convertit, "5" + 3 donne "53" alors que "5" - 3 donne 2.
  • PHP : le point colle des textes, le + est réservé aux nombres.
  • Perl : un opérateur pour les nombres et un pour les textes, x répète un texte ("ab" x 3 donne "ababab"), ** élève à la puissance.
Sécurité de l’information

Le coin cyber

Cet article décrit des opérateurs de langage ; il ne contient aucune méthode d’attaque. Les erreurs d’opérateurs sont pourtant à l’origine de vulnérabilités sérieuses.

C.1Débordements et sécurité

Un calcul qui déborde produit une valeur fausse ; si cette valeur sert ensuite à réserver de la mémoire ou à vérifier une limite, elle ouvre la voie à des corruptions de mémoire. La famille de faiblesses est répertoriée sous le nom CWE-190 (dépassement d’entier) dans le catalogue Common Weakness Enumeration, tenu par l’organisme MITRE. Les guides de programmation sûre recommandent de vérifier les bornes avant le calcul, d’utiliser des types assez grands et de se servir des fonctions de calcul « avec détection de dépassement » qu’offrent les compilateurs et les langages récents.

C.2Idée reçue

« Les opérateurs sont la partie facile d’un langage : ils font ce qu’on croit. » Faux. Division entière, débordement silencieux, comparaisons qui convertissent, priorité surprenante : les opérateurs concentrent des comportements qui ne correspondent pas à l’intuition, et ils sont à l’origine d’erreurs de sécurité bien réelles. On les vérifie, on les teste aux limites, on les parenthèse.

C.3Bonnes pratiques

Particulier

  • Activer les avertissements du compilateur et les lire.
  • Tester les cas limites : zéro, négatifs, valeur maximale.
  • Comparer avec === et jamais avec == en JavaScript.

Organisation

  • Imposer un analyseur de code (outil qui lit le code et signale les erreurs probables) dans la chaîne de livraison.
  • Fixer des règles de codage : parenthèses, un effet de bord par ligne.
  • Faire relire les calculs qui touchent à des tailles, à des montants ou à des droits.

Référentiels : CWE-190 (MITRE, dépassement d’entier) · CWE-681 (conversion numérique incorrecte) · SEI CERT C Coding Standard, règles INT30-C à INT34-C · Norme ISO/IEC 9899 (langage C).

Références

  1. Commission d’enquête Ariane 501, Rapport de la commission d’enquête, 19 juillet 1996.
  2. Brian Kernighan, Dennis Ritchie, Le langage C, Dunod, 2e édition.
  3. ISO/IEC 9899, Programming languages, C.
  4. ECMA-262, ECMAScript Language Specification, section sur les opérateurs.
  5. FAA, Airworthiness Directive 2015-09-07, 2015.

Voir aussi

Citer cet article

« Les opérateurs », Encyclopédie informatique, révision du 4 novembre 2026.