Fil d'Ariane
Mis à jour le mardi 25 juillet 2017
  • 40 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

Ce cours existe en livre papier.

Ce cours existe en eBook.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

Vous pouvez être accompagné et mentoré par un professeur particulier par visioconférence sur ce cours.

J'ai tout compris !

Les chaînes de caractères

Connectez-vous ou inscrivez-vous pour bénéficier de toutes les fonctionnalités de ce cours !

Une « chaîne de caractères », c'est un nom programmatiquement correct pour désigner… du texte, tout simplement !
Une chaîne de caractères, c'est donc du texte que l'on peut retenir sous forme de variable en mémoire. On pourrait ainsi stocker le nom de l'utilisateur.

Comme nous l'avons dit plus tôt, notre ordinateur ne peut retenir que des nombres. Les lettres sont exclues. Comment diable les programmeurs font-ils pour manipuler du texte, alors ? Eh bien ils sont malins, vous allez voir !

Le type char

Dans ce chapitre, nous allons porter une attention particulière au typechar.
Si vous vous souvenez bien, le typecharpermet de stocker des nombres compris entre -128 et 127.

Le typecharest en fait prévu pour stocker… une lettre ! Attention, j'ai bien dit : UNE lettre.

Comme la mémoire ne peut stocker que des nombres, on a inventé une table qui fait la conversion entre les nombres et les lettres. Cette table indique ainsi par exemple que le nombre 65 équivaut à la lettre A.

Le langage C permet de faire très facilement la traduction lettre <=> nombre correspondant. Pour obtenir le nombre associé à une lettre, il suffit d'écrire cette lettre entre apostrophes, comme ceci :'A'. À la compilation,'A'sera remplacé par la valeur correspondante.

Testons :

int main(int argc, char *argv[])
{
    char lettre = 'A';

    printf("%d\n", lettre);

    return 0;
}
65

