Pointeurs et adresses mémoire en C

On peut se représenter la mémoire comme une suite d’octets numérotés. Chaque numéro est une adresse. Un objet comme un int occupe des octets consécutifs, et son adresse désigne son premier octet. Le nom utilisé dans le code source permet au compilateur de trouver cet objet ; le langage n’exige pas qu’une étiquette portant ce nom soit stockée à côté de sa valeur.

Mesurer le stockage avec sizeof

sizeof indique un nombre d’octets et produit une valeur size_t. Utilise %zu pour l’afficher :

int scores[4] = {12, 18, 15, 21};
printf("%zu %zu\n", sizeof scores, sizeof scores[0]);

Avec des int de 4 octets, ce code affiche 16 4. Le premier résultat mesure les quatre éléments ; le second en mesure un seul. sizeof(char) vaut toujours 1. Une disposition courante sur un ordinateur de bureau 64 bits utilise des int de 4 octets, des double de 8 octets et des pointeurs d’objets de 8 octets. D’autres plateformes peuvent être différentes. Même parmi les systèmes 64 bits, long occupe généralement 8 octets sous Linux et macOS, mais 4 sous Windows.

La taille du stockage et la longueur du texte répondent à des questions différentes. Pour char word[20] = "hi";, sizeof word vaut 20, tandis que strlen(word) vaut 2. Le tableau contient toujours 20 éléments, même si sa chaîne n’utilise que deux lettres et un caractère nul de fin de chaîne. Sauf pour les tableaux de longueur variable, ces tailles d’objets sont fixées à la compilation.

Suivre les adresses d’un tableau

Les adresses hexadécimales utilisent les chiffres de 0 à 9, puis de a à f. Le préfixe 0x indique la base 16. Pour un tableau donné à titre d’illustration et commençant à 0x1000, quatre éléments de 4 octets commencent aux adresses suivantes :

0x100C vaut 4 108 en décimal, douze octets après 0x1000. Les éléments d’un tableau ne comportent aucun espace entre eux. L’ordre et l’espacement des variables déclarées séparément ne sont pas garantis ; les adresses réelles affichées peuvent aussi changer d’une exécution à l’autre. Un compilateur peut garder une valeur dans un registre du processeur lorsqu’aucun stockage adressable n’est nécessaire.

Alignement et ordre des octets

L’alignement restreint les adresses auxquelles les objets d’un type peuvent commencer. Une disposition courante place les int de 4 octets à des adresses multiples de 4 et les double de 8 octets à des adresses multiples de 8. Le compilateur assure un alignement adapté aux objets déclarés.

Le boutisme est l’ordre des octets dans une valeur occupant plusieurs octets. Pour un unsigned int de 4 octets contenant 0x12345678, le stockage petit-boutiste donne les octets 78 56 34 12 des adresses les plus basses aux plus hautes ; le stockage gros-boutiste donne 12 34 56 78. Un unsigned char * peut examiner la représentation d’un objet un octet à la fois. L’ordre des octets ne change pas l’ordre des indices du tableau.

Veiller à la durée de vie de l’objet

Une variable locale ordinaire a une durée de stockage automatique : sa durée de vie couvre l’exécution de son bloc. Les implémentations typiques conservent ces objets dans le cadre de pile d’un appel et réutilisent ensuite cet espace de stockage. Les variables globales, les variables static et les littéraux de chaîne existent pendant toute l’exécution du programme. Enregistrer une adresse ne prolonge pas la durée de vie de son objet.

Un pointeur stocke une adresse et possède un type qui décrit l’objet auquel il peut accéder. Déclarer un int * réserve un espace pour un pointeur ; cela ne crée pas un int que ce pointeur pourra utiliser. Donne au pointeur une valeur connue dès sa déclaration.

Obtenir l’adresse d’un objet

int count = 42;
int *p = &count;

L’opérateur d’adressage unaire & obtient l’adresse de count. Si count commence à l’adresse fictive 0x1000, p contient 0x1000, tandis que count contient 42. Le pointeur est lui aussi un objet : &p est l’adresse de la zone de stockage distincte qui contient ce pointeur.

Tu peux obtenir l’adresse d’un élément de tableau, comme &scores[2]. Une constante numérique ou le résultat d’un calcul n’est pas un objet stocké dont tu peux obtenir l’adresse de cette façon : &42 et &(count + 1) sont invalides. L’expression binaire a & b utilise le même symbole pour le ET bit à bit ; le nombre d’opérandes indique de quelle opération il s’agit.

Lire chaque déclarateur

Les caractères blancs ne changent aucun de ces types. int* p et int *p sont équivalents. Déclarer un pointeur par ligne rend son étoile plus facile à repérer. Sur les ordinateurs de bureau 64 bits courants, un pointeur d’objet occupe 8 octets, mais sa propre taille n’indique pas celle de l’objet qu’il désigne.

