Character literal

From cppreference.net

Table des matières

Syntaxe


`'` c-char `'`	(1)

`u8'` c-char `'`	(2)	(depuis C++17)

`u'` c-char `'`	(3)	(depuis C++11)

`U'` c-char `'`	(4)	(depuis C++11)

`L'` c-char `'`	(5)

`'` c-char-sequence `'`	(6)

`L'` c-char-sequence `'`	(7)	(jusqu'à C++23)

c-char	-	soit un basic-c-char , une séquence d'échappement, telle que définie dans les séquences d'échappement un nom de caractère universel, tel que défini dans les séquences d'échappement
basic-c-char	-	Un caractère du jeu de caractères source de base (jusqu'en C++23) jeu de caractères de traduction (depuis C++23) , sauf l'apostrophe ' , la barre oblique inverse \ , ou le caractère de nouvelle ligne
c-char-sequence	-	deux ou plusieurs c-char s

Explication

1) Littéral de caractère ordinaire, par ex. 'a' ou ' \n ' ou ' \13 ' . Un tel littéral a le type char et la valeur égale à la représentation de c-char dans le jeu de caractères d'exécution (jusqu'à C++23) le point de code correspondant de l' encodage de littéral ordinaire (depuis C++23) .

2) Littéral de caractère UTF-8, par exemple u8 'a' . Un tel littéral a pour type char (jusqu'en C++20) char8_t (depuis C++20) et la valeur égale à la valeur du point de code ISO/IEC 10646 de c-char , à condition que la valeur du point de code soit représentable avec une seule unité de code UTF-8 (c'est-à-dire que c-char soit dans la plage 0x0-0x7F, inclus).

3) Littéral de caractère UTF-16, par exemple u '猫' , mais pas u '🍌' ( u ' \U0001f34c ' ). Un tel littéral a pour type char16_t et la valeur égale à la valeur du point de code ISO/IEC 10646 de c-char , à condition que la valeur du point de code soit représentable avec une seule unité de code UTF-16 (c'est-à-dire que c-char soit dans la plage 0x0-0xFFFF, inclusivement).

4) Littéral de caractère UTF-32, par exemple U '猫' ou U '🍌' . Un tel littéral a pour type char32_t et la valeur égale au ISO/IEC 10646 point de code de c-char .

5) Littéral de caractère large, par exemple L 'β' ou L '猫' . Un tel littéral a le type wchar_t et la valeur égale à la valeur de c-char dans le jeu de caractères large d'exécution (jusqu'à C++23) le point de code correspondant de l'encodage de littéral large (depuis C++23) .

6) Littéral multicaractère ordinaire (jusqu'en C++23) Littéral multicaractère (depuis C++23) , par exemple 'AB' , est conditionnellement supporté, a le type int et une valeur définie par l'implémentation.

7) Littéral multicaractère large, par exemple L 'AB' , est conditionnellement supporté, a le type wchar_t et une valeur définie par l'implémentation.

Caractères non codables

1-5) Étant donné que c-char n'est pas une séquence d'échappement numérique (voir ci-dessous), si c-char n'est pas représentable dans l'encodage de caractères associé au littéral ou ne peut pas être encodé comme une seule unité de code dans cet encodage (par exemple une valeur non-BMP sur Windows où wchar_t est 16-bit), le programme est mal formé.

6) Si un c-char dans la c-char-sequence ne peut pas être encodé comme une seule unité de code dans l'encodage littéral ordinaire , le programme est mal formé.

7) Si un c-char quelconque dans c-char-sequence ne peut pas être encodé comme une unité de code unique dans l'encodage littéral étendu , le programme est mal formé.

