Littéraux de chaîne C++
Un littéral de chaîne représente une séquence de caractères qui, ensemble, forment une chaîne terminée par le caractère Null. Les caractères doivent être placés entre guillemets doubles. Il existe les genres suivants de littéraux de chaîne :
Littéraux de chaîne étroits, représentés sous la forme "xxx".
Littéraux de chaîne étendus, représentés sous la forme L"xxx".
Littéraux de chaîne bruts, représentés sous la forme R"ddd(xxx) ddd", où ddd est un délimiteur. Les littéraux de chaîne bruts peuvent être étroits (représentés par R) ou étendus (représentés par LR).
Un littéral de chaîne étroit est un tableau de constantes char se terminant par un caractère Null et contenant tout caractère graphique à l'exception du guillemet double ("), de la barre oblique inverse (\) ou du caractère de saut de ligne. Un littéral de chaîne étroit peut contenir les séquences d'échappement répertoriées dans Littéraux de caractère C++.
const char *narrow = "abcd";
// represents the string: yes\no
const char *escaped = "yes\\no";
Un littéral de chaîne étendu est un tableau de constantes wchar_t se terminant par un caractère Null et contenant tout caractère graphique à l'exception du guillemet double ("), de la barre oblique inverse (\) ou du caractère de saut de ligne. Un littéral de chaîne étendu peut contenir les séquences d'échappement répertoriées dans Littéraux de caractère C++.
const wchar_t* wide = L"zyxw";
const wchar_t* newline = L"hello\ngoodbye";
Un littéral de chaîne brut est un tableau de constantes char ou de constantes wchar_t se terminant par le caractère Null et contenant tout caractère graphique, notamment le guillemet double ("), la barre oblique inverse (\) ou le caractère de saut de ligne. Les littéraux de chaîne bruts sont souvent utilisés dans les expressions régulières qui utilisent des classes de caractères et dans des chaînes XML et des chaînes HTML. Par exemple, voir l'article suivant : FAQ de Bjarne Stroustrup sur C++11.
// represents the string: An unescaped \ character
const char* raw_narrow = R"(An unescaped \ character)";
// represents the string: An unescaped " character
const wchar_t* raw_wide = LR"(An unescaped " character)";
Un délimiteur est une séquence définie par l'utilisateur, composée au maximum de 16 caractères, qui précède immédiatement la parenthèse ouvrante d'un littéral de chaîne brut et suit immédiatement sa parenthèse fermante. Vous pouvez utiliser un délimiteur pour distinguer les chaînes qui contiennent à la fois des guillemets doubles et des parenthèses. Ceci provoque une erreur du compilateur :
// meant to represent the string: )”
const char* bad_parens = R"()")";
Mais un délimiteur résout cette erreur :
const char* good_parens = R"xyz()")xyz";
Vous pouvez construire un littéral de chaîne brut dans lequel il existe un saut de ligne (pas le caractère d'échappement) dans la source :
// represents the string: hello
//goodbye
const wchar_t* newline = LR"(hello
goodbye)";
Taille des littéraux de chaîne
La taille (en octets) d'un littéral de chaîne étroit est le nombre de caractères plus 1 (pour le caractère Null de fin) ; la taille (en octets) d'un littéral de chaîne étendu est le nombre de caractères multiplié par 2 plus 2 (pour le caractère Null de fin). L'exemple suivant illustre la taille d'un littéral de chaîne étendu :
const wchar_t* str = L"Hello!";
const size_t byteSize = (wcslen(str) + 1) * sizeof(wchar_t);
Notez que strlen() et wcslen() n'incluent pas la taille du caractère Null de fin.
La longueur maximale d'un littéral de chaîne est de 65 535 octets. Cette limite s'applique à la fois aux littéraux de chaîne étroits et étendus.
Modification des littéraux de chaîne
Les littéraux de chaîne étant des constantes, toute tentative de modification (par exemple str[2] = 'A') provoque une erreur du compilateur.
Section spécifique à Microsoft
Dans Visual C++, vous pouvez utiliser un littéral de chaîne pour initialiser un pointeur vers un char ou wchar_t non const. Cela est autorisé en code C, mais est déconseillé en C++98 et supprimé en C++11. Toute tentative de modification de la chaîne provoque une violation d'accès, comme dans cet exemple :
wchar_t* str = L"hello";
str[2] = L'a'; // run-time error: access violation
Vous pouvez contraindre le compilateur à émettre une erreur lorsqu'un littéral de chaîne est converti en un caractère non_const lorsque vous définissez l'option du compilateur /Zc:strictStrings (Désactiver la conversion du type de littéral de chaîne). Il est recommandé d'utiliser le mot clé auto pour déclarer les pointeurs initialisés par des littéraux de chaîne, car il est résolu en type (const) correct. Par exemple, cet exemple intercepte une tentative d'écriture dans un littéral de chaîne au moment de la compilation :
auto str = L"hello";
str[2] = L'a'; // Compiler error: you cannot assign to a variable that is const
Dans certains cas, des littéraux de chaîne identiques peuvent être regroupés pour économiser de l'espace dans le fichier exécutable. Dans un regroupement de littéraux de chaîne, le compilateur fait en sorte que toutes les références à un littéral de chaîne particulier pointent vers le même emplacement en mémoire, au lieu que chaque référence pointe vers une instance distincte du littéral de chaîne. Pour activer le regroupement de chaînes, utilisez l'option du compilateur /GF.
Fin de la section spécifique à Microsoft
Concaténation de littéraux de chaîne adjacents
Les littéraux de chaîne adjacents sont concaténés. Cette déclaration :
char str[] = "12" "34";
est identique à la déclaration suivante :
char atr[] = "1234";
et à cette déclaration :
char atr[] = "12\
34";
L'utilisation de codes d'échappement hexadécimaux incorporés pour spécifier des constantes de chaîne peut provoquer des résultats inattendus. L'exemple suivant tente de créer un littéral de chaîne qui contient le caractère ASCII 5, suivi des caractères f, i, v et e :
"\x05five"
Le résultat réel est un hexadécimal 5F, qui correspond au code ASCII pour un trait de soulignement, suivi des caractères i, v et e. Pour obtenir le résultat correct, vous pouvez utiliser l'un des éléments suivants :
"\005five" // Use octal constant.
"\x05" "five" // Use string splicing.
Littéraux de chaîne avec caractères Unicode
Les paires de substitution et les caractères supplémentaires (comme dans UTF-16) sont représentés par un préfixe \U. Il s'agit de chaînes étendues plutôt que de caractères uniques, et elles sont représentées par des guillemets doubles et non des guillemets simples. Les préfixes U, u et u8 ne sont pas pris en charge.
const wchar_t* str1 = L"\U0002008A";
const wchar_t* str2 = L"\UD869DED6";
const wchar_t* str3 = L"\Udc00c800";
Pour plus d'informations sur Unicode, voir Unicode). Pour plus d'informations sur les paires de substitution, voir Paires de substitution et caractères supplémentaires.