Le type pointé compte. Pour double price = 9.5;, utilise double *r = &price;. Initialiser un int * avec &price produit un diagnostic de pointeurs incompatibles. Une conversion explicite qui masque le diagnostic ne rend pas valide un accès à ce double comme un int : le type détermine la manière d’accéder aux octets stockés.

Rediriger un pointeur

int a = 5, b = 8;
int *p = &a;
p = &b;

La dernière affectation remplace l’adresse dans p. Elle ne déplace aucun des deux entiers et ne copie pas la valeur d’un entier dans l’autre. Maintenant, p pointe vers b ; a vaut toujours 5 et b vaut toujours 8. Plusieurs variables de type pointeur peuvent aussi stocker la même adresse.

Utiliser un état vide connu

Un pointeur local non initialisé possède une valeur indéterminée ; on parle parfois de pointeur sauvage. Ne l’examine pas et ne le déréférence pas. Initialise-le avec l’adresse d’un objet valide ou avec NULL, disponible dans des fichiers d’en-tête comme <stddef.h> et <stdio.h> :

int *pending = NULL;
if (pending == NULL) {
    pending = &count;
}

Un pointeur nul ne désigne aucun objet. !pending est un autre test de nullité. Ces tests n’ont de sens que pour des pointeurs initialisés ; ils ne valident ni une adresse quelconque ni un pointeur dont l’objet n’existe plus.

Afficher un pointeur d’objet

printf("%p\n", (void *)p);

%p attend un void * : effectue donc la conversion explicite lorsque tu utilises un pointeur d’objet typé. Sa représentation à l’affichage est choisie par l’implémentation et est généralement hexadécimale. %d et %x attendent des arguments entiers de types précis et ne peuvent pas remplacer %p.

L’opérateur de déréférencement unaire * suit un pointeur jusqu’à son objet. Si p pointe vers x, *p désigne x lui-même. Lire *p lit cet objet ; effectuer une affectation à *p le modifie.

Suivre une écriture à travers une adresse

int x = 10;
int *p = &x;
*p = *p + 5;
int y = *p * 2;
printf("%d %d %d\n", x, *p, y);

D’abord, p stocke l’adresse de x. À droite de l’affectation, *p lit 10. Ajouter 5 donne 15, et le *p de gauche stocke 15 dans x. La ligne suivante multiplie la valeur actualisée par 2 : y devient donc 30. La sortie est 15 15 30.

Le contexte distingue les étoiles : int *p déclare un pointeur, l’opérateur unaire dans *p accède à un objet, et *p * 2 contient aussi une multiplication binaire. Pour un objet valide x, *&x désigne x ; pour un pointeur vers un objet valide, &*p redonne la valeur du pointeur.

Distinguer les adresses des contenus

Commence chaque trace avec deux lignes d’information : l’adresse contenue dans chaque pointeur et la valeur contenue dans chaque entier. Supposons que p pointe vers a, qui contient 3, et que q pointe vers b, qui contient 8.

Un schéma mémoire utilise une case pour chaque objet. Indique le nom et l’adresse de l’objet sur sa case, place sa valeur actuelle à l’intérieur et trace une flèche du pointeur vers sa cible. Une affectation d’adresse déplace une flèche ; une affectation à l’objet pointé modifie le contenu de la case cible.

Après p = q, les pointeurs sont des alias de b. Si tu exécutes ensuite *p = 20;, lire *q ou b donne 20. Copier une adresse crée un autre chemin vers le même objet, et non un autre entier.

Vérifier la validité d’un déréférencement

Un pointeur utilisé pour accéder à un objet doit désigner un objet dont la durée de vie n’est pas terminée et d’un type adapté ; pour écrire, l’objet doit aussi être modifiable. Les pointeurs nuls ne désignent aucun objet. Les pointeurs non initialisés n’ont aucune cible connue utilisable. Un pointeur devient pendant lorsque la durée de vie de sa cible prend fin.

Un accès à travers un pointeur invalide est un comportement indéfini : C n’impose aucune exigence sur le résultat. Le programme peut s’arrêter avec une erreur de segmentation, corrompre des données ou sembler fonctionner normalement. Une exécution apparemment réussie ne permet pas d’établir que l’accès était valide.

Pour un pointeur qui peut légitimement être nul, effectue un test avant d’y accéder :

if (p != NULL) {
    *p = 0;
}

Affecter NULL à un pointeur dont tu n’as plus besoin peut éviter une utilisation accidentelle ultérieure de cette variable. Cela ne réinitialise pas les autres alias. Suis séparément la durée de vie de l’objet.

Mettre des parenthèses autour de la valeur visée

L’opérateur postfixé ++ est prioritaire sur l’opérateur unaire *. Ainsi, *p++ signifie *(p++) : il utilise l’ancienne valeur du pointeur pour atteindre une valeur et avance le pointeur. (*p)++ incrémente la valeur pointée et laisse le pointeur en place. *p + 1 lit la valeur et ajoute 1 sans stocker le résultat. Ce sont trois actions différentes.

