Zeichenliteral
Inhalt |
[bearbeiten] Syntax
'c-char ' |
(1) | ||||||||
u8'c-char ' |
(2) | (seit C++17) | |||||||
u'c-char ' |
(3) | (seit C++11) | |||||||
U'c-char ' |
(4) | (seit C++11) | |||||||
L'c-char ' |
(5) | ||||||||
'c-char-sequence ' |
(6) | ||||||||
L'c-char-sequence ' |
(7) | (bis C++23) | |||||||
| c-char | - | entweder
|
| basic-c-char | - | Ein Zeichen aus dem grundlegenden Quellzeichen-Set(bis C++23)Übersetzungszeichen-Set(seit C++23), außer dem einfachen Anführungszeichen ', dem Backslash \ oder dem Zeilenumbruchzeichen |
| c-char-sequence | - | zwei oder mehr c-chars |
[bearbeiten] Erklärung
[bearbeiten] Nicht kodierbare Zeichen
|
7) Wenn irgendein c-char in c-char-sequence nicht als einzelne Codeeinheit in der weiten Literal-Kodierung kodiert werden kann, ist das Programm schlecht formatiert.
|
(bis C++23) |
[bearbeiten] Numerische Escape-Sequenzen
Numerische (oktale und hexadezimale) Escape-Sequenzen können zur Angabe des Zeichens verwendet werden.
|
Wenn das Zeichenliteral nur eine numerische Escape-Sequenz enthält und der durch die Escape-Sequenz angegebene Wert durch die vorzeichenlose Version seines Typs darstellbar ist, hat das Zeichenliteral den gleichen Wert wie der angegebene Wert (möglicherweise nach Konvertierung in den Zeichentyp). Ein UTF-N-Zeichenliteral kann jeden Wert haben, der von seinem Typ darstellbar ist. Wenn der Wert keinem gültigen Unicode-Codepunkt entspricht oder sein entsprechender Codepunkt nicht als einzelne Codeeinheit in UTF-N darstellbar ist, kann er dennoch durch eine numerische Escape-Sequenz mit diesem Wert angegeben werden. Z.B. ist u8'\xff' wohlformatiert und gleich char8_t(0xFF). |
(seit C++23) |
|
Wenn der durch eine numerische Escape-Sequenz in einem einfachen oder weiten Zeichenliteral angegebene Wert nicht durch char bzw. wchar_t darstellbar ist, ist der Wert des Zeichenliterals implementierungsdefiniert. |
(bis C++23) |
|
Wenn der durch eine numerische Escape-Sequenz in einem einfachen oder weiten Zeichenliteral mit einem c-char angegebene Wert durch die vorzeichenlose Version des zugrunde liegenden Typs von char bzw. wchar_t darstellbar ist, ist der Wert des Literals der ganzzahlige Wert dieses vorzeichenlosen Ganzzahltyps, konvertiert in den Typ des Literals. Andernfalls ist das Programm schlecht formatiert. |
(seit C++23) |
|
Wenn der durch eine numerische Escape-Sequenz in einem UTF-N-Zeichenliteral angegebene Wert nicht durch den entsprechenden |
(seit C++11) |
[bearbeiten] Anmerkungen
Mehrzeichenliterale wurden von C aus der B-Programmiersprache übernommen. Obwohl weder im C- noch im C++-Standard spezifiziert, implementieren die meisten Compiler (MSVC ist eine bemerkenswerte Ausnahme) Mehrzeichenliterale wie in B spezifiziert: Die Werte jedes Zeichens im Literal initialisieren aufeinanderfolgende Bytes des resultierenden Integers in Big-Endian-Null-Padding, rechtsbündig angeordnet. Z.B. ist der Wert von '\1' 0x00000001 und der Wert von '\1\2\3\4' ist 0x01020304.
In C haben Zeichenkonstanten wie 'a' oder '\n' den Typ int anstelle von char.
[bearbeiten] Beispiel
#include <cstdint> #include <iomanip> #include <iostream> #include <string_view> template<typename CharT> void dump(std::string_view s, const CharT c) { const uint8_t* data{reinterpret_cast<const uint8_t*>(&c)}; std::cout << s << " \t" << std::hex << std::uppercase << std::setfill('0'); for (auto i{0U}; i != sizeof(CharT); ++i) std::cout << std::setw(2) << static_cast<unsigned>(data[i]) << ' '; std::cout << '\n'; } void print(std::string_view str = "") { std::cout << str << '\n'; } int main() { print("Ordinary character literals:"); char c1 = 'a'; dump("'a'", c1); char c2 = '\x2a'; dump("'*'", c2); print("\n" "Ordinary multi-character literals:"); int mc1 = 'ab'; dump("'ab'", mc1); // implementation-defined int mc2 = 'abc'; dump("'abc'", mc2); // implementation-defined print("\n" "UTF-8 character literals:"); char8_t C1 = u8'a'; dump("u8'a'", C1); // char8_t C2 = u8'¢'; dump("u8'¢'", C2); // error: ¢ maps to two UTF-8 code units // char8_t C3 = u8'猫'; dump("u8'猫'", C3); // error: 猫 maps to three UTF-8 code units // char8_t C4 = u8'🍌'; dump("u8'🍌'", C4); // error: 🍌 maps to four UTF-8 code units print("\n" "UTF-16 character literals:"); char16_t uc1 = u'a'; dump("u'a'", uc1); char16_t uc2 = u'¢'; dump("u'¢'", uc2); char16_t uc3 = u'猫'; dump("u'猫'", uc3); // char16_t uc4 = u'🍌'; dump("u'🍌'", uc4); // error: 🍌 maps to two UTF-16 code units print("\n" "UTF-32 character literals:"); char32_t Uc1 = U'a'; dump("U'a'", Uc1); char32_t Uc2 = U'¢'; dump("U'¢'", Uc2); char32_t Uc3 = U'猫'; dump("U'猫'", Uc3); char32_t Uc4 = U'🍌'; dump("U'🍌'", Uc4); print("\n" "Wide character literals:"); wchar_t wc1 = L'a'; dump("L'a'", wc1); wchar_t wc2 = L'¢'; dump("L'¢'", wc2); wchar_t wc3 = L'猫'; dump("L'猫'", wc3); wchar_t wc4 = L'🍌'; dump("L'🍌'", wc4); // unsupported on Windows since C++23 }
Mögliche Ausgabe
Ordinary character literals: 'a' 61 '*' 2A Ordinary multi-character literals: 'ab' 62 61 00 00 'abc' 63 62 61 00 UTF-8 character literals: u8'a' 61 UTF-16 character literals: u'a' 61 00 u'¢' A2 00 u'猫' 2B 73 UTF-32 character literals: U'a' 61 00 00 00 U'¢' A2 00 00 00 U'猫' 2B 73 00 00 U'🍌' 4C F3 01 00 Wide character literals: L'a' 61 00 00 00 L'¢' A2 00 00 00 L'猫' 2B 73 00 00 L'🍌' 4C F3 01 00
[bearbeiten] Fehlerberichte
Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.
| DR | angewendet auf | Verhalten wie veröffentlicht | Korrigiertes Verhalten |
|---|---|---|---|
| CWG 912 | C++98 | Nicht kodierbares einfaches Zeichenliteral war nicht spezifiziert | spezifiziert als bedingt unterstützt |
| CWG 1024 | C++98 | Mehrzeichenliteral musste unterstützt werden | Wurde bedingt unterstützt gemacht |
| CWG 1656 | C++98 | die Bedeutung der numerischen Escape-Sequenz in einem Zeichenliteral war unklar |
spezifiziert |
| P1854R4 | C++98 | nicht kodierbare Zeichenliterale waren bedingt unterstützt | das Programm ist schlecht formatiert |
[bearbeiten] Referenzen
- C++23 Standard (ISO/IEC 14882:2024)
- 5.13.3 Zeichenliterale [lex.ccon]
- C++20 Standard (ISO/IEC 14882:2020)
- 5.13.3 Zeichenliterale [lex.ccon]
- C++17 Standard (ISO/IEC 14882:2017)
- 5.13.3 Zeichenliterale [lex.ccon]
- C++14 Standard (ISO/IEC 14882:2014)
- 2.14.3 Zeichenliterale [lex.ccon]
- C++11 Standard (ISO/IEC 14882:2011)
- 2.14.3 Zeichenliterale [lex.ccon]
- C++03-Standard (ISO/IEC 14882:2003)
- 2.13.2 Zeichenliterale [lex.ccon]
- C++98 Standard (ISO/IEC 14882:1998)
- 2.13.2 Zeichenliterale [lex.ccon]
[bearbeiten] Siehe auch
| benutzerdefinierte Literale(C++11) | Literale mit benutzerdefiniertem Suffix |
| C-Dokumentation für Zeichenkonstante
| |
