Littéraux de chaîne et deC++caractère ()String and character literals (C++)

C++ prend en charge divers types de chaîne et de caractère, et fournit les moyens d'exprimer les valeurs littérales de chacun de ces types.C++ supports various string and character types, and provides ways to express literal values of each of these types. Dans votre code source, vous exprimez le contenu de vos littéraux de caractère et de chaîne à l’aide d’un jeu de caractères.In your source code, you express the content of your character and string literals using a character set. Les noms de caractères universels et les caractères d’échappement vous permettent d’exprimer une chaîne en utilisant uniquement le jeu de caractères sources de base.Universal character names and escape characters allow you to express any string using only the basic source character set. Un littéral de chaîne brut vous permet d'éviter d'utiliser des caractères d'échappement et peut servir à exprimer tous les types de littéral de chaîne.A raw string literal enables you to avoid using escape characters, and can be used to express all types of string literals. Vous pouvez également créer std::string des littéraux sans avoir à effectuer d’étapes de conversion ou de construction supplémentaires.You can also create std::string literals without having to perform extra construction or conversion steps.

#include <string>
using namespace std::string_literals; // enables s-suffix for std::string literals

int main()
{
    // Character literals
    auto c0 =   'A'; // char
    auto c1 = u8'A'; // char
    auto c2 =  L'A'; // wchar_t
    auto c3 =  u'A'; // char16_t
    auto c4 =  U'A'; // char32_t

    // Multicharacter literals
    auto m0 = 'abcd'; // int, value 0x61626364

    // String literals
    auto s0 =   "hello"; // const char*
    auto s1 = u8"hello"; // const char*, encoded as UTF-8
    auto s2 =  L"hello"; // const wchar_t*
    auto s3 =  u"hello"; // const char16_t*, encoded as UTF-16
    auto s4 =  U"hello"; // const char32_t*, encoded as UTF-32

    // Raw string literals containing unescaped \ and "
    auto R0 =   R"("Hello \ world")"; // const char*
    auto R1 = u8R"("Hello \ world")"; // const char*, encoded as UTF-8
    auto R2 =  LR"("Hello \ world")"; // const wchar_t*
    auto R3 =  uR"("Hello \ world")"; // const char16_t*, encoded as UTF-16
    auto R4 =  UR"("Hello \ world")"; // const char32_t*, encoded as UTF-32

    // Combining string literals with standard s-suffix
    auto S0 =   "hello"s; // std::string
    auto S1 = u8"hello"s; // std::string
    auto S2 =  L"hello"s; // std::wstring
    auto S3 =  u"hello"s; // std::u16string
    auto S4 =  U"hello"s; // std::u32string

    // Combining raw string literals with standard s-suffix
    auto S5 =   R"("Hello \ world")"s; // std::string from a raw const char*
    auto S6 = u8R"("Hello \ world")"s; // std::string from a raw const char*, encoded as UTF-8
    auto S7 =  LR"("Hello \ world")"s; // std::wstring from a raw const wchar_t*
    auto S8 =  uR"("Hello \ world")"s; // std::u16string from a raw const char16_t*, encoded as UTF-16
    auto S9 =  UR"("Hello \ world")"s; // std::u32string from a raw const char32_t*, encoded as UTF-32
}

Il est possible que les littéraux de chaîne n’aient aucun préfixe, ou qu’ils aient les préfixes u8, L, uet U pour désigner un caractère étroit (codé sur un ou plusieurs octets), UTF-8, un caractère large (UCS-2 ou UTF-16), ainsi que les encodages UTF-16 et UTF-32, respectivement.String literals can have no prefix, or u8, L, u, and U prefixes to denote narrow character (single-byte or multi-byte), UTF-8, wide character (UCS-2 or UTF-16), UTF-16 and UTF-32 encodings, respectively. Un littéral de chaîne brut peut Ravoir u8Rdes préfixes UR ,, LR uR, et pour les équivalents en version brute de ces encodages.A raw string literal can have R, u8R, LR, uR, and UR prefixes for the raw version equivalents of these encodings. Pour créer des valeurs temporaires std::string ou statiques, vous pouvez utiliser des littéraux de chaîne ou des littéraux de chaîne bruts avec un s suffixe.To create temporary or static std::string values, you can use string literals or raw string literals with an s suffix. Pour plus d’informations, consultez la section littéraux de chaîne ci-dessous.For more information, see the String literals section below. Pour plus d’informations sur le jeu de caractères sources de base, les noms de caractères universels et l’utilisation de caractères de pages de codes étendues dans votre code source, consultez jeux de caractères.For more information on the basic source character set, universal character names, and using characters from extended codepages in your source code, see Character sets.

Littéraux de caractèreCharacter literals

