Les opérateurs en C : arithmétiques, logiques et précédence

Les opérateurs sont les verbes du C : ils prennent des valeurs et en produisent de nouvelles. Il y en a une quarantaine, mais une douzaine couvre la plupart du code, et deux d'entre eux ont des pièges assez tranchants pour mériter leur propre section.

Les opérateurs arithmétiques

#include <stdio.h>

int main(void) {
    int a = 17, b = 5;

    printf("a + b  = %d\n", a + b);   /* 22 */
    printf("a - b  = %d\n", a - b);   /* 12 */
    printf("a * b  = %d\n", a * b);   /* 85 */
    printf("a / b  = %d\n", a / b);   /* 3  - division entiere ! */
    printf("a %% b  = %d\n", a % b);  /* 2  - le reste */
    printf("-a     = %d\n", -a);      /* moins unaire */
    return 0;
}

(%% dans la chaîne de format affiche un signe pourcent littéral - % seul commencerait un spécificateur de format.)

Les cinq opérateurs arithmétiques binaires sont + - * / %, plus le - unaire pour la négation et le + qui ne fait essentiellement rien.

Le piège de la division entière

a / b avec deux entiers effectue une division entière et jette le reste. Il n'y a pas d'arrondi - le résultat est tronqué vers zéro.

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("7 / 2         = %d\n", total / count);          /* 3 */
    printf("7 / 2.0       = %f\n", total / 2.0);            /* 3.5 */
    printf("(double)7 / 2 = %f\n", (double)total / count);  /* 3.5 */

    double wrong = total / count;      /* la division a lieu D'ABORD, en int */
    printf("moyenne fausse = %f\n", wrong);   /* 3.000000 */
    return 0;
}

Ce dernier cas est le bug qui survit jusqu'en production. Affecter à un double n'aide pas : la division total / count est déjà terminée, et déjà un int, avant que l'affectation n'ait lieu. La solution est de rendre un opérande flottant dans l'expression, généralement avec un cast.

Deux règles voisines : diviser par zéro avec des entiers est un comportement indéfini et fait typiquement planter le programme, et INT_MIN / -1 déborde.

L'opérateur modulo

% donne le reste et ne fonctionne que sur les entiers :

#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            printf("%d est pair\n", i);
        } else {
            printf("%d est impair\n", i);
        }
    }

    int seconds = 3725;
    printf("\n%d secondes = %dh %dm %ds\n",
           seconds, seconds / 3600, (seconds % 3600) / 60, seconds % 60);
    return 0;
}

Tester x % 2 == 0 pour la parité et utiliser % n pour faire boucler un indice sur un tableau sont les deux usages quotidiens.

Avec des nombres négatifs, le % du C suit le signe du dividende :

#include <stdio.h>

int main(void) {
    printf(" 7 %% 3 = %d\n",  7 % 3);   /*  1 */
    printf("-7 %% 3 = %d\n", -7 % 3);   /* -1, pas 2 */
    printf(" 7 %% -3 = %d\n", 7 % -3);  /*  1 */
    return 0;
}

Donc x % 2 == 1 est un test d'imparité cassé quand x peut être négatif - -7 % 2 vaut -1. Utilisez plutôt x % 2 != 0.

Pour les restes en virgule flottante, % est une erreur de compilation ; utilisez fmod() de math.h.

Affectation et affectation composée

= stocke une valeur. Les formes composées combinent une opération et le stockage :

#include <stdio.h>

int main(void) {
    int x = 10;

    x += 5;   printf("x += 5   -> %d\n", x);   /* 15 */
    x -= 3;   printf("x -= 3   -> %d\n", x);   /* 12 */
    x *= 2;   printf("x *= 2   -> %d\n", x);   /* 24 */
    x /= 4;   printf("x /= 4   -> %d\n", x);   /* 6  */
    x %= 4;   printf("x %%= 4   -> %d\n", x);  /* 2  */
    return 0;
}

x += 5 signifie x = x + 5, mais il n'évalue x qu'une fois - ce qui compte quand la cible est quelque chose comme arr[compute_index()].

