字符字面量

c-char	-	要么是一个 basic-c-char，一个转义序列，定义于转义序列一个通用字符名，定义于转义序列
basic-c-char	-	来自基本源字符集(C++23 前)翻译字符集(C++23 起) 的字符，除了单引号 '、反斜杠 \ 或换行符
c-char-sequence	-	两个或更多个 c-char

[编辑] 解释

1) 普通字符字面量，例如 'a' 或 '\n' 或 '\13'。此类字面量的类型为 char，其值等于 c-char 在执行字符集中的表示(C++23 前)普通字面量编码中对应的码点(C++23 起)。

2) UTF-8 字符字面量，例如 u8'a'。此类字面量的类型为 char(C++20 前)char8_t(C++20 起)，其值等于 c-char 的 ISO/IEC 10646 码点值，前提是该码点值可以用单个 UTF-8 码元表示（即 c-char 在 0x0-0x7F 范围内，包含两端）。

3) UTF-16 字符字面量，例如 u'猫'，但不包括 u'🍌' (u'\U0001f34c')。此类字面量的类型为 char16_t，其值等于 c-char 的 ISO/IEC 10646 码点值，前提是该码点值可以用单个 UTF-16 码元表示（即 c-char 在 0x0-0xFFFF 范围内，包含两端）。

4) UTF-32 字符字面量，例如 U'猫' 或 U'🍌'。此类字面量的类型为 char32_t，其值等于 c-char 的 ISO/IEC 10646 码点值。

5) 宽字符字面量，例如 L'β' 或 L'猫'。此类字面量的类型为 wchar_t，其值等于 c-char 在执行宽字符集中的值(C++23 前)宽字面量编码中对应的码点(C++23 起)。

6) 普通多字符字面量(C++23 前)多字符字面量(C++23 起)，例如 'AB'，是条件支持的，其类型为 int，值由实现定义。

7) 宽多字符字面量，例如 L'AB'，是条件支持的，其类型为 wchar_t，值由实现定义。

[编辑] 不可编码字符

1-5) 假设 c-char 不是数值转义序列（见下文），如果 c-char 无法在字面量关联的字符编码中表示，或者无法在该编码中编码为单个码元（例如，Windows 上 wchar_t 为 16 位时，非 BMP 值），则程序是病态的。

6) 如果 c-char-sequence 中的任何 c-char 无法在普通字面量编码中编码为单个码元，则程序是病态的。

7) 如果 c-char-sequence 中的任何 c-char 无法在宽字面量编码中编码为单个码元，则程序是病态的。

(直至 C++23)

[编辑] 数值转义序列

数值（八进制和十六进制）转义序列可用于指定字符的值。

如果字符字面量只包含一个数值转义序列，并且该转义序列指定的值可以通过其类型的无符号版本表示，则该字符字面量的值与指定值相同（可能在转换为字符类型后）。

UTF-N 字符字面量可以具有其类型可表示的任何值。如果该值不对应于有效的 Unicode 码点，或者其对应的码点无法在 UTF-N 中表示为单个码元，它仍然可以通过具有该值的数值转义序列来指定。例如，u8'\xff' 是格式良好的，并且等于 char8_t(0xFF)。

(C++23 起)

如果在普通或宽字符字面量中使用的数值转义序列指定的值无法被 char 或 wchar_t 分别表示，则字符字面量的值由实现定义。	(直至 C++23)
如果在普通或宽字符字面量中使用的数值转义序列（带一个 c-char）指定的值可以通过 char 或 wchar_t 的基础类型的无符号版本分别表示，则字面量的值是该无符号整型的值，并且指定的值转换为字面量的类型。否则，程序是病态的。	(C++23 起)

如果在 UTF-N 字符字面量中使用的数值转义序列指定的值无法被对应的 charN_t 表示，则字符字面量的值由实现定义(C++17 前)程序是病态的(C++17 起)。

(C++11 起)

[编辑] 注意

多字符字面量由 C 语言从 B 编程语言继承而来。尽管 C 或 C++ 标准没有明确规定，但大多数编译器（MSVC 是一个显著例外）实现多字符字面量的方式与 B 语言中指定的一致：字面量中每个字符的值按大端零填充右对齐的顺序初始化结果整数的连续字节，例如，'\1' 的值是 0x00000001，而 '\1\2\3\4' 的值是 0x01020304。

在 C 语言中，字符常量如 'a' 或 '\n' 的类型是 int，而不是 char。

[编辑] 示例

运行此代码

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

可能的输出

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

[编辑] 缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告	应用于	发布时的行为	正确的行为
CWG 912	C++98	不可编码的普通字符字面量未指定	指定为条件支持
CWG 1024	C++98	多字符字面量要求被支持	改为条件支持
CWG 1656	C++98	数值转义序列的含义在字符字面量中不明确	已指定
P1854R4	C++98	不可编码的字符字面量是条件支持的	程序是病态的

[编辑] 参考

C++23 标准 (ISO/IEC 14882:2024)

5.13.3 字符字面量 [lex.ccon]

C++20 标准 (ISO/IEC 14882:2020)

5.13.3 字符字面量 [lex.ccon]

C++17 标准 (ISO/IEC 14882:2017)

5.13.3 字符字面量 [lex.ccon]

C++14 标准 (ISO/IEC 14882:2014)

2.14.3 字符字面量 [lex.ccon]

C++11 标准 (ISO/IEC 14882:2011)

2.14.3 字符字面量 [lex.ccon]

C++03 标准 (ISO/IEC 14882:2003)

2.13.2 字符字面量 [lex.ccon]

C++98 标准 (ISO/IEC 14882:1998)

2.13.2 字符字面量 [lex.ccon]

[编辑] 另请参阅

用户定义字面量(C++11)	带有用户定义后缀的字面量[编辑]
C 文档关于字符常量

编译器支持
自由（freestanding）与宿主（hosted）
语言
标准库
标准库头文件
具名要求
特性测试宏 (C++20)
语言支持库
概念库 (C++20)
诊断库
内存管理库
元编程库 (C++11)
通用工具库
容器库
迭代器库
范围库 (C++20)
算法库
字符串库
文本处理库
数值库
日期和时间库
输入/输出库
文件系统库 (C++17)
并发支持库 (C++11)
执行控制库 (C++26)
技术规范
符号索引
外部库


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

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

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

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

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

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

`L'`c-char-sequence `'`	(7)	(直至 C++23)

cppreference.cn

命名空间

变体

视图

操作