En C, chaque argument est passé par valeur. Un paramètre est une variable locale initialisée à partir de l’argument. Passer une adresse ne change pas cette règle : la fonction reçoit une copie de l’adresse et cette copie permet d’atteindre l’objet de la fonction appelante.

Comparer deux fonctions de remise à zéro

void reset_copy(int n) {
    n = 0;
}

void reset(int *n) {
    *n = 0;
}

Pour int score = 12;, reset_copy(score) ne modifie que sa variable locale n. score reste égal à 12. L’appel reset(&score) copie l’adresse de score dans le paramètre pointeur n ; l’affectation à *n donne ensuite la valeur 0 à score. Cette technique est souvent appelée passage par adresse, même si le langage continue de passer les arguments par valeur.

L’adresse dans l’appel et le déréférencement dans le corps de la fonction ont des rôles différents. &score indique à la fonction où se trouve l’objet. *n = 0 lui indique ce qu’elle doit y stocker. L’appel reset(score) fournit un entier là où un pointeur est requis et déclenche un diagnostic du compilateur.

Suivre un échange de valeurs

void swap(int *a, int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}

/* Inside a calling function: */
int x = 3, y = 8;
swap(&x, &y);

1. a pointe vers x et b pointe vers y.
2. t conserve la valeur initiale de x, soit 3.
3. *a = *b écrit 8 dans x.
4. *b = t écrit la valeur 3 conservée dans y.

Les deux variables de la fonction appelante changent. Une version qui prend de simples paramètres int a, int b n’échange que des copies. Une version avec des pointeurs qui exécute int *t = a; a = b; b = t; échoue elle aussi à échanger les entiers : elle ne redirige que les paramètres pointeurs locaux.

Fournir plusieurs résultats

Une instruction de retour fournit une valeur, mais des paramètres pointeurs peuvent transmettre des résultats supplémentaires :

void divide(int total, int size, int *q, int *r) {
    *q = total / size;
    *r = total % size;
}

/* size must be positive for these example inputs. */
int q, r;
divide(17, 5, &q, &r);

La division entière donne 3 à q et 2 à r. La fonction appelante fournit deux objets distincts dans lesquels l’écriture est possible. Une autre interface utile renvoie un code indiquant le succès ou l’échec et n’écrit un résultat qu’en cas de succès ; les fonctions appelantes vérifient ce code avant d’utiliser le résultat.

Reconnaître le même schéma dans les appels de bibliothèque

scanf("%d", &age) a besoin de l’adresse de age, car elle y stocke l’entier analysé. Passer age fournit une valeur au lieu du int * requis, ce qui produit un comportement indéfini. Vérifie que scanf renvoie 1 avant d’utiliser la valeur qui vient d’être lue.

Pour le texte, char name[20]; scanf("%19s", name); passe un pointeur vers le premier caractère du tableau. La largeur autorise au maximum 19 caractères en entrée et laisse de la place pour '\0'. L’expression du tableau fournit déjà le pointeur vers un caractère requis.

Un paramètre tableau reçoit de même une adresse, et non une copie du bloc d’éléments. Dans void zero(int *a, size_t n), les affectations à a[i] modifient le tableau de la fonction appelante. Passer l’adresse ne copie qu’un pointeur, ce qui permet aussi aux fonctions en lecture seule d’examiner de grands tableaux sans copier chaque élément.

Une interface utilisant un pointeur doit préciser deux choses : si la fonction peut écrire à travers ce pointeur et combien de temps la zone de stockage pointée reste valide. const répond à la première question. La durée de vie de l’objet répond à la seconde.

Repérer la restriction imposée par const

Un pointeur vers un objet constant limite ce chemin d’accès. Si x a été défini comme un simple int x = 5;, x = 6; reste autorisé même lorsqu’un const int * pointe vers cet objet. Si l’objet lui-même a été défini avec const, tenter de le modifier à travers n’importe quel pointeur constitue un comportement indéfini.

Un pointeur constant conserve une adresse. Il doit être initialisé et son adresse ne peut pas être remplacée ensuite. L’objet situé à cette adresse peut toujours changer si son type le permet. Lis la déclaration à partir du nom en allant vers l’extérieur : int *const p rend p constant ; const int *p protège le int atteint à travers p.

Utilise un paramètre en lecture seule comme const char *s lorsqu’une fonction ne fait qu’examiner une chaîne. Un simple char * peut être passé à ce paramètre sans conversion explicite. La fonction peut avancer son s local, mais une affectation à travers *s est rejetée. Pour revenir à un type qui permet l’écriture, il ne suffit pas de supprimer un avertissement du compilateur : l’objet sous-jacent doit réellement être modifiable.

Renvoyer une position dans la zone de stockage de la fonction appelante

int *find(int *a, size_t n, int target) {
    for (size_t i = 0; i < n; i++) {
        if (a[i] == target) return &a[i];
    }
    return NULL;
}

