Tableaux et chaînes de caractères en C

Un tableau donne un seul nom à un nombre fixe de valeurs de même type. Ses éléments sont placés les uns à côté des autres en mémoire. Utilise un tableau lorsque la même opération s’applique à plusieurs valeurs, par exemple pour mettre à jour un ensemble de scores.

Créer les éléments

int scores[5] = {90, 72, 85, 64, 99};
int primes[] = {2, 3, 5, 7};
int counts[6] = {0};

La première déclaration crée cinq entiers. Le compilateur compte quatre valeurs dans le deuxième initialiseur : primes possède donc quatre éléments. Dans le troisième, le premier élément est explicitement mis à zéro et chaque valeur d’initialisation manquante devient également zéro. De même, int a[5] = {1, 2}; contient 1, 2, 0, 0, 0. Un initialiseur désigné, disponible depuis C99, choisit une position : int b[5] = {[2] = 7}; place 7 dans le troisième élément et zéro dans les autres.

Une déclaration locale automatique comme int data[5]; réserve de l’espace sans fournir de valeurs initiales. Écris chaque élément avant de le lire. Les tableaux déclarés en dehors de toute fonction et ceux déclarés static sont initialisés à zéro lorsqu’aucun initialiseur explicite n’est fourni.

Accéder à une valeur par son indice

Les indices commencent à zéro. Pour cinq éléments, les positions valides vont de 0 à 4. scores[1] désigne le deuxième score, et non le premier. Un élément peut être utilisé partout où une variable ordinaire de son type peut l’être :

scores[1] = 75;
scores[1] += 5;
int last = scores[4];

Le deuxième score vaut maintenant 80. Le dernier vaut toujours 99. Un indice peut être une variable ou une expression : scores[n - 1] accède donc au dernier élément lorsque n est le nombre d’éléments et qu’il est positif. scores[5] ne désigne aucun élément.

Compter les éléments et les octets

sizeof scores mesure tout le tableau en octets. Sur un système où les entiers occupent 4 octets, les cinq éléments occupent 20 octets. Diviser par la taille d’un élément élimine la dépendance à la taille des entiers :

size_t n = sizeof scores / sizeof scores[0];
printf("%zu\n", n);

Ce code affiche 5. size_t est le type entier non signé utilisé pour les tailles ; %zu permet de l’afficher. Ce calcul fonctionne là où scores désigne le tableau lui-même. Un paramètre de fonction ne contient pas la taille complète du tableau.

Distinguer la taille des valeurs

Un nom comme #define NUM_SCORES 5 permet à la déclaration et à ses boucles d’utiliser une même taille. En C17, une déclaration locale const int n = 5; int a[n]; crée au contraire un tableau de longueur variable : const ne fait pas de n une expression constante entière. Sa taille est choisie lors de l’exécution de la déclaration, puis reste fixe pendant toute la durée de vie du tableau. Celui-ci ne peut pas utiliser de liste d’initialisation. La prise en charge des tableaux de longueur variable est facultative en C11 et C17 ; C23 ajoute constexpr pour les constantes connues à la compilation.

Les tableaux ne peuvent pas être affectés dans leur ensemble : b = a; est invalide. Copie leurs éléments avec une boucle ou une fonction de manipulation de la mémoire adaptée. Pour deux tableaux distincts, a == b compare les adresses, et non les valeurs des éléments. Compare les éléments correspondants pour vérifier l’égalité des valeurs. Une comparaison des octets avec memcmp teste quant à elle leurs représentations en mémoire ; des valeurs à virgule flottante égales, comme zéro positif et zéro négatif, peuvent avoir des représentations différentes.

Une boucle de comptage associe une opération aux positions d’un tableau. Détermine quels éléments contiennent des données utiles, puis parcours exactement ces positions. Le même modèle permet de calculer des totaux, d’effectuer des recherches et de mettre à jour des valeurs.

Parcourir les éléments utilisés

int t[5] = {12, 15, 9, 14, 10};
int sum = 0;
for (int i = 0; i < 5; i++) {
    sum += t[i];
}
double average = sum / 5.0;

La boucle utilise les indices 0, 1, 2, 3 et 4. Le total prend successivement les valeurs 12, 27, 36, 50 et 60 : la moyenne est donc de 12,0. Écrire i <= 5 ajoute un accès invalide à l’indice 5. Ce passage supplémentaire est une erreur de décalage d’une unité.

Pour calculer une moyenne, utilise une division à virgule flottante. Avec un total de 61, 61 / 5 donne l’entier 12 ; 61 / 5.0 donne 12,2. Stocker ensuite le premier résultat dans un double ne permet pas de retrouver la partie fractionnaire déjà supprimée.

Trouver un maximum ou une correspondance

Pour un tableau non vide, initialise le maximum avec sa première valeur :

int max = t[0];
for (int i = 1; i < 5; i++) {
    if (t[i] > max) max = t[i];
}

La première comparaison remplace 12 par 15. Les valeurs restantes sont plus petites : 15 est donc conservé. Partir de zéro échouerait pour une liste telle que {-8, -3, -11} : zéro est supérieur à toutes les valeurs stockées, mais ne figure pas dans la liste.

Une recherche séquentielle examine les valeurs dans l’ordre :

int found = -1;
for (int i = 0; i < 5; i++) {
    if (t[i] == 14) {
        found = i;
        break;
    }
}

Ici, found prend la valeur 3. La valeur -1 indique l’absence de correspondance, car elle ne peut pas être un indice valide. Ne signale l’échec qu’après avoir examiné tous les candidats. Renvoyer -1 après le premier élément différent fait manquer les correspondances situées plus loin dans le tableau.

Compter et réorganiser

Un tableau de compteurs stocke un compteur par catégorie. Pour les chiffres, int counts[10] = {0}; fournit les compteurs de 0 à 9. Après vérification de d >= 0 && d < 10, counts[d]++ augmente le compteur du chiffre d. Cette vérification protège le tableau lorsque la valeur du chiffre provient des données d’entrée.

Pour inverser un tableau, échange les paires d’éléments à partir de ses extrémités :

for (int i = 0; i < 5 / 2; i++) {
    int temp = t[i];
    t[i] = t[5 - 1 - i];
    t[5 - 1 - i] = temp;
}

Le premier échange intervertit 12 et 10. Le second intervertit 15 et 14. Le 9 du milieu reste en place, ce qui donne {10, 14, 9, 15, 12}. Arrête-toi à mi-parcours : continuer sur les cinq positions échangerait chaque paire deux fois.

Suivre séparément le nombre d’éléments et la capacité

Un tableau pouvant contenir 100 valeurs peut ne contenir actuellement que 37 éléments utiles. Sa capacité est de 100 ; son nombre d’éléments utilisés est de 37. Traite les positions inférieures à count. Pour ajouter une valeur, vérifie d’abord count < CAPACITY, stocke-la dans a[count], puis incrémente count. Une boucle allant jusqu’à la capacité peut lire des positions qui n’ont jamais reçu de valeurs utiles, même si elles se trouvent physiquement dans le tableau.

Une fonction peut traiter un tableau sans recevoir de copie distincte de chaque élément. L’appel donne accès au stockage de la fonction appelante. Transmets également le nombre d’éléments pour que la fonction sache où s’arrêter.

