Utilisation de la fonction strncpy

Contrairement à strcpy, qui copie l'intégralité d'une chaîne source vers une destination jusqu'à rencontrer le caractère nul, la fonction strncpy permet de spécifier le nombre exact de caractères à copier. On l'appelle souvent fonction "limitée" car elle offre un meilleur contrôle sur la taille des données manipulées.

Son prototype est le suivant :

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

Caractéristiques principales :

• Elle copie num caractères de la source vers la destination.
• Si la longueur de la source est inférieure à num, la destination est complétée par des caractères nuls (\0) jusqu'à atteindre num.
• Si la source est plus longue que num, le caractère de fin de chaîne n'est pas automatiquement ajouté à la fin de la destination après la copie.

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

int main() {
    char buffer[20] = "OldContent";
    char source[] = "NewDataStream";
    
    // Copie uniquement les 7 premiers caractères
    strncpy(buffer, source, 7);
    buffer[7] = '\0'; // Assure la terminaison de la chaîne
    
    printf("Résultat : %s\n", buffer);
    return 0;
}

Utilsiation de la fonction strncat

La fonction strncat permet de concaténer un nombre précis de caractères à la fin d'une chaîne de destination. Elle gère automatiquement l'ajout du caractère nul de fin de chaîne.

char * strncat ( char * destination, const char * source, size_t num );

Fonctionnement :

• Elle ajoute au maximum num caractères de la source à la fin de la destination.
• Un caractère nul est toujours ajouté après les caractères concaténés.
• Si la source contient moins de num caractères, elle s'arrête après avoir copié le \0 de la source.

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

int main() {
    char base[30] = "Utilisateur : ";
    char nom[] = "Jean_Dupont_Admin";
    
    // On ne veut ajouter que le prénom (4 caractères)
    strncat(base, nom, 4);
    
    printf("Chaîne finale : %s\n", base);
    return 0;
}

Comparaison avec strncmp

La fonction strncmp compare les premiers num caractères de deux chaînes. Elle retourne :

• 0 si les segments sont identiques.
• Une valeur positive si le premier caractère divergent a une valeur ASCII plus élevée dans la première chaîne.
• Une valeur négative dans le cas contraire.

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

int main() {
    char p1[] = "LOG_ERROR_404";
    char p2[] = "LOG_INFO_200";
    
    // Comparaison du préfixe "LOG_" (4 caractères)
    if (strncmp(p1, p2, 4) == 0) {
        printf("Les deux chaînes partagent le même préfixe.\n");
    }
    
    return 0;
}

Recherche de sous-chaîne avec strstr

La fonction strstr recherche la première occurrence d'une sous-chaîne dans une chaîne principale. Elle retourne un pointeur vers le début de la sous-chaîne trouvée, ou NULL si aucune correspondance n'est établie.

const char* strstr ( const char* str1, const char* str2);

Implémentation personnalisée de strstr

Pour comprendre le fonctionnement interne, nous pouvons implémenter notre propre version en utilisant une approcche par force brute :

#include <assert.h>

const char* mon_strstr(const char* haystack, const char* needle) {
    assert(haystack && needle);
    
    const char* ptr_h = haystack;
    const char* s1;
    const char* s2;

    if (*needle == '\0') return haystack;

    while (*ptr_h) {
        s1 = ptr_h;
        s2 = needle;

        while (*s1 && *s2 && (*s1 == *s2)) {
            s1++;
            s2++;
        }

        if (*s2 == '\0') {
            return ptr_h; // Sous-chaîne trouvée
        }
        ptr_h++;
    }
    return NULL;
}

Découpage de chaînes avec strtok

La fonction strtok est utilisée pour diviser une chaîne en plusieurs jetons (tokens) basés sur un ou plusieurs délimiteurs spécifiés.

char * strtok ( char * str, const char * sep);

Points de vigilance :

• strtok modifie la chaîne originale en remplaçant les délimiteurs par des caractères nuls.
• Lors du premier appel, on passe la chaîne à traiter. Pour les appels suivants sur la même chaîne, on passe NULL.

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

int main() {
    char data[] = "192.168.1.1:8080;admin";
    const char* delimiters = ".:;";
    char* token;

    token = strtok(data, delimiters);
    while (token != NULL) {
        printf("Segment : %s\n", token);
        token = strtok(NULL, delimiters);
    }
    return 0;
}

Gestion des erreurs avec strerror et perror

En C, de nombreuses fonctions de la bibliothèque standard utilisent une varible globale errno pour stocker un code d'erreur lorsqu'une opération échoue.

La fonction strerror

strerror convertit un code d'erreur numérique en une chaîne de caractères lisible par l'homme.

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

int main() {
    FILE* fd = fopen("fichier_inexistant.txt", "r");
    if (fd == NULL) {
        printf("Erreur d'ouverture : %s\n", strerror(errno));
    }
    return 0;
}

La fonction perror

perror est plus directe : elle affiche une chaîne personnalisée suivie d'un deux-points, d'un espace, puis du message d'erreur correspondant à la valeur actuelle de errno.

#include <stdio.h>

int main() {
    FILE* fd = fopen("config.sys", "r");
    if (fd == NULL) {
        perror("Échec de fopen");
    }
    return 0;
}