Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C

Moins unaire en C

Le moins unaire calcule l’opposé d’un opérande arithmétique après les promotions entières. Si le type du résultat est non signé, la négation suit les règles de l’arithmétique modulaire. Si c’est un type entier signé, la possibilité de représenter l’opposé dépend de la valeur de l’opérande et de la plage de ce type.

Version : ISO C23; implementation support may vary

Syntaxe

-operand
-(expression)

-x utilise le moins unaire, un opérateur préfixe à un seul opérande arithmétique. Il ne modifie pas x. En revanche, a - b soustrait un opérande à un autre. Dans -1, - est un opérateur appliqué à la constante entière 1, et non une partie de cette constante.

Les promotions entières s’appliquent et le résultat a le type obtenu après promotion. unsigned char est promu en int si int peut représenter toutes ses valeurs, sinon en unsigned int. Les valeurs ordinaires de type _BitInt échappent à ces promotions ; les champs de bits _BitInt suivent une règle distincte. Si le type résultant est non signé, la négation se calcule modulo son maximum plus un : -1u == UINT_MAX. En C23, -INT_MIN a un comportement indéfini : l’opposé de INT_MIN n’est pas représentable en int. INT_MIN, INT_MAX et UINT_MAX proviennent de <limits.h>.

qsort, déclaré dans <stdlib.h>, reçoit un pointeur vers une fonction de comparaison de type int (*)(const void *, const void *). Ses arguments pointent vers les éléments comparés ; pour un tableau d’int, on les lit via const int *. La fonction renvoie une valeur négative, nulle ou positive selon que le premier élément est inférieur, égal ou supérieur au second. a - b peut dépasser la plage de int, par exemple avec INT_MAX et INT_MIN ; des comparaisons qui renvoient -1, 0 ou 1 évitent ce problème. C ne garantit pas la stabilité de qsort : l’ordre des éléments jugés égaux n’est pas spécifié.

La recherche renvoie un indice non négatif, ou -1 si la clé est absente. NULL marque la fin du tableau de pointeurs vers des chaînes. Le test i < INT_MAX avant l’accès borne la recherche et empêche le dépassement du compteur de type int. Le tableau doit fournir un terminateur NULL accessible ou au moins INT_MAX entrées accessibles.

Exemples

#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int compare_int(const void *left, const void *right)
{
    const int a = *(const int *)left;
    const int b = *(const int *)right;
    return a < b ? -1 : a > b ? 1 : 0;
}

static int find_token(const char *const tokens[], const char *key)
{
    for (int i = 0; i < INT_MAX && tokens[i] != NULL; ++i) {
        if (strcmp(tokens[i], key) == 0) {
            return i;
        }
    }
    return -1;
}

int main(void)
{
    int values[] = {INT_MAX, 0, INT_MIN};
    const char *const tokens[] = {"red", "blue", NULL};

    printf("extremes: %d\n", compare_int(&values[2], &values[0]));
    qsort(values, sizeof values / sizeof values[0], sizeof values[0],
          compare_int);
    printf("sorted: %d\n",
           values[0] == INT_MIN && values[1] == 0 && values[2] == INT_MAX);
    printf("found: %d\n", find_token(tokens, "blue"));
    printf("missing: %d\n", find_token(tokens, "green"));
    return 0;
}

Résultat

extremes: -1
sorted: 1
found: 1
missing: -1

La comparaison des extrêmes donne `-1` sans soustraction. `sorted: 1` confirme l’ordre attendu. `blue` est à l’indice `1` ; l’absence de `green` donne `-1`.

Leçons associées

  • C · Leçon 88 · Avancé · Version : 3
  • C · Leçon 90 · Avancé · Version : 3

Sources