Fournir les données et leur longueur

#include <stddef.h>

double average(const int a[], size_t n) {
    if (n == 0) return 0.0;
    int sum = 0;
    for (size_t i = 0; i < n; i++) {
        sum += a[i];
    }
    return (double) sum / n;
}

La fonction appelante peut déclarer int values[] = {7, 8, 10}; et appeler average(values, sizeof values / sizeof values[0]). Les trois additions donnent 25 ; convertir sum en double avant la division produit environ 8,33. Renvoyer 0,0 en l’absence de valeurs est le comportement choisi pour cette fonction lorsque l’entrée est vide. Les petites valeurs de cet exemple maintiennent la somme entière dans la plage représentable.

Dans une déclaration de paramètre, int a[] est ajusté en int *a. Le paramètre reçoit l’adresse du premier élément. Même int a[10] ne vérifie ni n’impose la présence de dix éléments. La fonction appelante doit fournir une longueur correspondant aux données disponibles.

Pourquoi sizeof ne donne plus la longueur

Au point d’appel, sizeof values mesure le tableau. Dans la fonction, sizeof a mesure le paramètre pointeur. Lorsque les pointeurs occupent 8 octets et les entiers 4, diviser ces tailles donne 2, quel que soit le nombre d’éléments de la fonction appelante. Ce résultat ne décrit ni une copie de deux éléments ni le tableau d’origine. Conserve la longueur dans un paramètre explicite.

size_t, déclaré par des fichiers d’en-tête dont <stddef.h>, est le type non signé produit par sizeof. Il peut représenter les tailles des objets, et %zu permet de l’afficher. L’utiliser pour l’indice de boucle évite de comparer un indice signé à une longueur non signée.

Déterminer si les éléments peuvent changer

Le const de const int a[] empêche les affectations aux éléments par l’intermédiaire de ce paramètre. Il convient à une fonction qui calcule un résultat à partir des données. Une fonction destinée à modifier les éléments l’omet :

void zero(int a[], size_t n) {
    for (size_t i = 0; i < n; i++) {
        a[i] = 0;
    }
}

Après zero(values, 3), les trois éléments de la fonction appelante valent tous zéro. Le tableau compte toujours trois éléments. Un paramètre scalaire comme n est une copie distincte ; modifier cette copie ne changerait pas la variable de comptage de la fonction appelante.

Pour produire plusieurs résultats, laisse la fonction appelante fournir un tableau de sortie et sa longueur. Une fonction peut remplir out[i] avec chaque résultat. Les fonctions C ne peuvent pas renvoyer un tableau par valeur, et renvoyer l’adresse d’un tableau local ne fonctionne pas, car ce tableau cesse d’exister lorsque la fonction se termine.

Compter à rebours avec un indice non signé

Un indice non signé ne peut pas devenir négatif. Dans for (size_t i = n - 1; i >= 0; i--), le test est toujours vrai ; après zéro, la valeur reboucle vers un grand nombre positif. Avec n == 0, même la soustraction initiale provoque un rebouclage. Pars plutôt du nombre d’éléments :

for (size_t i = n; i > 0; i--) {
    printf("%d\n", a[i - 1]);
}

Avec trois éléments, les indices utilisés sont 2, 1 et 0. Avec zéro élément, le corps de la boucle ne s’exécute jamais. Inclus <stdio.h> pour printf.

Un caractère C est stocké sous forme de code numérique. Un programme peut ainsi afficher un symbole, le comparer à un autre ou effectuer des calculs sur son code. Le jeu de caractères détermine le nombre qui représente chaque symbole.

Lire le code et le caractère

Un char occupe un octet : sizeof(char) vaut 1 par définition. Une constante caractère comme 'A' est de type int. Dans le jeu de caractères fondé sur ASCII utilisé ici, son code est 65 :

printf("%c %d\n", 'A', 'A');

La sortie est « A 65 ». %c affiche le caractère ; %d affiche son nombre. ASCII attribue les codes de 0 à 127. Les chiffres vont de 48 à 57, les majuscules de 65 à 90, les minuscules de 97 à 122, et l’espace porte le code 32.

Les apostrophes et les guillemets doubles produisent des éléments différents. 'A' est un code de caractère. "A" est un tableau contenant 'A' et un octet nul de fin. Stocke un caractère avec char c = 'A'; et compare-le avec c == 'A'.

Écrire les caractères qui nécessitent un échappement

Le caractère nul est différent du chiffre visible '0', dont le code ASCII est 48. Une chaîne utilise le caractère nul pour marquer sa fin.

Transformer les codes en valeurs utiles

La norme C garantit que les codes des chiffres sont consécutifs. Après avoir vérifié que c est un chiffre, c - '0' produit sa valeur. Ainsi, '7' - '0' vaut 7, et non 55. Soustraire le code de départ retire la position du chiffre dans le jeu de caractères.

Les lettres ASCII sont elles aussi consécutives : soustraire 'A' convertit donc une majuscule en une position de 0 à 25. Un décalage de César de trois utilise :

char shifted = (c - 'A' + 3) % 26 + 'A';

Pour 'X', soustraire 65 donne 23 ; ajouter trois donne 26 ; le reste de la division par 26 vaut zéro ; ajouter 65 redonne 'A'. L’expression 'X' + 3 seule donne le code 91, soit '['. Les calculs sur les lettres dépendent d’un ordre de type ASCII ; C garantit que les chiffres sont consécutifs, mais ne l’exige pas pour les lettres.

Classer et convertir avec ctype.h

Inclus <ctype.h> pour utiliser isdigit, isalpha, isalnum, isspace, isupper, islower, toupper et tolower. Les tests renvoient une valeur non nulle en cas de correspondance et zéro sinon. toupper('q') renvoie 'Q' ; toupper('3') laisse le chiffre inchangé. isspace reconnaît les séparateurs tels que l’espace, la tabulation et le saut de ligne.

Un char sans autre qualification peut être signé. Un octet supérieur à 127 peut alors devenir une valeur négative, qui n’est pas un argument valide pour ces fonctions, sauf s’il s’agit du marqueur d’entrée spécial EOF. Lorsque tu traites les octets d’une chaîne, convertis-les d’abord :

if (isalpha((unsigned char) c)) {
    c = (char) toupper((unsigned char) c);
}

Dans la locale « C » par défaut, ces fonctions reconnaissent les lettres de base, mais pas les caractères UTF-8 complets codés sur plusieurs octets. La conversion explicite rend l’octet valide comme argument ; elle ne décode pas UTF-8.

Une chaîne de caractères C est une suite de caractères terminée par '\0'. Le caractère nul de fin fait partie du stockage, mais pas de la longueur du texte. C ne possède pas de type de chaîne intégré distinct : les caractères occupent un tableau.

Voir les octets dans le tableau

char word[] = "cat";
char name[20] = "Ada";

word contient quatre octets : 'c', 'a', 't', '\0'. La taille de son tableau est de 4 et strlen(word) vaut 3. Inclus <string.h> pour utiliser strlen. Le tableau name, plus grand, contient les trois lettres, leur caractère nul de fin et seize autres octets nuls. Sa capacité est de 20 tandis que sa longueur actuelle est de 3.