Un littéral de caractère est composé d'une constante caractère.A character literal is composed of a constant character. Elle est représentée par le caractère entouré de guillemets-apostrophes.It is represented by the character surrounded by single quotation marks. Il existe cinq genres de littéraux de caractère:There are five kinds of character literals:

  • Littéraux de caractère ordinaires de type char, par exemple'a'Ordinary character literals of type char, for example 'a'

  • Littéraux de caractère UTF-8 de type char (char8_t en c++ 20), par exempleu8'a'UTF-8 character literals of type char (char8_t in C++20), for example u8'a'

  • Littéraux de caractères étendus de type wchar_t, par exemple L'a'Wide-character literals of type wchar_t, for example L'a'

  • Littéraux de caractère UTF-16 de char16_ttype, par exempleu'a'UTF-16 character literals of type char16_t, for example u'a'

  • Littéraux de caractère UTF-32 de char32_ttype, par exempleU'a'UTF-32 character literals of type char32_t, for example U'a'

Le caractère utilisé pour un littéral de caractère peut être n’importe quel caractère, à l’exception des caractères\réservés («»), des guillemets simples (') ou des sauts de ligne.The character used for a character literal may be any character, except for the reserved characters backslash ('\'), single quotation mark ('), or newline. Les caractères réservés peuvent être spécifiés à l’aide d’une séquence d’échappement.Reserved characters can be specified by using an escape sequence. Vous pouvez spécifier des caractères à l’aide des noms de caractères universels, tant que le type est suffisamment grand pour contenir le caractère.Characters may be specified by using universal character names, as long as the type is large enough to hold the character.

EncodageEncoding

Les littéraux de caractère sont encodés différemment en fonction de leur préfixe.Character literals are encoded differently based their prefix.

  • Un littéral de caractère sans préfixe est un littéral de caractère ordinaire.A character literal without a prefix is an ordinary character literal. La valeur d’un littéral de caractère ordinaire contenant un caractère unique, une séquence d’échappement ou un nom de caractère universel qui peut être représenté dans le jeu de caractères d’exécution a une valeur égale à la valeur numérique de son encodage dans le jeu de caractères d’exécution.The value of an ordinary character literal containing a single character, escape sequence, or universal character name that can be represented in the execution character set has a value equal to the numerical value of its encoding in the execution character set. Un littéral de caractère ordinaire qui contient plus d’un caractère, une séquence d’échappement ou un nom de caractère universel est un littéral multicaractère.An ordinary character literal that contains more than one character, escape sequence, or universal character name is a multicharacter literal. Un littéral multicaractère ou un littéral de caractère ordinaire qui ne peut pas être représenté dans le jeu de caractères d’exécution a le type intet sa valeur est définie par l’implémentation.A multicharacter literal or an ordinary character literal that can't be represented in the execution character set has type int, and its value is implementation-defined. Pour MSVC, consultez la section spécifique à Microsoft ci-dessous.For MSVC, see the Microsoft specific section below.

  • Un littéral de caractère qui commence par L le préfixe est un littéral à caractères larges.A character literal that begins with the L prefix is a wide-character literal. La valeur d’un littéral à caractères larges contenant un caractère unique, une séquence d’échappement ou un nom de caractère universel a une valeur égale à la valeur numérique de son encodage dans le jeu de caractères larges d’exécution, à moins que le littéral de caractère n’ait aucune représentation dans le jeu de caractères larges d’exécution, auquel cas la valeur est définie par l’implémentation.The value of a wide-character literal containing a single character, escape sequence, or universal character name has a value equal to the numerical value of its encoding in the execution wide-character set unless the character literal has no representation in the execution wide-character set, in which case the value is implementation-defined. La valeur d’un littéral à caractères larges contenant plusieurs caractères, des séquences d’échappement ou des noms de caractères universels est définie par l’implémentation.The value of a wide-character literal containing multiple characters, escape sequences, or universal character names is implementation-defined. Pour MSVC, consultez la section spécifique à Microsoft ci-dessous.For MSVC, see the Microsoft specific section below.

  • Un littéral de caractère qui commence par u8 le préfixe est un littéral de caractère UTF-8.A character literal that begins with the u8 prefix is a UTF-8 character literal. La valeur d’un littéral de caractère UTF-8 contenant un caractère unique, une séquence d’échappement ou un nom de caractère universel a une valeur égale à sa valeur de point de code ISO 10646 si elle peut être représentée par une unité de code UTF-8 unique (correspondant aux contrôles C0 et latin de base Bloc Unicode).The value of a UTF-8 character literal containing a single character, escape sequence, or universal character name has a value equal to its ISO 10646 code point value if it can be represented by a single UTF-8 code unit (corresponding to the C0 Controls and Basic Latin Unicode block). Si la valeur ne peut pas être représentée par une unité de code UTF-8 unique, le programme est incorrect.If the value can't be represented by a single UTF-8 code unit, the program is ill-formed. Un littéral de caractère UTF-8 contenant plusieurs caractères, une séquence d’échappement ou un nom de caractère universel est incorrect.A UTF-8 character literal containing more than one character, escape sequence, or universal character name is ill-formed.

  • Un littéral de caractère qui commence par u le préfixe est un littéral de caractère UTF-16.A character literal that begins with the u prefix is a UTF-16 character literal. La valeur d’un littéral de caractère UTF-16 contenant un caractère unique, une séquence d’échappement ou un nom de caractère universel a une valeur égale à sa valeur de point de code ISO 10646 si elle peut être représentée par une seule unité de code UTF-16 (correspondant au plan multilingue de base). ).The value of a UTF-16 character literal containing a single character, escape sequence, or universal character name has a value equal to its ISO 10646 code point value if it can be represented by a single UTF-16 code unit (corresponding to the basic multi-lingual plane). Si la valeur ne peut pas être représentée par une seule unité de code UTF-16, le programme est incorrect.If the value can't be represented by a single UTF-16 code unit, the program is ill-formed. Un littéral de caractère UTF-16 contenant plusieurs caractères, une séquence d’échappement ou un nom de caractère universel est incorrect.A UTF-16 character literal containing more than one character, escape sequence, or universal character name is ill-formed.

  • Un littéral de caractère qui commence par U le préfixe est un littéral de caractère UTF-32.A character literal that begins with the U prefix is a UTF-32 character literal. La valeur d’un littéral de caractère UTF-32 contenant un caractère unique, une séquence d’échappement ou un nom de caractère universel a une valeur égale à sa valeur de point de code ISO 10646.The value of a UTF-32 character literal containing a single character, escape sequence, or universal character name has a value equal to its ISO 10646 code point value. Un littéral de caractère UTF-32 contenant plusieurs caractères, une séquence d’échappement ou un nom de caractère universel est incorrect.A UTF-32 character literal containing more than one character, escape sequence, or universal character name is ill-formed.

Séquences d’échappementEscape sequences

Il existe trois types de séquence d’échappement : simple, octal et hexadécimal.There are three kinds of escape sequences: simple, octal, and hexadecimal. Les séquences d'échappement peuvent être de l'une des formes suivantes :Escape sequences may be any of the following:

ValueValue Séquence d'échappementEscape sequence
saut de lignenewline \n\n
barre oblique inversebackslash \\
tabulation horizontalehorizontal tab \t\t
point d'interrogationquestion mark ?? ou \?or \?
tabulation verticalevertical tab \v\v
guillemet simplesingle quote \'\'
retour arrièrebackspace \b\b
guillemet doubledouble quote \"\"
retour chariotcarriage return \r\r
caractère Nullthe null character \0\0
saut de pageform feed \f\f
octaloctal \ooo\ooo
alerte (clochette)alert (bell) \a\a
hexadécimalhexadecimal \xhhh\xhhh

Une séquence d’échappement octale est une barre oblique inverse suivie d’une séquence de un à trois chiffres octaux.An octal escape sequence is a backslash followed by a sequence of one to three octal digits. Une séquence d’échappement octale se termine au premier caractère qui n’est pas un chiffre octal, si elle est rencontrée plus tôt que le troisième chiffre.An octal escape sequence terminates at the first character that's not an octal digit, if encountered sooner than the third digit. La valeur octale la plus \377élevée possible est.The highest possible octal value is \377.

Une séquence d’échappement hexadécimale est une barre oblique inverse xsuivie du caractère, suivi d’une séquence d’un ou de plusieurs chiffres hexadécimaux.A hexadecimal escape sequence is a backslash followed by the character x, followed by a sequence of one or more hexadecimal digits. Les zéros non significatifs sont ignorés.Leading zeroes are ignored. Dans un littéral de caractère préfixé ordinaire ou U8, la valeur hexadécimale la plus élevée est 0xFF.In an ordinary or u8-prefixed character literal, the highest hexadecimal value is 0xFF. Dans un littéral de caractère large avec le préfixe L ou le préfixe u, la valeur hexadécimale la plus élevée est 0xFFFF.In an L-prefixed or u-prefixed wide character literal, the highest hexadecimal value is 0xFFFF. Dans un littéral de caractère large avec le préfixe U, la valeur hexadécimale la plus élevée est 0xFFFFFFFF.In a U-prefixed wide character literal, the highest hexadecimal value is 0xFFFFFFFF.

Cet exemple de code illustre quelques exemples de caractères d’échappement utilisant des littéraux de caractère ordinaires.This sample code shows some examples of escaped characters using ordinary character literals. La même syntaxe de séquence d’échappement est valide pour les autres types de littéraux de caractère.The same escape sequence syntax is valid for the other character literal types.

#include <iostream>
using namespace std;

int main() {
    char newline = '\n';
    char tab = '\t';
    char backspace = '\b';
    char backslash = '\\';
    char nullChar = '\0';

    cout << "Newline character: " << newline << "ending" << endl; // Newline character:
                                                                  //  ending
    cout << "Tab character: " << tab << "ending" << endl; // Tab character : ending
    cout << "Backspace character: " << backspace << "ending" << endl; // Backspace character : ending
    cout << "Backslash character: " << backslash << "ending" << endl; // Backslash character : \ending
    cout << "Null character: " << nullChar << "ending" << endl; //Null character:  ending
}

La barre oblique inverse\() est un caractère de continuation de ligne lorsqu’elle est placée à la fin d’une ligne.The backslash character (\) is a line-continuation character when it's placed at the end of a line. Pour qu'une barre oblique inverse apparaisse comme un littéral de caractère, vous devez taper deux barres obliques inverses sur une ligne (\\).If you want a backslash character to appear as a character literal, you must type two backslashes in a row (\\). Pour plus d’informations sur le caractère de continuation de ligne, consultez Phases of Translation.For more information about the line continuation character, see Phases of Translation.

Spécifique à MicrosoftMicrosoft specific

Pour créer une valeur à partir d’un littéral à plusieurs caractères étroit, le compilateur convertit le caractère ou la séquence de caractères entre guillemets simples en valeurs 8 bits dans un entier 32 bits.To create a value from a narrow multicharacter literal, the compiler converts the character or character sequence between single quotes into 8-bit values within a 32-bit integer. Plusieurs caractères dans le littéral remplissent les octets correspondants selon les besoins, des octets de poids fort aux octets poids faible.Multiple characters in the literal fill corresponding bytes as needed from high-order to low-order. Le compilateur convertit ensuite l’entier en type de destination en suivant les règles habituelles.The compiler then converts the integer to the destination type following the usual rules. Par exemple, pour créer une valeur char , le compilateur prend l’octet de poids faible.For example, to create a char value, the compiler takes the low-order byte. Pour créer une valeur wchar_t char16_t ou, le compilateur prend le mot de poids faible.To create a wchar_t or char16_t value, the compiler takes the low-order word. Le compilateur avertit que le résultat est tronqué si tous les bits sont définis au-dessus de l’octet ou du mot assigné.The compiler warns that the result is truncated if any bits are set above the assigned byte or word.

char c0    = 'abcd';    // C4305, C4309, truncates to 'd'
wchar_t w0 = 'abcd';    // C4305, C4309, truncates to '\x6364'
int i0     = 'abcd';    // 0x61626364

Une séquence d’échappement octale qui contient plus de trois chiffres est traitée comme une séquence octale à 3 chiffres, suivie des chiffres suivants comme caractères dans un littéral multicaractère, ce qui peut produire des résultats étonnants.An octal escape sequence that appears to contain more than three digits is treated as a 3-digit octal sequence, followed by the subsequent digits as characters in a multicharacter literal, which can give surprising results. Par exemple :For example:

char c1 = '\100';   // '@'
char c2 = '\1000';  // C4305, C4309, truncates to '0'

Les séquences d’échappement qui semblent contenir des caractères non octaux sont évaluées comme une séquence octale jusqu’au dernier caractère octal, suivies des caractères restants en tant que caractères suivants dans un littéral multicaractère.Escape sequences that appear to contain non-octal characters are evaluated as an octal sequence up to the last octal character, followed by the remaining characters as the subsequent characters in a multicharacter literal. L’avertissement C4125 est généré si le premier caractère non octal est un chiffre décimal.Warning C4125 is generated if the first non-octal character is a decimal digit. Par exemple :For example:

char c3 = '\009';   // '9'
char c4 = '\089';   // C4305, C4309, truncates to '9'
char c5 = '\qrs';   // C4129, C4305, C4309, truncates to 's'

Une séquence d’échappement octale qui a une valeur \377 supérieure à provoque l’erreur C2022: 'value-in-Decimal': trop grand pour le caractère.An octal escape sequence that has a higher value than \377 causes error C2022: 'value-in-decimal': too big for character.

Une séquence d’échappement qui semble avoir des caractères hexadécimaux et non hexadécimaux est évaluée comme un littéral multicaractère qui contient une séquence d’échappement hexadécimale jusqu’au dernier caractère hexadécimal, suivi des caractères non hexadécimaux.An escape sequence that appears to have hexadecimal and non-hexadecimal characters is evaluated as a multicharacter literal that contains a hexadecimal escape sequence up to the last hexadecimal character, followed by the non-hexadecimal characters. Une séquence d’échappement hexadécimale qui ne contient aucun chiffre hexadécimal provoque l’erreur du compilateur C2153: «les littéraux hexadécimaux doivent avoir au moins un chiffre hexadécimal».A hexadecimal escape sequence that contains no hexadecimal digits causes compiler error C2153: "hex literals must have at least one hex digit".

char c6 = '\x0050'; // 'P'
char c7 = '\x0pqr'; // C4305, C4309, truncates to 'r'

Si un littéral à caractères larges préfixé avec L contient une séquence multicaractère, la valeur est extraite du premier caractère et le compilateur déclenche l’avertissement C4066.If a wide character literal prefixed with L contains a multicharacter sequence, the value is taken from the first character, and the compiler raises warning C4066. Les caractères suivants sont ignorés, contrairement au comportement du littéral multicaractère ordinaire équivalent.Subsequent characters are ignored, unlike the behavior of the equivalent ordinary multicharacter literal.

wchar_t w1 = L'\100';   // L'@'
wchar_t w2 = L'\1000';  // C4066 L'@', 0 ignored
wchar_t w3 = L'\009';   // C4066 L'\0', 9 ignored
wchar_t w4 = L'\089';   // C4066 L'\0', 89 ignored
wchar_t w5 = L'\qrs';   // C4129, C4066 L'q' escape, rs ignored
wchar_t w6 = L'\x0050'; // L'P'
wchar_t w7 = L'\x0pqr'; // C4066 L'\0', pqr ignored

Fin spécifique à MicrosoftEnd Microsoft specific

Noms de caractères universelsUniversal character names

Dans les littéraux de caractère et les littéraux de chaîne natifs (non bruts), un nom de caractère universel peut représenter n’importe quel caractère.In character literals and native (non-raw) string literals, any character may be represented by a universal character name. Les noms de caractères universels sont formés \U d’un préfixe suivi d’un point de code Unicode à huit chiffres \u , ou d’un préfixe suivi d’un point de code Unicode à quatre chiffres.Universal character names are formed by a prefix \U followed by an eight-digit Unicode code point, or by a prefix \u followed by a four-digit Unicode code point. Tous les points de code Unicode à huit ou quatre chiffres, respectivement, doivent être présents pour constituer un nom de caractère universel bien formé.All eight or four digits, respectively, must be present to make a well-formed universal character name.

char u1 = 'A';          // 'A'
char u2 = '\101';       // octal, 'A'
char u3 = '\x41';       // hexadecimal, 'A'
char u4 = '\u0041';     // \u UCN 'A'
char u5 = '\U00000041'; // \U UCN 'A'

Paires de substitutionSurrogate Pairs

Les noms de caractères universels ne peuvent pas encoder des valeurs dans la plage de points de code de substitution D800-DFFF.Universal character names can't encode values in the surrogate code point range D800-DFFF. Pour les paires de substitution Unicode, spécifiez le nom de caractère universel à l’aide de \UNNNNNNNN, où NNNNNNNN représente le point de code à huit chiffres du caractère.For Unicode surrogate pairs, specify the universal character name by using \UNNNNNNNN, where NNNNNNNN is the eight-digit code point for the character. Le compilateur génère une paire de substitution, si nécessaire.The compiler generates a surrogate pair if necessary.

En C++03, le langage autorisait uniquement un sous-ensemble de caractères à être représentés par leurs noms de caractères universels. En outre, il autorisait certains noms de caractères universels qui ne représentaient pas en réalité des caractères Unicode valides.In C++03, the language only allowed a subset of characters to be represented by their universal character names, and allowed some universal character names that didn’t actually represent any valid Unicode characters. Cette erreur a été corrigée dans la norme C++ 11.This mistake was fixed in the C++11 standard. En C++11, les littéraux de caractère et de chaîne, ainsi que les identificateurs, peuvent utiliser des noms de caractères universels.In C++11, both character and string literals and identifiers can use universal character names. Pour plus d’informations sur les noms de caractères universels, consultez Character Sets.For more information on universal character names, see Character Sets. Pour plus d’informations sur Unicode, consultez Unicode.For more information about Unicode, see Unicode. Pour plus d’informations sur les paires de substitution, consultez Paires de substitution et caractères supplémentaires.For more information about surrogate pairs, see Surrogate Pairs and Supplementary Characters.

Littéraux de chaîneString literals

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.A string literal represents a sequence of characters that together form a null-terminated string. Les caractères doivent être placés entre guillemets doubles.The characters must be enclosed between double quotation marks. Il existe les genres suivants de littéraux de chaîne :There are the following kinds of string literals:

Littéraux de chaîne étroitsNarrow string literals

Un littéral de chaîne étroit est un tableau de type const char[n]non préfixé, délimité par des guillemets doubles et se terminant par un caractère null, où n est la longueur du tableau en octets.A narrow string literal is a non-prefixed, double-quote delimited, null-terminated array of type const char[n], where n is the length of the array in bytes. Un littéral de chaîne étroit peut contenir n’importe quel caractère graphique à l’exception du guillemet double ("), de la barre oblique inverse (\) ou du caractère de nouvelle ligne.A narrow string literal may contain any graphic character except the double quotation mark ("), backslash (\), or newline character. Un littéral de chaîne étroit peut également contenir les séquences d’échappement répertoriées ci-dessus, ainsi que les noms de caractères universels qui tiennent dans un octet.A narrow string literal may also contain the escape sequences listed above, and universal character names that fit in a byte.

const char *narrow = "abcd";

// represents the string: yes\no
const char *escaped = "yes\\no";

Chaînes encodées UTF-8UTF-8 encoded strings

Une chaîne encodée en UTF-8 est un tableau préfixé préfixé, délimité par des const char[n]guillemets doubles et se terminant par un caractère null, où n est la longueur du tableau encodé en octets.A UTF-8 encoded string is a u8-prefixed, double-quote delimited, null-terminated array of type const char[n], where n is the length of the encoded array in bytes. Un littéral de chaîne ayant le préfixe u8 peut contenir n’importe quel caractère graphique à l’exception du guillemet double ("), de la barre oblique inverse (\) ou du caractère de nouvelle ligne.A u8-prefixed string literal may contain any graphic character except the double quotation mark ("), backslash (\), or newline character. Un littéral de chaîne ayant le préfixe u8 peut également contenir les séquences d’échappement répertoriées ci-dessus, ainsi que des noms de caractères universels.A u8-prefixed string literal may also contain the escape sequences listed above, and any universal character name.

const char* str1 = u8"Hello World";
const char* str2 = u8"\U0001F607 is O:-)";

Littéraux de chaîne largesWide string literals

Un littéral de chaîne étendu est un tableau de constante wchar_t se terminant par un caractère null qui estLpréfixé par' 'et contient tout caractère graphique à l’exception du guillemet double ("\), de la barre oblique inverse () ou du caractère de saut de ligne.A wide string literal is a null-terminated array of constant wchar_t that is prefixed by 'L' and contains any graphic character except the double quotation mark ("), backslash (\), or newline character. Un littéral de chaîne large peut contenir les séquences d’échappement répertoriées ci-dessus, ainsi que des noms de caractères universels.A wide string literal may contain the escape sequences listed above and any universal character name.

const wchar_t* wide = L"zyxw";
const wchar_t* newline = L"hello\ngoodbye";

char16_t et char32_t (C++11)char16_t and char32_t (C++11)

C++11 présente les types de caractère portables char16_t (Unicode 16 bits) et char32_t (Unicode 32 bits) :C++11 introduces the portable char16_t (16-bit Unicode) and char32_t (32-bit Unicode) character types:

auto s3 = u"hello"; // const char16_t*
auto s4 = U"hello"; // const char32_t*

Littéraux de chaîne bruts (C++ 11)Raw string literals (C++11)

Un littéral de chaîne brut est un tableau se terminant par un caractère null, de n’importe quel type de caractère, qui contient tout caractère graphique, y compris le guillemet\double ("), la barre oblique inverse () ou le caractère de saut de ligne.A raw string literal is a null-terminated array—of any character type—that contains any graphic character, including the double quotation mark ("), backslash (\), or newline character. 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.Raw string literals are often used in regular expressions that use character classes, and in HTML strings and XML strings. Pour obtenir des exemples, consultez l’article suivant: FAQ de Bjarne Stroustrup sur c++ 11.For examples, see the following article: Bjarne Stroustrup's FAQ on C++11.

// represents the string: An unescaped \ character
const char* raw_narrow = R"(An unescaped \ character)";
const wchar_t* raw_wide = LR"(An unescaped \ character)";
const char*       raw_utf8  = u8R"(An unescaped \ character)";
const char16_t* raw_utf16 = uR"(An unescaped \ character)";
const char32_t* raw_utf32 = UR"(An unescaped \ character)";

Un délimiteur est une séquence définie par l’utilisateur, comportant jusqu’à 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.A delimiter is a user-defined sequence of up to 16 characters that immediately precedes the opening parenthesis of a raw string literal, and immediately follows its closing parenthesis. Par exemple, dans R"abc(Hello"\()abc" , la séquence du délimiteur est abc , et le contenu de la chaîne est Hello"\(.For example, in R"abc(Hello"\()abc" the delimiter sequence is abc and the string content is Hello"\(. Vous pouvez utiliser un délimiteur pour distinguer les chaînes brutes qui contiennent à la fois des guillemets doubles et des parenthèses.You can use a delimiter to disambiguate raw strings that contain both double quotation marks and parentheses. Ce littéral de chaîne provoque une erreur du compilateur:This string literal causes a compiler error:

// meant to represent the string: )"
const char* bad_parens = R"()")";  // error C2059

Mais un délimiteur résout cette erreur :But a delimiter resolves it:

const char* good_parens = R"xyz()")xyz";

Vous pouvez construire un littéral de chaîne brut qui contient un saut de ligne (pas le caractère d’échappement) dans la source:You can construct a raw string literal that contains a newline (not the escaped character) in the source:

// represents the string: hello
//goodbye
const wchar_t* newline = LR"(hello
goodbye)";

littéraux std:: String (C++ 14)std::string literals (C++14)

