String literal

Syntaxe

Explication

Dans les types listés dans le tableau ci-dessus, N est le nombre d'unités de code encodées, qui est déterminé ci-dessous .

Les littéraux de chaîne ordinaires et UTF-8 (depuis C++11) sont collectivement appelés littéraux de chaîne étroite.

L'évaluation d'un littéral de chaîne résulte en un objet littéral de chaîne avec une durée de stockage statique. Le fait que tous les littéraux de chaîne soient stockés dans des objets non chevauchants et que des évaluations successives d'un littéral de chaîne produisent le même objet ou un objet différent n'est pas spécifié.

L'effet de tenter de modifier un objet littéral de chaîne est indéfini.

bool b = "bar" == 3 + "foobar"; // peut être vrai ou faux, non spécifié
const char* pc = "Hello";
char* p = const_cast<char*>(pc);
p[0] = 'M'; // comportement indéfini

// OK: contains one backslash,
// equivalent to "\\"
R"(\)";
// OK: contains four \n pairs,
// equivalent to "\\n\\n\\n\\n"
R"(\n\n\n\n)";
// OK: contains one close-parenthesis, two double-quotes and one open-parenthesis,
// equivalent to ")\"\"("
R"-()""()-";
// OK: equivalent to "\n)\\\na\"\"\n"
R"a(
)\
a""
)a";
// OK: equivalent to "x = \"\"\\y\"\""
R"(x = ""\y"")";
// R"<<(-_-)>>"; // Error: begin and end delimiters do not match
// R"-()-"-()-"; // Error: )-" appears in the middle and terminates the literal

Initialisation

Les objets littéraux de chaîne sont initialisés avec la séquence de valeurs d'unités de code correspondant à la séquence de s-char s et de r-char s (depuis C++11) , plus un caractère nul de terminaison (U+0000), dans l'ordre comme suit :

Concaténation

Les littéraux de chaîne adjacents sont concaténés lors de la phase de traduction 6 (après le préprocesseur) :

• Si les deux littéraux de chaîne sont du même type , le littéral de chaîne concaténé est également de ce type.

"Hello, " "world!" // à la phase 6, les 2 littéraux de chaîne forment "Hello, world!"
L"Δx = %" PRId16   // à la phase 4, PRId16 se développe en "d"
                   // à la phase 6, L"Δx = %" et "d" forment L"Δx = %d"

1. ↑ Aucune implémentation connue ne prend en charge une telle concaténation.

Chaînes non évaluées

Les contextes suivants attendent un littéral de chaîne, mais ne l'évaluent pas :

• linkage de langage spécification

Notes

Les littéraux de chaîne peuvent être utilisés pour initialiser des tableaux de caractères . Si un tableau est initialisé comme char str [ ] = "foo" ; , str contiendra une copie de la chaîne "foo" .

Un littéral de chaîne n'est pas nécessairement une séquence de caractères terminée par un caractère nul : si un littéral de chaîne contient des caractères nuls intégrés, il représente un tableau qui contient plus d'une chaîne.

const char* p = "abc\0def"; // std::strlen(p) == 3, mais le tableau a une taille de 8

Si un chiffre hexadécimal valide suit une séquence d'échappement hexadécimale dans un littéral de chaîne, cela échouerait à compiler en tant que séquence d'échappement invalide. La concaténation de chaînes peut être utilisée comme solution de contournement :

//const char* p = "\xfff"; // erreur : séquence d'échappement hexadécimale hors plage
const char* p = "\xff""f"; // OK : le littéral est const char[3] contenant {'\xff','f','\0'}

Exemple

#include <iostream>
// array1 et array2 contiennent les mêmes valeurs :
char array1[] = "Foo" "bar";
char array2[] = {'F', 'o', 'o', 'b', 'a', 'r', '\0'};
const char* s1 = R"foo(
Hello
  World
)foo";
// identique à
const char* s2 = "\nHello\n  World\n";
// identique à
const char* s3 = "\n"
                 "Hello\n"
                 "  World\n";
const wchar_t* s4 = L"ABC" L"DEF"; // OK, identique à
const wchar_t* s5 = L"ABCDEF";
const char32_t* s6 = U"GHI" "JKL"; // OK, identique à
const char32_t* s7 = U"GHIJKL";
const char16_t* s9 = "MN" u"OP" "QR"; // OK, identique à
const char16_t* sA = u"MNOPQR";
// const auto* sB = u"Mixed" U"Types";
        // avant C++23, peut être supporté ou non par
        // l'implémentation ; incorrect depuis C++23
const wchar_t* sC = LR"--(STUV)--"; // OK, littéral de chaîne brute
int main()
{
    std::cout << array1 << ' ' << array2 << '\n'
              << s1 << s2 << s3 << std::endl;
    std::wcout << s4 << ' ' << s5 << ' ' << sC
               << std::endl;
}

Foobar Foobar
Hello
  World
Hello
  World
Hello
  World
ABCDEF ABCDEF STUV

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

1. ↑ P1854R4 a été accepté comme DR ultérieurement, annulant cette résolution.

Références

Voir aussi