Namensräume
Varianten
Aktionen

Zeichenkonstante

Von cppreference.com
< c‎ | Sprache
 
C
 
C-Sprache
 
Ausdrücke
 

Inhalt

[bearbeiten] Syntax

'c-char ' (1)
u8'c-char ' (2) (seit C23)
u'c-char ' (3) (seit C11)
U'c-char ' (4) (seit C11)
L'c-char ' (5)
'c-char-sequence ' (6)
L'c-char-sequence ' (7)
u'c-char-sequence ' (8) (seit C11)(entfernt in C23)
U'c-char-sequence ' (9) (seit C11)(entfernt in C23)

wobei

  • c-char ist entweder
  • ein Zeichen aus dem grundlegenden Quellzeichenvorrat abzüglich des einfachen Anführungszeichens ('), des Backslashes (\) oder des Zeilenumbruchzeichens.
  • Escape-Sequenz: eine der speziellen Zeichen-Escapes \' \" \? \\ \a \b \f \n \r \t \v, Hexadezimal-Escapes \x... oder Oktal-Escapes \... wie in Escape-Sequenzen definiert.
 (seit C99)
  • c-char-sequence ist eine Sequenz aus zwei oder mehr c-chars.
1) ein Byte lange Ganzzahl-Zeichenkonstante, z. B. 'a' oder '\n' oder '\13'. Eine solche Konstante hat den Typ int und einen Wert, der gleich der Darstellung von c-char im Ausführungszeichenvorrat als Wert vom Typ char, zu int abgebildet ist. Wenn c-char nicht als einzelnes Byte im Ausführungszeichenvorrat darstellbar ist, ist der Wert implementierungsdefiniert.
2) UTF-8-Zeichenkonstante, z. B. u8'a'. Eine solche Konstante hat den Typ char8_t und einen Wert, der gleich dem ISO 10646 Codepunktwert von c-char ist, vorausgesetzt, der Codepunktwert ist mit einer einzigen UTF-8-Codeeinheit darstellbar (d. h. c-char liegt im Bereich 0x0-0x7F, einschließlich). Wenn c-char nicht mit einer einzigen UTF-8-Codeeinheit darstellbar ist, ist das Programm fehlerhaft.
3) 16-Bit breite Zeichenkonstante, z. B. u'貓', aber nicht u'🍌' (u'\U0001f34c'). Eine solche Konstante hat den Typ char16_t und einen Wert, der dem Wert von c-char in der 16-Bit-Kodierung entspricht, die von mbrtoc16 erzeugt wird (normalerweise UTF-16). Wenn c-char nicht darstellbar ist oder mehr als einem 16-Bit-Zeichen zugeordnet wird, ist der Wert implementierungsdefiniert.
4) 32-Bit breite Zeichenkonstante, z. B. U'貓' oder U'🍌'. Eine solche Konstante hat den Typ char32_t und einen Wert, der dem Wert von c-char in der 32-Bit-Kodierung entspricht, die von mbrtoc32 erzeugt wird (normalerweise UTF-32). Wenn c-char nicht darstellbar ist oder mehr als einem 32-Bit-Zeichen zugeordnet wird, ist der Wert implementierungsdefiniert.
 (bis C23)
3) UTF-16-Zeichenkonstante, z. B. u'貓', aber nicht u'🍌' (u'\U0001f34c'). Eine solche Konstante hat den Typ char16_t und einen Wert, der gleich dem ISO 10646 Codepunktwert von c-char ist, vorausgesetzt, der Codepunktwert ist mit einer einzigen UTF-16-Codeeinheit darstellbar (d. h. c-char liegt im Bereich 0x0-0xD7FF oder 0xE000-0xFFFF, einschließlich). Wenn c-char nicht mit einer einzigen UTF-16-Codeeinheit darstellbar ist, ist das Programm fehlerhaft.
4) UTF-32-Zeichenkonstante, z. B. U'貓' oder U'🍌'. Eine solche Konstante hat den Typ char32_t und einen Wert, der gleich dem ISO 10646 Codepunktwert von c-char ist, vorausgesetzt, der Codepunktwert ist mit einer einzigen UTF-32-Codeeinheit darstellbar (d. h. c-char liegt im Bereich 0x0-0xD7FF oder 0xE000-0x10FFFF, einschließlich). Wenn c-char nicht mit einer einzigen UTF-32-Codeeinheit darstellbar ist, ist das Programm fehlerhaft.
 (seit C23)
5) breite Zeichenkonstante, z. B. L'β' oder L'貓. Eine solche Konstante hat den Typ wchar_t und einen Wert, der dem Wert von c-char im Ausführungs-Breitzeichenvorrat entspricht (d. h. der Wert, der von mbtowc erzeugt würde). Wenn c-char nicht darstellbar ist oder mehr als einem breiten Zeichen zugeordnet wird (z. B. ein Wert außerhalb des BMP unter Windows, wo wchar_t 16-Bit hat), ist der Wert implementierungsdefiniert.
6) Mehrzeichenkonstante, z. B. 'AB', hat den Typ int und einen implementierungsdefinierten Wert.
7) breite Mehrzeichenkonstante, z. B. L'AB', hat den Typ wchar_t und einen implementierungsdefinierten Wert.
8) 16-Bit-Mehrzeichenkonstante, z. B. u'CD', hat den Typ char16_t und einen implementierungsdefinierten Wert.
9) 32-Bit-Mehrzeichenkonstante, z. B. U'XY', hat den Typ char32_t und einen implementierungsdefinierten Wert.