Un initialiseur caractère par caractère peut créer la même chaîne :

char word[] = {'c', 'a', 't', '\0'};

Omettre le dernier élément crée trois caractères sans caractère nul de fin de chaîne. C autorise aussi char word[3] = "cat";, qui remplit les trois positions et omet l’octet nul. Un tel tableau n’est pas une chaîne C. Une fonction comme strlen ou printf avec %s continue à lire jusqu’à rencontrer un octet nul : elle ne peut donc pas traiter ce tableau de trois octets comme du texte en toute sécurité.

Choisir un tableau modifiable ou un littéral

a[0] = 'H'; modifie la copie pour donner « Hello ». Un littéral ne doit pas être modifié. Même s’il est affecté à un char * sans autre qualification, écrire par l’intermédiaire de ce pointeur provoque un comportement indéfini. Écrire const char * rend cette restriction visible pour le compilateur.

Le compilateur réunit les littéraux de chaîne adjacents : "Hello, " "world" donne le même texte que "Hello, world". La chaîne obtenue ne possède toujours qu’un seul caractère nul de fin. Cela permet de répartir un long littéral sur plusieurs lignes du code source.

Afficher et modifier le texte

printf("%s\n", word);
printf("%c\n", word[0]);

Le premier appel affiche toute la chaîne. Le second affiche son premier caractère. Un littéral de chaîne dans printf est entouré de guillemets doubles parce qu’il s’agit d’un texte contenant un format ; %c reçoit un code de caractère.

L’affectation à un élément modifie un caractère stocké. Avec char name[20] = "Ada";, l’instruction name[0] = 'E'; produit « Eda ». L’instruction name[1] = '\0'; produit ensuite la chaîne « E ». Les octets de 'a' et de l’ancien caractère nul de fin existent toujours plus loin dans le tableau, mais les opérations sur les chaînes s’arrêtent au premier zéro.

Après sa déclaration, un tableau ne peut pas recevoir un texte de remplacement avec name = "Bob";. Copie-y les caractères avec un appel vérifié à strcpy ou une boucle, sans oublier le caractère nul de fin. La longueur du texte de remplacement doit être inférieure à la capacité.

Représenter l’absence de texte

La chaîne vide "" occupe tout de même un octet pour '\0'. Sa longueur est nulle et elle peut être testée avec name[0] == '\0'. Une chaîne vide est une véritable chaîne avec un caractère nul de fin ; un pointeur nul, lui, ne désigne aucun espace de stockage de chaîne.

Le caractère nul de fin d’une chaîne indique à une boucle où s’arrêter. Parcours les octets qui le précèdent pour compter, convertir ou filtrer le texte. Lors de la création d’une nouvelle chaîne, le programme doit lui-même écrire un nouveau caractère nul de fin.

Parcourir la chaîne une seule fois jusqu’à la fin

for (size_t i = 0; s[i] != '\0'; i++) {
    /* Process s[i]. */
}

À chaque passage, le test vérifie si l’octet courant appartient au texte. La boucle s’arrête avant le caractère nul de fin. Appeler strlen(s) dans ce test peut parcourir à nouveau toute la chaîne à chaque passage. Teste directement l’octet courant ou calcule size_t len = strlen(s); une seule fois lorsque la longueur restera inchangée.

Pour convertir en majuscules, utilise un tableau modifiable et <ctype.h> :

for (size_t i = 0; s[i] != '\0'; i++) {
    s[i] = (char) toupper((unsigned char) s[i]);
}

« Hello, World 42 » devient « HELLO, WORLD 42 ». La conversion conserve la virgule, les espaces et les chiffres. La conversion en type non signé rend chaque octet stocké valide comme argument pour une fonction de ctype.

Compter les catégories et les débuts de mots

Le texte initial « Hello, World 42 » contient 15 octets de texte : 10 lettres, deux chiffres, deux espaces et une virgule. Des compteurs distincts peuvent utiliser isalpha, isdigit et isspace. Définis ce qu’est un mot avant de le compter. Pour une suite de lettres, un nouveau mot commence lorsqu’une lettre suit un caractère qui n’est pas une lettre ou qu’elle est le premier caractère :

int in_word = 0;
size_t words = 0;
for (size_t i = 0; s[i] != '\0'; i++) {
    int letter = isalpha((unsigned char) s[i]) != 0;
    if (letter && !in_word) words++;
    in_word = letter;
}

L’exemple contient deux suites de lettres, « Hello » et « World ». Selon cette définition, les chiffres ne forment pas un mot. La mise à jour de in_word à chaque passage permet à la ponctuation de terminer une suite.

Inverser uniquement le texte

Pour une chaîne dont chaque caractère occupe un octet, obtiens len une seule fois, puis échange s[i] et s[len - 1 - i] tant que i < len / 2. L’inversion de « stressed » échange sa première et sa dernière lettre, puis la paire suivante, jusqu’à obtenir « desserts ». L’octet nul reste à l’indice len. Commencer un échange à s[len] déplacerait cet octet nul au début. Cette inversion des octets convient au texte ASCII ; les caractères codés sur plusieurs octets doivent être décodés avant d’être réorganisés.

Construire un résultat filtré

Utilise des indices distincts pour la lecture et l’écriture, car certains octets d’entrée sont ignorés :

char in[] = "a1b2c3";
char out[sizeof in];
size_t j = 0;
for (size_t i = 0; in[i] != '\0'; i++) {
    if (isalpha((unsigned char) in[i])) {
        out[j++] = in[i];
    }
}
out[j] = '\0';

Le résultat est « abc ». La destination dispose d’assez d’espace, car le filtrage ne peut pas allonger cette entrée. Sans out[j] = '\0';, la chaîne produite n’a pas de fin définie.

Pour un chiffrement de César, décale les majuscules par rapport à 'A' et les minuscules par rapport à 'a', puis copie les autres octets sans les modifier. Avec la clé 13, « Hello, World! » devient « Uryyb, Jbeyq! ». Répéter ce décalage rétablit le texte initial, car deux décalages donnent un total de 26. Une comparaison comme s[i] == 'a' teste un caractère ; utilise strcmp pour comparer des textes complets.

La longueur d’un texte peut désigner un nombre d’octets ou un nombre de points de code Unicode. Ces nombres diffèrent souvent. Un tableau C de char donne accès aux octets individuels : ses indices et les fonctions de manipulation des chaînes ne suivent donc pas automatiquement les caractères complets hors ASCII.

Distinguer caractères, points de code et octets

Un encodage des caractères décrit la façon dont le texte est stocké. ASCII utilise les codes de 0 à 127 pour les lettres de base, les chiffres, la ponctuation et les caractères de contrôle. Unicode attribue des points de code aux caractères de nombreux systèmes d’écriture : « é » a pour point de code U+00E9 et « € » a pour point de code U+20AC. UTF-8 encode les valeurs scalaires Unicode sur un à quatre octets.

Les points de code ASCII conservent leur encodage sur un octet. Le « é » précomposé utilise deux octets, 0xC3 et 0xA9 ; « € » en utilise trois. De nombreux points de code correspondant chacun à un émoji utilisent quatre octets. Un symbole affiché peut contenir plusieurs points de code : même le nombre de points de code ne correspond donc pas toujours au nombre de symboles visibles.