Pour int v[] = {4, 9, 2, 9};, find(v, 4, 9) renvoie &v[1]. La fonction se termine, mais v appartient à la fonction appelante et y existe toujours. Après avoir vérifié que le résultat diffère de NULL, la fonction appelante peut calculer found - v pour obtenir l’indice 1 ou effectuer l’affectation *found = 0 pour modifier l’élément. Une recherche de 7 renvoie NULL, qui ne doit pas être déréférencé. strchr et strstr utilisent la même convention : un pointeur nul signifie que l’élément n’a pas été trouvé.

Rejeter les adresses de variables locales dont la durée de vie est terminée

int *bad(void) {
    int result = 42;
    return &result;
}

result a une durée de stockage automatique. Sa durée de vie prend fin lorsque l’appel se termine, laissant à la fonction appelante un pointeur pendant. Le compilateur peut émettre un avertissement et tout accès ultérieur à travers ce pointeur constitue un comportement indéfini. Le fait que les anciens octets soient visibles lors d’une exécution ne prolonge pas la durée de vie de l’objet.

Le même problème peut se produire à l’accolade fermante d’un bloc intérieur. Un pointeur extérieur ne peut pas prolonger la durée de vie d’une variable intérieure dont il a enregistré l’adresse.

Choisir un stockage qui dure suffisamment longtemps

Renvoie une valeur int lorsque la fonction appelante n’a besoin que d’un résultat entier. Pour plusieurs résultats, laisse la fonction appelante fournir une zone de stockage à remplir. Un pointeur renvoyé peut aussi désigner le tableau de la fonction appelante, un littéral de chaîne accessible par un const char * ou un objet static.

Une variable locale statique est initialisée une fois et existe pendant toute l’exécution du programme, mais tous les appels la partagent. Si un appel ultérieur y stocke une nouvelle valeur, tous les pointeurs renvoyés précédemment voient cette modification. Le stockage statique résout le problème de durée de vie sans donner à chaque appel son propre objet résultat indépendant.

Ajouter un entier à un pointeur le déplace par éléments du type pointé. Si p pointe vers l’élément i d’un tableau, p + n pointe vers l’élément i + n, à condition que la position obtenue soit dans le tableau ou juste après celui-ci.

Appliquer une seule fois le facteur de taille à l’adresse

À partir de l’adresse fictive 0x1000, ajouter 3 donne les résultats suivants :

Le compilateur applique le facteur de taille. Écrire p + 3 * sizeof *p l’applique deux fois et mène généralement au mauvais élément. Utilise un unsigned char * lorsque le pas souhaité correspond réellement à un octet de la représentation d’un objet.

Pour int a[6] = {10, 20, 30, 40, 50, 60}; et int *p = &a[1];, *(p + 2) lit a[3], qui vaut 40. L’affectation p += 3; déplace le pointeur lui-même vers a[4], qui contient 50. De là, *(p - 1) lit 40. p++, p--, p += n et p -= n se déplacent tous par éléments.

Soustraire des positions pour compter les éléments

&a[5] - &a[1] vaut 4 et inverser les opérandes donne -4. Le résultat compte déjà les éléments ; ne le divise pas par sizeof(int). Son type signé est ptrdiff_t, déclaré dans <stddef.h>, et %td permet de l’afficher.

Ne soustrais que des pointeurs vers un même tableau, y compris sa position juste après le dernier élément, avec un résultat représentable dans ptrdiff_t. Cette opération décrit des positions dans ce tableau. Soustraire les adresses de variables sans lien constitue un comportement indéfini, même si les nombres affichés sont proches par hasard.

Utiliser la position juste après le dernier élément comme borne

Pour six éléments, a + 6 est un pointeur juste après le dernier élément valide. Il peut servir de borne et intervenir dans une soustraction valide entre pointeurs d’un même tableau, mais il ne peut pas être déréférencé. a + 7 et a - 1 constituent déjà un comportement indéfini dès leur formation ; éviter un déréférencement ultérieur ne corrige pas le problème.

for (int *p = a; p < a + 6; p++) {
    printf("%d\n", *p);
}

Le corps s’exécute pour les indices de 0 à 5. Après la dernière incrémentation, p est égal à a + 6 et le test suivant arrête la boucle. Utiliser <= permettrait au corps d’accéder à cette position qui ne correspond pas à un élément.

Pour les règles arithmétiques, un objet seul se comporte comme un tableau d’un élément. Tu peux former &x + 1 ; tu ne peux pas l’utiliser pour lire une prétendue variable suivante.

Ne comparer que des positions qui ont un sens

Les opérateurs d’ordre comme < comparent des positions dans un même tableau. Ne compare pas l’ordre de pointeurs vers des objets sans lien. Les opérateurs d’égalité et d’inégalité permettent de comparer des pointeurs de types compatibles et de tester un pointeur par rapport à un pointeur nul.

Tu ne peux pas additionner deux pointeurs, multiplier des pointeurs ou effectuer des opérations arithmétiques en C standard sur un void * ou un pointeur de fonction. Pour trouver le milieu d’une plage [p, q) située dans un même tableau, utilise p + (q - p) / 2 : soustrais les positions pour obtenir un nombre d’éléments, divise ce nombre, puis avance à partir de p.

