Character literal

From cppreference.net

Inhaltsverzeichnis

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 ein basic-c-char , eine Escape-Sequenz, wie definiert in escape sequences ein universeller Zeichenname, wie definiert in escape sequences
basic-c-char	-	Ein Zeichen aus dem basic source character set (bis C++23) translation character set (seit C++23) , außer dem einfachen Anführungszeichen ' , Backslash \ oder dem Zeilenumbruchzeichen
c-char-sequence	-	zwei oder mehr c-char s

Erklärung

1) Gewöhnliches Zeichenliteral, z.B. 'a' oder ' \n ' oder ' \13 ' . Ein solches Literal hat den Typ char und den Wert gleich der Repräsentation von c-char im Ausführungszeichensatz (bis C++23) dem entsprechenden Codepunkt aus der gewöhnlichen Literalkodierung (seit C++23) .

2) UTF-8-Zeichenliteral, z.B. u8 'a' . Ein solches Literal hat den Typ char (bis C++20) char8_t (seit C++20) und den Wert gleich dem ISO/IEC 10646 Codepunktwert von c-char , vorausgesetzt, dass der Codepunktwert mit einer einzelnen UTF-8-Codeeinheit darstellbar ist (d.h. c-char liegt im Bereich 0x0-0x7F, inklusive).

3) UTF-16-Zeichenliteral, z.B. u '猫' , aber nicht u '🍌' ( u ' \U0001f34c ' ). Ein solches Literal hat den Typ char16_t und den Wert gleich dem ISO/IEC 10646 Codepunktwert von c-char , vorausgesetzt, dass der Codepunktwert mit einer einzelnen UTF-16-Codeeinheit darstellbar ist (d.h. c-char liegt im Bereich 0x0-0xFFFF, inklusive).

4) UTF-32-Zeichenliteral, z.B. U '猫' oder U '🍌' . Ein solches Literal hat den Typ char32_t und den Wert entsprechend dem ISO/IEC 10646 Codepunktwert von c-char .

5) Breitzeichen-Literal, z.B. L 'β' oder L '猫' . Ein solches Literal hat den Typ wchar_t und den Wert des Werts von c-char im ausgeführten Breitzeichen-Zeichensatz (bis C++23) dem entsprechenden Codepunkt aus der Breitliteral-Kodierung (seit C++23) .

6) Gewöhnliches Multizeichen-Literal (bis C++23) Multizeichen-Literal (seit C++23) , z.B. 'AB' , ist bedingt unterstützt, hat den Typ int und einen implementierungsdefinierten Wert.

7) Breite Multicharacter-Literale, z.B. L 'AB' , sind bedingt unterstützt, haben den Typ wchar_t und einen implementierungsdefinierten Wert.

Nicht kodierbare Zeichen

1-5) Vorausgesetzt, dass c-char keine numerische Escape-Sequenz ist (siehe unten), falls c-char in der assoziierten Zeichenkodierung des Literals nicht darstellbar ist oder nicht als einzelne Codeeinheit in dieser Kodierung encodiert werden kann (z.B. ein Nicht-BMP-Wert unter Windows, wo wchar_t 16-Bit ist), ist das Programm fehlerhaft.

6) Wenn irgendein c-char in der c-char-sequence nicht als einzelne Codeeinheit in der ordinary literal encoding kodiert werden kann, ist das Programm fehlerhaft.

7) Wenn ein beliebiges c-char in der c-char-sequence nicht als einzelne Codeeinheit in der wide literal encoding kodiert werden kann, ist das Programm fehlerhaft.

(until C++23)

Numerische Escape-Sequenzen

Numerische (oktale und hexadezimale) Escape-Sequenzen können zur Angabe des Werts des Zeichens verwendet werden.

Wenn das Zeichenliteral nur eine numerische Escape-Sequenz enthält und der durch die Escape-Sequenz spezifizierte Wert durch die vorzeichenlose Version seines Typs darstellbar ist, hat das Zeichenliteral denselben Wert wie der spezifizierte Wert (möglicherweise nach Konvertierung in den Zeichentyp).

Ein UTF- N -Zeichenliteral kann jeden durch seinen Typ darstellbaren Wert haben. Wenn der Wert nicht einem gültigen Unicode-Codepunkt entspricht oder wenn der entsprechende Codepunkt nicht als einzelne Codeeinheit in UTF- N darstellbar ist, kann er dennoch durch eine numerische Escape-Sequenz mit dem Wert spezifiziert werden. Z.B. ist u8 ' \xff ' wohlgeformt und gleich char8_t ( 0xFF ) .

(since C++23)

Wenn der durch eine numerische Escape-Sequenz in einem gewöhnlichen oder breiten 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 gewöhnlichen oder breiten Zeichenliteral mit einem c-char angegebene Wert durch die vorzeichenlose Version des zugrundeliegenden Typs von char bzw. wchar_t darstellbar ist, ist der Wert des Literals der ganzzahlige Wert dieses vorzeichenlosen Ganzzahltyps und der angegebene Wert, konvertiert in den Typ des Literals. Andernfalls ist das Programm fehlerhaft.

(seit C++23)

Wenn der durch eine numerische Escape-Sequenz in einem UTF- N -Zeichenliteral spezifizierte Wert nicht durch den entsprechenden char N _t -Typ darstellbar ist, ist der Wert des Zeichenliterals implementierungsdefiniert (bis C++17) ist das Programm fehlerhaft (seit C++17) .

(seit C++11)

Hinweise

Multicharacter-Literale wurden von C aus der Programmiersprache B übernommen. Obwohl nicht durch den C- oder C++-Standard spezifiziert, implementieren die meisten Compiler (MSVC ist eine bemerkenswerte Ausnahme) Multicharacter-Literale wie in B festgelegt: Die Werte jedes Zeichens im Literal initialisieren aufeinanderfolgende Bytes des resultierenden Integer-Werts in Big-Endian-Reihenfolge, rechtsbündig mit Nullauffüllung, z.B. ist der Wert von ' \1 ' gleich 0x00000001 und der Wert von ' \1 \2 \3 \4 ' gleich 0x01020304 .

In C haben Zeichenkonstanten wie 'a' oder ' \n ' den Typ int , nicht char .

Beispiel

Diesen Code ausführen

#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

Fehlerberichte

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

DR	Angewendet auf	Verhalten wie veröffentlicht	Korrektes Verhalten
CWG 912	C++98	nicht kodierbare gewöhnliche Zeichenliterale waren nicht spezifiziert	als bedingt unterstützt spezifiziert
CWG 1024	C++98	Mehrzeichenliterale mussten unterstützt werden	als bedingt unterstützt festgelegt
CWG 1656	C++98	die Bedeutung numerischer Escape-Sequenzen in Zeichenliteralen war unklar	spezifiziert
P1854R4	C++98	nicht kodierbare Zeichenliterale waren bedingt unterstützt	das Programm ist fehlerhaft

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]

Siehe auch

benutzerdefinierte Literale (C++11)	Literale mit benutzerdefiniertem Suffix
C-Dokumentation für Zeichenkonstante

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants