Comment utiliser le littéral de chaîne C++

How Use C String Literal



Le clavier de l'ordinateur comporte des caractères imprimés. Lorsque vous appuyez sur une touche, vous voyez le caractère à l'écran. Remarque : l'espace est aussi un caractère. Un littéral de chaîne est une séquence de caractères. Cet article explique comment utiliser les littéraux de chaîne C++. Vous devez connaître les tableaux et les pointeurs C++ pour comprendre cet article.

Caractère littéral

Un littéral de caractère est un caractère entre guillemets simples. Donc,







carboniserident1= 'À'; carboniserident2= 'b'; carboniserident3= '4'; carboniserident4= '6';

sont toutes des définitions différentes des caractères. Notez qu'un chiffre entre guillemets simples est un caractère et non un entier.



Une séquence d'échappement telle que (voir ci-dessous) entre guillemets simples, est un caractère. Donc,



carboniserident1= '' ';

est un personnage.





Un seul symbole entre guillemets n'est pas un caractère ; c'est une chaîne d'un caractère. Donc A ou c ou 2 n'est pas un caractère mais une chaîne d'un caractère chacun.

La variable d'un caractère peut être réaffectée, plus tard dans le programme, comme suit :



carboniseridentifiant= 'X';
identifiant= 'ET';

Pour empêcher la modification d'un caractère affecté à un identifiant, plus loin dans le programme, faites précéder la définition du mot réservé, const, de la manière suivante :

const carboniseridentifiant= 'ré';

La variable ident est dite en lecture seule.

Littéral de chaîne

Un littéral de chaîne est une séquence de caractères entre guillemets doubles. Donc,

carboniserident1[] = 'Je vous aime'; carboniserident2[] = 'Je déteste 3 d'entre vous'; carboniserident3[]
= 'nous sommes le monde'; carboniserident4[] = 'Bonjour le monde!';

sont toutes des définitions différentes de littéraux de chaîne. Notez l'utilisation de guillemets doubles. Il n'y a rien de tel qu'une variable ordinaire pour une chaîne. Un littéral de chaîne est un tableau de caractères, où au lieu d'être délimité par {}, la séquence est délimitée par . Les caractères ne sont pas séparés par des virgules. Tout nombre supérieur au nombre de caractères du littéral de chaîne peut être placé entre crochets. Cependant, il est préférable de laisser les crochets vides.

Un seul caractère entre guillemets n'est pas un caractère ; c'est une chaîne d'un caractère. Donc A ou c ou 2 n'est pas un caractère, mais une chaîne d'un caractère chacun.

Une variable de chaîne ne permet pas la réaffectation du littéral complet, plus tard dans le programme - voir ci-dessous. Cependant, des caractères individuels peuvent être réaffectés - voir ci-dessous.

Citation simple et double en caractère ou littéral

Pour avoir une seule guillemet comme personnage, faites quelque chose comme,

carboniseridentifiant= ' '';

Pour avoir un guillemet double comme caractère dans un littéral de chaîne, faites quelque chose comme,

carboniseridentifiant[] = 'une façon'CD';

La barre oblique inverse est utilisée dans une séquence d'échappement, pour éviter les conflits avec les délimiteurs. Pour avoir un guillemet double comme caractère, il n'y a pas besoin de la barre oblique inverse : ' ' est bien. Pour avoir un guillemet simple dans un littéral de chaîne, il n'y a pas besoin de barre oblique inverse : ab'cd est correct.

Étant donné que la barre oblique inverse est utilisée pour échapper à un caractère, elle doit être échappée avec une autre barre oblique inverse lorsqu'elle est utilisée comme caractère ou dans un littéral de chaîne.

Séquence d'échappement

Une séquence d'échappement est l'une des suivantes :

''? \ à  F > v

Chaque séquence d'échappement est normalement saisie soit sous forme de caractère entre guillemets simples, soit sous forme de séquence d'échappement entre guillemets doubles.

  • ' : est utilisé comme caractère de guillemet simple, entre guillemets simples.
  • : est utilisé comme guillemet double, dans un littéral.
  • ? : puisque ? est un caractère réservé, il doit être échappé dans un littéral.
  • \ : la barre oblique inverse doit être échappée sous la forme d'un caractère ou d'un littéral de chaîne, afin de ne pas donner une autre signification.
  • a : sonne une fois l'alarme, lorsqu'il est utilisé comme caractère ou dans une chaîne littérale.
  •  : résulte en un retour arrière dans l'affichage dans un littéral de chaîne, enlevant le caractère précédent.
  • f : provoque l'alimentation de la page suivante vers l'imprimante lorsqu'elle est utilisée comme caractère ou dans un littéral.
  • : renvoie le curseur, où le caractère suivant doit être imprimé, mais dans la ligne courante.
  • : renvoie le curseur au début de la ligne suivante ou juste à la ligne suivante, selon le système d'exploitation.
  • : crée une tabulation horizontale.
  • v : crée un onglet vertical.

