La chaîne peut être définie comme un tableau unidimensionnel de caractères terminé par un nul («  »). Le tableau de caractères ou la chaîne est utilisé pour manipuler du texte tel que des mots ou des phrases. Chaque caractère du tableau occupe un octet de mémoire et le dernier caractère doit toujours être 0. Le caractère de fin («  ») est important dans une chaîne car c'est le seul moyen d'identifier où se termine la chaîne. Lorsque nous définissons une chaîne comme char s[10], le caractère s[10] est implicitement initialisé avec le null dans la mémoire.

Il existe deux manières de déclarer une chaîne en langage C.

1. Par tableau de caractères
2. Par chaîne littérale

Voyons l'exemple de déclaration chaîne par tableau de caractères en langage C.

 char ch[10]={'j', 'a', 'v', 'a', 't', 'p', 'o', 'i', 'n', 't', ''}; 

Comme nous le savons, l'index du tableau commence à 0, il sera donc représenté comme dans la figure ci-dessous.

Lors de la déclaration d'une chaîne, la taille n'est pas obligatoire. Nous pouvons donc écrire le code ci-dessus comme indiqué ci-dessous :

 char ch[]={'j', 'a', 'v', 'a', 't', 'p', 'o', 'i', 'n', 't', ''}; 

On peut également définir le chaîne par la chaîne littérale en langage C. Par exemple:

 char ch[]='javatpoint'; 

Dans ce cas, '' sera ajouté à la fin de la chaîne par le compilateur.

Différence entre un tableau de caractères et une chaîne littérale

Il existe deux différences principales entre un tableau de caractères et un littéral.

• Nous devons ajouter nous-mêmes le caractère nul '' à la fin du tableau alors qu'il est ajouté en interne par le compilateur dans le cas du tableau de caractères.
• La chaîne littérale ne peut pas être réaffectée à un autre jeu de caractères alors que nous pouvons réaffecter les caractères du tableau.

Exemple de chaîne en C

Voyons un exemple simple où une chaîne est déclarée et en cours d'impression. Le '%s' est utilisé comme spécificateur de format pour la chaîne en langage C.

 #include #include int main(){ char ch[11]={'j', 'a', 'v', 'a', 't', 'p', 'o', 'i', 'n', 't', ''}; char ch2[11]='javatpoint'; printf('Char Array Value is: %s
', ch); printf('String Literal Value is: %s
', ch2); return 0; } 

Sortir

 Char Array Value is: javatpoint String Literal Value is: javatpoint 

Chaîne de déplacement

Le parcours de la chaîne est l’un des aspects les plus importants dans tous les langages de programmation. Nous devrons peut-être manipuler un texte très volumineux, ce qui peut être fait en parcourant le texte. Le parcours d’une chaîne est quelque peu différent du parcours d’un tableau d’entiers. Nous avons besoin de connaître la longueur du tableau pour parcourir un tableau d'entiers, alors que nous pouvons utiliser le caractère nul dans le cas d'une chaîne pour identifier la fin de la chaîne et terminer la boucle.

Il existe donc deux manières de parcourir une chaîne.

• En utilisant la longueur de la chaîne
• En utilisant le caractère nul.

Discutons de chacun d'eux.

Utiliser la longueur de la chaîne

