Langage C

les chaines de caractères en C

Les chaînes sont définies comme un tableau de caractères. La différence entre un tableau de caractères et une chaîne est que la chaîne se termine par un caractère spécial "\0".

Déclaration de chaîne

Déclarer une chaîne est aussi simple que déclarer un tableau à une dimension. Vous trouverez ci-dessous la syntaxe de base pour déclarer une chaîne.

                                char nom_chaine[taille];
                            

Dans la syntaxe ci-dessus, str_name désigne n'importe quel nom attribué à la variable de chaîne. La taille est utilisée pour définir la longueur de la chaîne, c'est-à-dire le nombre de caractères que les chaînes vont stocker. N'oubliez pas qu'il existe un caractère de fin supplémentaire, le caractère Null ('\0'), utilisé pour indiquer la fin d'une chaîne qui diffère des chaînes des tableaux de caractères normaux.

Initialiser une chaîne

Une chaîne peut être initialisée de différentes manières. Nous allons expliquer cela à l'aide d'un exemple.
Voici un exemple pour déclarer une chaîne ville et l'initialiser avec "Meknes".

Exemple 1 :
                                char ville[] = "Meknes";
                                char ville[20] = "Meknes";
                                char ville[]={'M','e','k','n','e','s','\0'};
                                char ville[20]={'M','e','k','n','e','s','\0'};
                            

Examinons maintenant un exemple de programme pour bien comprendre la déclaration et l’initialisation d’une chaîne en C ainsi que l’impression d’une chaîne.

Exemple 2 :
                                #include< stdio.h>

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

Nous pouvons voir dans le programme ci-dessus que les chaînes peuvent être affichées en utilisant des instructions printf normales, tout comme nous affichons n'importe quelle autre variable.
Contrairement aux tableaux, nous n'avons pas besoin d'afficher une chaîne, caractère par caractère.
Le langage C ne fournit pas de type de données intégré pour les chaînes, mais il dispose d'un spécificateur d'accès %s qui peut être utilisé pour afficher et lire directement des chaînes.

Ci-dessous est un exemple de programme pour lire une chaîne de caractères

Exemple 3 :
                                #include< stdio.h>

                                int main(void){
                                    char ville[20];
                                    scanf("%s",ville); 
                                    printf("%s", ville);
                                    return 0;
                                }
                            

Vous pouvez voir dans le programme ci-dessus que cette chaîne peut également être lue à l'aide d'une seule instruction scanf.

Vous pensez peut-être aussi que nous n’avons pas utilisé le signe "&" avec le nom de chaîne "ville" dans la déclaration scanf!
Pour comprendre cela, vous devrez vous rappeler vos connaissances de scanf.
Nous savons que le signe "&" sert à fournir l’adresse de la variable à la fonction scanf() pour stocker la valeur lue en mémoire. Comme ville[] est un tableau de caractères, utiliser ville sans accolades "[" et "]" donnera l’adresse de base de cette chaîne. C’est pourquoi nous n’avons pas utilisé "&" dans ce cas, car nous fournissons déjà l’adresse de base de la chaîne à scanf.

Chaînes utilisant des pointeurs de caractères

Les chaînes de pointeur de caractère peuvent être stockées de deux manières:

Chaîne en lecture seule dans un segment partagé.

Lorsqu'une valeur de chaîne est directement affectée à un pointeur, dans la plupart des compilateurs, elle est stockée dans un bloc en lecture seule (généralement dans un segment de données) partagé entre les fonctions.

                                    char *ville  =  "Meknes"; 
                            

Dans la ligne ci-dessus, "Meknes" est stocké dans un emplacement partagé en lecture seule, mais le pointeur ville est stocké dans une mémoire en lecture-écriture.
Vous pouvez changer ville pour indiquer autre chose, mais vous ne pouvez pas changer la valeur pour le moment. Donc, ce type de chaîne ne doit être utilisé que lorsque nous ne voulons pas modifier la chaîne à un stade ultérieur du programme.

Alloué dynamiquement dans le segment de tas

Les chaînes sont stockées comme d'autres objets alloués dynamiquement en C et peuvent être partagées entre des fonctions.

Exemple 4 :
                                #include< stdio.h>
                                #include < stdlib.h>

                                int main(void){
                                    char *ville;
                                    int taille = 7;
                                    ville = (char *)malloc(sizeof(char)*taille); 
                                    *(ville+0) = 'M';
                                    *(ville+1) = 'e';
                                    *(ville+2) = 'k';
                                    *(ville+3) = 'n';
                                    *(ville+4) = 'e';
                                    *(ville+5) = 's';
                                    *(ville+6) = '\0';

                                    puts(ville);

                                    return 0;
                                }
                            
Meknes
Exemple 5 :

Le programme ci-dessous peut se bloquer (erreur de segmentation) car la ligne *(ville+1) = 'n' essaie d’écrire dans une mémoire à lecture seule.

                                #include< stdio.h>

                                int main(void){
                                    char *ville  =  "Meknes";
                                    *(ville+1) = 'n';

                                    return 0;
                                }
                            
Bus error: 10
Exemple 6 :