Opérations avec des personnages

Enchaînement

Lors de la définition, deux littéraux de chaîne peuvent être joints avec un espace comme suit :

carboniseridentifiant[] = 'abc' 'déf';
cout<<identifiant<< ' ';

La sortie est : abcdef . Cette définition peut être étendue à plus de deux littéraux. Remarque : la déclaration est une définition, pas seulement une affectation. La définition peut même continuer jusqu'à la ligne suivante avec un espace séparant les lignes comme suit :

carboniseridentifiant[] = 'abc' 'déf'
'prendre note';
cout<<identifiant<< ' ';

La sortie est, abcdefghi.

Remarque : Les caractères ne peuvent pas être concaténés de cette manière, car les guillemets simples du caractère ne peuvent pas avoir plus d'un symbole.

Opérateurs d'égalité

Les mêmes caractères dans la même casse sont égaux. Ils ne sont pas égaux s'ils ne sont pas du même cas. Envisager,

résultat booléen= 'B' == 'B';
cout<<résultat<< ' ';

== signifie égal, tandis que = signifie attribué à et non égal. La sortie est 1 pour vrai. Envisager,

résultat booléen= 'B' == 'b';
cout<<résultat<< ' ';

La sortie est 0 pour faux. Envisager,

résultat booléen= 'b' == 'c';
cout<<résultat<< ' ';

La sortie est 0 pour faux. Envisager,

résultat booléen= 'B' ! = 'B';
cout<<résultat<< ' ';

!= signifie non égal, tandis que = signifie attribué à et non égal. La sortie est 0 pour faux. Envisager,

résultat booléen= 'B' ! = 'b';
cout<<résultat<< ' ';

La sortie est 1 pour vrai. Envisager,

résultat booléen= 'b' ! = 'c';
cout<<résultat<< ' ';

La sortie est 1 pour vrai.

Donc, == et != sont des opérateurs d'égalité.

Opérateurs relationnels

Pour les caractères ordinaires en C++, dans l'ordre croissant, les nombres précèdent les lettres majuscules, qui précèdent les lettres minuscules.

Donc= s'expliquent de la même manière.

Le littéral de chaîne en tant qu'objet

Le tableau est un pointeur constant vers le début d'une séquence de type de données particulier. De même, la chaîne est un pointeur constant vers le début d'une séquence de caractères. Comparez les définitions suivantes :

entierarr[] = {3, 4, 5, 6, 7};
carboniserp[] = {'dans', 'ou', 'm', 'à', 'n'};
carboniserstri[] = 'femme';

Le premier tableau est un tableau d'entiers et comporte cinq éléments. Les deuxième et troisième tableaux sont des tableaux de caractères avec des noms différents, mais le même nombre d'éléments. Les deuxième et troisième tableaux sont les mêmes, mais pour leurs noms. Le contenu textuel du deuxième tableau est délimité par des accolades ; les caractères sont séparés par des virgules et chaque caractère est entre guillemets simples. Le contenu textuel du troisième tableau est délimité par des guillemets ; les caractères ne sont pas séparés par des virgules et chaque caractère n'est pas entre guillemets simples. Les deuxième et troisième tableaux sont deux manières de produire une chaîne, la troisième étant la meilleure.

arr est un pointeur constant vers le premier élément de son tableau, ce qui signifie que arr pointera toujours vers l'emplacement ayant l'entier, 3 même si la valeur de 3 est modifiée. La taille du tableau, cinq éléments, ne reste pas vraiment constante. Cependant, chacune des valeurs du tableau peut être modifiée.

str est un pointeur constant vers le premier élément de son tableau, ce qui signifie que str pointera toujours vers l'emplacement ayant le caractère « w » même si la valeur de « w » est modifiée. La taille du tableau de caractères, cinq éléments, ne reste pas vraiment constante. Cependant, chacune des valeurs du littéral peut être modifiée.

stri est un pointeur constant vers le premier élément de son littéral (tableau), ce qui signifie que stri pointera toujours vers l'emplacement ayant le caractère w même si la valeur de w est modifiée. La taille du littéral de chaîne (tableau), cinq éléments, ne reste pas vraiment constante. Cependant, chacune des valeurs du littéral peut être modifiée.

Qu'est-ce qui est constant dans un tableau ou un littéral de chaîne ? L'adresse mémoire du premier élément du tableau ou du littéral reste la valeur du nom (identifiant) du tableau ou du littéral et ne peut pas être modifiée. Eh bien, la taille du tableau ou du littéral ne reste pas vraiment constante. Chaque valeur du tableau ou du littéral peut être modifiée. Le code suivant montre comment le quatrième élément de chacun des tableaux a été modifié :

entierarr[] = {3, 4, 5, 6, 7};
carboniserp[] = {'dans', 'ou', 'm', 'à', 'n'};
carboniserstri[] = 'femme';