Voyons un exemple de comptage du nombre de voyelles dans une chaîne.

 #include void main () { char s[11] = &apos;javatpoint&apos;; int i = 0; int count = 0; while(i<11) { if(s[i]="=&apos;a&apos;" || s[i]="=" 'e' 'i' 'u' 'o') count ++; } i++; printf('the number of vowels %d',count); < pre> <p> <strong>Output</strong> </p> <pre> The number of vowels 4 </pre> <h3>Using the null character</h3> <p>Let&apos;s see the same example of counting the number of vowels by using the null character.</p> <pre> #include void main () { char s[11] = &apos;javatpoint&apos;; int i = 0; int count = 0; while(s[i] != NULL) { if(s[i]==&apos;a&apos; || s[i] == &apos;e&apos; || s[i] == &apos;i&apos; || s[i] == &apos;u&apos; || s[i] == &apos;o&apos;) { count ++; } i++; } printf(&apos;The number of vowels %d&apos;,count); } </pre> <p> <strong>Output</strong> </p> <pre> The number of vowels 4 </pre> <h2>Accepting string as the input</h2> <p>Till now, we have used scanf to accept the input from the user. However, it can also be used in the case of strings but with a different scenario. Consider the below code which stores the string while space is encountered.</p> <pre> #include void main () { char s[20]; printf(&apos;Enter the string?&apos;); scanf(&apos;%s&apos;,s); printf(&apos;You entered %s&apos;,s); } </pre> <p> <strong>Output</strong> </p> <pre> Enter the string?javatpoint is the best You entered javatpoint </pre> <p>It is clear from the output that, the above code will not work for space separated strings. To make this code working for the space separated strings, the minor changed required in the scanf function, i.e., instead of writing scanf(&apos;%s&apos;,s), we must write: scanf(&apos;%[^
]s&apos;,s) which instructs the compiler to store the string s while the new line (
) is encountered. Let&apos;s consider the following example to store the space-separated strings.</p> <pre> #include void main () { char s[20]; printf(&apos;Enter the string?&apos;); scanf(&apos;%[^
]s&apos;,s); printf(&apos;You entered %s&apos;,s); } </pre> <p> <strong>Output</strong> </p> <pre> Enter the string?javatpoint is the best You entered javatpoint is the best </pre> <p>Here we must also notice that we do not need to use address of (&amp;) operator in scanf to store a string since string s is an array of characters and the name of the array, i.e., s indicates the base address of the string (character array) therefore we need not use &amp; with it.</p> <h3>Some important points</h3> <p>However, there are the following points which must be noticed while entering the strings by using scanf.</p> <ul> <li>The compiler doesn&apos;t perform bounds checking on the character array. Hence, there can be a case where the length of the string can exceed the dimension of the character array which may always overwrite some important data.</li> <li>Instead of using scanf, we may use gets() which is an inbuilt function defined in a header file string.h. The gets() is capable of receiving only one string at a time.</li> </ul> <h2>Pointers with strings</h2> <p>We have used pointers with the array, functions, and primitive data types so far. However, pointers can be used to point to the strings. There are various advantages of using pointers to point strings. Let us consider the following example to access the string via the pointer.</p> <pre> #include void main () { char s[11] = &apos;javatpoint&apos;; char *p = s; // pointer p is pointing to string s. printf(&apos;%s&apos;,p); // the string javatpoint is printed if we print p. } </pre> <p> <strong>Output</strong> </p> <pre> javatpoint </pre> <img src="//techcodeview.com/img/c-tutorial/32/c-strings-2.webp" alt="C Strings"> <p>As we know that string is an array of characters, the pointers can be used in the same way they were used with arrays. In the above example, p is declared as a pointer to the array of characters s. P affects similar to s since s is the base address of the string and treated as a pointer internally. However, we can not change the content of s or copy the content of s into another string directly. For this purpose, we need to use the pointers to store the strings. In the following example, we have shown the use of pointers to copy the content of a string into another.</p> <pre> #include void main () { char *p = &apos;hello javatpoint&apos;; printf(&apos;String p: %s
&apos;,p); char *q; printf(&apos;copying the content of p into q...
&apos;); q = p; printf(&apos;String q: %s
&apos;,q); } </pre> <p> <strong>Output</strong> </p> <pre> String p: hello javatpoint copying the content of p into q... String q: hello javatpoint </pre> <p>Once a string is defined, it cannot be reassigned to another set of characters. However, using pointers, we can assign the set of characters to the string. Consider the following example.</p> <pre> #include void main () { char *p = &apos;hello javatpoint&apos;; printf(&apos;Before assigning: %s
&apos;,p); p = &apos;hello&apos;; printf(&apos;After assigning: %s
&apos;,p); } </pre> <p> <strong>Output</strong> </p> <pre> Before assigning: hello javatpoint After assigning: hello </pre> <hr></11)>

Utiliser le caractère nul

Voyons le même exemple de comptage du nombre de voyelles en utilisant le caractère nul.

 #include void main () { char s[11] = 'javatpoint'; int i = 0; int count = 0; while(s[i] != NULL) { if(s[i]=='a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'u' || s[i] == 'o') { count ++; } i++; } printf('The number of vowels %d',count); } 

Sortir

 The number of vowels 4 

