命名空间
变体
操作

字符字面量

来自 cppreference.cn
< cpp‎ | language
 
C++
 
C++ 语言
通用主题
流程控制
条件执行语句
if
迭代语句 (循环)
for
范围 for (C++11)
跳转语句
函数
函数声明
Lambda 函数表达式
inline 说明符
动态异常规范 (在 C++17 前已弃用*)
noexcept 说明符 (C++11)
异常
命名空间
类型
说明符
const/volatile
decltype (C++11)
auto (C++11)
constexpr (C++11)
consteval (C++20)
constinit (C++20)
存储期说明符
初始化
 
表达式
通用
字面量
运算符
转换
 

目录

[编辑] 语法

'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 前)
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 起) 类型，且值等于 ISO/IEC 10646 c-char 的代码点值，前提是该代码点值能以单个 UTF-8 代码单元表示（即 c-char 在 0x0-0x7F 范围内，含边界）。
3) UTF-16 字符字面量，例如 u'猫'，但非 u'🍌' (u'\U0001f34c')。此类字面量具有 char16_t 类型，且值等于 ISO/IEC 10646 c-char 的代码点值，前提是该代码点值能以单个 UTF-16 代码单元表示（即 c-char 在 0x0-0xFFFF 范围内，含边界）。
4) UTF-32 字符字面量，例如 U'猫' 或 U'🍌'。此类字面量具有 char32_t 类型，且值等于 ISO/IEC 10646 c-char 的代码点值。
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 中所指定：字面量中每个 char 的值初始化结果整数的连续字节，以大端序、零填充、右对齐的顺序，例如 '\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++ 标准。

DR 应用于 已发布行为 正确行为
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 文档 关于 字符常量
取自“https://cppreference.cn/mwiki/index.php?title=cpp/language/character_literal&oldid=157264”