Programmation C : Bits, pointeurs et bonnes pratiques

Introduction

La programmation en C est une discipline exigeante qui nécessite une approche minutieuse et une compréhension approfondie des concepts fondamentaux du langage. Contrairement aux langages modernes qui protègent le développeur de nombreuses erreurs, le C offre un accès direct à la mémoire et aux ressources système, ce qui implique une responsabilité accrue.

Qu’est-ce que l’Undefined Behavior (UB) ?

L’Undefined Behavior (comportement indéfini) est l’un des concepts les plus importants et les plus dangereux en C. Lorsque le standard C indique qu’une opération a un comportement indéfini, cela signifie que le compilateur est libre de faire absolument n’importe quoi : le programme peut sembler fonctionner correctement, planter immédiatement, corrompre silencieusement des données, ou même “voyager dans le temps” (le compilateur peut supposer que l’UB ne se produit jamais et optimiser en conséquence).

Les causes les plus fréquentes d’UB incluent :

• Dépassement d’entiers signés (signed integer overflow)
• Décalage de bits sur des valeurs négatives ou au-delà de la taille du type
• Déréférencement de pointeurs nuls ou invalides
• Accès hors limites de tableaux
• Modification multiple d’une variable entre deux points de séquence
• Violation des règles d’aliasing strict

Pourquoi connaître ces pièges ?

Un développeur C expérimenté doit connaître ces pièges pour plusieurs raisons :

1. Portabilité : Un code qui “fonctionne” sur une plateforme peut échouer sur une autre
2. Sécurité : De nombreuses failles de sécurité (buffer overflow, use-after-free) sont liées à l’UB
3. Performance : Les compilateurs modernes exploitent agressivement l’absence d’UB pour optimiser
4. Maintenance : Un code qui repose sur un comportement indéfini peut casser lors d’une mise à jour du compilateur

Dans ce tutoriel approfondi, nous explorerons les pièges les plus courants : opérations sur les bits, arithmétique des pointeurs, commentaires, comparaison de flottants, et bien d’autres. Chaque section contient des exemples concrets et des solutions éprouvées.

Opérations sur les bits

Les opérations bitwise sont au coeur de nombreux programmes C, notamment pour la manipulation de registres matériels, les protocoles de communication, et l’optimisation de performances. Cependant, elles recèlent plusieurs pièges subtils.

Masques et tests de bits

L’évaluation de champs bits est une opération courante en programmation. Cependant, il est facile de se tromper dans l’utilisation des opérateurs pour vérifier si un bit spécifique est activé ou non. Voici un exemple basique :

bool isUpperBitSet(uint8_t bitField) {
    /* Si le bit supérieur est set, le résultat est 0x80
       que le if évaluera comme true */
    if (bitField & 0x80) {
        return true;
    } else {
        return false;
    }
}

Ce code fonctionne mais peut être amélioré. Voici une version plus explicite et portable :

bool isUpperBitSet(uint8_t bitField) {
    return (bitField & (1U << 7)) != 0;
}

Bonnes pratiques pour les masques de bits :

/* Définition claire des masques avec des constantes nommées */
#define BIT_0  (1U << 0)   /* 0x01 */
#define BIT_1  (1U << 1)   /* 0x02 */
#define BIT_7  (1U << 7)   /* 0x80 */

/* Macros utilitaires pour manipuler les bits */
#define SET_BIT(value, bit)    ((value) |= (bit))
#define CLEAR_BIT(value, bit)  ((value) &= ~(bit))
#define TOGGLE_BIT(value, bit) ((value) ^= (bit))
#define TEST_BIT(value, bit)   (((value) & (bit)) != 0)

/* Utilisation */
uint8_t flags = 0;
SET_BIT(flags, BIT_0);           /* flags = 0x01 */
SET_BIT(flags, BIT_7);           /* flags = 0x81 */
if (TEST_BIT(flags, BIT_7)) {
    printf("Bit 7 est actif\n");
}
CLEAR_BIT(flags, BIT_0);         /* flags = 0x80 */