Accepter la chaîne comme entrée

Jusqu'à présent, nous avons utilisé scanf pour accepter les entrées de l'utilisateur. Cependant, il peut également être utilisé dans le cas de chaînes mais avec un scénario différent. Considérez le code ci-dessous qui stocke la chaîne lorsqu'un espace est rencontré.

 #include void main () { char s[20]; printf('Enter the string?'); scanf('%s',s); printf('You entered %s',s); } 

Sortir

 Enter the string?javatpoint is the best You entered javatpoint 

Il ressort clairement du résultat que le code ci-dessus ne fonctionnera pas pour les chaînes séparées par des espaces. Pour que ce code fonctionne pour les chaînes séparées par des espaces, la modification mineure requise dans la fonction scanf, c'est-à-dire qu'au lieu d'écrire scanf('%s',s), nous devons écrire : scanf('%[^ ]s' ,s) qui demande au compilateur de stocker la chaîne s pendant que la nouvelle ligne ( ) est rencontrée. Considérons l'exemple suivant pour stocker les chaînes séparées par des espaces.

 #include void main () { char s[20]; printf('Enter the string?'); scanf('%[^
]s',s); printf('You entered %s',s); } 

Sortir

 Enter the string?javatpoint is the best You entered javatpoint is the best 

Ici, nous devons également remarquer que nous n'avons pas besoin d'utiliser l'adresse de l'opérateur (&) dans scanf pour stocker une chaîne puisque la chaîne s est un tableau de caractères et le nom du tableau, c'est-à-dire s indique l'adresse de base de la chaîne ( tableau de caractères), nous n'avons donc pas besoin d'utiliser & avec.

Quelques points importants

Cependant, les points suivants doivent être pris en compte lors de la saisie des chaînes à l'aide de scanf.

• Le compilateur n'effectue pas de vérification des limites du tableau de caractères. Par conséquent, il peut arriver que la longueur de la chaîne dépasse la dimension du tableau de caractères, ce qui peut toujours écraser certaines données importantes.
• Au lieu d'utiliser scanf, nous pouvons utiliser gets() qui est une fonction intégrée définie dans un fichier d'en-tête string.h. gets() est capable de recevoir une seule chaîne à la fois.

Pointeurs avec des chaînes

Jusqu’à présent, nous avons utilisé des pointeurs avec le tableau, les fonctions et les types de données primitifs. Cependant, des pointeurs peuvent être utilisés pour pointer vers les chaînes. L’utilisation de pointeurs pour pointer des chaînes présente divers avantages. Considérons l'exemple suivant pour accéder à la chaîne via le pointeur.

 #include void main () { char s[11] = 'javatpoint'; char *p = s; // pointer p is pointing to string s. printf('%s',p); // the string javatpoint is printed if we print p. } 

Sortir

Sree Ramanujan

 javatpoint 

Comme nous savons que la chaîne est un tableau de caractères, les pointeurs peuvent être utilisés de la même manière qu’ils l’étaient avec les tableaux. Dans l'exemple ci-dessus, p est déclaré comme pointeur vers le tableau de caractères s. P affecte de la même manière que s puisque s est l'adresse de base de la chaîne et est traitée comme un pointeur en interne. Cependant, nous ne pouvons pas modifier le contenu de s ou copier directement le contenu de s dans une autre chaîne. Pour cela, nous devons utiliser les pointeurs pour stocker les chaînes. Dans l'exemple suivant, nous avons montré l'utilisation de pointeurs pour copier le contenu d'une chaîne dans une autre.

 #include void main () { char *p = 'hello javatpoint'; printf('String p: %s
',p); char *q; printf('copying the content of p into q...
'); q = p; printf('String q: %s
',q); } 

Sortir

 String p: hello javatpoint copying the content of p into q... String q: hello javatpoint 

Une fois qu'une chaîne est définie, elle ne peut pas être réaffectée à un autre jeu de caractères. Cependant, à l’aide de pointeurs, nous pouvons attribuer le jeu de caractères à la chaîne. Considérez l'exemple suivant.

 #include void main () { char *p = 'hello javatpoint'; printf('Before assigning: %s
',p); p = 'hello'; printf('After assigning: %s
',p); } 

Sortir

 Before assigning: hello javatpoint After assigning: hello