HOWTO · C

Effacer le tableau de caractères en C

Cet article montre comment nettoyer les tableaux de caractères en C

Sur cette page

Un tableau C de char contient des octets. Choisissez l’opération selon que le programme a besoin d’un motif d’octets connu, d’une chaîne à réutiliser ou de libérer une allocation. L’exemple autonome applique chaque opération à une zone dont la capacité est connue.

Choisir ce que signifie « effacer » un tableau de char en C

Choisissez l’opération selon le résultat recherché : utilisez memset(array, 0, sizeof array) ou une boucle parcourant toute la longueur pour écraser chaque octet ; écrivez le premier caractère de terminaison nul (array[0] = '\0') pour rendre une chaîne C logiquement vide ; appelez free(pointer) pour libérer une zone allouée dynamiquement. free libère l’allocation sans en effacer les octets. Ces opérations ont des effets différents sur le tableau et sur la durée de vie de la mémoire.

Exécutez cet exemple :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

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

int main(void) {
    char bytes[8] = "secret";
    memset(bytes, 0, sizeof bytes);
    printf("first byte after memset: %u\n", (unsigned int)(unsigned char)bytes[0]);

    char text[16] = "hello";
    strcpy(text, "");
    printf("string after strcpy: '%s'; next byte: %u\n",
           text, (unsigned int)(unsigned char)text[1]);

    char items[8] = "Hi";
    for (size_t i = 0; i < sizeof items; ++i) {
        items[i] = '\0';
    }
    printf("string after loop: '%s'\n", items);

    char *dynamic_text = malloc(16);
    if (dynamic_text == NULL) {
        return EXIT_FAILURE;
    }
    strcpy(dynamic_text, "hello");
    free(dynamic_text);
    dynamic_text = NULL;

    return EXIT_SUCCESS;
}
first byte after memset: 0
string after strcpy: ''; next byte: 101
string after loop: ''

Le programme utilise memset pour mettre à zéro les huit octets de bytes. La lecture ultérieure de text[1] montre que la copie d’une chaîne vide écrit son premier caractère de terminaison, mais laisse inchangé l’octet suivant du tableau. La boucle écrit \0 dans chaque élément. Après l’appel à free, le programme ne lit pas la zone libérée ; affecter NULL ne modifie que cette variable pointeur locale.

Mettre chaque octet à zéro avec memset

memset est déclarée dans <string.h> et écrit la même valeur d’octet sur un nombre donné d’octets. Pour un tableau dans la portée courante, memset(array, 0, sizeof array) couvre le tableau entier, y compris les éléments situés après son caractère de terminaison de chaîne actuel. Si le tableau est transmis à une fonction sous forme de pointeur, sizeof y renvoie la taille du pointeur ; transmettez donc séparément la longueur du tableau.

La valeur 0 écrit des octets de valeur nulle. La valeur '0' répète le caractère chiffre ; ces octets ne sont pas nuls. Cela peut être utile pour le remplissage ou l’affichage, mais ne met pas à zéro le contenu antérieur.

Effacer un tableau avec une boucle

Une boucle est utile lorsqu’il faut affecter explicitement chaque élément ou lorsque la plage à traiter est plus courte que le tableau entier. Parcourez uniquement les éléments compris dans la longueur réelle du tableau et écrivez \0 dans chacun pour l’écraser avec un octet nul. Dans l’exemple exécutable, sizeof items convient parce que items est un tableau dans cette portée. Une fonction qui reçoit un pointeur doit aussi recevoir la longueur afin de ne pas avoir à deviner la capacité.

Rendre une chaîne C vide avec un caractère de terminaison nul

Pour une chaîne terminée par un caractère nul, remplacer son premier caractère par \0 suffit à ramener sa longueur logique à zéro. strcpy(array, "") produit le même effet visible : la fonction copie au début du tableau le caractère de terminaison de la chaîne vide. Aucune de ces opérations n’écrase les autres octets du tableau. Choisissez cette méthode si vous voulez réutiliser le tableau comme chaîne et si les octets restants n’ont pas besoin d’être écrasés. Si chaque octet doit être modifié, utilisez plutôt memset ou une boucle parcourant toute la longueur.

Comprendre la portabilité de bzero et explicit_bzero

bzero et explicit_bzero ne font pas partie des interfaces ISO C. Leurs déclarations et leur disponibilité dépendent du système d’exploitation et de ses en-têtes ; le code qui utilise l’une ou l’autre doit respecter la documentation de la plateforme cible et ses exigences en matière de macros de test de fonctionnalités. Lorsqu’elles sont disponibles, elles demandent toutes deux la mise à zéro d’une plage d’octets. explicit_bzero vise à empêcher qu’une optimisation supprime l’écriture demandée au motif qu’elle serait inobservable. Elle ne garantit toutefois pas la suppression de toutes les copies, des valeurs dans les registres, des copies dans l’espace d’échange ou d’autres traces au niveau du système. Pour du code C portable, préférez memset, une fonction standard, pour l’initialisation ordinaire des tableaux ; pour les données sensibles, consultez les recommandations de la plateforme.

Libérer la mémoire dynamique sans confondre cela avec un effacement

free libère un bloc obtenu au moyen d’une fonction d’allocation telle que malloc, calloc ou realloc. Cela ne signifie pas que le programme peut ensuite examiner un tableau effacé : accéder à l’ancienne allocation par un pointeur après free est invalide. N’appelez pas free sur un tableau automatique comme char local[16], ni sur une zone qui n’a pas été renvoyée par une fonction d’allocation.

Une fonction qui reçoit un paramètre pointeur reçoit sa propre copie de la valeur du pointeur. Affecter NULL à ce paramètre ne modifie pas le pointeur de l’appelant. Après avoir appelé free, l’appelant peut affecter NULL à sa propre variable, comme dans l’exemple, pour que cette variable cesse visiblement de désigner le bloc libéré. Cela n’efface pas les octets de l’allocation et ne modifie aucun autre pointeur qui peut encore la désigner.