String literal

Syntax

Erklärung

In den in der obigen Tabelle aufgeführten Typen ist N die Anzahl der kodierten Codeeinheiten, die unten bestimmt wird.

Gewöhnliche und UTF-8 (since C++11) String-Literale werden zusammen als schmale String-Literale bezeichnet.

Die Auswertung eines String-Literals ergibt ein String-Literal-Objekt mit statischer Speicherdauer . Ob alle String-Literale in sich nicht überlappenden Objekten gespeichert werden und ob aufeinanderfolgende Auswertungen eines String-Literals dasselbe oder ein unterschiedliches Objekt ergeben, ist nicht spezifiziert.

Der Effekt eines Versuchs, ein String-Literal-Objekt zu modifizieren, ist undefiniert.

bool b = "bar" == 3 + "foobar"; // kann true oder false sein, nicht spezifiziert
const char* pc = "Hello";
char* p = const_cast<char*>(pc);
p[0] = 'M'; // undefiniertes Verhalten

// 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

Initialisierung

String-Literal-Objekte werden mit der Folge von Codeeinheitenwerten initialisiert, die der Folge von s-char s und r-char s (since C++11) , plus einem abschließenden Nullzeichen (U+0000), in der folgenden Reihenfolge entspricht:

Verkettung

Benachbarte String-Literale werden in der Übersetzungsphase 6 (nach der Präprozessierung) verkettet:

• Wenn die beiden Zeichenkettenliterale vom selben Typ sind, dann ist das verkettete Zeichenkettenliteral ebenfalls von diesem Typ.

"Hello, " "world!" // in Phase 6 bilden die 2 String-Literale "Hello, world!"
L"Δx = %" PRId16   // in Phase 4 wird PRId16 zu "d" expandiert
                   // in Phase 6 bilden L"Δx = %" und "d" L"Δx = %d"

1. ↑ Keine bekannte Implementierung unterstützt eine solche Verkettung.

Nicht ausgewertete Zeichenketten

Die folgenden Kontexte erwarten ein String-Literal, werten es jedoch nicht aus:

• Sprachbindung Spezifikation

Hinweise

String-Literale können verwendet werden, um Zeichenarrays zu initialisieren . Wenn ein Array wie char str [ ] = "foo" ; initialisiert wird, str wird eine Kopie des Strings "foo" enthalten.

Ein String-Literal ist nicht notwendigerweise eine nullterminierte Zeichenfolge: Wenn ein String-Literal eingebettete Nullzeichen enthält, repräsentiert es ein Array, das mehr als eine Zeichenkette enthält.

const char* p = "abc\0def"; // std::strlen(p) == 3, aber das Array hat die Größe 8

Wenn auf eine hexadezimale Escape-Sequenz in einem String-Literal eine gültige hexadezimale Ziffer folgt, würde dies als ungültige Escape-Sequenz zu einem Kompilierungsfehler führen. String-Konkatenation kann als Workaround verwendet werden:

//const char* p = "\xfff"; // Fehler: Hexadezimale Escape-Sequenz außerhalb des gültigen Bereichs
const char* p = "\xff""f"; // OK: das Literal ist const char[3] mit {'\xff','f','\0'}

Beispiel

#include <iostream>
// array1 und array2 enthalten dieselben Werte:
char array1[] = "Foo" "bar";
char array2[] = {'F', 'o', 'o', 'b', 'a', 'r', '\0'};
const char* s1 = R"foo(
Hello
  World
)foo";
// gleich wie
const char* s2 = "\nHello\n  World\n";
// gleich wie
const char* s3 = "\n"
                 "Hello\n"
                 "  World\n";
const wchar_t* s4 = L"ABC" L"DEF"; // OK, gleich wie
const wchar_t* s5 = L"ABCDEF";
const char32_t* s6 = U"GHI" "JKL"; // OK, gleich wie
const char32_t* s7 = U"GHIJKL";
const char16_t* s9 = "MN" u"OP" "QR"; // OK, gleich wie
const char16_t* sA = u"MNOPQR";
// const auto* sB = u"Mixed" U"Types";
        // vor C++23 möglicherweise durch die Implementierung unterstützt oder nicht;
        // seit C++23 ungültig
const wchar_t* sC = LR"--(STUV)--"; // OK, Raw-String-Literal
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

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

1. ↑ P1854R4 wurde später als DR angenommen und überschreibt diese Resolution.

Referenzen

Siehe auch