Mesurer une chaîne UTF-8

char s[] = "café";
printf("%zu %zu\n", strlen(s), sizeof s);

Avec un texte d’exécution en UTF-8, ce code affiche « 5 6 ». Les trois premières lettres utilisent trois octets et « é » en utilise deux, soit cinq octets de texte. Le caractère nul de fin ajoute un sixième octet de stockage. s[3] est le premier octet de « é », et non la lettre entière.

Une coupure après quatre octets conserverait 0xC3, mais supprimerait son octet de continuation 0xA9. Le résultat ne serait plus du UTF-8 valide. Une limite de tampon exprimée en octets nécessite donc une vérification des frontières de caractères si le programme tronque du texte UTF-8.

Compter les octets de début dans un UTF-8 valide

Un octet de continuation commence par les bits 10. Sa valeur est comprise entre 0x80 et 0xBF. Un octet de début ou un octet ASCII ne présente pas cette configuration :

size_t points = 0;
for (size_t i = 0; s[i] != '\0'; i++) {
    unsigned char c = (unsigned char) s[i];
    if ((c & 0xC0) != 0x80) points++;
}

Le masque 0xC0 ne conserve que les deux bits de poids fort ; 0x80 représente la configuration 10 à ces positions. Le test compte quatre points de code dans « café » en comptant ses quatre octets de début. Il suppose que le texte UTF-8 est valide et ne valide pas les séquences mal formées ni ne regroupe les points de code en symboles visibles.

Choisir des opérations qui préservent l’encodage

Copier une chaîne UTF-8 complète préserve ses octets. Concaténer des chaînes complètes, comparer leurs séquences d’octets pour vérifier leur égalité et rechercher un caractère ASCII ou une sous-chaîne UTF-8 complète fonctionnent également. Les octets de continuation UTF-8 ne peuvent pas être confondus avec des caractères ASCII ni avec des octets de début.

strcmp classe les valeurs des octets non signés : son ordre diffère donc de l’ordre alphabétique propre à chaque langue. En UTF-8, les lettres latines accentuées ordinaires ont des octets de début supérieurs au code ASCII de 'z'. Une comparaison des octets place donc ces lettres après 'z', quelles que soient les conventions du dictionnaire.

Dans la locale « C » par défaut, toupper et isalpha traitent un octet et ne décodent pas « é » comme une lettre. La conversion explicite en unsigned char rend l’appel valide, mais ne peut pas en faire une conversion de casse Unicode. Cette tâche nécessite des fonctions pour caractères larges ou une bibliothèque Unicode. Une boucle de César limitée à ASCII peut préserver les lettres accentuées en ne modifiant que les octets de A à Z ou de a à z.

L’octet zéro est l’encodage UTF-8 de U+0000 ; les autres points de code encodés ne contiennent pas d’octet zéro. Cela convient à la convention du caractère nul de fin en C. UTF-16 peut placer des octets zéro dans du texte ordinaire encodé : un tableau d’octets UTF-16 ne peut donc pas être traité comme une chaîne ordinaire de char.

Les fonctions de <string.h> manipulent du texte terminé par un caractère nul. Elles peuvent déterminer sa longueur, le copier ou lui ajouter du texte, mais les fonctions de copie ne découvrent pas la capacité de la destination. Détermine l’espace nécessaire avant d’écrire.

Mesurer la longueur sans le caractère nul de fin

strlen(s) renvoie un size_t indiquant le nombre d’octets avant le premier octet nul. Ainsi, strlen("hello") vaut 5 et strlen("") vaut zéro. Affiche le résultat avec %zu.

char buf[64] = "hi";
printf("%zu %zu\n", strlen(buf), sizeof buf);

Ce code affiche « 2 64 ». Le premier résultat mesure le texte actuel ; le second mesure l’espace disponible dans le tableau. Une copie ultérieure peut modifier le premier sans changer le second. Les deux appels sont utiles ici, car buf est un tableau et contient déjà une chaîne valide.

Copier une chaîne complète

strcpy(dest, src) copie le texte et son octet nul final. La capacité nécessaire est égale à la longueur de la source plus un :

char dest[12];
const char *src = "Maple";
if (strlen(src) < sizeof dest) {
    strcpy(dest, src);
}

« Maple » occupe cinq octets de texte et un caractère nul de fin : la chaîne tient donc dans le tableau. Le signe strict < compte : une source dont la longueur égale la capacité ne laisse aucune place pour son octet nul. Si la vérification échoue, le programme doit traiter l’erreur avant d’utiliser la destination comme nouvelle chaîne.

Une affectation de tableau telle que dest = src; ne peut pas remplacer son contenu. Affecter une variable char * à une autre est autorisé, mais ne copie qu’une référence au même espace de stockage. Cela ne crée pas une autre copie des caractères.

Ajouter du texte à une chaîne existante

strcat(dest, src) cherche d’abord le caractère nul de fin déjà présent dans dest. La fonction le remplace par le premier octet de la source et écrit un nouveau caractère nul après le texte ajouté. La capacité de la destination doit couvrir les deux longueurs actuelles plus un.

char full[16];
strcpy(full, "Ada");
strcat(full, " ");
strcat(full, "Lovelace");

Les longueurs passent de 3 à 4 puis à 12. Le résultat final « Ada Lovelace » nécessite 13 octets de stockage, ce qui laisse trois octets inutilisés. Une destination de 12 octets serait trop petite d’un octet, bien qu’elle corresponde à la longueur du texte visible.

N’ajoute jamais de texte à un tampon local non initialisé. Avec char out[20]; strcat(out, "hi");, strcat ne dispose d’aucune fin de texte établie à rechercher. Commence par char out[20] = "";, écris out[0] = '\0'; ou effectue d’abord une copie vérifiée.

Tenir compte du stockage et du coût des parcours

La source et la destination ne doivent pas se chevaucher avec strcpy ou strcat. Déplacer du texte à l’intérieur d’un même tampon peut créer un chevauchement, même lorsque les deux emplacements sont valides séparément. memmove est la fonction prévue pour les zones d’octets qui se chevauchent.

strlen doit parcourir la chaîne jusqu’au caractère nul de fin. strcat doit parcourir la destination actuelle avant l’ajout. Des ajouts répétés dans une boucle parcourent donc à nouveau le texte déjà construit. Pour assembler de nombreux morceaux, conserve la longueur actuelle de la sortie et écris chaque morceau à cet indice, en vérifiant la capacité restante et en maintenant le caractère nul de fin. Une longueur connue n’est utile que tant qu’elle correspond au contenu réel.

La comparaison de chaînes répond à des questions sur leur texte, tandis que la recherche trouve un emplacement dans ce texte. Aucune de ces opérations ne se fait en comparant des noms de tableaux avec ==. Utilise le résultat de la bibliothèque selon ce qu’il représente : un signe de comparaison, une longueur ou l’emplacement d’une correspondance.

Comparer le texte et les préfixes