arr[3] = 9;
p[3] = 'Et';
stri[3] = 'Et';

cout<<arr[3] << ' ';
cout<<p<< ' ';
cout<<stri<< ' ';

La sortie est :

9
femmes
femmes

Notez que les éléments d'un littéral de chaîne défini, comme pour la troisième définition ci-dessus, sont accessibles avec l'index de tableau (indice). La raison de la deuxième ligne de la sortie est donnée ci-dessous.

Indice de définition

Notez que dans les définitions ci-dessus, il n'y a pas d'entier pour l'indice. Lorsque le nombre d'éléments ne peut pas être facilement déterminé par le programmeur, l'entier de l'indice doit être omis. Quoi qu'il en soit, l'entier ne doit pas être inférieur au nombre d'éléments du tableau.

Pour le littéral de chaîne, l'entier doit être supérieur d'au moins 1 au nombre de caractères de la chaîne. En effet, le caractère nul () est toujours ajouté par le compilateur, à la fin d'un tableau qui est une chaîne, délimité par des guillemets doubles. Le caractère nul n'est pas ajouté à la fin du deuxième tableau ci-dessus, car ce n'est pas une chaîne officielle. Le troisième tableau est une chaîne officielle. Le code suivant montre les valeurs d'indice minimales.

entierarr[5] = {3, 4, 5, 6, 7};
carboniserp[5] = {'dans', 'ou', 'm', 'à', 'n'};
carboniserstri[6] = 'femme';

Afin de faire de la deuxième définition une chaîne officielle, le caractère nul doit être ajouté comme suit :

entierarr[5] = {3, 4, 5, 6, 7};
carboniserp[6] = {'dans', 'ou', 'm', 'à', 'n', ' 0'};
carboniserstri[6] = 'femme';

La sortie devrait maintenant être,

9
femmes
femmes

sans la deuxième femme. Notez que l'indice correspondant pour le deuxième tableau est 6, et non 5 comme c'était le cas.

Valeurs littérales constantes

Pour empêcher la modification de tout caractère des guillemets affectés à un identifiant, plus loin dans le programme, faites précéder la définition du mot réservé, const, de la manière suivante :

const carboniseridentifiant[] = 'Je vous aime';

Opérations avec des littéraux de chaîne

Opérations d'égalité

Les opérateurs d'égalité sont == et != . Lorsque les variables (identifiants) de deux chaînes sont comparées, ce sont les pointeurs (adresses) des littéraux qui finissent par être comparés ; C'est faux. Pour comparer des chaînes, les littéraux doivent être comparés, comme dans le code suivant :

résultat booléen= 'femme' == 'femme';
cout<<résultat<< ' ';

La sortie est 1 pour vrai. La comparaison se fait à la manière d'un dictionnaire, mais avec des chiffres venant en premier dans l'ordre croissant, avant les majuscules, qui viennent avant les minuscules. La sortie du code suivant est 0, pour false.

résultat booléen= 'femme' ! = 'femme';
cout<<résultat<< ' ';

Opérateurs relationnels avec des littéraux de chaîne

Les opérateurs relationnels ne fonctionnent pas avec les littéraux de chaîne.

Littéral de chaîne brute

Un littéral de chaîne brut, permet à une chaîne d'être affichée comme tapée, en ignorant les séquences d'échappement et en respectant les nouvelles lignes. Considérez le code suivant :

carboniserp[] =R'(abc\d efg il
klmn '
'opq
premier)';
cout<< str << '
';

La sortie est :

abc\d efg il
klmn n'' opq
d'abord

Dans le code, le littéral de chaîne brut commence par R, suivi de et ( . Il se termine par ) et .

Types littéraux de chaîne principale C++

carboniser

Le type char est le type C++ d'origine et stocke généralement un caractère sur 8 bits.

char16_t

Cela stocke un caractère en 16 bits.

char32_t

Cela stocke un caractère en 32 bits.

wchar_t

char16_t et char32_t sont des caractères larges. wchar_t est un caractère large qui est propriétaire et défini par l'implémentation.

Conclusion

Un littéral de caractère est un caractère unique entre guillemets simples. Une séquence d'échappement est un caractère qui peut également être entre guillemets simples. Un littéral de chaîne est une séquence de caractères entre guillemets. Un littéral de chaîne est un tableau de caractères qui se termine par . Les opérateurs d'égalité et de relation fonctionnent avec des littéraux de caractère. Les opérateurs d'égalité fonctionnent avec des littéraux de chaîne, mais les opérateurs relationnels ne fonctionnent pas avec des littéraux de chaîne. Les identificateurs de caractères peuvent être utilisés dans les comparaisons, mais les identificateurs de chaîne ne doivent pas être utilisés dans les comparaisons. Un littéral de chaîne brut permet à une chaîne d'être affichée comme tapée, en ignorant les séquences d'échappement et en respectant les nouvelles lignes.

Chrys