Character constant

Syntaxe

où

• c-char est soit

• un caractère de l'ensemble de caractères source de base, à l'exclusion de l'apostrophe ( ' ), de la barre oblique inverse ( \ ) ou du caractère de nouvelle ligne.
• séquence d'échappement : l'un des caractères spéciaux d'échappement \ ' \ " \ ? \\ \a \b \f \n \r \t \v , les échappements hexadécimaux \x... ou les échappements octaux \... tels que définis dans les séquences d'échappement .

• c-char-sequence est une séquence de deux ou plusieurs c-char s.

Notes

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

En C++, les littéraux de caractères ordinaires encodables ont le type char , plutôt que int .

Contrairement aux constantes entières , une constante de caractère peut avoir une valeur négative si char est signé : sur de telles implémentations ' \xFF ' est un int avec la valeur - 1 .

Lorsqu'ils sont utilisés dans une expression de contrôle de #if ou #elif , les constantes de caractères peuvent être interprétées en fonction du jeu de caractères source, du jeu de caractères d'exécution, ou d'un autre jeu de caractères défini par l'implémentation.

Les constantes multi-caractères 16/32 bits ne sont pas largement supportées et ont été supprimées dans C23. Certaines implémentations courantes (par exemple clang) ne les acceptent pas du tout.

Exemple

#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);
}

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

Références

Voir aussi