les chaines de caractères en C

Les chaînes de caractères en langage C

En C, il n'existe pas de type string natif. Une chaîne de caractères est représentée comme un tableau de char terminé par le caractère spécial '\0' (caractère nul), qui marque la fin de la chaîne.

Ainsi, la chaîne "Meknes" occupe 7 octets en mémoire : 6 caractères + 1 terminateur '\0'.

1. Déclarer une chaîne

char nom_chaine[taille];

char ville[7];   /* peut stocker "Meknes" (6 car.) + '\0' */

2. Initialiser une chaîne

Il existe quatre façons équivalentes d'initialiser une chaîne en C.

Exemple n°1 — Déclaration, initialisation et affichage

#include <stdio.h>

int main(void)
{
    char ville[] = "Meknes";

    printf("Chaîne   : %s\n",   ville);
    printf("Longueur : %lu\n",  sizeof(ville) - 1);  /* -1 pour exclure '\0' */
    printf("Taille   : %lu\n",  sizeof(ville));       /* inclut '\0'          */

    return 0;
}

Chaîne   : Meknes
Longueur : 6
Taille   : 7

3. Afficher et lire une chaîne

a. printf / scanf

C dispose du spécificateur %s qui permet d'afficher et de lire une chaîne entière en une seule instruction.

Exemple n°2 — Affichage avec printf

#include <stdio.h>

int main(void)
{
    char ville[] = "Meknes";
    printf("%s\n", ville);
    return 0;
}

Meknes

Exemple n°3 — Lecture avec scanf

#include <stdio.h>

int main(void)
{
    char ville[20];
    scanf("%s", ville);    /* pas de & car "ville" est déjà une adresse */
    printf("%s\n", ville);
    return 0;
}

4. Chaînes et pointeurs de caractères

Une chaîne peut aussi être manipulée via un pointeur char *. Le comportement diffère selon la zone mémoire utilisée.

a. Chaîne en lecture seule (segment partagé)

Exemple n°4 — Modification interdite d'un littéral

#include <stdio.h>

int main(void)
{
    char *ville = "Meknes";   /* stockée en lecture seule */
    *(ville + 1) = 'n';       /* tentative d'écriture — erreur */

    return 0;
}

Bus error: 10

const char *ville = "Meknes";   /* intention claire : lecture seule */

b. Chaîne modifiable (tableau)

Exemple n°5 — Modification autorisée sur char[]

#include <stdio.h>

int main(void)
{
    char ville[] = "Meknes";   /* copie sur la pile — modifiable */
    *(ville + 1) = 'n';        /* autorisé */

    puts(ville);
    return 0;
}

Mnknes

c. Chaîne allouée dynamiquement (malloc)

Exemple n°6 — Allocation sur le tas avec malloc

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

int main(void)
{
    int taille = 7;
    char *ville = (char *)malloc(sizeof(char) * taille);

    if (ville == NULL) { fprintf(stderr, "Allocation échouée\n"); return 1; }

    *(ville + 0) = 'M';
    *(ville + 1) = 'e';
    *(ville + 2) = 'k';
    *(ville + 3) = 'n';
    *(ville + 4) = 'e';
    *(ville + 5) = 's';
    *(ville + 6) = '\0';

    puts(ville);

    free(ville);   /* libération obligatoire */
    return 0;
}

Meknes

#include <string.h>
char *copie = strdup("Meknes");   /* alloue + copie en une ligne */
free(copie);

5. Retourner une chaîne depuis une fonction

Le segment mémoire utilisé détermine si une chaîne retournée par une fonction est valide ou non.

Exemple n°7 — Retour valide : pointeur vers littéral (segment partagé)

#include <stdio.h>

char *getVille()
{
    char *ville = "Meknes";   /* segment partagé — persiste après retour */
    return ville;
}

int main(void)
{
    printf("%s\n", getVille());
    return 0;
}

Meknes

Exemple n°8 — Retour invalide : adresse d'un tableau local (pile)

#include <stdio.h>

char *getVille()
{
    char ville[] = "Meknes";   /* sur la pile — libérée après retour ! */
    return ville;              /* retourne une adresse invalide         */
}

int main(void)
{
    printf("%s\n", getVille());
    return 0;
}

warning: address of stack memory associated with local variable 'ville' returned
return ville;
^~~~~

6. Passer une chaîne en paramètre

Comme une chaîne est un tableau, elle est automatiquement convertie en pointeur lors du passage à une fonction.

Exemple n°9 — Passage de chaîne à une fonction

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

/* Les deux signatures sont équivalentes */
void afficher(char str[])          /* ou : void afficher(char *str) */
{
    printf("Ville : %s (longueur : %lu)\n", str, strlen(str));
}

int main(void)
{
    char ville[20];
    printf("Entrer une ville : ");
    scanf("%s", ville);

    afficher(ville);
    return 0;
}

7. puts() vs printf() pour l'affichage

Exemple n°10 — puts : chaque appel ajoute un saut de ligne

#include <stdio.h>

int main(void)
{
    puts("Sedoki ");   /* affiche "Sedoki " puis '\n' */
    puts("Mostafa");   /* affiche "Mostafa" puis '\n' */
    return 0;
}

Sedoki 
Mostafa

Exemple n°11 — fputs : sans saut de ligne automatique

#include <stdio.h>

int main(void)
{
    fputs("Sedoki ",  stdout);
    fputs("Mostafa",  stdout);
    printf("\n");
    return 0;
}

Sedoki Mostafa

/* Incorrect — faille de sécurité */
printf(str);

/* Correct — toujours spécifier le format */
printf("%s", str);

Exemple n°12 — printf interprète le % dans la chaîne

#include <stdio.h>

int main(void)
{
    printf("Sedokimo%stafa");   /* % interprété comme format — warning */
    return 0;
}

warning: more '%' conversions than data arguments [-Wformat]

Exemple n°13 — puts affiche le % tel quel

#include <stdio.h>

int main(void)
{
    puts("Sedokimo%stafa");   /* % n'est pas interprété */
    return 0;
}

Sedokimo%stafa

8. Lire une chaîne avec espaces : fgets et gets

scanf("%s", …) s'arrête au premier espace. Pour lire une ligne complète contenant des espaces, deux fonctions sont disponibles — avec des niveaux de sécurité très différents.

a. fgets() — lecture sécurisée

char *fgets(char *buf, int n, FILE *flux);
/* Lit au plus n-1 caractères depuis flux (stdin, fichier…)
   S'arrête à '\n', à EOF, ou après n-1 caractères
   Ajoute automatiquement '\0' en fin de chaîne */

Exemple n°14 — fgets avec limite de taille

#include <stdio.h>
#define MAX 15

int main(void)
{
    char buf[MAX];
    printf("Entrer une phrase : ");
    fgets(buf, MAX, stdin);
    printf("Chaîne lue : %s\n", buf);
    return 0;
}

Entrer une phrase : mostafa est un professeur d'informatique
Chaîne lue : mostafa est un

#include <string.h>
buf[strcspn(buf, "\n")] = '\0';   /* supprime le '\n' s'il est présent */

b. gets() — à éviter absolument

Exemple n°15 — gets : débordement de tampon

#include <stdio.h>
#define MAX 6

int main(void)
{
    char buf[MAX];
    printf("Saisir une chaîne : ");
    gets(buf);   /* dangereux — aucune limite de taille ! */
    printf("Chaîne : %s\n", buf);
    return 0;
}

warning: this program uses gets(), which is unsafe.
Saisir une chaîne : mostafa est un professeur
Chaîne : mostafa est un professeur
Segmentation fault: 11

Récapitulatif