Le programme ci-dessous fonctionne parfaitement puisque ville[] est stocké dans un segment de pile en écriture.

                                #include< stdio.h>

                                int main(void){
                                    char ville[]  =  "Meknes";
                                    *(ville+1) = 'n';

                                    puts(ville);
                                    return 0;
                                }
                            
Mnknes
Exemple 7 : Essayer de retourner une chaîne à partir d'une fonction

Le programme ci-dessous fonctionne parfaitement car la chaîne est stockée dans un segment partagé et les données stockées y restent même après le retour de getVille()

                                #include< stdio.h>
                                char *getVille()
                                {
                                    char *ville  =  "Meknes";
                                    return ville;
                                }
                                int main(void){
                                    printf("%s", getVille()); 
                                    return 0;
                                }
                            
Meknes
Exemple 8

Cependant, le programme ci-dessous peut afficher des données erronées, car la Chaîne est stockée dans le cadre de pile de la fonction getVille() et les données peuvent ne pas être présentes après le retour de getVille().

                                #include< stdio.h>
                                char *getVille()
                                {
                                    char ville[]  =  "Meknes";
                                    return ville;
                                }
                                int main(void){
                                    printf("%s", getVille()); 
                                    return 0;
                                }
                            
prog.c:7:12: warning: address of stack memory associated with local variable 'ville' returned [-Wreturn-stack-address]
return ville;
^~~~~
1 warning generated.

Passer une chaîne de caractères en paramètres

Comme les chaînes sont des tableaux de caractères, nous pouvons donc les transmettre pour fonctionner de la même manière que nous transmettons un tableau à une fonction. Voici un exemple de programme pour ce faire:

Exemple 9 :
                                #include< stdio.h>

                                void afficher(str[])
                                {
                                    printf("%s ", str);
                                }

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

                                    afficher(ville);
                                    return 0;
                                }
                            

puts() vs printf() pour afficher une chaîne

puts() peut être préféré pour l'impression d'une chaîne de caractères car il est généralement moins coûteux, et si la chaîne de caractères a des caractères de formatage comme "%", alors printf() donnerait des résultats inattendus.
De plus, si la chaîne "str" est une chaîne de caractères d'entrée utilisateur, l'utilisation de printf() pourrait causer des problèmes de sécurité.
Notez également que puts() déplace le curseur à la ligne suivante. Si vous ne voulez pas que le curseur soit déplacé à la ligne suivante, alors vous pouvez utiliser la variation suivante de puts().

                                fputs(str, stdout)
                            
Exemple 10 :
                                #include< stdio.h>

                                int main(void){
                                    puts("Sedoki ");
                                    puts("Mostafa"); 

                                    return 0;
                                }
                            
Sedoki Mostafa
Exemple 11 :
                                #include< stdio.h>

                                int main(void){
                                    fputs("Sedoki ", stdout);
                                    fputs("Mostafa", stdout); 

                                    return 0;
                                }
                            
Sedoki Mostafa
Exemple 12 :
                                #include< stdio.h>

                                int main(void)
                                {
                                    printf("Sedokimo%stafa");

                                    return 0;
                                }
                            
prog.c:5:22: warning: more '%' conversions than data arguments [-Wformat]
printf("Sedokimo%stafa");
~^
1 warning generated.
Exemple 13 :
                                #include< stdio.h>

                                int main(void)
                                {
                                    puts("Sedokimo%stafa");

                                    return 0;
                                }
                            
Sedokimo%stafa

fgets() and gets()

Pour lire une valeur de chaîne de caractères avec des espaces, nous pouvons utiliser gets() ou fgets().

fgets()

Il lit une ligne du flux spécifié et la stocke dans la chaîne pointée par str. Il s'arrête lorsque soit les caractères (n - 1) sont lus, soit le caractère newline(\n) est lu, soit la fin du fichier est atteinte, selon la première éventualité.

  • Il suit certains paramètres tels que la longueur maximale, le buffer, la référence du périphérique d'entrée.
  • Il est sûr à utiliser car il vérifie la taille du tableau lié.
Exemple 14 :
                                #include< stdio.h>
                                #define MAX 15

                                int main(void)
                                {
                                    char buf[MAX];
                                    fgets(buf, MAX, stdin); 
                                    printf("la chaine est : %s\n", buf); 

                                    return 0;
                                }
                            
mostafa est un professeur d'informatique
la chaine est : mostafa est un
gets()

Lit les caractères de l'entrée standard (stdin) et les stocke sous forme de chaîne dans 'str' jusqu'à ce qu'un caractère newline(\n) ou la fin du fichier soit atteinte.

Son utilisation n'est pas sûre car elle ne vérifie pas la taille du tableau lié.
Exemple 15 :
                                #include< stdio.h>
                                #define MAX 6

                                int main(void)
                                {
                                    char buf[MAX];
                                    printf("Saisir une chaine : "); 
                                    gets(buf); 
                                    printf("la chaine est : %s\n", buf); 
                                    return 0;
                                }
                            
warning: this program uses gets(), which is unsafe.
Saisir une chaine : mostafa est un professeur
la chaine est : mostafa est un professeur
Segmentation fault: 11

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :