C++-Zeichenfolgenliterale
Ein Zeichenfolgenliteral stellt eine Folge von Zeichen dar, die zusammen eine auf NULL endende Zeichenfolge bilden. Die Zeichen müssen zwischen doppelten Anführungszeichen eingeschlossen werden. Es gibt die folgenden Arten von Zeichenfolgenliteralen:
Schmale Zeichenfolgenliterale, dargestellt als "xxx".
Breite Zeichenfolgenliterale, dargestellt als L"xxx".
Unformatierte Zeichenfolgenliterale, dargestellt als R"ddd(xxx) ddd", wobei ddd ein Trennzeichen ist. Unformatierte Zeichenfolgenliterale können schmal (dargestellt mit R) oder breit (dargestellt mit LR) sein.
Ein schmales Zeichenfolgenliteral ist ein mit Null endendes Array eines konstanten char, das jedes Schriftzeichen außer das doppelte Anführungszeichen ("), den umgekehrten Schrägstrich (\) oder die Zeilenendemarke enthält. Ein schmales Zeichenfolgenliteral kann die Escapesequenzen enthalten, die in C++-Zeichenliterale aufgeführt sind.
const char *narrow = "abcd";
// represents the string: yes\no
const char *escaped = "yes\\no";
Ein breites Zeichenfolgenliteral ist ein mit Null endendes Array eines konstanten wchar_t, das jedes Schriftzeichen außer das doppelte Anführungszeichen ("), den umgekehrten Schrägstrich (\) oder die Zeilenendemarke enthält. Ein breites Zeichenfolgenliteral kann die Escapesequenzen enthalten, die in C++-Zeichenliterale aufgeführt sind.
const wchar_t* wide = L"zyxw";
const wchar_t* newline = L"hello\ngoodbye";
Ein unformatiertes Zeichenfolgenliteral ist ein auf NULL endendes Array (entweder ein konstantes char oder wchar_t), das jedes Schriftzeichen einschließlich des doppelten Anführungszeichens ("), umgekehrten Schrägstrichs (\) oder des Zeilenumbruchzeichens enthält. Unformatierte Zeichenfolgenliterale werden häufig in regulären Ausdrücken, die Zeichenklassen verwenden, und in HTML-Zeichenfolgen und XML-Zeichenfolgen verwendet. Beispiele finden Sie im folgenden Artikel: Bjarne Stroustrups FAQ zu 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)";
Ein Trennzeichen ist eine benutzerdefinierte Sequenz von bis zu 16 Zeichen, die der öffnenden Klammer eines unformatierten Zeichenfolgenliterals unmittelbar vorangestellt wird und dessen schließender Klammer unmittelbar folgt. Sie können ein Trennzeichen verwenden, um mehrdeutige Zeichenfolgen aufzulösen, die doppelte Anführungszeichen und Klammern enthalten. Dies löst einen Compilerfehler aus:
// meant to represent the string: )”
const char* bad_parens = R"()")";
Durch ein Trennzeichen wird er jedoch behoben:
const char* good_parens = R"xyz()")xyz";
Sie können ein unformatiertes Zeichenfolgenliteral konstruieren, in dessen Quelle ein Zeilenumbruch (nicht das Escapezeichen) enthalten ist:
// represents the string: hello
//goodbye
const wchar_t* newline = LR"(hello
goodbye)";
Größe von Zeichenfolgenliteralen
Die Größe (in Bytes) eines schmalen Zeichenfolgenliterals ist die Anzahl von Zeichen plus 1 (für das beendende NULL-Zeichen). Die Größe eines breiten Zeichenfolgenliterals (in Bytes) ist die Anzahl von Zeichen mal 2 plus 2 (für das beendende NULL-Zeichen). Nachfolgend wird die Größe eines breiten Zeichenfolgenliterals gezeigt:
const wchar_t* str = L"Hello!";
const size_t byteSize = (wcslen(str) + 1) * sizeof(wchar_t);
Beachten Sie, dass strlen() und wcslen() nicht die Größe des beendenden NULL-Zeichens enthalten.
Die maximale Länge eines Zeichenfolgenliterals beträgt 65535 Bytes. Diese Begrenzung gilt sowohl für schmale Zeichenfolgenliterale als auch für breite Zeichenfolgenliterale.
Ändern von Zeichenfolgenliteralen
Da Zeichenfolgenliterale Konstanten sind, wird bei dem Versuch, sie zu ändern (beispielsweise str [2] = 'A') ein Compilerfehler ausgelöst.
Microsoft-spezifisch
In Visual C++ können Sie ein Zeichenfolgenliteral verwenden, um einen Zeiger auf ein nicht konstantes char oder wchar_t zu initialisieren. Dies ist in C-Code zulässig, in C++98 jedoch veraltet und wurde in C++11 entfernt. Ein Versuch, die Zeichenfolge zu ändern, verursacht eine Zugriffsverletzung, wie in diesem Beispiel:
wchar_t* str = L"hello";
str[2] = L'a'; // run-time error: access violation
Sie können den Compiler anweisen, einen Fehler auszugegeben, wenn ein Zeichenfolgenliteral beim Festlegen der Compileroption /Zc:strictStrings (Zeichenfolgenliteral-Typkonvertierung deaktivieren) in ein non_const-Zeichen konvertiert wird. Es ist empfehlenswert, Zeiger, die mithilfe von Zeichenfolgenliteralen initialisiert werden, mit dem auto-Schlüsselwort zu deklarieren, da es den richtigen (const) Typ auflöst. In diesem Beispiel wird ein Versuch abgefangen, zur Kompilierungszeit in ein Zeichenfolgenliteral zu schreiben:
auto str = L"hello";
str[2] = L'a'; // Compiler error: you cannot assign to a variable that is const
In einigen Fällen können identische Zeichenfolgenliterale "zusammengelegt" werden, um Speicherplatz in der ausführbaren Datei zu sparen. Im Zeichenfolgenliteral-Pooling bewirkt der Compiler, dass alle Verweise auf ein bestimmtes Zeichenfolgenliteral auf die gleiche Position im Arbeitsspeicher zeigen, anstatt dass alle Verweise auf eine separate Instanz des Zeichenfolgenliterals zeigen. Verwenden Sie die /GF-Compileroption, um Stringpooling zu aktivieren.
Ende Microsoft-spezifisch
Verketten von benachbarten Zeichenfolgenliteralen
Benachbarte Zeichenfolgenliterale werden verkettet. Diese Deklaration ist:
char str[] = "12" "34";
mit dieser Deklaration identisch:
char atr[] = "1234";
und mit dieser Deklaration identisch:
char atr[] = "12\
34";
Durch die Verwendung eingebetteter hexadezimaler Escapesequenzen für die Angabe von Zeichenfolgenkonstanten können unerwartete Ergebnisse verursacht werden. Im folgenden Beispiel soll ein Zeichenfolgenliteral erstellt werden, das ASCII 5-Zeichen enthält, gefolgt von den Zeichen f, i, v und e:
"\x05five"
Das eigentliche Ergebnis ist ein hexadezimales 5F, also der ASCII-Code für einen Unterstrich, gefolgt von den Zeichen i, v und e. Sie können eines der folgenden Elemente verwenden, um das richtige Ergebnis zu erhalten:
"\005five" // Use octal constant.
"\x05" "five" // Use string splicing.
Zeichenfolgenliterale mit Unicode-Zeichen
Ersatzzeichenpaare und zusätzliche Zeichen (wie in UTF-16) werden mit einem \U-Präfix dargestellt. Dies sind breite Zeichenfolgen statt einzelne Zeichen, die mit doppelten Anführungszeichen statt mit einfachen Anführungszeichen dargestellt werden. Die Präfixe U, u und u8 werden nicht unterstützt.
const wchar_t* str1 = L"\U0002008A";
const wchar_t* str2 = L"\UD869DED6";
const wchar_t* str3 = L"\Udc00c800";
Weitere Informationen zu Unicode finden Sie unter Unicode). Weitere Informationen zu Ersatzzeichenpaaren finden Sie unter Ersatzzeichenpaare und zusätzliche Zeichen.