Shift sur types signés - Attention UB !

Les opérations de décalage (shift) sur des types signés sont une source majeure d’Undefined Behavior. Les règles sont strictes :

Décalage à gauche (<<) sur signed :

• UB si la valeur est négative
• UB si le résultat ne peut pas être représenté dans le type

/* DANGER : Undefined Behavior ! */
int x = -1;
int y = x << 2;  /* UB : shift d'une valeur négative */

int z = 1 << 31; /* UB sur système 32-bit : overflow signed int */

/* CORRECT : utiliser des types unsigned */
unsigned int a = 1U;
unsigned int b = a << 31;  /* OK : 0x80000000 */

Décalage à droite (>>) sur signed :

• Le comportement est implementation-defined (pas UB, mais non portable)
• Certains compilateurs font un arithmetic shift (préserve le signe)
• D’autres font un logical shift (remplit avec des zéros)

int x = -8;
int y = x >> 2;  /* Implementation-defined : peut être -2 ou une grande valeur positive */

/* PORTABLE : utiliser unsigned pour un comportement prévisible */
unsigned int a = 0xFFFFFFF8;  /* -8 en complément à 2 sur 32 bits */
unsigned int b = a >> 2;      /* Toujours 0x3FFFFFFE (logical shift) */

Décalage au-delà de la taille du type :

/* DANGER : UB si le décalage >= nombre de bits du type */
uint32_t x = 1;
uint32_t y = x << 32;  /* UB ! décalage de 32 bits sur un type 32-bit */
uint32_t z = x << 33;  /* UB ! */

/* CORRECT : vérifier la valeur du décalage */
unsigned int shift_amount = 32;
uint32_t result;
if (shift_amount >= 32) {
    result = 0;  /* ou gérer l'erreur */
} else {
    result = x << shift_amount;
}

Promotion implicite des entiers

En C, les opérandes de type plus petit que int sont automatiquement promus vers int avant les opérations arithmétiques. Cela peut causer des surprises :

uint8_t a = 0xFF;
uint8_t b = 0x01;

/* a est promu en int (signé !) avant le shift */
int result = a << 24;  /* Peut être UB sur système 32-bit ! */

/* Explication : 0xFF devient 0x000000FF (int)
   0xFF << 24 = 0xFF000000 qui dépasse INT_MAX sur 32-bit
   => Signed integer overflow = UB */

/* CORRECT : forcer le type unsigned */
uint32_t safe_result = (uint32_t)a << 24;  /* OK : 0xFF000000 */

Autre exemple subtil :

uint16_t x = 0xFFFF;
uint16_t y = 0x0001;

/* x et y sont promus en int (signé) */
int z = x * y;  /* OK : 0xFFFF = 65535 */

/* Mais attention avec des valeurs plus grandes */
uint16_t a = 0x8000;  /* 32768 */
uint16_t b = 0x0002;
int product = a * b;  /* 65536, OK si int est 32-bit */

/* Sur un système où int est 16-bit : OVERFLOW ! */

Règle d’or : Toujours utiliser des suffixes explicites (U, UL, ULL) et des casts pour contrôler les types dans les opérations bitwise :

/* Définir des masques avec le bon type */
#define MASK_32BIT  0xFFFFFFFFU      /* unsigned int */
#define MASK_64BIT  0xFFFFFFFFFFFFFFFFULL  /* unsigned long long */

/* Utiliser des casts explicites */
uint64_t value = (uint64_t)1 << 40;  /* OK */

Arithmétique des pointeurs

L’arithmétique des pointeurs est l’une des fonctionnalités les plus puissantes du C, mais aussi l’une des plus dangereuses. Une mauvaise compréhension peut mener à des bugs subtils, des corruptions de mémoire et des failles de sécurité.

Calcul correct des adresses

Dans la programmation en C, les opérations arithmétiques sur des pointeurs sont interprétées en termes d’éléments, pas d’octets. Lorsque vous ajoutez 1 à un pointeur, vous avancez de sizeof(*ptr) octets en mémoire :

int array[] = {1, 2, 3, 4, 5};
int *ptr = &array[0];

/* ptr + 1 pointe sur array[1], pas sur le prochain octet ! */
printf("array[0] = %d\n", *ptr);        /* 1 */
printf("array[1] = %d\n", *(ptr + 1));  /* 2 */
printf("array[2] = %d\n", *(ptr + 2));  /* 3 */

/* La différence entre deux pointeurs donne le nombre d'éléments */
int *end = &array[4];
ptrdiff_t count = end - ptr;  /* 4 (pas 16 octets !) */

Erreur classique avec sizeof

L’erreur la plus courante est de multiplier par sizeof lors de l’arithmétique des pointeurs :

int array[] = {1, 2, 3, 4, 5};
int *ptr = &array[0];

/* ERREUR COURANTE : double multiplication ! */
int *ptr2 = ptr + sizeof(int) * 2;  /* FAUX ! */

Ce code est problématique car si sizeof(int) vaut 4, l’expression correspond a “8 elements apres array[0]”, ce qui est hors limite et cause un Undefined Behavior. Pour pointer sur le troisieme element, utilisez simplement :

/* CORRECT : l'arithmétique des pointeurs gère déjà la taille */
int *ptr2 = ptr + 2;          /* Pointe sur array[2] */

/* OU avec la notation tableau (équivalent et plus lisible) */
int *ptr3 = &array[2];        /* Même résultat */

Quand utiliser sizeof avec les pointeurs :

/* sizeof est nécessaire pour les opérations sur les octets bruts */
void *raw_ptr = array;
void *offset_ptr = (char *)raw_ptr + sizeof(int) * 2;

/* Ou pour allouer de la mémoire */
int *dynamic_array = malloc(10 * sizeof(int));
if (dynamic_array == NULL) {
    /* Gérer l'erreur d'allocation */
}

Pointeurs void* et conversions

Les pointeurs void* sont des pointeurs génériques qui peuvent pointer sur n’importe quel type, mais l’arithmétique n’est pas définie sur eux (extension GNU uniquement) :

void *vptr = array;

/* ERREUR : arithmétique sur void* non standard */
void *vptr2 = vptr + 2;  /* Extension GNU, non portable ! */

/* CORRECT : caster vers le bon type d'abord */
int *iptr = (int *)vptr;
int *iptr2 = iptr + 2;

/* OU caster vers char* pour des calculs en octets */
char *cptr = (char *)vptr;
char *cptr2 = cptr + sizeof(int) * 2;
void *vptr2 = (void *)cptr2;

Règles de validité des pointeurs

Un pointeur résultant d’une arithmétique doit pointer :

• Sur un élément du tableau, OU
• Sur un élément juste après le dernier (one-past-the-end), OU
• Sur NULL

Tout autre cas est Undefined Behavior :

int array[5] = {1, 2, 3, 4, 5};
int *ptr = array;

/* VALIDE */
int *p0 = ptr;           /* array[0] */
int *p4 = ptr + 4;       /* array[4] */
int *p5 = ptr + 5;       /* one-past-the-end, OK mais ne pas déréférencer ! */

/* UNDEFINED BEHAVIOR */
int *bad1 = ptr - 1;     /* Avant le début du tableau */
int *bad2 = ptr + 6;     /* Trop loin après la fin */
int *bad3 = ptr + 100;   /* Complètement hors limites */

/* On peut comparer one-past-the-end, mais pas le déréférencer */
for (int *p = array; p < ptr + 5; p++) {
    printf("%d ", *p);
}

Soustraction de pointeurs

La soustraction de deux pointeurs n’est valide que s’ils pointent dans le même tableau (ou one-past-the-end) :

int array1[5] = {1, 2, 3, 4, 5};
int array2[5] = {6, 7, 8, 9, 10};