strcmp(a, b) compare les octets correspondants comme des valeurs unsigned char jusqu’à une différence ou à la fin de la chaîne. Le résultat est nul si les textes sont égaux, négatif si a vient en premier et positif si cette chaîne vient après. Seul le signe est spécifié ; ne t’attends pas exactement à -1 ou 1.

if (strcmp(command, "quit") == 0) {
    puts("Goodbye");
}

Le test explicite de zéro signifie que les textes sont égaux. Un simple if (strcmp(command, "quit")) entre dans le bloc lorsque les textes diffèrent, car une valeur non nulle est vraie. La comparaison command == "quit" comparerait les emplacements de stockage.

Dans l’ordre ASCII, « apple » vient avant « banana » dès la première lettre. « Zebra » vient avant « apple », car la majuscule 'Z' a le code 90 et la minuscule 'a' le code 97. « app » vient avant « apple », car son octet nul est rencontré avant le 'l' de l’autre chaîne. Il s’agit d’un classement des octets, et non d’une comparaison selon le dictionnaire.

strncmp(a, b, n) compare au plus n octets. strncmp(s, "--", 2) == 0 reconnaît un préfixe de deux tirets, mais ne signifie pas que toute la chaîne se limite à « -- ». Le C standard ne possède pas de fonction de comparaison de chaînes entières insensible à la casse. Un programme peut comparer lui-même les octets convertis ; POSIX fournit strcasecmp dans <strings.h>.

Rechercher un emplacement

Utilise strchr pour la première occurrence d’un caractère, strrchr pour la dernière et strstr pour la première occurrence d’une sous-chaîne complète. Ces fonctions renvoient un pointeur vers l’emplacement de la correspondance ou NULL s’il n’y en a pas.

char name[] = "report.final.txt";
char *extension = strrchr(name, '.');
if (extension != NULL) {
    printf("%s\n", extension);
}

Ce code affiche « .txt », point trouvé compris. Partir du premier point avec strchr afficherait « .final.txt ». strstr(name, "final") trouve la partie finale qui commence par « final.txt » ; rechercher « draft » donne NULL. Vérifie que le résultat n’est pas NULL avant de l’afficher ou de le lire.

Repérer un séparateur ou découper du texte

strcspn(s, set) compte les octets initiaux qui ne correspondent à aucun des caractères de set. Avec "oak:pine,birch" et l’ensemble ":,", la fonction s’arrête aux deux-points. Pour une chaîne d’entrée valide, ce modèle supprime le premier saut de ligne :

buf[strcspn(buf, "\n")] = '\0';

S’il n’y a pas de saut de ligne, l’indice renvoyé est la longueur de la chaîne : l’affectation réécrit donc le caractère nul de fin déjà présent.

strtok découpe une chaîne modifiable en utilisant n’importe quel caractère d’un ensemble de délimiteurs :

char colors[] = "red, green,blue";
char *token = strtok(colors, " ,");
while (token != NULL) {
    puts(token);
    token = strtok(NULL, " ,");
}

Les jetons sont « red », « green » et « blue ». Le premier appel fournit le tableau ; les appels suivants transmettent NULL pour continuer. La fonction écrit des octets nuls dans l’entrée et conserve un état caché entre les appels. Utilise un espace de stockage modifiable et ne t’attends pas à retrouver intacte la chaîne d’origine avec ses séparateurs. Des délimiteurs consécutifs ne produisent pas de jetons vides.

Une limite de longueur n’est utile que si elle décrit la bonne quantité. Certaines fonctions limitent les octets de la source, d’autres la capacité de la destination, et les fonctions de manipulation de la mémoire traitent des octets bruts sans tenir compte des fins de chaînes. Lis les règles de chaque fonction avant de choisir sa limite.

Comprendre ce que signifie n

strncpy(dest, src, n) écrit exactement n positions lorsque la source est plus courte, en complétant avec des octets nuls. Lorsque la source contient au moins n octets de texte, la fonction copie ces octets sans caractère nul de fin. Pour un tableau de capacité positive, voici une copie avec troncature qui se termine par un caractère nul :

strncpy(dest, src, sizeof dest - 1);
dest[sizeof dest - 1] = '\0';

La dernière affectation est essentielle lorsque la source atteint la limite. Tronquer un nom ou une commande peut tout de même en changer le sens : rejette donc une entrée trop longue lorsqu’une copie complète est nécessaire.

strncat(dest, src, n) ajoute au plus n octets de texte, puis un caractère nul de fin. La fonction ne reçoit pas la capacité totale. Pour une chaîne valide déjà présente dans un tableau de destination, l’espace restant pour le texte est sizeof dest - strlen(dest) - 1. Passer sizeof dest comme valeur de n peut provoquer un débordement.

Formater et détecter la troncature

snprintf, déclarée dans <stdio.h>, reçoit la capacité totale de la destination. Si la capacité est supérieure à zéro, la fonction écrit au plus ce nombre d’octets de texte moins un, puis un caractère nul de fin :

char buf[8];
int needed = snprintf(buf, sizeof buf, "%s-%d", "item", 2026);
if (needed < 0) {
    puts("Formatting error");
} else if ((size_t) needed >= sizeof buf) {
    puts("Text did not fit");
}

Le résultat complet « item-2026 » contient neuf octets de texte. Le tampon stocke « item-20 » et son octet nul, tandis que needed vaut 9. La valeur de retour compte le texte qui aurait été produit, sans le caractère nul de fin. Vérifie si le résultat est négatif avant de le convertir en size_t.

Copier et remplir des octets

memcpy(dest, src, n) copie exactement n octets, y compris les éventuels octets nuls, sans chercher de caractère nul de fin. Pour deux tableaux d’entiers de même taille, memcpy(b, a, sizeof a) copie tout leur espace de stockage lorsque les zones ne se chevauchent pas. Lorsque chacun des cinq entiers occupe quatre octets, cela représente 20 octets. memmove effectue une copie d’octets dont le comportement est défini pour les zones qui se chevauchent.

memset(a, 0, sizeof a) remplit chaque octet avec zéro et met à zéro un tableau d’entiers. Son deuxième argument décrit chaque octet, et non chaque élément. Avec des entiers de quatre octets, un remplissage avec 1 donne les octets 01 01 01 01, soit 16 843 009 dans la représentation ordinaire, et non l’entier 1. Utilise une boucle pour affecter des valeurs entières non nulles.

memcmp(a, b, n) compare les octets stockés. Un résultat nul signifie que ces séquences d’octets correspondent. Pour vérifier l’égalité des valeurs, compare les éléments : les valeurs à virgule flottante 0.0 et -0.0 sont égales à la comparaison, même si leurs représentations peuvent différer.

Reconnaître d’autres familles de bibliothèques

strlcpy et strlcat, issues de BSD, ont rejoint POSIX en 2024, mais ne font pas partie des fonctions de base de C17. Elles renvoient une longueur qu’elles ont tenté de créer ; un résultat supérieur ou égal à la taille fournie indique une troncature. strlcpy écrit un caractère nul de fin lorsque la taille est positive. strlcat ne le fait que si le texte existant se termine dans la taille indiquée. Elles sont disponibles dans glibc 2.38 et les versions ultérieures. Les fonctions facultatives de l’annexe K, comme strcpy_s, sont absentes de nombreuses bibliothèques, dont glibc.