L'affectation est elle-même une expression qui produit la valeur affectée, c'est pourquoi a = b = c = 0 fonctionne (l'affectation va de droite à gauche) et pourquoi l'erreur = contre == compile silencieusement.

Incrémentation et décrémentation

++ ajoute un, -- en retire un. Chacun existe en forme préfixe et postfixe :

#include <stdio.h>

int main(void) {
    int i = 5;
    int a = i++;    /* a recoit 5 (l'ancienne valeur), puis i devient 6 */
    printf("postfixe : a = %d, i = %d\n", a, i);

    int j = 5;
    int b = ++j;    /* j devient 6 d'abord, puis b recoit 6 */
    printf("prefixe  : b = %d, j = %d\n", b, j);

    int k = 5;
    k++;            /* en instruction isolee, identique a ++k */
    printf("instruction : k = %d\n", k);
    return 0;
}

En instruction isolée, les deux sont interchangeables, et i++ est le choix conventionnel dans un en-tête de for sans autre raison que la tradition.

Ce que vous ne devez pas faire, c'est utiliser une variable plus d'une fois dans une expression où elle est aussi modifiée :

int i = 5;
int x = i++ + i++;      /* comportement indefini */
arr[i] = i++;           /* comportement indefini */
printf("%d %d", i++, i);/* comportement indefini */

Le C ne définit pas l'ordre d'évaluation de ces sous-expressions, donc le résultat n'est pas simplement non spécifié - c'est le comportement de tout le programme qui est indéfini. Coupez l'instruction en deux et l'ambiguïté disparaît.

Les opérateurs de comparaison

Il y en a six, et tous produisent un int : 1 pour vrai et 0 pour faux.

#include <stdio.h>

int main(void) {
    int a = 5, b = 8;

    printf("a == b : %d\n", a == b);   /* 0 */
    printf("a != b : %d\n", a != b);   /* 1 */
    printf("a <  b : %d\n", a <  b);   /* 1 */
    printf("a >  b : %d\n", a >  b);   /* 0 */
    printf("a <= 5 : %d\n", a <= 5);   /* 1 */
    printf("a >= 9 : %d\n", a >= 9);   /* 0 */
    return 0;
}

Le fait que le résultat soit un simple int plutôt qu'un type booléen dédié est une caractéristique définitoire du C - voir les booléens en C pour ce qui en découle, y compris le bug = contre ==.

Deux erreurs de comparaison sont propres au C. Le chaînage ne fonctionne pas comme les mathématiques le suggèrent : if (1 < x < 10) est toujours vrai, car 1 < x s'évalue à 0 ou 1 puis cela est comparé à 10. Écrivez if (x > 1 && x < 10). Et comparer des chaînes avec == compare des pointeurs, pas du texte - utilisez strcmp de string.h.

Les opérateurs logiques

#include <stdio.h>

int main(void) {
    int age = 25;
    int has_license = 1;

    if (age >= 18 && has_license) {
        printf("Peut conduire\n");
    }

    if (age < 13 || age > 65) {
        printf("Billet a tarif reduit\n");
    } else {
        printf("Plein tarif\n");
    }

    printf("!has_license = %d\n", !has_license);   /* 0 */
    printf("!0 = %d\n", !0);                       /* 1 */
    return 0;
}

&& est le ET, || le OU, ! le NON. Tous trois traitent toute valeur non nulle comme vraie.

Ils évaluent en court-circuit : && s'arrête dès qu'un opérande est faux, et || dès qu'un est vrai. Le reste n'est jamais évalué, ce qui n'est pas qu'une optimisation - c'est une garantie sur laquelle vous pouvez compter pour la sûreté :

#include <stdio.h>

int is_safe(int *p) {
    /* Si p est NULL, *p n'est jamais evalue - le && s'arrete avant. */
    return p != NULL && *p > 0;
}

int main(void) {
    int value = 7;
    printf("avec un vrai pointeur : %d\n", is_safe(&value));
    printf("avec NULL :             %d\n", is_safe(NULL));
    return 0;
}

Inversez l'ordre de ces deux tests et l'appel avec NULL déréférence un pointeur nul et plante. Protégez d'abord, utilisez ensuite - l'ordre dans une chaîne && fait partie de la logique.

L'opérateur conditionnel

Le seul opérateur à trois opérandes du C choisit entre deux valeurs :

#include <stdio.h>

int main(void) {
    int a = 12, b = 30;

    int max = (a > b) ? a : b;
    printf("max = %d\n", max);

    printf("%d element%s\n", a, (a == 1) ? "" : "s");
    return 0;
}

condition ? valeur_si_vrai : valeur_si_faux. C'est une expression, elle tient donc là où une instruction if ne peut pas - dans un argument de printf, dans un initialiseur. Gardez-la courte ; les conditionnels imbriqués deviennent vite illisibles.

Les opérateurs bit à bit, brièvement

Ils travaillent sur les bits individuels d'un entier :

#include <stdio.h>

int main(void) {
    unsigned int a = 12;   /* 1100 en binaire */
    unsigned int b = 10;   /* 1010 */

    printf("a & b  = %u\n", a & b);    /* 8  - 1000, ET */
    printf("a | b  = %u\n", a | b);    /* 14 - 1110, OU  */
    printf("a ^ b  = %u\n", a ^ b);    /* 6  - 0110, OU exclusif */
    printf("~a     = %u\n", ~a);       /* NON - inverse chaque bit */
    printf("a << 2 = %u\n", a << 2);   /* 48 - decalage a gauche, multiplie par 4 */
    printf("a >> 2 = %u\n", a >> 2);   /* 3  - decalage a droite, divise par 4 */
    return 0;
}

Ils servent aux drapeaux, aux masques et aux registres matériels. Deux mises en garde : & et | ne sont pas && et || (ils n'évaluent pas en court-circuit et travaillent bit à bit), et décaler une valeur signée ou décaler de plus que la largeur du type est indéfini. Utilisez des types non signés pour le travail sur les bits.

La précédence

Quand une expression n'a pas de parenthèses, cette table décide de ce qui s'attache à quoi. La précédence la plus forte d'abord :

Les conséquences pratiques :

a + b * c       /* signifie a + (b * c) */
a < b == c < d  /* signifie (a < b) == (c < d) - rarement ce que vous vouliez */
x & 1 == 0      /* signifie x & (1 == 0), c.-a-d. x & 0 - un bug classique */
*p++            /* signifie *(p++) - dereferencer p, puis l'avancer */

Cette troisième ligne mérite d'être mémorisée : == s'attache plus fort que &, donc les tests de masque de bits ont besoin de parenthèses - (x & 1) == 0.

Personne ne retient les quinze niveaux, et personne n'en a besoin. Retenez que * bat +, que les comparaisons battent && qui bat ||, et que tout le reste reçoit des parenthèses :

if ((flags & MASK) != 0 && (count > 0 || force)) { ... }

Cette ligne a des parenthèses redondantes et s'en porte mieux.