[bearbeiten] Hinweise

Mehrzeichenkonstanten wurden von der Programmiersprache C aus der Programmiersprache B übernommen. Obwohl nicht vom C-Standard spezifiziert, implementieren die meisten Compiler (MSVC ist eine bemerkenswerte Ausnahme) Mehrzeichenkonstanten wie in B spezifiziert: Die Werte jedes Zeichens in der Konstante initialisieren nacheinander Bytes des resultierenden Integers in Big-Endian-Nullauffüllungs-Rechtsausrichtung, z. B. ist der Wert von '\1' 0x00000001 und der Wert von '\1\2\3\4' ist 0x01020304.

In C++ haben kodierbare gewöhnliche Zeichenliterale den Typ char und nicht int.

Im Gegensatz zu Ganzzahlkonstanten kann eine Zeichenkonstante einen negativen Wert haben, wenn char vorzeichenbehaftet ist: Auf solchen Implementierungen ist '\xFF' ein int mit dem Wert -1.

Wenn Zeichenkonstanten in einem Steuerungs-Ausdruck von #if oder #elif verwendet werden, können sie im Sinne des Quellzeichenvorrats, des Ausführungszeichenvorrats oder eines anderen implementierungsdefinierten Zeichenvorrats interpretiert werden.

16/32-Bit-Mehrzeichenkonstanten werden nicht breit unterstützt und wurden in C23 entfernt. Einige gängige Implementierungen (z. B. Clang) akzeptieren sie gar nicht.

[bearbeiten] Beispiel

Führen Sie diesen Code aus
#include <stddef.h>
#include <stdio.h>
#include <uchar.h>
 
int main (void)
{
    printf("constant value     \n");
    printf("-------- ----------\n");
 
    // integer character constants,
    int c1='a'; printf("'a':\t %#010x\n", c1);
    int c2='🍌'; printf("'🍌':\t %#010x\n\n", c2); // implementation-defined
 
    // multicharacter constant
    int c3='ab'; printf("'ab':\t %#010x\n\n", c3); // implementation-defined
 
    // 16-bit wide character constants
    char16_t uc1 = u'a'; printf("'a':\t %#010x\n", (int)uc1);
    char16_t uc2 = u'¢'; printf("'¢':\t %#010x\n", (int)uc2);
    char16_t uc3 = u'猫'; printf("'猫':\t %#010x\n", (int)uc3);
    // implementation-defined (🍌 maps to two 16-bit characters)
    char16_t uc4 = u'🍌'; printf("'🍌':\t %#010x\n\n", (int)uc4);
 
    // 32-bit wide character constants
    char32_t Uc1 = U'a'; printf("'a':\t %#010x\n", (int)Uc1);
    char32_t Uc2 = U'¢'; printf("'¢':\t %#010x\n", (int)Uc2);
    char32_t Uc3 = U'猫'; printf("'猫':\t %#010x\n", (int)Uc3);
    char32_t Uc4 = U'🍌'; printf("'🍌':\t %#010x\n\n", (int)Uc4);
 
    // wide character constants
    wchar_t wc1 = L'a'; printf("'a':\t %#010x\n", (int)wc1);
    wchar_t wc2 = L'¢'; printf("'¢':\t %#010x\n", (int)wc2);
    wchar_t wc3 = L'猫'; printf("'猫':\t %#010x\n", (int)wc3);
    wchar_t wc4 = L'🍌'; printf("'🍌':\t %#010x\n\n", (int)wc4);
}

Mögliche Ausgabe

constant value     
-------- ----------
'a':	 0x00000061
'🍌':	 0xf09f8d8c
 
'ab':	 0x00006162
 
'a':	 0x00000061
'¢':	 0x000000a2
'猫':	 0x0000732b
'🍌':	 0x0000df4c
 
'a':	 0x00000061
'¢':	 0x000000a2
'猫':	 0x0000732b
'🍌':	 0x0001f34c
 
'a':	 0x00000061
'¢':	 0x000000a2
'猫':	 0x0000732b
'🍌':	 0x0001f34c

[bearbeiten] Referenzen

  • C17-Standard (ISO/IEC 9899:2018)
  • 6.4.4.4 Zeichenkonstanten (S. 48-50)
  • C11-Standard (ISO/IEC 9899:2011)
  • 6.4.4.4 Zeichenkonstanten (S. 67-70)
  • C99-Standard (ISO/IEC 9899:1999)
  • 6.4.4.4 Zeichenkonstanten (S. 59-61)
  • C89/C90-Standard (ISO/IEC 9899:1990)
  • 3.1.3.4 Zeichenkonstanten

[bearbeiten] Siehe auch

C++ Dokumentation für Zeichenliteral
Abgerufen von "https://cppreference.de/mwiki/index.php?title=c/language/character_constant&oldid=146412"