Un tableau est un bloc d’éléments. Un pointeur est un objet distinct qui contient une adresse. Leur lien étroit provient d’une conversion automatique qui se produit dans la plupart des expressions : ce ne sont pas deux objets de même nature.

Convertir une expression de tableau

int a[5] = {3, 1, 4, 1, 5};
int *p = a;

Ici, a est converti en pointeur vers a[0]. Cette conversion de tableau en pointeur rend l’initialiseur équivalent à &a[0]. Lire *p ou a[0] donne 3 dans les deux cas.

C définit l’indexation par l’arithmétique des pointeurs : a[i] signifie *(a + i). Par conséquent, p[3] fonctionne aussi et donne 1. &a[i] et a + i désignent le même élément. Même 3[a] a le même sens défini que a[3], bien que l’écriture habituelle soit beaucoup plus claire.

Savoir quand le tableau entier reste un tableau

La conversion ne se produit pas pour les opérandes de sizeof ou de l’opérateur unaire &. Elle ne se produit pas non plus pour typeof et typeof_unqual en C23, ni lorsqu’un littéral de chaîne initialise un tableau de caractères.

Tu ne peux pas affecter une nouvelle adresse à un tableau ni incrémenter son nom : a = p; et a++; sont invalides. Tu peux rediriger p, par exemple avec p = a + 2;. Copie le contenu du tableau avec une boucle sur ses éléments ou un appel adapté à memcpy.

Suivre le type ajusté du paramètre

int sum(const int *values, size_t n) {
    int total = 0;
    for (size_t i = 0; i < n; i++) total += values[i];
    return total;
}

La fonction appelante fournit à la fois une adresse et un nombre d’éléments. Pour le tableau précédent, sum(a + 2, 3) parcourt les indices initiaux 2, 3 et 4, et additionne 4, 1 et 5 pour renvoyer 10. Dans la fonction, l’indice 0 est relatif au pointeur de départ fourni.

Dans une liste de paramètres de fonction, int a[], int a[10] et int *a déclarent tous un paramètre pointeur. L’écriture simple [10] ne fournit aucune borne vérifiée et ne transmet aucune longueur. Dans une telle fonction, sizeof a mesure un pointeur. L’expression sizeof a / sizeof a[0] donnerait 2 sur un système avec un pointeur de 8 octets et un int de 4 octets, quelle que soit la longueur réelle du tableau de la fonction appelante.

Distinguer un pointeur vers un élément d’un pointeur vers un tableau

a est converti en int *, tandis que &a a le type int (*)[5], un pointeur vers le tableau entier de cinq éléments. Les deux désignent le début de la même zone de stockage, mais l’arithmétique suit leurs types différents. a + 1 avance d’un int, soit 4 octets dans cette disposition. &a + 1 avance d’un tableau entier, soit 20 octets, jusqu’à la position juste après ce tableau.

Une adresse de départ affichée ne peut pas révéler cette différence de type. Lis la déclaration et garde le type pointé à côté du pointeur lorsque tu suis une expression.

Une boucle avec un pointeur a besoin d’une position courante et d’une règle d’arrêt. Un tableau parcouru selon un nombre d’éléments utilise un pointeur de fin ; une chaîne utilise son '\0' final. Choisis la forme qui permet de voir le plus facilement les éléments parcourus.

Parcourir une plage de longueur connue

int a[] = {3, 1, 4, 1, 5};
int total = 0;
for (const int *p = a; p < a + 5; p++) {
    total += *p;
}

Les totaux successifs sont 3, 4, 8, 9 et 14. Une boucle à indice qui ajoute a[i] pour les indices inférieurs à 5 donne le même résultat. Les compilateurs optimisants modernes produisent souvent un code similaire pour ces formes ; la syntaxe des pointeurs ne garantit à elle seule aucun gain de vitesse.

Lire avant ou après le déplacement

Avec p sur le 3 dans {3, 1, 4}, int v = *p++; affecte 3 à v et laisse p sur le 1. L’incrémentation postfixée fournit l’ancienne valeur du pointeur à * et met le pointeur à jour. *++p se déplace d’abord vers l’élément suivant, puis le lit. (*p)++ modifie l’élément courant et ne déplace pas le pointeur.

S’arrêter au caractère nul de fin de chaîne

size_t my_strlen(const char *s) {
    const char *p = s;
    while (*p != '\0') p++;
    return (size_t)(p - s);
}

Pour "pointer", p s’arrête sur le caractère nul de fin de chaîne, à sept positions du début. Le résultat exclut ce caractère. Pour compter des caractères, on effectue le même parcours : parcourir "mississippi" et incrémenter un compteur chaque fois que *p == 's' compte quatre occurrences parmi onze lettres.

Un pointeur vers le milieu d’une chaîne donne accès à son suffixe. Avec const char *msg = "hello world";, puts(msg + 6) affiche "world". Les caractères précédents restent à leur place.

Copier aussi le caractère nul de fin de chaîne