On sait donc que la lettre A majuscule est représentée par le nombre 65. B vaut 66, C vaut 67, etc.
Testez avec des minuscules et vous verrez que les valeurs sont différentes. En effet, la lettre'a'n'est pas identique à la lettre'A', l'ordinateur faisant la différence entre les majuscules et les minuscules (on dit qu'il « respecte la casse »).

La plupart des caractères « de base » sont codés entre les nombres 0 et 127. Une table fait la conversion entre les nombres et les lettres : la table ASCII (prononcez « Aski »). Le site AsciiTable.com est célèbre pour proposer cette table mais ce n'est pas le seul, on peut aussi la retrouver sur Wikipédia et bien d'autres sites encore.

Afficher un caractère

La fonctionprintf, qui n'a décidemment pas fini de nous étonner, peut aussi afficher un caractère. Pour cela, on doit utiliser le symbole%c(c comme caractère) :

int main(int argc, char *argv[])
{
    char lettre = 'A';

    printf("%c\n", lettre);

    return 0;
}
A

Hourra !
Nous savons afficher une lettre.

On peut aussi demander à l'utilisateur d'entrer une lettre en utilisant le%cdans un scanf :

int main(int argc, char *argv[])
{
    char lettre = 0;

    scanf("%c", &lettre);
    printf("%c\n", lettre);

    return 0;
}

Si je tape la lettre B, je verrai :

B
B

Le premier des deux B est celui que j'ai tapé au clavier, le second est celui affiché par leprintf.

Voici à peu près tout ce qu'il faut savoir sur le typechar. Retenez bien :

  • le typecharpermet de stocker des nombres allant de -128 à 127,unsigned chardes nombres de 0 à 255 ;

  • il y a une table que votre ordinateur utilise pour convertir les lettres en nombres et inversement, la table ASCII ;

  • on peut donc utiliser le typecharpour stocker UNE lettre ;

  • 'A'est remplacé à la compilation par la valeur correspondante (65 en l'occurrence). On utilise donc les apostrophes pour obtenir la valeur d'une lettre.

Les chaînes sont des tableaux de char

Comme on dit, tout est dans le titre. En effet : une chaîne de caractères n'est rien d'autre qu'un tableau de typechar. Un bête tableau de rien du tout.

Si on crée un tableau :

char chaine[5];

et qu'on met danschaine[0]la lettre'S', danschaine[1]la lettre'a'… on peut ainsi former une chaîne de caractères, c'est-à-dire du texte.

La fig. suivante vous donne une idée de la façon dont la chaîne est stockée en mémoire (attention : je vous préviens de suite, c'est un peu plus compliqué que ça en réalité, je vous explique après pourquoi).

Une chaîne de caractères en mémoire (simplifiée)

Comme on peut le voir, c'est un tableau qui prend 5 cases en mémoire pour représenter le mot « Salut ». Pour la valeur, j'ai volontairement écrit sur le schéma les lettres entre apostrophes pour indiquer que c'est un nombre qui est stocké, et non une lettre. En réalité, dans la mémoire, ce sont bel et bien les nombres correspondant à ces lettres qui sont stockés.

Toutefois, une chaîne de caractères ne contient pas que des lettres ! Le schéma de la fig. suivante est en fait incomplet. Une chaîne de caractère doit impérativement contenir un caractère spécial à la fin de la chaîne, appelé « caractère de fin de chaîne ». Ce caractère s'écrit'\0'.

Pourquoi faut-il que la chaîne de caractères se termine par un\0?

Tout simplement pour que votre ordinateur sache quand s'arrête la chaîne ! Le caractère\0permet de dire : « Stop, c'est fini, y'a plus rien à lire après, circulez ! »

Par conséquent, pour stocker le mot « Salut » (qui comprend 5 lettres) en mémoire, il ne faut pas un tableau de 5char, mais de 6 !
Chaque fois que vous créez une chaîne de caractères, vous allez donc devoir penser à prévoir de la place pour le caractère de fin de chaîne. Il faut toujours toujours toujours ajouter un bloc de plus dans le tableau pour stocker ce caractère\0, c'est impératif !

Oublier le caractère de fin\0est une source d'erreurs impitoyable du langage C. Je le sais pour en avoir fait les frais plus d'une fois.

La fig. suivante est le schéma correct de la représentation de la chaîne de caractères « Salut » en mémoire.

Une chaîne de caractères en mémoire

Comme vous le voyez, la chaîne prend 6 caractères et non pas 5, il va falloir s'y faire. La chaîne se termine par'\0', le caractère de fin de chaîne qui permet d'indiquer à l'ordinateur que la chaîne se termine là.

Voyez le caractère\0comme un avantage. Grâce à lui, vous n'aurez pas à retenir la taille de votre tableau car il indique que le tableau s'arrête à cet endroit. Vous pourrez passer votre tableau decharà une fonction sans avoir à ajouter à côté une variable indiquant la taille du tableau.
Cela n'est valable que pour les chaînes de caractères (c'est-à-dire le typechar*, qu'on peut aussi écrirechar[]). Pour les autres types de tableaux, vous êtes toujours obligés de retenir la taille du tableau quelque part.

Création et initialisation de la chaîne

Si on veut initialiser notre tableauchaineavec le texte « Salut », on peut utiliser la méthode manuelle mais peu efficace :

char chaine[6]; // Tableau de 6 char pour stocker S-a-l-u-t + le \0
    
chaine[0] = 'S';
chaine[1] = 'a';
chaine[2] = 'l';
chaine[3] = 'u';
chaine[4] = 't';
chaine[5] = '\0';

Cette méthode marche. On peut le vérifier avec unprintf.

Pour faire unprintfil faut utiliser le symbole%s(scomme string}, qui signifie « chaîne » en anglais). Voici le code complet qui crée une chaîne « Salut » en mémoire et qui l'affiche :

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

int main(int argc, char *argv[])
{
    char chaine[6]; // Tableau de 6 char pour stocker S-a-l-u-t + le \0

    // Initialisation de la chaîne (on écrit les caractères un à un en mémoire)
    chaine[0] = 'S';
    chaine[1] = 'a';
    chaine[2] = 'l';
    chaine[3] = 'u';
    chaine[4] = 't';
    chaine[5] = '\0';

    // Affichage de la chaîne grâce au %s du printf
    printf("%s", chaine);

    return 0;
}

Résultat :

Salut

Vous remarquerez que c'est un peu fatigant et répétitif de devoir écrire les caractères un à un comme on l'a fait dans le tableauchaine. Pour initialiser une chaîne, il existe heureusement une méthode plus simple :

int main(int argc, char *argv[])
{
    char chaine[] = "Salut"; // La taille du tableau chaine est automatiquement calculée

    printf("%s", chaine);

    return 0;
}
Salut

Comme vous le voyez à la première ligne, je crée une variable de typechar[]. J'aurais pu écrire aussichar*, le résultat aurait été le même.

En tapant entre guillemets la chaîne que vous voulez mettre dans votre tableau, le compilateur C calcule automatiquement la taille nécessaire. C'est-à-dire qu'il compte les lettres et ajoute 1 pour placer le caractère\0. Il écrit ensuite une à une les lettres du mot « Salut » en mémoire et ajoute le\0comme on l'a fait nous-mêmes manuellement quelques instants plus tôt.
Bref, c'est bien plus pratique.

Il y a toutefois un défaut : ça ne marche que pour l'initialisation ! Vous ne pouvez pas écrire plus loin dans le code :

chaine = "Salut";

Cette technique est donc à réserver à l'initialisation. Après cela, il faudra écrire les caractères manuellement un à un en mémoire comme on l'a fait au début.

Récupération d'une chaîne via unscanf

Vous pouvez enregistrer une chaîne entrée par l'utilisateur via unscanf, en utilisant là encore le symbole%s.
Seul problème : vous ne savez pas combien de caractères l'utilisateur va entrer. Si vous lui demandez son prénom, il s'appelle peut-être Luc (3 caractères), mais qui vous dit qu'il ne s'appelle pas Jean-Edouard (beaucoup plus de caractères) ?

Pour ça, il n'y a pas 36 solutions. Il va falloir créer un tableau dechartrès grand, suffisamment grand pour pouvoir stocker le prénom. On va donc créer unchar[100]. Vous avez peut-être l'impression de gâcher de la mémoire, mais souvenez-vous encore une fois que de la place en mémoire, ce n'est pas ce qui manque (et il y a des programmes qui gâchent la mémoire de façon bien pire que cela !).

int main(int argc, char *argv[])
{
    char prenom[100];

    printf("Comment t'appelles-tu petit Zero ? ");
    scanf("%s", prenom);
    printf("Salut %s, je suis heureux de te rencontrer !", prenom);

    return 0;
}
Comment t'appelles-tu petit Zero ? Mateo21

Salut Mateo21, je suis heureux de te rencontrer !

Fonctions de manipulation des chaînes

Les chaînes de caractères sont, vous vous en doutez, fréquemment utilisées. Tous les mots, tous les textes que vous voyez sur votre écran sont en fait des tableaux decharen mémoire qui fonctionnent comme je viens de vous l'expliquer.
Afin de nous aider un peu à manipuler les chaînes, on nous fournit dans la bibliothèquestring.hune pléthore de fonctions dédiées aux calculs sur des chaînes.

Je ne peux pas vraiment toutes vous les présenter ici, ce serait un peu long et elles ne sont pas toutes indispensables.
Je vais me contenter de vous parler des principales dont vous aurez très certainement besoin dans peu de temps.

Pensez à inclurestring.h

Même si cela devrait vous paraître évident, je préfère vous le préciser encore au cas où : comme on va utiliser une nouvelle bibliothèque appeléestring.h, vous devez l'inclure en haut des fichiers.coù vous en avez besoin :

#include <string.h>

Si vous ne le faites pas, l'ordinateur ne connaîtra pas les fonctions que je vais vous présenter car il n'aura pas les prototypes, et la compilation plantera.
En bref, n'oubliez pas d'inclure cette bibliothèque à chaque fois que vous utilisez des fonctions de manipulation de chaînes.

strlen: calculer la longueur d'une chaîne

strlenest une fonction qui calcule la longueur d'une chaîne de caractères (sans compter le caractère\0).
Vous devez lui envoyer un seul paramètre : votre chaîne de caractères. Cette fonction vous retourne la longueur de la chaîne.

Maintenant que vous savez ce qu'est un prototype, je vais vous donner le prototype des fonctions dont je vous parle. Les programmeurs s'en servent comme « mode d'emploi » de la fonction (même si quelques explications à côté ne sont jamais superflues) :

size_t strlen(const char* chaine);

La fonction prend un paramètre de typeconst char*. Leconst(qui signifie constante, rappelez-vous) fait que la fonctionstrlen« s'interdit » en quelque sorte de modifier votre chaîne. Quand vous voyez unconst, vous savez que la variable n'est pas modifiée par la fonction, elle est juste lue.

Testons la fonctionstrlen:

int main(int argc, char *argv[])
{
    char chaine[] = "Salut";
    int longueurChaine = 0;

    // On récupère la longueur de la chaîne dans longueurChaine
    longueurChaine = strlen(chaine);

    // On affiche la longueur de la chaîne
    printf("La chaine %s fait %d caracteres de long", chaine, longueurChaine);

    return 0;
}
La chaine Salut fait 5 caracteres de long

Cette fonctionstrlenest d'ailleurs facile à écrire. Il suffit de faire une boucle sur le tableau decharqui s'arrête quand on tombe sur le caractère\0. Un compteur s'incrémente à chaque tour de boucle, et c'est ce compteur que la fonction retourne.

Tiens, tout ça m'a donné envie d'écrire moi-même une fonction similaire àstrlen. Ça vous permettra en plus de bien comprendre comment la fonction marche :

int longueurChaine(const char* chaine);

int main(int argc, char *argv[])
{
    char chaine[] = "Salut";
    int longueur = 0;

    longueur = longueurChaine(chaine);

    printf("La chaine %s fait %d caracteres de long", chaine, longueur);

    
    return 0;
}

int longueurChaine(const char* chaine)
{
    int nombreDeCaracteres = 0;
    char caractereActuel = 0;

    do
    {
        caractereActuel = chaine[nombreDeCaracteres];
        nombreDeCaracteres++;
    }
    while(caractereActuel != '\0'); // On boucle tant qu'on n'est pas arrivé à l'\0

    nombreDeCaracteres--; // On retire 1 caractère de long pour ne pas compter le caractère \0

    return nombreDeCaracteres;
}

La fonctionlongueurChainefait une boucle sur le tableauchaine. Elle stocke les caractères un par un danscaractereActuel. Dès quecaractèreActuelvaut'\0', la boucle s'arrête.
À chaque passage dans la boucle, on ajoute 1 au nombre de caractères qu'on a analysés.

À la fin de la boucle, on retire 1 caractère au nombre total de caractères qu'on a comptés. Cela permet de ne pas compter le caractère\0dans le lot. Enfin, on retournenombreDeCaractereset le tour est joué !

strcpy: copier une chaîne dans une autre

La fonctionstrcpy(comme « string copy ») permet de copier une chaîne à l'intérieur d'une autre.
Son prototype est :

char* strcpy(char* copieDeLaChaine, const char* chaineACopier);

Cette fonction prend deux paramètres :

  • copieDeLaChaine: c'est un pointeur vers unchar*(tableau dechar). C'est dans ce tableau que la chaîne sera copiée ;

  • chaineACopier: c'est un pointeur vers un autre tableau dechar. Cette chaîne sera copiée danscopieDeLaChaine.

La fonction renvoie un pointeur surcopieDeLaChaine, ce qui n'est pas très utile. En général, on ne récupère pas ce que cette fonction renvoie. Testons cela :

int main(int argc, char *argv[])
{
    /* On crée une chaîne "chaine" qui contient un peu de texte
    et une copie (vide) de taille 100 pour être sûr d'avoir la place
    pour la copie */
    
    char chaine[] = "Texte", copie[100] = {0};

    strcpy(copie, chaine); // On copie "chaine" dans "copie"

    // Si tout s'est bien passé, la copie devrait être identique à chaine
    printf("chaine vaut : %s\n", chaine);
    printf("copie vaut : %s\n", copie);

    return 0;
}
chaine vaut : Texte
copie vaut : Texte

On voit quechainevaut « Texte ». Jusque-là, c'est normal.
Par contre, on voit aussi que la variablecopie, qui était vide au départ, a été remplie par le contenu dechaine. La chaîne a donc bien été copiée danscopie.

Schématiquement, la copie a fonctionné comme sur la fig. suivante.

Copie d'une chaîne de caractères

Chaque caractère dechainea été placé danscopie.
La chaînecopiecontient de nombreux caractères inutilisés, vous l'aurez remarqué. Je lui ai donné la taille 100 par sécurité, mais en toute rigueur, la taille 6 aurait suffit. L'avantage de créer un tableau un peu plus grand, c'est que de cette façon la chaînecopiesera capable de recevoir d'autres chaînes peut-être plus grandes dans la suite du programme.

strcat: concaténer 2 chaînes

Cette fonction ajoute une chaîne à la suite d'une autre. On appelle cela la concaténation.
Supposons que l'on ait les variables suivantes :

  • chaine1 = "Salut "

  • chaine2 = "Mateo21"

Si je concatènechaine2danschaine1, alorschaine1vaudra"Salut Mateo21". Quant à
chaine2, elle n'aura pas changé et vaudra donc toujours"Mateo21". Seulechaine1est modifiée.

C'est exactement ce que faitstrcat, dont voici le prototype :

char* strcat(char* chaine1, const char* chaine2);

Comme vous pouvez le voir,chaine2ne peut pas être modifiée car elle est définie comme constante dans le prototype de la fonction.
La fonction retourne un pointeur verschaine1, ce qui, comme pourstrcpy, ne sert pas à grand-chose dans le cas présent : on peut donc ignorer ce que la fonction nous renvoie.

La fonction ajoute àchaine1le contenu dechaine2. Regardons-y de plus près :

int main(int argc, char *argv[])
{
    /* On crée 2 chaînes. chaine1 doit être assez grande pour accueillir
    le contenu de chaine2 en plus, sinon risque de plantage */
    char chaine1[100] = "Salut ", chaine2[] = "Mateo21";

    strcat(chaine1, chaine2); // On concatène chaine2 dans chaine1

    // Si tout s'est bien passé, chaine1 vaut "Salut Mateo21"
    printf("chaine1 vaut : %s\n", chaine1);
    // chaine2 n'a pas changé :
    printf("chaine2 vaut toujours : %s\n", chaine2);

    return 0;
}
chaine1 vaut : Salut Mateo21
chaine2 vaut toujours : Mateo21

Vérifiez absolument quechaine1est assez grande pour qu'on puisse lui ajouter le contenu dechaine2, sinon vous ferez un débordement en mémoire qui peut conduire à un plantage.
C'est pour cela que j'ai définichaine1de taille 100. Quant àchaine2, j'ai laissé l'ordinateur calculer sa taille (je n'ai donc pas précisé la taille) car cette chaîne n'est pas modifiée, il n'y a donc pas besoin de la rendre plus grande que nécessaire.

La fig. suivante résume le fonctionnement de la concaténation.

Concaténation de chaînes

Le tableauchaine2a été ajouté à la suite dechaine1(qui comprenait une centaine de cases).
Le\0dechaine1a été supprimé (en fait, il a été remplacé par le M de Mateo21). En effet, il ne faut pas laisser un\0au milieu de la chaîne, sinon celle-ci aurait été « coupée » au milieu ! On ne met qu'un\0à la fin de la chaîne, une fois qu'elle est finie.

strcmp: comparer 2 chaînes

strcmpcompare 2 chaînes entre elles. Voici son prototype :

int strcmp(const char* chaine1, const char* chaine2);

Les variableschaine1etchaine2sont comparées. Comme vous le voyez, aucune d'elles n'est modifiée car elles sont indiquées comme constantes.

Il est important de récupérer ce que la fonction renvoie. En effet,strcmprenvoie :

  • 0 si les chaînes sont identiques ;

  • une autre valeur (positive ou négative) si les chaînes sont différentes.

Voici un code de test :

int main(int argc, char *argv[])
{
    char chaine1[] = "Texte de test", chaine2[] = "Texte de test";

    if (strcmp(chaine1, chaine2) == 0) // Si chaînes identiques
    {
        printf("Les chaines sont identiques\n");
    }
    else
    {
        printf("Les chaines sont differentes\n");
    }

    return 0;
}
Les chaines sont identiques

Les chaînes étant identiques, la fonctionstrcmpa renvoyé le nombre 0.
Notez que j'aurais pu stocker ce que renvoiestrcmpdans une variable de typeint. Toutefois, ce n'est pas obligatoire, on peut directement mettre la fonction dans leifcomme je l'ai fait.

Je n'ai pas grand-chose à ajouter à propos de cette fonction. Elle est assez simple à utiliser en fait, mais il ne faut pas oublier que 0 signifie « identique » et une autre valeur signifie « différent ». C'est la seule source d'erreurs possible ici.

strchr: rechercher un caractère

La fonctionstrchrrecherche un caractère dans une chaîne.
Prototype :

char* strchr(const char* chaine, int caractereARechercher);

La fonction prend 2 paramètres :

  • chaine: la chaîne dans laquelle la recherche doit être faite ;

  • caractereARechercher: le caractère que l'on doit rechercher dans la chaîne.

La fonction renvoie un pointeur vers le premier caractère qu'elle a trouvé, c'est-à-dire qu'elle renvoie l'adresse de ce caractère dans la mémoire. Elle renvoieNULLsi elle n'a rien trouvé.
Dans l'exemple suivant, je récupère ce pointeur danssuiteChaine:

int main(int argc, char *argv[])
{
    char chaine[] = "Texte de test", *suiteChaine = NULL;

    suiteChaine = strchr(chaine, 'd');
    if (suiteChaine != NULL) // Si on a trouvé quelque chose
    {
        printf("Voici la fin de la chaine a partir du premier d : %s", suiteChaine);
    }

    return 0;
}
Voici la fin de la chaine a partir du premier d : de test

Avez-vous bien compris ce qu'il se passe ici ? C'est un peu particulier.
En fait,suiteChaineest un pointeur commechaine, sauf quechainepointe sur le premier caractère (le'T'majuscule), tandis quesuiteChainepointe sur le premier caractère'd'qui a été trouvé danschaine.

Le schéma de la fig. suivante vous montre où pointe chaque pointeur :

Pointeurs et chaînes

chainecommence au début de la chaine ('T'majuscule), tandis quesuiteChainepointe sur le'd'minuscule.

Lorsque je fais unprintfdesuiteChaine, il est donc normal que l'on m'affiche juste « de test ». La fonctionprintfaffiche tous les caractères qu'elle rencontre ('d', 'e', ' ', 't', 'e', 's', 't') jusqu'à ce qu'elle tombe sur le\0qui lui dit que la chaîne s'arrête là.

Variante

Il existe une fonctionstrrchrstrictement identique àstrchr, sauf que celle-là renvoie un pointeur vers le dernier caractère qu'elle a trouvé dans la chaîne plutôt que vers le premier.

strpbrk: premier caractère de la liste

Cette fonction ressemble beaucoup à la précédente. Celle-ci recherche un des caractères dans la liste que vous lui donnez sous forme de chaîne, contrairement àstrchrqui ne peut rechercher qu'un seul caractère à la fois.

Par exemple, si on forme la chaîne"xds"et qu'on en fait une recherche dans"Texte de test", la fonction renvoie un pointeur vers le premier de ces caractères qu'elle y a trouvé. En l'occurrence, le premier caractère de"xds"qu'elle trouve dans"Texte de test"est lex, doncstrpbrkrenverra un pointeur sur'x'.

Prototype :

char* strpbrk(const char* chaine, const char* lettresARechercher);

Testons la fonction :

int main(int argc, char *argv[])
{
    char *suiteChaine;

    // On cherche la première occurrence de x, d ou s dans "Texte de test" 
    suiteChaine = strpbrk("Texte de test", "xds");

    if (suiteChaine != NULL)
    {
        printf("Voici la fin de la chaine a partir du premier des caracteres trouves : %s", suiteChaine);
    }

    return 0;
}
Voici la fin de la chaine a partir du premier des caracteres trouves :
xte de test

Pour cet exemple, j'ai directement écrit les valeurs à envoyer à la fonction (entre guillemets). Nous ne sommes en effet pas obligés d'employer une variable à tous les coups, on peut très bien écrire la chaîne directement.
Il faut simplement retenir la règle suivante :

  • si vous utilisez les guillemets"", cela signifie chaîne ;

  • si vous utilisez les apostrophes'', cela signifie caractère.

strstr: rechercher une chaîne dans une autre

Cette fonction recherche la première occurrence d'une chaîne dans une autre chaîne.
Son prototype est :

char* strstr(const char* chaine, const char* chaineARechercher);

Le prototype est similaire àstrpbrk, mais attention à ne pas confondre :strpbrkrecherche UN des caractères, tandis questrstrrecherche toute la chaîne.

Exemple :

int main(int argc, char *argv[])
{
    char *suiteChaine;

    // On cherche la première occurrence de "test" dans "Texte de test" :
    suiteChaine = strstr("Texte de test", "test");
    if (suiteChaine != NULL)
    {
        printf("Premiere occurrence de test dans Texte de test : %s\n", suiteChaine);
    }

    return 0;
}
Premiere occurrence de test dans Texte de test : test

La fonctionstrstrrecherche la chaîne "test" dans "Texte de test".
Elle renvoie, comme les autres, un pointeur quand elle a trouvé ce qu'elle cherchait. Elle renvoieNULLsi elle n'a rien trouvé.

Jusqu'ici, je me suis contenté d'afficher la chaîne à partir du pointeur retourné par les fonctions. Dans la pratique, ça n'est pas très utile. Vous ferez juste unif (resultat != NULL)pour savoir si la recherche a ou non donné quelque chose, et vous afficherez « Le texte que vous recherchiez a été trouvé ».

sprintf: écrire dans une chaîne

Ce nom doit vaguement vous rappeler quelque chose. Cette fonction ressemble énormément auprintfque vous connaissez mais, au lieu d'écrire à l'écran,sprintfécrit dans… une chaîne ! D'où son nom d'ailleurs, qui commence par le « s » de « string » (chaîne en anglais).

C'est une fonction très pratique pour mettre en forme une chaîne. Petit exemple :

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

int main(int argc, char *argv[])
{
    char chaine[100];
    int age = 15;

    // On écrit "Tu as 15 ans" dans chaine
    sprintf(chaine, "Tu as %d ans !", age);

    // On affiche chaine pour vérifier qu'elle contient bien cela :
    printf("%s", chaine);

    return 0;
}
Tu as 15 ans !

Elle s'utilise de la même manière queprintf, mis à part le fait que vous devez lui donner en premier paramètre un pointeur vers la chaîne qui doit recevoir le texte.

Dans mon exemple, j'écris danschaine« Tu as %d ans », où%dest remplacé par le contenu de la variableage. Toutes les règles duprintfs'appliquent, vous pouvez donc si vous le voulez mettre des%spour insérer d'autres chaînes à l'intérieur de votre chaîne !

Comme d'habitude, vérifiez que votre chaîne est suffisamment grande pour accueillir tout le texte que lesprintfva lui envoyer. Sinon, comme on l'a vu, vous vous exposez à des dépassements de mémoire et donc à un plantage de votre programme.

En résumé

  • Un ordinateur ne sait pas manipuler du texte, il ne connaît que les nombres. Pour régler le problème, on associe à chaque lettre de l'alphabet un nombre correspondant dans une table appelée la table ASCII.

  • Le typecharest utilisé pour stocker une et une seule lettre. Il stocke en réalité un nombre mais ce nombre est automatiquement traduit par l'ordinateur à l'affichage.

  • Pour créer un mot ou une phrase, on doit construire une chaîne de caractères. Pour cela, on utilise un tableau dechar.

  • Toute chaîne de caractère se termine par un caractère spécial appelé\0qui signifie « fin de chaîne ».

  • Il existe de nombreuses fonctions toutes prêtes de manipulation des chaînes dans la bibliothèque string. Il faut inclurestring.hpour pouvoir les utiliser.

Exemple de certificat de réussite
Exemple de certificat de réussite