(jusqu'à C++23)

Séquences d'échappement numériques

Les séquences d'échappement numériques (octales et hexadécimales) peuvent être utilisées pour spécifier la valeur du caractère.

Si le littéral de caractère contient une seule séquence d'échappement numérique, et que la valeur spécifiée par la séquence d'échappement est représentable par la version non signée de son type, le littéral de caractère a la même valeur que la valeur spécifiée (éventuellement après conversion vers le type caractère).

Un littéral de caractère UTF- N peut avoir n'importe quelle valeur représentable par son type. Si la valeur ne correspond pas à un point de code Unicode valide, ou si son point de code correspondant n'est pas représentable comme une unité de code unique en UTF- N , il peut toujours être spécifié par une séquence d'échappement numérique avec la valeur. Par exemple, u8 ' \xff ' est bien formé et égal à char8_t ( 0xFF ) .

(depuis C++23)

Si la valeur spécifiée par une séquence d'échappement numérique utilisée dans un littéral de caractère ordinaire ou large n'est pas représentable par char ou wchar_t respectivement, la valeur du littéral de caractère est définie par l'implémentation.

(jusqu'en C++23)

Si la valeur spécifiée par une séquence d'échappement numérique utilisée dans un littéral de caractère ordinaire ou large avec un c-char est représentable par la version non signée du type sous-jacent de char ou wchar_t respectivement, la valeur du littéral est la valeur entière de ce type entier non signé et la valeur spécifiée convertie vers le type du littéral. Sinon, le programme est mal formé.

(depuis C++23)

Si la valeur spécifiée par une séquence d'échappement numérique utilisée dans un littéral de caractère UTF- N n'est pas représentable par le char N _t correspondant, la valeur du littéral de caractère est définie par l'implémentation (jusqu'en C++17) le programme est mal formé (depuis C++17) .

(depuis C++11)

Notes

Les littéraux multi-caractères ont été hérités par C depuis le langage de programmation B. Bien que non spécifiés par les normes C ou C++, la plupart des compilateurs (MSVC est une exception notable) implémentent les littéraux multi-caractères comme spécifié dans B : les valeurs de chaque caractère dans le littéral initialisent les octets successifs de l'entier résultant, dans l'ordre big-endian complété à droite par des zéros, par exemple la valeur de ' \1 ' est 0x00000001 et la valeur de ' \1 \2 \3 \4 ' est 0x01020304 .

En C, les constantes de caractères telles que 'a' ou ' \n ' ont le type int , plutôt que char .

Exemple

Exécuter ce code

#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("Littéraux de caractères ordinaires :");
    char c1 = 'a'; dump("'a'", c1);
    char c2 = '\x2a'; dump("'*'", c2);
    print("\n" "Littéraux multi-caractères ordinaires :");
    int mc1 = 'ab'; dump("'ab'", mc1);       // défini par l'implémentation
    int mc2 = 'abc'; dump("'abc'", mc2);     // défini par l'implémentation
    print("\n" "Littéraux de caractères UTF-8 :");
    char8_t C1 = u8'a'; dump("u8'a'", C1);
//  char8_t C2 = u8'¢'; dump("u8'¢'", C2);   // erreur : ¢ correspond à deux unités de code UTF-8
//  char8_t C3 = u8'猫'; dump("u8'猫'", C3); // erreur : 猫 correspond à trois unités de code UTF-8
//  char8_t C4 = u8'🍌'; dump("u8'🍌'", C4); // erreur : 🍌 correspond à quatre unités de code UTF-8
    print("\n" "Littéraux de caractères UTF-16 :");
    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); // erreur : 🍌 correspond à deux unités de code UTF-16
    print("\n" "Littéraux de caractères UTF-32 :");
    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" "Littéraux de caractères larges :");
    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);  // non supporté sur Windows depuis C++23
}

Sortie possible :

Littéraux de caractères ordinaires :
'a' 	61 
'*' 	2A 
Littéraux multi-caractères ordinaires :
'ab' 	62 61 00 00 
'abc' 	63 62 61 00 
Littéraux de caractères UTF-8 :
u8'a' 	61 
Littéraux de caractères UTF-16 :
u'a' 	61 00 
u'¢' 	A2 00 
u'猫' 	2B 73 
Littéraux de caractères UTF-32 :
U'a' 	61 00 00 00 
U'¢' 	A2 00 00 00 
U'猫' 	2B 73 00 00 
U'🍌' 	4C F3 01 00 
Littéraux de caractères larges :
L'a' 	61 00 00 00 
L'¢' 	A2 00 00 00 
L'猫' 	2B 73 00 00 
L'🍌' 	4C F3 01 00

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	Appliqué à	Comportement publié	Comportement corrigé
CWG 912	C++98	le littéral de caractère ordinaire non encodable n'était pas spécifié	spécifié comme conditionnellement pris en charge
CWG 1024	C++98	le littéral multi-caractères devait être pris en charge	rendu conditionnellement pris en charge
CWG 1656	C++98	la signification de la séquence d'échappement numérique dans un littéral de caractère n'était pas claire	spécifiée
P1854R4	C++98	les littéraux de caractères non encodables étaient conditionnellement pris en charge	le programme est mal formé

Références

Norme C++23 (ISO/IEC 14882:2024) :

5.13.3 Littéraux de caractères [lex.ccon]

Norme C++20 (ISO/CEI 14882:2020) :

5.13.3 Littéraux de caractères [lex.ccon]

Norme C++17 (ISO/CEI 14882:2017) :

5.13.3 Littéraux de caractères [lex.ccon]

Norme C++14 (ISO/CEI 14882:2014) :

2.14.3 Littéraux de caractères [lex.ccon]

Norme C++11 (ISO/CEI 14882:2011) :

2.14.3 Littéraux de caractères [lex.ccon]

Norme C++03 (ISO/CEI 14882:2003) :

2.13.2 Littéraux de caractères [lex.ccon]

Norme C++98 (ISO/CEI 14882:1998) :

2.13.2 Littéraux de caractères [lex.ccon]

Voir aussi

littéraux définis par l'utilisateur (C++11)	littéraux avec suffixe défini par l'utilisateur
Documentation C pour Constante de caractère

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