char destination[4];
const char *src = "cat";
char *dst = destination;
while ((*dst++ = *src++) != '\0') {
}

Chaque itération affecte un caractère, teste la valeur affectée et avance les deux pointeurs. La dernière itération copie '\0' : la destination est donc une chaîne complète. Les deux pointeurs se trouvent alors juste après leurs caractères nuls de fin de chaîne. La zone de stockage doit contenir la longueur du texte plus un octet ; omettre cet octet supplémentaire provoque un débordement de tampon. Ce schéma de copie exige aussi que les plages source et destination ne se chevauchent pas.

Inverser depuis les deux extrémités

Pour une chaîne modifiable, obtiens d’abord sa longueur. Si la longueur est nulle, arrête-toi avant de former un pointeur vers le dernier caractère. Sinon, affecte left = s et right = s + length - 1. Tant que left < right, échange les caractères, incrémente left et décrémente right. Pour "stressed", quatre échanges produisent "desserts" ; le caractère nul de fin reste à sa place initiale.

La vérification de la chaîne vide est importante, car soustraire 1 à son pointeur de départ formerait un pointeur situé avant le tableau.

Choisir une zone de stockage de caractères modifiable

char word[] = "hello"; crée un tableau modifiable de six octets, caractère nul de fin compris. const char *word = "hello"; pointe vers un littéral de chaîne à durée de stockage statique. Modifier un littéral de chaîne constitue un comportement indéfini, même si une déclaration utilise char * sans const. Utilise const char * pour que les écritures accidentelles provoquent une erreur de compilation.

Une boucle sur un tableau doit s’arrêter avant la position juste après le dernier élément, et un parcours de chaîne doit effectivement rencontrer un caractère nul de fin dans la zone de stockage accessible. Un pointeur ne contient ni longueur ni garantie que les octets forment une chaîne.

Un pointeur est un objet stocké : il possède donc une adresse qu’un autre pointeur peut contenir. Un pointeur de pointeur ajoute une étape entre l’expression et les données finales.

Suivre les flèches une par une

int x = 7;
int *p = &x;
int **pp = &p;

Utilisons des adresses fictives : x, à l’adresse 0x2000, contient 7 ; p, à l’adresse 0x3000, contient 0x2000 ; pp, à l’adresse 0x4000, contient 0x3000. Évaluer *pp permet d’atteindre p, dont la valeur est de type int *. Évaluer **pp suit ce pointeur jusqu’à x, un int.

&p possède un niveau de pointeur de plus que p ; chaque déréférencement retire un niveau. Initialiser int **pp avec &x crée une incompatibilité, car &x est de type int *.

Choisir le niveau de l’affectation

Avec un autre entier y dont la durée de vie n’est pas terminée, **pp = 9; modifie x. L’affectation *pp = &y; modifie le pointeur p : les utilisations ultérieures de **pp atteignent donc y. Elle laisse x à sa valeur actuelle. Si q est un autre int *, pp = &q; ne modifie que le pointeur extérieur : sa première flèche atteint alors q au lieu de p.

Ne te contente pas de compter les étoiles : vérifie aussi l’objet à chaque niveau. Avant d’évaluer **pp, le chemin vers l’objet pointeur et celui qui mène de cet objet à l’entier doivent tous deux être valides.

Déplacer un pointeur de chaîne de la fonction appelante

void skip_spaces(const char **s) {
    while (**s == ' ') {
        (*s)++;
    }
}

/* In the caller: */
const char *text = "   hi";
skip_spaces(&text);
puts(text);

La fonction appelante passe l’adresse de sa variable de type pointeur. *s désigne donc text ; **s lit le caractère courant. Chaque (*s)++ avance text d’un caractère. Après trois itérations, le pointeur désigne 'h' et puts affiche "hi". La fonction nécessite un pointeur valide vers un pointeur qui désigne une chaîne terminée par un caractère nul.

Une version qui prend const char *s et incrémente s ne modifie qu’une copie locale. Les parenthèses de (*s)++ sont elles aussi indispensables : *s++ incrémente le pointeur local extérieur au lieu du pointeur de caractères de la fonction appelante. Dans const char **s, les caractères sont accessibles en lecture seule par ce chemin, mais le pointeur de la fonction appelante peut être déplacé.

Lire un pointeur de sortie d’une fonction de bibliothèque

strtol de <stdlib.h> utilise un paramètre de sortie de type char ** :

char *end;
long number = strtol("42abc", &end, 10);

La fonction renvoie 42 et stocke dans end un pointeur vers le premier caractère non utilisé, qui désigne maintenant "abc". Si le pointeur de fin est égal au pointeur de départ, aucun chiffre n’a été converti. Une analyse numérique entièrement vérifiée traite aussi les erreurs de dépassement de plage ; ici, le rôle du pointeur est d’indiquer la position d’arrêt.

Un tableau peut stocker des pointeurs comme éléments. Un tableau à deux dimensions stocke quant à lui des lignes complètes comme éléments. Les deux acceptent deux indices, mais leur stockage et les types de pointeurs obtenus après conversion diffèrent.