std::stringles littéraux sont des implémentations de bibliothèque standard de littéraux définis par l’utilisateur (voir ci- "xyz"s dessous) qui s sont représentés sous la forme (avec un suffixe).std::string literals are Standard Library implementations of user-defined literals (see below) that are represented as "xyz"s (with a s suffix). Ce type de littéral de chaîne produit un objet temporaire de std::stringtype std::wstring std::u32string,, ou std::u16string, selon le préfixe spécifié.This kind of string literal produces a temporary object of type std::string, std::wstring, std::u32string, or std::u16string, depending on the prefix that is specified. Quand aucun préfixe n’est utilisé, une std::string est produite comme indiqué ci-dessus.When no prefix is used, as above, a std::string is produced. L"xyz"sproduit un std::wstring.L"xyz"s produces a std::wstring. u"xyz"sproduit un std:: u16stringet U"xyz"s produit un std:: u32string.u"xyz"s produces a std::u16string, and U"xyz"s produces a std::u32string.

//#include <string>
//using namespace std::string_literals;
string str{ "hello"s };
string str2{ u8"Hello World" };
wstring str3{ L"hello"s };
u16string str4{ u"hello"s };
u32string str5{ U"hello"s };

Le s suffixe peut également être utilisé sur des littéraux de chaîne bruts:The s suffix may also be used on raw string literals:

u32string str6{ UR"(She said "hello.")"s };

std::stringles littéraux sont définis dans l' std::literals::string_literals espace de <noms de la chaîne > fichier d’en-tête.std::string literals are defined in the namespace std::literals::string_literals in the <string> header file. Étant donné que std::literals::string_literalset std::literals sont tous deux déclarés comme espaces de noms inline, std::literals::string_literals est automatiquement traité comme s'il appartenait directement à l'espace de noms std.Because std::literals::string_literals, and std::literals are both declared as inline namespaces, std::literals::string_literals is automatically treated as if it belonged directly in namespace std.

Taille des littéraux de chaîneSize of string literals

Pour les char* chaînes ANSI et autres encodages sur un octet (mais pas UTF-8), la taille (en octets) d’un littéral de chaîne est le nombre de caractères plus 1 pour le caractère null de fin.For ANSI char* strings and other single-byte encodings (but not UTF-8), the size (in bytes) of a string literal is the number of characters plus 1 for the terminating null character. Pour tous les autres types de chaîne, la taille n'est pas strictement liée au nombre de caractères.For all other string types, the size is not strictly related to the number of characters. UTF-8 utilise jusqu’à quatre éléments char pour encoder certaines unités de char16_t code, et ou wchar_t encodé au format UTF-16 peut utiliser deux éléments (pour un total de quatre octets) pour encoder une seule unité de code.UTF-8 uses up to four char elements to encode some code units, and char16_t or wchar_t encoded as UTF-16 may use two elements (for a total of four bytes) to encode a single code unit. Cet exemple illustre la taille d’un littéral de chaîne large en octets :This example shows the size of a wide string literal in bytes:

const wchar_t* str = L"Hello!";
const size_t byteSize = (wcslen(str) + 1) * sizeof(wchar_t);

Notez que strlen() et wcslen() n’incluez pas la taille du caractère null de fin, dont la taille est égale à la taille de l’élément du type chaîne: un char* octet sur une chaîne, wchar_t* deux char16_t* octets sur les chaînes ou, et quatre octets sur char32_t* les chaînes.Notice that strlen() and wcslen() don't include the size of the terminating null character, whose size is equal to the element size of the string type: one byte on a char* string, two bytes on wchar_t* or char16_t* strings, and four bytes on char32_t* strings.

La longueur maximale d’un littéral de chaîne est de 65 535 octets.The maximum length of a string literal is 65,535 bytes. Cette limite s'applique à la fois aux littéraux de chaîne étroits et étendus.This limit applies to both narrow string literals and wide string literals.

Modification des littéraux de chaîneModifying string literals

Étant donné que les littéraux de std::string chaîne (à l’exclusion des littéraux) sont des constantes, toute str[2] = 'A'tentative de modification (par exemple,) provoque une erreur du compilateur.Because string literals (not including std::string literals) are constants, trying to modify them—for example, str[2] = 'A'—causes a compiler error.

Spécifique à MicrosoftMicrosoft specific

Dans Microsoft C++, vous pouvez utiliser un littéral de chaîne pour initialiser un pointeur vers non const char ou wchar_t.In Microsoft C++, you can use a string literal to initialize a pointer to non-const char or wchar_t. Cette initialisation non const est autorisée dans le code C99, mais est dépréciée dans C++ 98 et supprimée dans C++ 11.This non-const initialization is allowed in C99 code, but is deprecated in C++98 and removed in C++11. Toute tentative de modification de la chaîne provoque une violation d'accès, comme dans cet exemple :An attempt to modify the string causes an access violation, as in this example:

wchar_t* str = L"hello";
str[2] = L'a'; // run-time error: access violation

