Guide approfondi : La fonction strncpy en C

La fonction strncpy (string copy with length) est une version plus sécurisée de strcpy qui limite la quantité de caractères copiés d’une chaîne source à une destination. Cependant, elle a des comportements spécifiques qu’il faut bien comprendre pour éviter les erreurs.

1. Prototype de `strncpy`

char *strncpy(char *destination, const char *source, size_t n);

Arguments

destination : Le tableau où les caractères seront copiés.
source : La chaîne à copier.
n : Nombre maximal de caractères à copier.

Retour

Retourne un pointeur vers la chaîne destination.

2. Fonctionnement de `strncpy`

Copie jusqu’à n caractères :
- Si la longueur de source est inférieure à n, tous les caractères sont copiés, y compris le caractère nul (\0).
- Si la longueur de source est supérieure ou égale à n, seuls les n premiers caractères sont copiés, mais sans garantir l’ajout de \0.
Remplissage avec des zéros :
- Si source contient moins de n caractères, les caractères restants dans destination sont remplis avec des zéros (\0).
Terminaison :
- Contrairement à strcpy, strncpy ne garantit pas que la chaîne résultante sera terminée par un caractère nul (\0) si la longueur de source est supérieure ou égale à n.

3. Cas particuliers

3.1 La source est plus courte que `n`

Tous les caractères de source sont copiés, et les caractères restants dans destination sont remplis avec des zéros (\0).

Exemple :

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

int main() {
    char source[] = "C";
    char destination[5];

    strncpy(destination, source, 5); // Remplit les caractères restants avec `\0`

    printf("Destination : ");
    for (int i = 0; i < 5; i++) {
        printf("%c ", destination[i] == '\0' ? '_' : destination[i]);
    }
    printf("\n");

    return 0;
}

Sortie :

Destination : C _ _ _ _

3.2 La source est plus longue ou égale à `n`

Seuls les n premiers caractères sont copiés.
Aucun caractère nul (\0) n’est ajouté automatiquement.

Exemple :

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

int main() {
    char source[] = "Programmation";
    char destination[5];

    strncpy(destination, source, 4); // Copie seulement les 4 premiers caractères
    destination[4] = '\0';           // Ajouter manuellement `\0`

    printf("Destination : %s\n", destination);

    return 0;
}

Sortie :

Destination : Prog

3.3 La source est vide

Si source est vide (""), destination sera remplie avec des zéros (\0) jusqu’à n.

Exemple :

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

int main() {
    char source[] = "";
    char destination[5];

    strncpy(destination, source, 5);

    printf("Destination : ");
    for (int i = 0; i < 5; i++) {
        printf("%c ", destination[i] == '\0' ? '_' : destination[i]);
    }
    printf("\n");

    return 0;
}

Sortie :

Destination : _ _ _ _ _

4. Avantages de `strncpy`

Sécurité accrue :
- Limite le nombre de caractères copiés, évitant les dépassements de mémoire (buffer overflow).
Polyvalence :
- Peut être utilisé pour copier une sous-chaîne ou pour remplir des zones spécifiques de mémoire.

5. Inconvénients de `strncpy`

Pas de terminaison automatique :
- Si source est plus longue que n, le caractère nul (\0) n’est pas ajouté à destination, ce qui peut entraîner des comportements imprévisibles.
- Solution : Toujours ajouter manuellement \0 à la fin de destination si nécessaire.
Remplissage inutile avec des zéros :
- Lorsque source est plus courte que n, les caractères restants dans destination sont remplis avec des zéros, ce qui peut être inefficace dans certains cas.

6. Bonnes pratiques avec `strncpy`

Toujours vérifier la taille de destination :
- Assurez-vous que destination est suffisamment grand pour contenir la chaîne copiée.
Ajoutez manuellement \0 si nécessaire :
- Lorsque vous limitez la copie avec strncpy, terminez toujours la chaîne avec destination[n-1] = '\0'.
Utilisez snprintf pour plus de sécurité :
- Dans les cas critiques, utilisez snprintf au lieu de strncpy.

7. Exercices corrigés

Exercice 1 : Copie sécurisée

Copiez une chaîne source dans une destination en limitant la copie à 10 caractères. Assurez-vous que destination est toujours terminée par \0.

Solution :

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

int main() {
    char source[] = "Programmation en C";
    char destination[11]; // 10 caractères + 1 pour `\0`

    strncpy(destination, source, 10);
    destination[10] = '\0'; // Assurez la terminaison

    printf("Destination : %s\n", destination);

    return 0;
}

Exercice 2 : Remplissage de mémoire

Créez un tableau de 10 caractères. Copiez une chaîne courte et affichez les caractères restants remplis par des zéros.

Solution :

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

int main() {
    char source[] = "C";
    char destination[10];

    strncpy(destination, source, 10); // Les caractères restants sont remplis avec `\0`

    printf("Destination : ");
    for (int i = 0; i < 10; i++) {
        printf("%c ", destination[i] == '\0' ? '_' : destination[i]);
    }
    printf("\n");

    return 0;
}

Exercice 3 : Gestion des erreurs

Écrivez un programme qui vérifie si destination a suffisamment d’espace pour copier la chaîne source en toute sécurité.

Solution :

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

int main() {
    char source[] = "Programmation";
    char destination[8];

    if (strlen(source) >= sizeof(destination)) {
        printf("Erreur : espace insuffisant pour copier la chaîne.\n");
    } else {
        strncpy(destination, source, sizeof(destination) - 1);
        destination[sizeof(destination) - 1] = '\0';
        printf("Destination : %s\n", destination);
    }

    return 0;
}

8. Comparaison avec `strcpy`

Critère	`strcpy`	`strncpy`
Terminaison par `\0`	Toujours	Non garanti si `n` est atteint.
Gestion de dépassement	Non sécurisé, dépassement possible	Limite la copie
Remplissage restant	Aucun remplissage	Remplit les caractères restants avec `\0`
Performance	Plus rapide	Légèrement plus lente

9. Conclusion

La fonction strncpy est un outil puissant pour copier des chaînes de manière sécurisée. Cependant, elle nécessite une gestion attentive pour éviter des erreurs comme l’absence de terminaison par \0. En suivant les bonnes pratiques et en ajoutant toujours un caractère nul lorsque nécessaire, vous pouvez tirer pleinement parti de cette fonction pour des programmes robustes et sûrs.