Stocker les adresses de chaînes distinctes

const char *days[] = {"Mon", "Tue", "Wed"};

days contient trois pointeurs de caractères. Chacun pointe vers un littéral de chaîne distinct. days[1] est le pointeur vers "Tue", et days[1][0] lit 'T'. Avec des pointeurs d’objets de 8 octets, sizeof days vaut 24, quelles que soient les longueurs des chaînes. Les chaînes elles-mêmes occupent une zone de stockage ailleurs.

Les longueurs peuvent différer, ce qui forme une collection irrégulière. Pour réordonner la liste, on peut échanger les éléments pointeurs sans copier le texte. L’affectation days[0] = "Thursday"; est autorisée : l’élément pointeur peut changer même si les caractères qu’il désigne sont accessibles en lecture seule.

Dans la plupart des expressions, days est converti en pointeur vers son premier élément. Comme un élément est un const char *, le type obtenu est const char ** :

for (const char **d = days; d < days + 3; d++) {
    puts(*d);
}

La boucle avance d’un élément pointeur par itération. *d récupère le pointeur de caractères dont puts a besoin.

Lire les chaînes de la ligne de commande

int main(int argc, char *argv[]) reçoit le même type de paramètre que char **argv. argc est positif ou nul et compte les chaînes disponibles. Lorsqu’il est positif, argv[0] représente le nom du programme ou une chaîne vide si ce nom n’est pas disponible. Les arguments de l’utilisateur occupent les indices de 1 à argc - 1, et argv[argc] est un pointeur nul.

Pour une invocation typique ./greet Ada 42, argc vaut 3, argv[1] pointe vers "Ada" et argv[2] pointe vers "42". Le dernier argument est du texte jusqu’à ce qu’une conversion comme strtol le lise. argv[1][0] vaut 'A'. Vérifie argc > 2 avant d’utiliser argv[2].

Une boucle qui affiche les arguments de l’utilisateur peut utiliser for (int i = 1; i < argc; i++) puts(argv[i]);. Pour parcourir les arguments à partir de argv + 1 jusqu’à un pointeur nul, vérifie d’abord argc > 0 ; si argc vaut zéro, aucune plage d’arguments utilisateur ne permet de commencer ainsi. Les chaînes des arguments sont modifiables, contrairement aux littéraux de chaîne.

Suivre des lignes complètes

int grid[3][4] contient douze entiers rangés par lignes : toute la ligne 0, puis la ligne 1 et enfin la ligne 2. Avec des int de 4 octets, chaque ligne occupe 16 octets. grid[2][1] se trouve 36 octets après grid[0][0] : les deux lignes complètes représentent 32 octets et la colonne en ajoute 4.

grid + 1 avance d’une ligne. Une fonction qui accepte ce tableau peut utiliser int g[][4] ou int (*g)[4], avec un nombre de lignes distinct. Elle ne peut pas utiliser int ** : la grille ne contient aucun pointeur de ligne à déréférencer. Une conversion explicite ne peut pas créer ces pointeurs manquants.

De même, char names[3][6] possède dix-huit emplacements de caractères dans des lignes de taille fixe. const char *names[3] possède trois emplacements de pointeurs qui peuvent désigner des chaînes de longueurs différentes.

Un pointeur de fonction stocke une référence à une fonction qui pourra être appelée plus tard. Son type comprend le type de retour et les types des paramètres. Ces types doivent correspondre à la fonction utilisée à travers le pointeur.

Mettre le nom du pointeur entre parenthèses

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }

int (*op)(int, int) = add;

Pars de op : c’est un pointeur ; l’élément pointé est une fonction qui prend deux int et renvoie un int. Sans les parenthèses, int *op(int, int); déclare une fonction qui renvoie un pointeur vers un entier. Les parenthèses changent le sens de la déclaration.

Dans cet initialiseur, un nom de fonction est converti en pointeur de fonction. op = &add; équivaut à op = add;. op(6, 3) et (*op)(6, 3) appellent tous deux add et renvoient 9. L’affectation op = sub; fait renvoyer 3 au même appel. Dans l’expression d’appel, rien n’a changé à part la fonction stockée dans le pointeur.

Garder une signature compatible

Un pointeur de type int (*)(int, int) ne peut pas appeler en toute sécurité une fonction qui prend et renvoie un double. Par exemple, lui affecter sqrt produit un diagnostic de types incompatibles. Convertir explicitement le pointeur de fonction pour supprimer un diagnostic ne rend pas valide un appel incompatible ; le comportement est indéfini.

Le C standard traite séparément les pointeurs d’objets et les pointeurs de fonctions. void * est le type pointeur générique d’objet ; il ne permet pas de stocker un pointeur de fonction de façon portable. Les pointeurs de fonctions acceptent les tests d’égalité et d’inégalité, mais pas l’arithmétique des pointeurs.

Un pointeur de fonction nul signifie qu’aucune fonction ne peut être appelée. Lorsqu’une interface autorise cet état, vérifie-le :