Un tableau de données nécessite un indice de ligne et un indice de colonne. En C, un tableau à deux dimensions est un tableau dont les éléments sont eux-mêmes des tableaux. Chaque ligne possède le même nombre d’éléments et chaque indice a sa propre borne.

Déclarer les lignes et les colonnes

int grid[3][4];
int m[2][3] = {{1, 2, 3}, {4, 5, 6}};

grid contient trois lignes de quatre entiers chacune, soit douze entiers en tout. Ses indices de ligne vont de 0 à 2 ; ses indices de colonne vont de 0 à 3. grid[1][2] accède à la troisième valeur de la deuxième ligne.

Les accolades d’initialisation imbriquées montrent le regroupement par ligne. Les éléments dont la valeur d’initialisation manque deviennent nuls. Tu peux laisser le compilateur compter les lignes dans int m[][3] = {{1, 2, 3}, {4, 5, 6}};, mais le nombre de colonnes doit être fourni. Sans lui, le compilateur ne pourrait pas déterminer où chaque ligne se termine.

Suivre le rangement par lignes

C stocke une ligne complète avant de commencer la suivante. Dans grid, les quatre premiers entiers stockés constituent la ligne 0, les quatre suivants la ligne 1 et les quatre derniers la ligne 2. grid[1][2] est le septième entier à partir du début, à la position 6 lorsque les éléments sont numérotés à partir de zéro : une ligne complète de quatre éléments, puis deux éléments supplémentaires.

Lorsque les entiers occupent quatre octets, une ligne utilise seize octets et le tableau entier quarante-huit. À l’endroit de la déclaration :

size_t rows = sizeof grid / sizeof grid[0];
size_t cols = sizeof grid[0] / sizeof grid[0][0];

La première division donne 3 et la seconde 4. Une ligne est elle-même un tableau : c’est pourquoi sizeof grid[0] mesure plus d’un entier.

Parcourir le tableau et calculer ses sommes

int sales[2][3] = {{4, 0, 7}, {5, 2, 1}};
int total = 0;
for (int r = 0; r < 2; r++) {
    int row_sum = 0;
    for (int c = 0; c < 3; c++) {
        row_sum += sales[r][c];
    }
    printf("%d\n", row_sum);
    total += row_sum;
}

La première ligne donne 11 et la seconde 8. L’addition de ces sommes donne 19. Réinitialiser row_sum dans la boucle externe permet de commencer une nouvelle somme pour chaque ligne. Si la variable n’était initialisée qu’une fois avant les deux boucles, la deuxième valeur affichée inclurait aussi la première ligne.

Pour les sommes par colonne, place la boucle des colonnes à l’extérieur et celle des lignes à l’intérieur, en accédant toujours à sales[r][c]. Les trois sommes deviennent 9, 2 et 8, ce qui donne à nouveau 19. Changer l’ordre du parcours n’oblige pas à changer le sens des deux indices. Un parcours ligne par ligne suit le stockage contigu et améliore souvent l’utilisation du cache pour les grands tableaux.

Respecter les bornes de chaque dimension

grid[c][r] inverse le sens des indices. Si c atteint 3, l’expression demande une quatrième ligne qui n’existe pas. Le fait que l’objet entier contienne douze entiers n’autorise pas à dépasser la borne d’une ligne avec un indice de colonne.

Écris deux opérations d’indexation distinctes : grid[1][2]. En C17, grid[1, 2] évalue l’expression avec l’opérateur virgule et sélectionne grid[2], une ligne, au lieu d’un élément. Avec davantage de dimensions, le même principe s’applique à plusieurs reprises : int cube[2][3][4] contient 24 éléments entiers, sélectionnés par trois indices.

Une fonction qui reçoit un tableau de données doit disposer d’assez d’informations pour identifier chaque ligne. Une liste de chaînes présente un autre choix : stocker les caractères dans des lignes de même largeur ou stocker des références à des chaînes de longueurs différentes.

Donner sa largeur de ligne à un paramètre tableau

void double_grid(int rows, int g[][4]) {
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < 4; c++) {
            g[r][c] *= 2;
        }
    }
}

La première dimension peut être omise, car le nombre de lignes est transmis séparément. La largeur 4 définit le type de chaque ligne. Sans elle, l’écart entre les lignes ne serait pas connu pour accéder à g[r][c]. Une déclaration avec int g[][] est invalide. Les modifications effectuées par l’intermédiaire de ce paramètre persistent dans le tableau de la fonction appelante ; un paramètre tableau accessible en lecture seule peut utiliser const int g[][4].

Depuis C99, les compilateurs qui prennent en charge les paramètres de type variablement modifié acceptent des dimensions déclarées plus tôt dans la liste des paramètres :

void print_grid(int rows, int cols, int g[rows][cols]);

GCC et Clang prennent en charge cette forme en C17. Elle permet à une seule fonction de recevoir des lignes de différentes largeurs ; transmets des dimensions positives qui correspondent au tableau réel. C23 exige la prise en charge de ces types de paramètres, tandis que les objets locaux de type tableau de longueur variable restent une fonctionnalité facultative distincte. Les paramètres de largeur fixe sont utiles lorsque la prise en charge par le compilateur est limitée.

Stocker les chaînes dans des lignes

char days[7][10] = {
    "Monday", "Tuesday", "Wednesday", "Thursday",
    "Friday", "Saturday", "Sunday"
};

Chaque ligne dispose d’un espace de stockage de dix caractères, quelle que soit la longueur actuelle de son texte. « Wednesday » nécessite les dix positions : neuf lettres et un caractère nul de fin. days[2] sélectionne toute cette ligne comme chaîne ; days[2][0] sélectionne 'W'.

Une ligne peut être affichée avec %s, mesurée avec strlen ou comparée avec strcmp. Elle peut aussi recevoir une copie vérifiée. strcpy(days[0], "Mon"); tient dans dix octets et modifie le texte de la ligne 0. La ligne conserve sa largeur de dix octets et la suivante reste au même emplacement. Un texte de remplacement de dix octets nécessiterait onze octets et ne tiendrait pas.

Stocker des références à des littéraux

const char *names[] = {"Ann", "Bartholomew", "Li"};

Cette instruction déclare un tableau de pointeurs. Chaque élément désigne un littéral occupant l’espace correspondant à sa longueur plus un caractère nul de fin. names[1] désigne « Bartholomew » et names[1][0] vaut 'B'. Les littéraux ne doivent pas être modifiés.

Les éléments pointeurs peuvent changer, même si les caractères des littéraux ne le peuvent pas. names[0] = "Anna"; change le littéral désigné par le premier élément ; cette instruction n’allonge pas « Ann » en place. Dans la forme à 2 dimensions, un élément est un tableau de caractères de largeur fixe et ne peut pas être réaffecté de cette façon. Choisis des lignes modifiables pour le texte modifié en place, et des références à des littéraux pour une liste de textes fixes. Le paramètre de ligne de commande argv prend la forme d’un tableau de pointeurs, même si les caractères des arguments fournis sont modifiables.

Les arguments de ligne de commande permettent à la fonction appelante de fournir du texte au lancement d’un programme. L’environnement d’exécution met ces chaînes à la disposition de main. Vérifie combien ont été reçues avant d’y accéder par indice.