int *p1 = &array1[2];
int *p2 = &array1[4];

/* VALIDE : même tableau */
ptrdiff_t diff = p2 - p1;  /* 2 */

/* UNDEFINED BEHAVIOR : tableaux différents */
int *p3 = &array2[0];
ptrdiff_t bad_diff = p3 - p1;  /* UB ! Résultat imprévisible */

Commentaires en C

Les commentaires semblent simples, mais ils cachent quelques pièges qui peuvent surprendre même les développeurs expérimentés.

Les commentaires /* */ ne s’imbriquent pas

Les commentaires multi-lignes en C, délimités par /* et */, ne s’imbriquent pas. Le premier */ rencontré termine le commentaire, peu importe le nombre de /* précédents :

/* Ceci est un commentaire
   /* Ceci n'est PAS un commentaire imbriqué */
   Cette ligne cause une erreur de compilation ! */

Le problème se manifeste souvent quand on veut “commenter” temporairement du code qui contient déjà des commentaires :

/*
 * max(): Trouve le plus grand entier dans un tableau.
 * arr: Le tableau d'entiers à parcourir.
 * num: Le nombre d'éléments dans arr.
 */
int max(int arr[], int num) {
    int max = arr[0];
    /* Parcourir tous les éléments */
    for (int i = 0; i < num; i++) {
        if (arr[i] > max) max = arr[i];
    }
    return max;
}

Si vous essayez d’entourer ce code avec /* ... */, le commentaire se terminera prématurément au premier */ du commentaire interne :

/*  <-- Début du commentaire
/*
 * max(): Trouve le plus grand entier...
 */  <-- FIN DU COMMENTAIRE ! Le reste est du code normal
int max(int arr[], int num) {  /* ERREUR : code non commenté */
    ...
}
*/  <-- ERREUR : */ sans /* correspondant

Solution avec #if 0

La solution standard est d’utiliser les directives du préprocesseur #if 0 … #endif, qui peuvent s’imbriquer correctement :

#if 0
/*
 * max(): Trouve le plus grand entier dans un tableau.
 * arr: Le tableau d'entiers à parcourir.
 * num: Le nombre d'éléments dans arr.
 */
int max(int arr[], int num) {
    int max = arr[0];
    /* Parcourir tous les éléments */
    for (int i = 0; i < num; i++) {
        if (arr[i] > max) max = arr[i];
    }
    return max;
}
#endif

Avantages de #if 0 :

• S’imbrique correctement avec d’autres #if / #endif
• Le code reste syntaxiquement correct (coloration syntaxique fonctionne)
• Facile à réactiver : changer #if 0 en #if 1
• Le préprocesseur ignore complètement le bloc

Variante avec macro nommée :

#define DISABLE_MAX 1  /* Mettre 0 pour réactiver */

#if DISABLE_MAX
/* Code désactivé */
int max(int arr[], int num) { ... }
#endif

Commentaires // en C99

