Langage C : types, pointeurs et mémoire

Le C est le langage « proche de la machine » du programme MP2I : il impose de comprendre comment les données sont représentées et où elles vivent en mémoire. Cette fiche rassemble ce qu'il faut maîtriser pour écrire des programmes corrects et répondre aux questions de cours des concours.

Les entiers signés sont codés en **complément à deux** : sur $n$ bits, on représente les entiers de $-2^{n-1}$ à $2^{n-1}-1$, et l'opposé de $x$ s'obtient en inversant les bits puis en ajoutant 1. L'arithmétique **non signée** est définie modulo $2^n$ ; le **débordement signé** est en revanche un comportement indéfini.

Les flottants IEEE 754 stockent un signe, un exposant et une mantisse binaire : double = 1 + 11 + 52 bits, précision relative $\approx 2,2\cdot 10^{-16}$. La plupart des décimaux (0,1 ; 0,2) ne sont pas représentables exactement.

Les booléens sont des entiers : 0 est faux, tout le reste est vrai. Les opérateurs && et || sont évalués paresseusement (l'opérande droit n'est évalué que si nécessaire), ce qui autorise p != NULL && p->val > 0.

Un tableau statique int t[10]; est un bloc contigu de 10 entiers ; les indices valides vont de 0 à 9 et aucun contrôle n'est fait à l'exécution. sizeof(t) vaut 10 * sizeof(int) tant que t est un tableau dans la portée courante.

Passé à une fonction, un tableau décroît en pointeur vers son premier élément : void f(int t[], int n) est strictement équivalent à void f(int *t, int n). La fonction ne connaît pas la taille, qu'il faut transmettre explicitement.

Une chaîne est un tableau de char terminé par le caractère nul '\0' : "abc" occupe 4 octets et strlen("abc") vaut 3. Un tableau prévu pour $n$ caractères doit avoir $n+1$ cases. Une chaîne littérale (char *s = "bonjour";) est en lecture seule : la modifier est un comportement indéfini ; char s[] = "bonjour"; crée une copie modifiable.

Un pointeur est une variable qui contient une adresse. Avec int x = 3; int *p = &x; :

• &x est l'adresse de x ;
• p est la valeur stockée à l'adresse contenue dans p, c'est-à-dire x ; p = 10; modifie x.

L'arithmétique des pointeurs compte en éléments : si p est un int , p + 1 avance de sizeof(int) octets, et t[i] est défini comme (t + i). La taille d'un pointeur (8 octets en 64 bits) ne dépend pas du type pointé.

Le passage d'arguments se fait par valeur : une fonction reçoit des copies. Pour modifier une variable de l'appelant, on passe son adresse :

void swap(int *a, int *b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}
/* appel : swap(&x, &y); */

NULL est l'adresse conventionnelle « ne pointe vers rien » ; la déréférencer provoque en pratique une erreur de segmentation.

Chaque appel de fonction empile un **cadre** contenant ses variables locales ; il est détruit au `return`. Renvoyer l'adresse d'une variable locale (`return &x;`, ou un tableau local) produit un **pointeur pendant**. La pile est petite (quelques Mo) : une récursion trop profonde ou un tableau local énorme provoque un débordement de pile.

#include <stdlib.h>
int *t = malloc(n * sizeof(int));   /* n octets * sizeof, non initialisés */
if (t == NULL) { /* traiter l'échec */ }
/* ... utilisation de t[0] .. t[n-1] ... */
free(t);
t = NULL;

• malloc(n) renvoie NULL en cas d'échec et n'initialise pas la mémoire ; calloc(n, taille) met tout à zéro.
• free(p) libère un bloc obtenu par malloc ; free(NULL) est sans effet.
• Fuite mémoire : perdre l'adresse d'un bloc sans l'avoir libéré. Double free et utilisation après free : comportements indéfinis.

typedef struct cell {
    int val;
    struct cell *next;   /* l'alias 'cell' n'existe pas encore ici */
} cell;

cell *c = malloc(sizeof(cell));
c->val = 42;            /* équivaut à (*c).val = 42 */
c->next = NULL;

L'opérateur -> accède à un champ via un pointeur. Les listes chaînées, piles et arbres du programme se construisent sur ce modèle : chaque maillon est alloué sur le tas et libéré explicitement.

Une variable déclarée dans un bloc n'est visible que dans ce bloc et masque toute variable homonyme extérieure. Une globale vit pendant tout le programme ; static dans une fonction conserve la valeur entre deux appels. Le préprocesseur traite #include et #define avant la compilation ; on compile toujours avec gcc -Wall -Wextra pour détecter les erreurs classiques (if (x = 0), variable non utilisée, conversion implicite douteuse).

Entrées-sorties : printf("%d %f %s\n", n, x, s) ; scanf("%d", &n) exige l'adresse ; fichiers avec FILE *f = fopen("nom", "r"), test f != NULL, lecture par fscanf ou fgets (qui renvoie NULL en fin de fichier), puis fclose(f).

1. 1Accès hors bornes d'un tableau.
2. 2Lecture d'une variable ou d'une case non initialisée.
3. 3Déréférencement de NULL ou d'un pointeur pendant.
4. 4Débordement d'entier signé, division par zéro.
5. 5free double, utilisation après free, modification d'une chaîne littérale.
6. 6Expressions sans ordre d'évaluation défini comme i = i++.

• Toujours passer la taille avec un tableau et vérifier les bornes dans les boucles (for (int i = 0; i < n; i++)).
• Pour chaque malloc : tester NULL, prévoir le free correspondant, remettre le pointeur à NULL après libération.
• Pour modifier une variable dans une fonction : passer son adresse. Pour une structure volumineuse : passer un pointeur plutôt qu'une copie.
• Dans une question « que affiche ce programme ? », suivre à la main les adresses et les valeurs, et repérer les divisions entières, les débordements et les chaînes sans '\0'.
• Savoir énoncer la différence pile/tas et la notion de comportement indéfini : ce sont des questions de cours fréquentes à l'oral.