Lire la liste des arguments

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        printf("%d: %s\n", i, argv[i]);
    }
    return 0;
}

Inclus <stdio.h> pour l’affichage. argc est le nombre d’arguments et argv est la liste des chaînes. L’écriture équivalente char **argv décrit la même interface. La boucle commence à 1, car l’indice 0 contient normalement le nom utilisé pour lancer le programme.

Dans un interpréteur de commandes ordinaire, l’exécution de ./greet Ada Lovelace fournit trois chaînes : « ./greet », « Ada » et « Lovelace ». Ainsi, argc vaut 3 et le dernier argument utilisateur est argv[2]. Un pointeur nul se trouve à argv[argc], ici argv[3] ; il sert de sentinelle après les chaînes des arguments proprement dits.

Laisser l’interpréteur regrouper le texte

Les guillemets influent sur la façon dont l’interpréteur construit les arguments. L’exécution de ./greet "Ada Lovelace" fournit un argument utilisateur contenant un espace. Les guillemets regroupent les mots et ne font pas partie du texte de l’argument. argc vaut maintenant 2.

Les interpréteurs de type Unix peuvent aussi développer les motifs avant le démarrage du programme. Dans ./count *.txt, le programme reçoit généralement les noms correspondant au motif comme arguments distincts. Il reçoit les chaînes résultantes, et non une demande de développer lui-même le motif. Le comportement exact dépend de l’interpréteur et de ses paramètres.

Rejeter un argument manquant ou supplémentaire

Si un programme a besoin d’exactement un argument utilisateur, exige argc == 2 avant de l’utiliser :

if (argc != 2) {
    printf("Usage: %s name\n", argv[0]);
    return 1;
}
printf("Hello, %s\n", argv[1]);

Lorsque argc vaut 1, argv[1] est le pointeur nul servant de sentinelle et ne peut pas être passé à strlen ni affiché avec %s. Les indices au-delà de la sentinelle sont hors du tableau d’arguments.

Renvoyer zéro depuis main indique une réussite. Un code de retour non nul, comme le 1 ci-dessus, indique à l’interpréteur que le programme ne s’est pas terminé correctement. <stdlib.h> fournit aussi EXIT_SUCCESS et EXIT_FAILURE.

Traiter chaque argument comme une chaîne

argv[i][0] accède au premier caractère de l’argument ; strlen(argv[i]) mesure les octets de son texte ; strcmp(argv[i], "-v") == 0 vérifie une option complète. Un argument qui ressemble à un nombre reste du texte et doit être converti avant tout calcul.

argv[0] indique généralement comment le programme a été lancé, mais peut être vide lorsque cette information n’est pas disponible. Il est utile pour les messages, mais pas pour une vérification d’identité fixe. Les caractères des arguments peuvent être modifiés pendant l’exécution, mais l’espace de stockage fourni ne permet pas de supposer qu’un texte de remplacement plus long y tiendra. Pour ajouter une extension ou allonger le texte autrement, copie-le d’abord dans un tampon dimensionné séparément.

Un argument numérique arrive sous forme de caractères, et non d’un entier. Une conversion fiable vérifie trois points distincts : des chiffres ont-ils formé un nombre, la conversion a-t-elle utilisé le texte requis et la valeur obtenue est-elle autorisée ?

Éviter de perdre les informations sur les erreurs

atoi, déclarée dans <stdlib.h>, effectue une conversion simple. Elle transforme « 13 » en 13, mais aussi « 12abc » en 12. Elle renvoie zéro aussi bien pour « 0 » que pour un texte comme « abc » qui ne commence pas par un nombre. Un résultat hors de la plage représentable provoque un comportement indéfini : un test vérifiant uniquement la présence de chiffres, suivi de atoi, reste donc dangereux pour une entrée très longue.

Une règle de forme comme « un ou plusieurs chiffres uniquement » nécessite un parcours distinct. Rejette une chaîne vide et exige que chaque octet satisfasse isdigit((unsigned char) c). Cette règle accepte « 13 » et rejette « 13a », « -5 » et « ». Elle vérifie la forme du texte, pas si la valeur est représentable dans un entier machine.

Utiliser strtol et examiner où la conversion s’est arrêtée

#include <errno.h>
#include <stdlib.h>

char *end;
errno = 0;
long count = strtol(argv[1], &end, 10);
if (end == argv[1] || *end != '\0' || errno == ERANGE) {
    puts("Enter a whole number");
    return 1;
}
if (count < 1 || count > 100) {
    puts("Count must be from 1 to 100");
    return 1;
}

Ce fragment vient après une vérification du nombre d’arguments et utilise <stdio.h> pour puts. Le 10 sélectionne une conversion décimale. end reçoit l’emplacement où la conversion s’est arrêtée ; &end permet à la fonction de stocker cet emplacement. *end lit le caractère qui s’y trouve. Aucune arithmétique des pointeurs n’est nécessaire.

Pour « 13a », la valeur renvoyée est 13 mais *end vaut 'a' : le texte est donc rejeté. Pour une chaîne vide ou « abc », end est égal au début de l’argument, ce qui montre qu’aucun nombre n’a été consommé. Les deux vérifications sont nécessaires : tester seulement le zéro final accepterait à tort une chaîne vide.

Avant chaque conversion, remets errno à zéro. Une valeur hors de la plage de long amène strtol à renvoyer une valeur extrême et à définir l’erreur ERANGE. Sans cette remise à zéro, une ancienne erreur pourrait sembler provenir de cette conversion. Vérifie le résultat avant une conversion vers le type plus restreint int ; utilise INT_MIN et INT_MAX de <limits.h> lorsque toute la plage de int constitue le domaine accepté.

Appliquer la règle propre au programme

strtol accepte les caractères blancs initiaux et un signe facultatif. Décide si ces formes sont autorisées. Si l’interface exige uniquement des chiffres, effectue le parcours vérifiant que la chaîne n’est pas vide et ne contient que des chiffres, en plus des vérifications de conversion. Après une conversion réussie, vérifie la plage de valeurs autorisée par l’application avant d’utiliser une valeur comme nombre d’éléments ou comme indice. « 0 » peut être un texte numérique parfaitement valide tout en étant invalide pour un nombre d’éléments qui doit être positif.

Un programme de César qui accepte une clé non négative vérifie d’abord argc, puis sa forme composée uniquement de chiffres, puis le résultat complet de strtol et la plage de valeurs. Réduire une clé valide avec % 26 produit un décalage de 0 à 25 avant les calculs sur les lettres. La clé 27 a le même effet que la clé 1. Vérifie les bornes avant une conversion explicite vers un type plus restreint ou tout calcul susceptible de déborder. Pour les valeurs décimales, strtod fournit une interface correspondante pour la position de fin et les erreurs de dépassement de plage.

Chaque accès à un tableau nécessite un indice valide. C n’exige pas de vérification des bornes à l’exécution : le programmeur doit donc maintenir l’indice à l’intérieur de l’objet. Un accès hors de ses bornes a un comportement indéfini : le langage ne garantit aucun résultat.

Reconnaître un accès invalide