Depuis C99, les commentaires style C++ (//) sont officiellement supportés :

// Commentaire sur une seule ligne (C99+)
int x = 42;  // Commentaire en fin de ligne

/* Commentaire multi-ligne classique
   toujours valide et nécessaire pour
   les blocs de plusieurs lignes */

Avantages des commentaires // :

• Pas de problème d’imbrication
• Plus facile à commenter/décommenter une ligne
• Intention claire : une seule ligne

Attention en C89/C90 :

/* En mode strict C89, // n'est pas valide ! */
// gcc -std=c89 -pedantic génère un warning/erreur

Piège : le backslash en fin de ligne

// Attention : le backslash continue le commentaire \
   sur la ligne suivante ! Cette ligne est commentée.
int x = 5;  // Cette ligne est du code normal

Recommandations pour les commentaires

/* Style recommandé pour la documentation de fonction */
/**
 * @brief Trouve le maximum dans un tableau
 * @param arr Tableau d'entiers à parcourir
 * @param num Nombre d'éléments (doit être > 0)
 * @return Le plus grand entier trouvé
 * @note Comportement indéfini si num <= 0
 */
int max(int arr[], int num);

/* Utiliser // pour les commentaires inline */
int count = 0;  // Compteur initialisé à zéro

/* Utiliser #if 0 pour désactiver du code */
#if 0
code_desactive();
#endif

Comparaison de nombres en virgule flottante

Les types flottants en C (float, double et long double) ne peuvent pas représenter exactement tous les nombres réels. Cette limitation fondamentale de la représentation IEEE 754 est source de nombreux bugs subtils.

Le problème de précision IEEE 754

Les nombres flottants sont stockés en notation scientifique binaire avec une précision finie. Certains nombres décimaux simples comme 0.1 n’ont pas de représentation binaire exacte :

double a = 0.1;
/* En mémoire, a vaut approximativement :
   0.1000000000000000055511151231257827021181583404541015625 */

/* Cette comparaison peut échouer ! */
if (a + a + a + a + a + a + a + a + a + a == 1.0) {
    printf("10 * 0.1 is indeed 1.0.\n");  /* Peut ne jamais s'afficher */
} else {
    printf("10 * 0.1 != 1.0 (surprise !)\n");  /* Probable */
}

Cela n’est pas garanti car la représentation numérique de 0.1 est imprécise. L’accumulation de ces petites erreurs rend la comparaison directe avec == dangereuse.

Epsilon absolu vs relatif

La solution naive utilise un epsilon absolu :

#include <float.h>
#include <math.h>

/* Solution naive avec epsilon absolu */
int nearly_equal_absolute(double a, double b, double epsilon) {
    return fabs(a - b) < epsilon;
}

/* Utilisation avec DBL_EPSILON */
if (fabs(result - expected) < DBL_EPSILON) {
    printf("Les valeurs sont proches\n");
}

Problème : DBL_EPSILON (environ 2.2e-16) est la plus petite différence entre 1.0 et le prochain nombre representable. Mais pour des grandes valeurs, cette tolerance est beaucoup trop petite :

double big = 1e15;
double slightly_bigger = big + 1.0;

/* DBL_EPSILON est ~2.2e-16, mais la différence est 1.0 */
if (fabs(big - slightly_bigger) < DBL_EPSILON) {
    /* Ne sera JAMAIS vrai pour des grandes valeurs ! */
}

Solution : epsilon relatif

/* Epsilon relatif : compare en proportion de la magnitude */
int nearly_equal_relative(double a, double b, double rel_epsilon) {
    double diff = fabs(a - b);
    double largest = fmax(fabs(a), fabs(b));
    return diff <= largest * rel_epsilon;
}

ULP (Units in Last Place)

La méthode la plus précise pour comparer des flottants utilise les ULP (Units in Last Place), qui mesurent la distance entre deux nombres en termes du plus petit incrément representable :

#include <stdint.h>
#include <math.h>

/* Comparer deux doubles avec une tolérance en ULPs */
int nearly_equal_ulps(double a, double b, int max_ulps) {
    /* Cas spéciaux */
    if (a == b) return 1;  /* Gère +0 == -0 et identiques */
    if (isnan(a) || isnan(b)) return 0;  /* NaN != tout */
    if ((a < 0) != (b < 0)) return 0;  /* Signes différents */

    /* Interpréter les bits comme des entiers */
    int64_t ia, ib;
    memcpy(&ia, &a, sizeof(double));
    memcpy(&ib, &b, sizeof(double));

    /* Calculer la différence en ULPs */
    int64_t ulps_diff = llabs(ia - ib);

    return ulps_diff <= max_ulps;
}

Fonctions de comparaison robustes

Voici une fonction de comparaison combinant plusieurs approches :

#include <float.h>
#include <math.h>
#include <stdbool.h>

/**
 * Compare deux doubles avec tolérance absolue ET relative
 * @param a Premier nombre
 * @param b Deuxième nombre
 * @param abs_epsilon Tolérance absolue (pour valeurs proches de 0)
 * @param rel_epsilon Tolérance relative (pour grandes valeurs)
 * @return true si les nombres sont "égaux" selon les tolérances
 */
bool nearly_equal(double a, double b, double abs_epsilon, double rel_epsilon) {
    /* Cas identiques (gère aussi +0 == -0) */
    if (a == b) return true;

    /* Cas NaN */
    if (isnan(a) || isnan(b)) return false;

    /* Cas infini */
    if (isinf(a) || isinf(b)) return false;

    double diff = fabs(a - b);

    /* Tolérance absolue pour les petites valeurs */
    if (diff < abs_epsilon) return true;

    /* Tolérance relative pour les grandes valeurs */
    double largest = fmax(fabs(a), fabs(b));
    return diff <= largest * rel_epsilon;
}

/* Utilisation recommandée */
int main(void) {
    double result = 0.1 + 0.1 + 0.1 + 0.1 + 0.1 +
                    0.1 + 0.1 + 0.1 + 0.1 + 0.1;
    double expected = 1.0;

    /* Tolérance absolue de 1e-9, relative de 1e-6 */
    if (nearly_equal(result, expected, 1e-9, 1e-6)) {
        printf("10 * 0.1 est effectivement proche de 1.0\n");
    }

    return 0;
}

Cas spéciaux à gérer

/* Infinis */
double pos_inf = 1.0 / 0.0;   /* +inf */
double neg_inf = -1.0 / 0.0;  /* -inf */
pos_inf == pos_inf;  /* true */
pos_inf == neg_inf;  /* false */

/* NaN (Not a Number) */
double nan_val = 0.0 / 0.0;   /* NaN */
nan_val == nan_val;  /* false ! NaN n'est égal à rien */
isnan(nan_val);      /* true - utilisez cette fonction */

/* Zéros signés */
double pos_zero = +0.0;
double neg_zero = -0.0;
pos_zero == neg_zero;  /* true (ils sont égaux !) */
1.0 / pos_zero;        /* +inf */
1.0 / neg_zero;        /* -inf (comportement différent !) */

Résumé des comparaisons flottantes

Situation	Méthode recommandée
Valeurs proches de zéro	Epsilon absolu
Valeurs de magnitude similaire	Epsilon relatif
Précision maximale	Comparaison ULP
Usage général	Combinaison abs + rel
Égalité stricte avec constante	Direct == (si constante exacte)

Autres pièges courants

Au-dela des sujets traites en detail ci-dessus, plusieurs autres pieges meritent d’etre mentionnes.

Integer overflow (UB pour signed)

Le dépassement d’entier signé est l’un des UB les plus courants et les plus dangereux :

#include <limits.h>

int a = INT_MAX;

/* UNDEFINED BEHAVIOR : overflow sur signed */
int b = a + 1;  /* UB ! Le compilateur peut faire n'importe quoi */

/* Le compilateur peut supposer que l'overflow n'arrive jamais */
if (a + 1 > a) {
    /* Le compilateur peut optimiser ce test en "toujours vrai"
       car mathématiquement x + 1 > x est toujours vrai
       (en ignorant l'overflow car c'est UB) */
}

Solution : utiliser unsigned ou vérifier avant l’opération

/* Les unsigned ont un comportement défini (wrap-around) */
unsigned int ua = UINT_MAX;
unsigned int ub = ua + 1;  /* Défini : ub vaut 0 */

/* Vérification avant addition pour signed */
int safe_add(int a, int b, int *result) {
    if ((b > 0 && a > INT_MAX - b) ||
        (b < 0 && a < INT_MIN - b)) {
        return -1;  /* Overflow détecté */
    }
    *result = a + b;
    return 0;
}

Buffer overflow

Le dépassement de buffer est la source de nombreuses failles de sécurité :

char buffer[10];

/* DANGER : pas de vérification de taille */
strcpy(buffer, user_input);  /* Buffer overflow si input > 9 caractères */

/* DANGER : gets() ne vérifie jamais la taille (OBSOLÈTE en C11) */
gets(buffer);  /* NE JAMAIS UTILISER */

/* CORRECT : utiliser les versions sécurisées */
strncpy(buffer, user_input, sizeof(buffer) - 1);
buffer[sizeof(buffer) - 1] = '\0';  /* Assurer la terminaison */

/* OU avec snprintf */
snprintf(buffer, sizeof(buffer), "%s", user_input);

/* OU avec fgets pour l'entrée */
fgets(buffer, sizeof(buffer), stdin);

Règles pour éviter les buffer overflows :

/* 1. Toujours utiliser les fonctions avec limite de taille */
size_t len = strlen(src);
if (len >= sizeof(dest)) {
    /* Gérer l'erreur */
}
memcpy(dest, src, len + 1);

/* 2. Utiliser sizeof pour les tableaux locaux */
char local[256];
snprintf(local, sizeof(local), "Message: %s", msg);

/* 3. Valider les indices avant accès */
int array[100];
if (index >= 0 && index < 100) {
    value = array[index];
}

Points de séquence et effets de bord

En C, l’ordre d’évaluation des expressions n’est pas toujours défini. Un point de séquence est un moment où tous les effets de bord précédents sont garantis d’être terminés.

int i = 0;

/* UNDEFINED BEHAVIOR : i modifié deux fois entre points de séquence */
i = i++;        /* UB ! */
i = ++i;        /* UB ! */

/* UNDEFINED BEHAVIOR : ordre d'évaluation non défini */
int a = i++ + i++;  /* UB ! Quel i++ est évalué en premier ? */

/* UNDEFINED BEHAVIOR : modification et lecture sans point de séquence */
array[i] = i++;     /* UB ! L'indice utilise i avant ou après ++ ? */

/* AUSSI UB : dans les appels de fonction */
printf("%d %d\n", i++, i++);  /* UB ! Ordre non défini */

Points de séquence en C :

• Fin d’une expression complète (;)
• Avant l’appel d’une fonction (après évaluation des arguments)
• &&, ||, ?:, , (opérateur virgule)

Code correct :

int i = 0;

/* Séparer les modifications */
int temp = i;
i++;
int a = temp + i;

/* Ou utiliser des expressions séparées */
i++;
array[i] = i;

/* Appels de fonction clairs */
int x = i++;
int y = i++;
printf("%d %d\n", x, y);

Aliasing strict

Le C a des règles strictes sur quels types de pointeurs peuvent accéder à quelles données :

/* UNDEFINED BEHAVIOR : violation d'aliasing strict */
float f = 3.14f;
int *pi = (int *)&f;
int bits = *pi;  /* UB ! int* ne peut pas accéder à un float */

/* CORRECT : utiliser memcpy ou union */
float f = 3.14f;
int bits;
memcpy(&bits, &f, sizeof(bits));  /* OK */

/* OU avec union (C99+) */
union {
    float f;
    int i;
} u;
u.f = 3.14f;
int bits = u.i;  /* OK en C99 */

Exception : char* peut aliaser n’importe quel type :

float f = 3.14f;
unsigned char *bytes = (unsigned char *)&f;
/* OK : char* peut lire n'importe quelle mémoire */
for (size_t i = 0; i < sizeof(f); i++) {
    printf("%02x ", bytes[i]);
}

Bonnes pratiques

Pour eviter les pieges courants en C, voici un resume des bonnes pratiques essentielles.

Compilation avec warnings

# GCC : activer tous les warnings utiles
gcc -Wall -Wextra -Wpedantic -Werror -std=c11 source.c

# Clang : warnings supplémentaires
clang -Wall -Wextra -Wpedantic -Weverything -std=c11 source.c

# Options supplémentaires recommandées
gcc -Wall -Wextra -Wconversion -Wshadow -Wformat=2 \
    -Wuninitialized -Wnull-dereference -std=c11 source.c

Utiliser les types appropriés

/* Utiliser les types à taille fixe pour la portabilité */
#include <stdint.h>
uint32_t counter;    /* Toujours 32 bits */
int64_t big_number;  /* Toujours 64 bits */

/* Utiliser size_t pour les tailles et indices */
size_t array_size = sizeof(array) / sizeof(array[0]);
for (size_t i = 0; i < array_size; i++) { ... }

/* Utiliser unsigned pour les opérations bitwise */
uint32_t flags = 0;
flags |= (1U << 31);  /* OK, pas d'UB */

/* Utiliser bool pour les valeurs booléennes (C99) */
#include <stdbool.h>
bool is_valid = true;

Initialiser les variables

/* Toujours initialiser les variables */
int count = 0;
char buffer[256] = {0};  /* Tout à zéro */
int *ptr = NULL;

/* Vérifier les pointeurs avant utilisation */
if (ptr != NULL) {
    *ptr = value;
}

/* Utiliser des valeurs par défaut sensées */
struct config {
    int timeout;
    int retries;
    char *hostname;
};

struct config cfg = {
    .timeout = 30,
    .retries = 3,
    .hostname = NULL
};

Vérifier les retours de fonctions

/* Toujours vérifier malloc */
int *data = malloc(n * sizeof(int));
if (data == NULL) {
    fprintf(stderr, "Erreur d'allocation\n");
    return -1;
}

/* Vérifier les fonctions d'I/O */
FILE *fp = fopen("file.txt", "r");
if (fp == NULL) {
    perror("fopen");
    return -1;
}

/* Vérifier les conversions */
char *endptr;
long value = strtol(str, &endptr, 10);
if (endptr == str || *endptr != '\0') {
    fprintf(stderr, "Conversion invalide\n");
}

Utiliser des outils d’analyse

# Valgrind : détection de fuites mémoire et accès invalides
valgrind --leak-check=full ./programme

# AddressSanitizer (GCC/Clang)
gcc -fsanitize=address -g source.c
./a.out

# UndefinedBehaviorSanitizer
gcc -fsanitize=undefined -g source.c
./a.out

# Analyse statique avec Clang
scan-build gcc source.c

Conclusion

La programmation en C exige une vigilance constante face aux nombreux pieges du langage. Les principaux points a retenir sont :

1. Opérations sur les bits : Utiliser des types unsigned, vérifier les valeurs de décalage
2. Arithmétique des pointeurs : Ne pas multiplier par sizeof, respecter les limites
3. Commentaires : Utiliser #if 0 pour désactiver du code, pas /* */
4. Flottants : Ne jamais comparer avec ==, utiliser des epsilon appropriés
5. Integer overflow : UB pour signed, défini (wrap-around) pour unsigned
6. Buffer overflow : Toujours vérifier les tailles, utiliser les fonctions sécurisées

Tableau récapitulatif des Undefined Behaviors

Piège	Cause	Solution
Signed integer overflow	INT_MAX + 1	Utiliser unsigned ou vérifier avant
Left shift négatif	-1 << n	Utiliser unsigned
Shift >= largeur type	1 << 32 (sur 32-bit)	Vérifier la valeur de shift
Déréférencement NULL	*ptr où ptr == NULL	Vérifier avant
Buffer overflow	array[n] où n >= size	Vérifier les indices
Double modification	i++ + i++	Séparer les expressions
Pointeur hors limites	ptr + n hors tableau	Respecter les bornes
Aliasing strict	*(int*)&float_var	Utiliser memcpy ou union
Division par zéro	a / 0	Vérifier le diviseur
Accès après free	*ptr après free(ptr)	Mettre ptr à NULL après free

En suivant ces bonnes pratiques et en comprenant les subtilités du langage, vous pourrez écrire du code C plus robuste, portable et sécurisé.