Vous pouvez forcer le compilateur à émettre une erreur lorsqu’un littéral de chaîne est converti en pointeur de caractère non const lorsque vous définissez l’option de compilateur /Zc: strictStrings (désactiver la conversion du type de littéral de chaîne) .You can cause the compiler to emit an error when a string literal is converted to a non-const character pointer when you set the /Zc:strictStrings (Disable string literal type conversion) compiler option. Nous vous recommandons de procéder ainsi pour que la portabilité du code soit conforme aux normes.We recommend it for standards-compliant portable code. Il est également 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.It is also a good practice to use the auto keyword to declare string literal-initialized pointers, because it resolves to the correct (const) type. Par exemple, cet exemple de code intercepte une tentative d’écriture dans un littéral de chaîne au moment de la compilation :For example, this code example catches an attempt to write to a string literal at compile time:

auto str = L"hello";
str[2] = L'a'; // C3892: 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.In some cases, identical string literals may be pooled to save space in the executable file. 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.In string-literal pooling, the compiler causes all references to a particular string literal to point to the same location in memory, instead of having each reference point to a separate instance of the string literal. Pour activer le regroupement de chaînes, utilisez l'option du compilateur /GF .To enable string pooling, use the /GF compiler option.

Fin spécifique à MicrosoftEnd Microsoft specific

Concaténation de littéraux de chaîne adjacentsConcatenating adjacent string literals

Les littéraux de chaîne étendus ou étroits adjacents sont concaténés.Adjacent wide or narrow string literals are concatenated. Cette déclaration :This declaration:

char str[] = "12" "34";

est identique à la déclaration suivante :is identical to this declaration:

char atr[] = "1234";

et à cette déclaration :and to this declaration:

char atr[] =  "12\
34";

L'utilisation de codes d'échappement hexadécimaux incorporés pour spécifier des littéraux de chaîne peut provoquer des résultats inattendus.Using embedded hexadecimal escape codes to specify string literals can cause unexpected results. 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 :The following example seeks to create a string literal that contains the ASCII 5 character, followed by the characters f, i, v, and 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.The actual result is a hexadecimal 5F, which is the ASCII code for an underscore, followed by the characters i, v, and e. Pour obtenir le résultat correct, vous pouvez utiliser l'un des éléments suivants :To get the correct result, you can use one of these:

"\005five"     // Use octal literal.
"\x05" "five"  // Use string splicing.

std::stringles littéraux, car il std::string s’agit de types, peuvent être concaténés avec l’opérateur défini pour les + types basic_string .std::string literals, because they are std::string types, can be concatenated with the + operator that is defined for basic_string types. Ils peuvent également être concaténés de la même façon que des littéraux de chaîne adjacents.They can also be concatenated in the same way as adjacent string literals. Dans les deux cas, l’encodage de chaîne et le suffixe doivent correspondre :In both cases, the string encoding and the suffix must match:

auto x1 = "hello" " " " world"; // OK
auto x2 = U"hello" " " L"world"; // C2308: disagree on prefix
auto x3 = u8"hello" " "s u8"world"s; // OK, agree on prefixes and suffixes
auto x4 = u8"hello" " "s u8"world"z; // C3688, disagree on suffixes

Littéraux de chaîne avec des noms de caractères universelsString literals with universal character names

Les littéraux de chaîne natifs (non bruts) peuvent utiliser des noms de caractères universels pour représenter un caractère, du moment que le nom de caractère universel peut être encodé sous forme d’un ou de plusieurs caractères dans le type de chaîne.Native (non-raw) string literals may use universal character names to represent any character, as long as the universal character name can be encoded as one or more characters in the string type. Par exemple, un nom de caractère universel représentant un caractère étendu ne peut pas être encodé dans une chaîne étroite à l’aide de la page de codes ANSI. Toutefois, il peut être encodé dans les chaînes étroites de certaines pages de codes multioctets, dans les chaînes UTF-8 ou dans une chaîne large.For example, a universal character name representing an extended character cannot be encoded in a narrow string using the ANSI code page, but it can be encoded in narrow strings in some multi-byte code pages, or in UTF-8 strings, or in a wide string. En c++ 11, la prise en charge d’Unicode char16_t* est char32_t* étendue par les types de chaîne et:In C++11, Unicode support is extended by the char16_t* and char32_t* string types:

// ASCII smiling face
const char*     s1 = ":-)";

// UTF-16 (on Windows) encoded WINKING FACE (U+1F609)
const wchar_t*  s2 = L"😉 = \U0001F609 is ;-)";

// UTF-8  encoded SMILING FACE WITH HALO (U+1F607)
const char*     s3 = u8"😇 = \U0001F607 is O:-)";

// UTF-16 encoded SMILING FACE WITH OPEN MOUTH (U+1F603)
const char16_t* s4 = u"😃 = \U0001F603 is :-D";

// UTF-32 encoded SMILING FACE WITH SUNGLASSES (U+1F60E)
const char32_t* s5 = U"😎 = \U0001F60E is B-)";

Voir aussiSee also

Character SetsCharacter Sets
Littéraux numériques, booléens et de pointeurNumeric, Boolean and Pointer Literals
Littéraux définis par l’utilisateurUser-Defined Literals