if (op != NULL) {
    int result = op(6, 3);
    printf("%d\n", result);
}

Appeler une fonction à travers un pointeur de fonction nul constitue un comportement indéfini.

Nommer le type une fois

typedef int (*binop)(int, int);
binop ops[] = {add, sub, mul};

Le typedef donne un nom à un type pointeur. binop selected = mul; déclare un pointeur ; binop pick(char symbol); déclare une fonction qui en renvoie un. Sans le typedef, cette déclaration de retour serait int (*pick(char symbol))(int, int);.

Un tableau de pointeurs de fonctions est une table de dispatch. ops[2](6, 3) sélectionne mul et renvoie 18. Pour un indice de sélection signé i, vérifie i >= 0 && i < 3 avant d’évaluer ops[i]. Accéder à un indice situé hors de la table est invalide, même si toutes les fonctions stockées peuvent par ailleurs être appelées.

Lire les déclarations plus longues à partir du nom

Commence par le nom et résous les parenthèses et les parties postfixées avant de continuer vers l’extérieur. Dans int (*table[3])(int, int), table[3] forme un tableau de trois éléments, * fait de chaque élément un pointeur et (int, int) fait de sa cible une fonction qui renvoie un int.

Dans char *(*f)(const char *), f est un pointeur vers une fonction qui prend un const char * ; cette fonction renvoie un char *. Distingue les exigences de durée de vie du pointeur renvoyé des exigences de compatibilité d’appel du pointeur de fonction.

Une fonction de rappel est une fonction fournie à une autre fonction, qui l’appelle dans le cadre de son travail. Cela sépare l’opération générale de parcours ou de tri de l’action ou de l’ordre particulier que tu choisis.

Passer une opération sans l’appeler

void twice(int *x) { *x *= 2; }

void for_each(int *a, size_t n, void (*fn)(int *)) {
    for (size_t i = 0; i < n; i++) fn(&a[i]);
}

Pour int v[] = {1, 2, 3};, for_each(v, 3, twice); produit {2, 4, 6}. Le nom de la fonction fournit un pointeur. Écrire twice() tenterait de l’appeler immédiatement, sans l’argument requis, au lieu de fournir une opération pour des appels ultérieurs.

Retrouver un type à partir d’un pointeur générique d’objet

Un void * peut contenir un pointeur d’objet et être reconverti dans le type d’origine. Il ne peut pas être déréférencé ni utilisé dans l’arithmétique des pointeurs en C standard, car il ne fournit aucun type d’élément. Préserve les qualificatifs : les données en lecture seule passent par const void *, puis par un pointeur adapté vers un objet constant.

qsort de <stdlib.h> prend une adresse de base, un nombre d’éléments, une taille d’élément en octets et une fonction de rappel de comparaison. Celle-ci est de type int (*)(const void *, const void *). Chaque argument pointe vers un élément du tableau, et le signe de la valeur renvoyée indique où placer le premier élément :

Trier des entiers sans débordement

int cmp_int(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    return (x > y) - (x < y);
}

/* In the caller: */
int v[] = {42, -7, 19, 0, 3};
qsort(v, 5, sizeof v[0], cmp_int);

Le tableau devient {-7, 0, 3, 19, 42}. Les comparaisons produisent 0 ou 1 : l’expression de retour ne produit donc que -1, 0 ou 1. Inverser l’expression d’ordre en (y > x) - (y < x) trie par ordre décroissant.

N’utilise pas return x - y; pour des entiers signés quelconques. Pour un int de 32 bits, soustraire -2 000 000 000 de 2 000 000 000 dépasse INT_MAX. Le débordement d’un entier signé est un comportement indéfini : aucun résultat après rebouclage ni signe de comparaison fiable n’est donc garanti.

Trier des pointeurs vers des chaînes

int cmp_str(const void *a, const void *b) {
    return strcmp(*(const char *const *)a,
                  *(const char *const *)b);
}

const char *names[] = {"Lin", "Ada", "Grace"};
qsort(names, 3, sizeof names[0], cmp_str);

Inclus <string.h> pour strcmp. Ici, un élément du tableau est lui-même un pointeur. La fonction de rappel reçoit l’adresse de cet élément pointeur : le déréférencer une fois permet donc de récupérer l’adresse de la chaîne. Le const intérieur ajouté empêche de modifier l’élément par ce chemin d’accès. Après le tri, l’ordre est "Ada", "Grace", "Lin".

strcmp(a, b) lirait les octets des emplacements de pointeurs comme du texte. Utilise aussi sizeof names[0], la taille d’un élément pointeur, et non sizeof(char) ou la longueur d’un nom.

Les fonctions de comparaison doivent laisser les éléments inchangés et répondre de façon cohérente, notamment en respectant la transitivité de l’ordre. qsort ne garantit pas de conserver l’ordre des éléments considérés comme égaux. bsearch accepte le même type de fonction de comparaison pour rechercher un élément dans un tableau déjà trié selon cet ordre.