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 de
char en 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èque
string.h une 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 à inclure string.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ée
string.h, vous devez l'inclure en haut des fichiers
.c où vous en avez besoin :
Code : C
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
strlen est 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) :
Code : C | size_t strlen(const char* chaine);
|
size_t est un type spécial qui signifie que la fonction renvoie un nombre correspondant à une taille. Ce n'est pas un type de base comme int, long ou char, c'est un type « inventé ». Nous apprendrons nous aussi à créer nos propres types de variables quelques chapitres plus loin.
Pour le moment, on va se contenter de stocker la valeur renvoyée par strlen dans une variable de type int (l'ordinateur convertira de size_t en int automatiquement). En toute rigueur, il faudrait plutôt stocker le résultat dans une variable de type size_t, mais en pratique un int est suffisant pour cela.
La fonction prend un paramètre de type
const char*. Le
const (qui signifie constante, rappelez-vous) fait que la fonction
strlen « s'interdit » en quelque sorte de modifier votre chaîne. Quand vous voyez un
const, vous savez que la variable n'est pas modifiée par la fonction, elle est juste lue.
Testons la fonction
strlen :
Code : C 1
2
3
4
5
6
7
8
9
10
11
12
13 | 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 fonction
strlen est d'ailleurs facile à écrire. Il suffit de faire une boucle sur le tableau de
char qui 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 :
Code : C 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31 | 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 fonction
longueurChaine fait une boucle sur le tableau
chaine. Elle stocke les caractères un par un dans
caractereActuel. Dès que
caractèreActuel vaut
'\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
\0 dans le lot. Enfin, on retourne
nombreDeCaracteres et le tour est joué !
strcpy : copier une chaîne dans une autre
La fonction
strcpy (comme « string copy ») permet de copier une chaîne à l'intérieur d'une autre.
Son prototype est :
Code : C | char* strcpy(char* copieDeLaChaine, const char* chaineACopier);
|
Cette fonction prend deux paramètres :
- copieDeLaChaine : c'est un pointeur vers un char* (tableau de char). C'est dans ce tableau que la chaîne sera copiée ;
- chaineACopier : c'est un pointeur vers un autre tableau de char. Cette chaîne sera copiée dans copieDeLaChaine.
La fonction renvoie un pointeur sur
copieDeLaChaine, 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 :
Code : C 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | 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 que
chaine vaut « Texte ». Jusque-là, c'est normal.
Par contre, on voit aussi que la variable
copie, qui était vide au départ, a été remplie par le contenu de
chaine. La chaîne a donc bien été copiée dans
copie.
Vérifiez que la chaîne copie est assez grande pour accueillir le contenu de chaine. Si, dans mon exemple, j'avais défini copie[5] (ce qui n'est pas suffisant car il n'y aurait pas eu de place pour le \0), la fonction strcpy aurait « débordé en mémoire » et probablement fait planter votre programme. À éviter à tout prix, sauf si vous aimez faire planter votre ordinateur, bien sûr.
Schématiquement, la copie a fonctionné comme sur la fig. suivante.
Chaque caractère de
chaine a été placé dans
copie.
La chaîne
copie contient 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îne
copie sera 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ène
chaine2 dans
chaine1, alors
chaine1 vaudra
"Salut Mateo21". Quant à
chaine2, elle n'aura pas changé et vaudra donc toujours
"Mateo21". Seule
chaine1 est modifiée.
C'est exactement ce que fait
strcat, dont voici le prototype :
Code : C | char* strcat(char* chaine1, const char* chaine2);
|
Comme vous pouvez le voir,
chaine2 ne peut pas être modifiée car elle est définie comme constante dans le prototype de la fonction.
La fonction retourne un pointeur vers
chaine1, ce qui, comme pour
strcpy, ne sert pas à grand-chose dans le cas présent : on peut donc ignorer ce que la fonction nous renvoie.
La fonction ajoute à
chaine1 le contenu de
chaine2. Regardons-y de plus près :
Code : C 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 | 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 que
chaine1 est assez grande pour qu'on puisse lui ajouter le contenu de
chaine2, sinon vous ferez un débordement en mémoire qui peut conduire à un plantage.
C'est pour cela que j'ai défini
chaine1 de 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.
Le tableau
chaine2 a été ajouté à la suite de
chaine1 (qui comprenait une centaine de cases).
Le
\0 de
chaine1 a été supprimé (en fait, il a été remplacé par le M de Mateo21). En effet, il ne faut pas laisser un
\0 au 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
strcmp compare 2 chaînes entre elles. Voici son prototype :
Code : C | int strcmp(const char* chaine1, const char* chaine2);
|
Les variables
chaine1 et
chaine2 sont 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,
strcmp renvoie :
- 0 si les chaînes sont identiques ;
- une autre valeur (positive ou négative) si les chaînes sont différentes.
Il aurait été plus logique, je le reconnais, que la fonction renvoie 1 si les chaînes avaient été identiques pour dire « vrai » (rappelez-vous des booléens). La raison est simple : la fonction compare les valeurs de chacun des caractères un à un. Si tous les caractères sont identiques, elle renvoie 0. Si les caractères de la chaine1 sont supérieurs à ceux de la chaine2, la fonction renvoie un nombre positif. Si c'est l'inverse, la fonction renvoie un nombre négatif. Dans la pratique, on se sert surtout de strcmp pour vérifier si 2 chaînes sont identiques ou non.
Voici un code de test :
Code : C 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 | 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 fonction
strcmp a renvoyé le nombre 0.
Notez que j'aurais pu stocker ce que renvoie
strcmp dans une variable de type
int. Toutefois, ce n'est pas obligatoire, on peut directement mettre la fonction dans le
if comme 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 fonction
strchr recherche un caractère dans une chaîne.
Prototype :
Code : C | 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.
Vous remarquerez que caractereARechercher est de type int et non de type char. Ce n'est pas réellement un problème car, au fond, un caractère est et restera toujours un nombre. Néanmoins, on utilise quand même plus souvent un char qu'un int pour stocker un caractère en mémoire.
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 renvoie
NULL si elle n'a rien trouvé.
Dans l'exemple suivant, je récupère ce pointeur dans
suiteChaine :
Code : C 1
2
3
4
5
6
7
8
9
10
11
12 | 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,
suiteChaine est un pointeur comme
chaine, sauf que
chaine pointe sur le premier caractère (le
'T' majuscule), tandis que
suiteChaine pointe sur le premier caractère
'd' qui a été trouvé dans
chaine.
Le schéma de la fig. suivante vous montre où pointe chaque pointeur :
chaine commence au début de la chaine (
'T' majuscule), tandis que
suiteChaine pointe sur le
'd' minuscule.
Lorsque je fais un
printf de
suiteChaine, il est donc normal que l'on m'affiche juste « de test ». La fonction
printf affiche tous les caractères qu'elle rencontre ('d', 'e', ' ', 't', 'e', 's', 't') jusqu'à ce qu'elle tombe sur le
\0 qui lui dit que la chaîne s'arrête là.
Variante
Il existe une fonction
strrchr strictement 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 à
strchr qui 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 le
x, donc
strpbrk renverra un pointeur sur
'x'.
Prototype :
Code : C | char* strpbrk(const char* chaine, const char* lettresARechercher);
|
Testons la fonction :
Code : C 1
2
3
4
5
6
7
8
9
10
11
12
13
14 | 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 :
Code : C | char* strstr(const char* chaine, const char* chaineARechercher);
|
Le prototype est similaire à
strpbrk, mais attention à ne pas confondre :
strpbrk recherche UN des caractères, tandis que
strstr recherche toute la chaîne.
Exemple :
Code : C 1
2
3
4
5
6
7
8
9
10
11
12
13 | 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 fonction
strstr recherche la chaîne "test" dans "Texte de test".
Elle renvoie, comme les autres, un pointeur quand elle a trouvé ce qu'elle cherchait. Elle renvoie
NULL si 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 un
if (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
Cette fonction se trouve dans stdio.h contrairement aux autres fonctions que nous avons étudiées jusqu'ici, qui étaient dans string.h.
Ce nom doit vaguement vous rappeler quelque chose. Cette fonction ressemble énormément au
printf que 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 :
Code : C 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | #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;
}
|
Elle s'utilise de la même manière que
printf, 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 dans
chaine « Tu as %d ans », où
%d est remplacé par le contenu de la variable
age. Toutes les règles du
printf s'appliquent, vous pouvez donc si vous le voulez mettre des
%s pour 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 le
sprintf va lui envoyer. Sinon, comme on l'a vu, vous vous exposez à des dépassements de mémoire et donc à un plantage de votre programme.
Les chaînes de caractères
Cachander
Trouvez une formation
Suggestions
Flux RSS News
Twitter
Facebook
Google+