Pour int a[5], les indices valides vont de 0 à 4. L’indice 5 est déjà trop grand et -1 est négatif. Un compilateur peut signaler une erreur visible, mais de nombreux indices invalides dépendent des données reçues à l’exécution et ne sont pas rejetés à la compilation.

Un programme défectueux peut sembler fonctionner, planter ou produire des valeurs inattendues. Une écriture peut corrompre des données voisines ; le symptôme peut apparaître plus tard dans un calcul sans rapport. Une lecture peut accéder à des octets hors de l’objet visé. Aucune des deux opérations n’a de résultat fiable. Répéter une exécution réussie ne permet pas d’établir que l’accès est valide.

Compter chaque écriture, y compris celle du caractère nul de fin

char name[8];
strcpy(name, "Christopher");

« Christopher » compte onze octets de texte. Sa copie écrit aussi le caractère nul de fin : cet appel tente donc d’écrire douze octets dans huit positions. C’est un débordement de tampon. Sur les systèmes réels, un débordement peut endommager d’autres données ou des informations de contrôle. Historiquement, des attaques, dont le ver Morris de 1988, ont exploité de tels bogues de traitement des données d’entrée.

Un débordement peut ne concerner qu’un octet :

char s[5];
for (int i = 0; i <= 5; i++) {
    s[i] = 'x';
}

Le corps s’exécute six fois et écrit à l’indice 5. Remplacer le test par i < 5 maintient cinq écritures de caractères dans le tableau, mais ne crée toujours pas de chaîne. Pour une chaîne de quatre caractères 'x', écris uniquement aux indices de 0 à 3, puis stocke '\0' à l’indice 4.

Valider les indices calculés

Un tableau de compteurs peut transformer un caractère en indice, mais la soustraction seule ne garantit aucune plage de valeurs :

int counts[26] = {0};
if (c >= 'a' && c <= 'z') {
    counts[c - 'a']++;
}

Avec l’ordre ASCII, ce test limite le résultat à l’intervalle de 0 à 25. Pour 'A' ou un octet de ponctuation, utiliser c - 'a' sans le test pourrait créer un indice négatif. Teste la valeur d’origine avant d’accéder au tableau ; vérifier après l’écriture est trop tard.

Pour un tableau à plusieurs dimensions, valide séparément la ligne et la colonne. Dans int g[2][3], un indice de colonne égal à 3 est invalide, même si la ligne suivante est adjacente en mémoire. Ne te sers pas de l’espace de stockage du tableau entier pour justifier le dépassement de la borne d’une ligne.

Utiliser des vérifications adaptées à l’opération

Une boucle sur un tableau utilise une borne supérieure stricte ; un ajout compare le nombre d’éléments à la capacité ; une copie de chaîne vérifie la longueur du texte plus un. Les fonctions reçoivent les longueurs ou capacités réelles de leurs fonctions appelantes. Ces vérifications portent sur des quantités différentes : une seule taille inscrite en dur ne peut donc pas toutes les remplacer.

Compile avec des avertissements comme -Wall -Wextra. L’option -fsanitize=address -g de GCC et Clang peut signaler de nombreux accès invalides sur les chemins exécutés et montrer leur emplacement dans le code source. Ces tests aident à trouver les erreurs, mais les chemins non exécutés nécessitent toujours un raisonnement sur les bornes. Examine chaque lecture et écriture par indice en identifiant son objet, sa borne et la condition qui maintient cet indice valide.

La longueur des données d’entrée dépend de la personne qui les fournit. Donne aux fonctions de lecture une limite correspondant réellement au tampon et vérifie ce qu’elles renvoient. Détermine ensuite si les données forment une ligne complète et si elles respectent les règles propres au programme.

Lire un mot avec une largeur

Pour char word[16];, scanf("%15s", word) lit au plus quinze caractères qui ne sont pas des caractères blancs et ajoute '\0'. La largeur laisse une des seize positions pour le caractère nul de fin. %s sans largeur n’impose aucune limite de longueur ; gets posait le même problème fondamental pour les lignes et a été retirée du C en C11.

Vérifie que scanf renvoie 1 avant d’utiliser un mot. La fonction lit un mot, et non une ligne entière contenant des espaces. Les octets excédentaires du mot peuvent rester non lus : une largeur protège donc le stockage sans décider si toute l’entrée est acceptable.

Lire une ligne avec fgets

char buf[8];
if (fgets(buf, sizeof buf, stdin) == NULL) {
    return 1;
}

Ici, fgets lit au plus sept caractères et écrit un octet nul final. La fonction conserve un saut de ligne lorsqu’elle l’atteint avant la limite. Une ligne contenant « hello » et un saut de ligne devient "hello\n" plus le caractère nul de fin. La lecture d’une dernière ligne qui se termine en fin de fichier sans saut de ligne peut tout de même réussir. Si aucun caractère n’a été lu avant la fin du fichier ou si une erreur de lecture s’est produite, le résultat est NULL ; ne traite pas alors ce tampon comme une nouvelle entrée.

Distinguer un saut de ligne stocké d’une ligne partielle

Repère un saut de ligne avant de le supprimer :

size_t end = strcspn(buf, "\n");
int had_newline = buf[end] == '\n';
buf[end] = '\0';

Inclus <string.h>. Si aucun saut de ligne n’a été stocké, end est la longueur du texte et l’affectation réécrit le caractère nul de fin existant. L’absence de saut de ligne peut indiquer une ligne partielle, un tampon rempli exactement avant un saut de ligne ou une dernière ligne terminée en fin de fichier. Elle ne suffit pas à établir qu’il reste des caractères.

Pour la ligne d’entrée « abcdefghij » et un tampon de huit octets, la première lecture stocke « abcdefg » et la suivante peut lire « hij\n ». Traiter le second morceau comme une réponse distincte couperait en deux une même entrée logique. Un programme peut rejeter une ligne à laquelle manque un saut de ligne obligatoire, ou lire et éliminer le reste de la ligne avant de redemander une saisie. Définis la règle de saisie avant de l’implémenter.

Pour au plus trente caractères ASCII de nom, plus un saut de ligne et un caractère nul de fin, utilise 32 octets. Pour UTF-8, il s’agit d’une limite en octets : trente caractères affichés peuvent nécessiter davantage d’espace.

Copier uniquement après avoir vérifié toutes les conditions

char user[10];
if (argc != 2) return 1;
if (strlen(argv[1]) >= sizeof user) {
    puts("Name too long");
    return 1;
}
strcpy(user, argv[1]);

La vérification du nombre d’arguments vient en premier. Celle de la longueur accepte ensuite au plus neuf octets de texte, laissant la dixième position pour zéro. Une fonction qui écrit devrait recevoir explicitement la capacité, comme dans read_name(out, capacity), car sizeof out mesure un paramètre pointeur à l’intérieur de cette fonction.

Pour une entrée numérique, lis une ligne complète et convertis-la avec strtol, en vérifiant la position de fin, l’erreur de dépassement de plage et la plage de valeurs autorisée. Un échec de scanf("%d", &n) peut laisser le texte en cause non lu ; répéter aveuglément l’appel peut échouer indéfiniment sur les mêmes octets. Vérifie au minimum le nombre d’affectations réussies et traite l’entrée invalide avant de réessayer.