MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

C++字符常量的存储方式

2022-12-197.7k 阅读

C++ 字符常量基础概念

字符常量定义

在 C++ 中，字符常量是用单引号括起来的单个字符。例如，'a'、'A'、'0' 都是字符常量。C++ 字符常量通常基于 ASCII 编码系统，每个字符都对应一个唯一的整数值。

char c1 = 'a';
char c2 = 'Z';

在上述代码中，c1 被初始化为字符 'a'，c2 被初始化为字符 'Z'。这里的 'a' 和 'Z' 就是字符常量。

字符常量与整数值关系

字符常量在底层是以整数形式存储的。例如，在 ASCII 编码中，字符 'a' 对应的整数值是 97，字符 'A' 对应的整数值是 65。我们可以通过将字符常量赋值给整型变量来验证这一点。

int num1 = 'a';
int num2 = 'A';
std::cout << "The integer value of 'a' is: " << num1 << std::endl;
std::cout << "The integer value of 'A' is: " << num2 << std::endl;

运行上述代码，会输出 'a' 对应的整数值 97 和 'A' 对应的整数值 65。这表明字符常量在存储时，实际存储的是其对应的整数值。

基本字符常量存储方式

存储单元

字符常量在 C++ 中通常占用一个字节（8 位）的存储空间。这是因为 ASCII 编码系统使用 7 位来表示 128 个基本字符，再加上一个符号位（在字符存储中通常用不到），总共 8 位。

std::cout << "Size of char: " << sizeof(char) << " bytes" << std::endl;

上述代码输出结果为 1，说明 char 类型（用于存储字符常量）占用 1 字节空间。

存储原理

当我们定义一个字符常量 'a' 时，编译器会将其对应的 ASCII 值 97 存储在分配给该字符变量的一个字节中。从二进制角度看，97 的二进制表示是 01100001，这个二进制序列就存储在那个字节中。

char c = 'a';
unsigned char* p = reinterpret_cast<unsigned char*>(&c);
for (int i = 7; i >= 0; --i) {
    std::cout << ((p[0] >> i) & 1);
}
std::cout << std::endl;

上述代码通过指针获取字符 'a' 的存储字节，并将其以二进制形式输出，输出结果为 01100001。

宽字符常量存储方式

宽字符常量定义

除了普通字符常量，C++ 还支持宽字符常量，用于表示非 ASCII 字符集，如 Unicode 字符。宽字符常量用前缀 L 表示，并用单引号括起来。例如，L'ä'。

wchar_t wc = L'ä';

这里 wc 是一个宽字符类型 wchar_t，用于存储宽字符常量 L'ä'。

存储单元与编码

宽字符常量的存储单元大小取决于编译器和平台。在许多系统中，wchar_t 是 2 字节（16 位）或 4 字节（32 位）。wchar_t 通常用于 UTF - 16 或 UTF - 32 编码。

std::cout << "Size of wchar_t: " << sizeof(wchar_t) << " bytes" << std::endl;

上述代码输出 wchar_t 类型的大小，不同平台结果可能不同，常见为 2 或 4。

宽字符存储原理

以 UTF - 16 编码为例，对于基本多文种平面（BMP）内的字符，直接使用 16 位表示。例如，字符 'ä' 在 UTF - 16 中的编码值可能是 0x00E4。如果 wchar_t 是 2 字节，那么 0x00E4 就会直接存储在这个 2 字节的空间中。

wchar_t wc = L'ä';
unsigned short* p = reinterpret_cast<unsigned short*>(&wc);
std::cout << "Hex value of L'ä': 0x" << std::hex << *p << std::endl;

上述代码将宽字符 L'ä' 的存储值以十六进制形式输出。

转义字符常量存储方式

转义字符定义

转义字符是一种特殊的字符常量，用于表示一些无法直接通过键盘输入的字符，或者具有特殊含义的字符。转义字符以反斜杠 \ 开头，后面跟着一个或多个字符。例如，'\n' 表示换行符，'\t' 表示制表符。

char newLine = '\n';
char tab = '\t';

这里 newLine 存储的是换行符，tab 存储的是制表符。

转义字符存储原理

转义字符同样是以其对应的整数值存储在一个字节中。例如，换行符 '\n' 对应的 ASCII 值是 10，制表符 '\t' 对应的 ASCII 值是 9。

char newLine = '\n';
int value = static_cast<int>(newLine);
std::cout << "The integer value of '\\n' is: " << value << std::endl;

上述代码输出换行符 '\n' 对应的整数值 10。

特殊转义字符

除了常见的 '\n'、'\t' 等，还有一些特殊的转义字符。例如，'\0' 表示空字符，用于表示字符串的结束。它对应的整数值是 0。

char nullChar = '\0';
int nullValue = static_cast<int>(nullChar);
std::cout << "The integer value of '\\0' is: " << nullValue << std::endl;

上述代码输出空字符 '\0' 对应的整数值 0。

字符常量在字符串中的存储

字符串与字符常量关系

字符串是由字符常量组成的序列，以空字符 '\0' 结尾。每个字符常量在字符串中都有其特定的存储位置。

const char* str = "Hello";

这里 "Hello" 是一个字符串常量，它包含了字符 'H'、'e'、'l'、'l'、'o' 以及结尾的 '\0'。

字符串存储方式

字符串常量通常存储在只读数据段。每个字符常量按照顺序依次存储，最后以 '\0' 作为结束标志。

const char* str = "Hello";
unsigned char* p = reinterpret_cast<unsigned char*>(const_cast<char*>(str));
for (int i = 0; p[i] != '\0'; ++i) {
    std::cout << static_cast<char>(p[i]) << " : " << static_cast<int>(p[i]) << std::endl;
}

上述代码遍历字符串 "Hello"，输出每个字符及其对应的整数值。可以看到，每个字符常量都以其对应的整数值存储在连续的内存位置，最后以 '\0'（整数值 0）结束。

字符常量存储与内存对齐

内存对齐概念

内存对齐是一种优化技术，它确保数据在内存中的存储地址是某些特定值的倍数。这有助于提高 CPU 对数据的访问效率。在 C++ 中，结构体和类中的成员变量存储时会涉及内存对齐。

字符常量在结构体中的存储与对齐

当字符常量作为结构体成员时，其存储位置会受到内存对齐的影响。

struct CharStruct {
    char c1;
    int num;
    char c2;
};
std::cout << "Size of CharStruct: " << sizeof(CharStruct) << " bytes" << std::endl;

理论上，CharStruct 中 c1 占 1 字节，num 占 4 字节，c2 占 1 字节，总共应该是 6 字节。但实际上，由于内存对齐，sizeof(CharStruct) 的结果可能是 8 字节。这是因为 num 的存储地址需要是 4 的倍数，所以在 c1 后面会填充 3 个字节，使得 num 的地址满足对齐要求。

对字符常量存储的影响

虽然字符常量本身只占 1 字节，但在结构体等复合类型中，其存储位置可能会因为内存对齐而发生变化，导致其前后可能会有填充字节。这在编写对内存布局敏感的代码时需要特别注意。

字符常量存储与编译器优化

编译器优化对存储的影响

编译器在编译过程中可能会对字符常量的存储进行优化。例如，对于相同的字符常量，编译器可能会将其合并为一个存储实例，以节省内存空间。

char c1 = 'a';
char c2 = 'a';

在某些编译器优化策略下，c1 和 c2 可能会共享同一个存储位置（虽然它们在逻辑上是不同的变量），因为它们的值都是 'a'。

优化策略与实现

编译器实现这种优化的策略可能包括常量折叠、公共子表达式消除等。对于字符常量，如果编译器在编译期能够确定其值不会改变，并且多个地方使用相同的值，就可能进行优化。

const char c3 = 'a';
const char c4 = 'a';

这里 c3 和 c4 都是常量，编译器更有可能对它们进行优化，将它们映射到相同的存储位置。

字符常量存储与不同平台差异

平台差异概述

不同的硬件平台和操作系统可能对字符常量的存储有不同的实现方式。这些差异主要体现在字符编码、存储单元大小等方面。

编码差异

例如，在 Windows 系统中，传统上使用的是 ASCII 扩展编码（如 CP1252），而在 Unix - like 系统中，更倾向于使用 UTF - 8 编码。这就导致对于一些非 ASCII 字符，其存储值和方式会有所不同。

// 在不同编码环境下存储非ASCII字符
// 假设在UTF - 8环境下
char nonAsciiUTF8 = '\xC3\xA4'; // 'ä' in UTF - 8
// 假设在CP1252环境下
char nonAsciiCP1252 = '\xE4'; // 'ä' in CP1252

上述代码展示了在不同编码环境下存储字符 'ä' 的不同方式。

存储单元大小差异

如前文所述，wchar_t 的大小在不同平台可能不同，这直接影响宽字符常量的存储。在一些 32 位系统中，wchar_t 可能是 2 字节，而在 64 位系统中，可能是 4 字节。

std::cout << "Size of wchar_t on this platform: " << sizeof(wchar_t) << " bytes" << std::endl;

通过上述代码可以查看当前平台下 wchar_t 的大小，不同平台可能输出不同结果。

字符常量存储的安全性与注意事项

溢出问题

当尝试将超出字符类型表示范围的值赋给字符变量时，会发生溢出。例如，在 8 位 char 类型中，其表示范围通常是 - 128 到 127（有符号）或 0 到 255（无符号）。

char c = 128; // 对于有符号char，这会导致溢出
unsigned char uc = 256; // 对于无符号char，这会导致溢出

上述代码在赋值时会发生溢出，可能导致未定义行为。

类型转换问题

在进行字符常量与其他类型之间的转换时，需要注意类型转换的规则。例如，将字符常量转换为浮点数时，会先将字符的整数值转换为浮点数。

char c = 'a';
float f = static_cast<float>(c);
std::cout << "Float value of 'a': " << f << std::endl;

这里将字符 'a'（整数值 97）转换为浮点数 97.0。但如果转换不当，可能会丢失精度或导致错误结果。

字符串处理中的安全性

在处理包含字符常量的字符串时，要注意缓冲区溢出等安全问题。例如，使用 strcpy 函数复制字符串时，如果目标缓冲区大小不够，会导致数据溢出。

char dest[5];
const char* src = "Hello";
// 下面这行代码会导致缓冲区溢出
strcpy(dest, src);

上述代码中，dest 大小为 5，而 "Hello" 加上结束符 '\0' 长度为 6，使用 strcpy 会导致缓冲区溢出，这是一个严重的安全隐患。应使用更安全的函数如 strncpy 来避免此类问题。

char dest[5];
const char* src = "Hello";
strncpy(dest, src, sizeof(dest) - 1);
dest[sizeof(dest) - 1] = '\0';

通过 strncpy 并手动添加结束符，可以确保不会发生缓冲区溢出。

在 C++ 编程中，深入理解字符常量的存储方式对于编写高效、安全的代码至关重要。无论是基本字符常量、宽字符常量、转义字符常量，还是它们在字符串、结构体中的存储，都涉及到诸多细节和潜在的问题。同时，编译器优化、平台差异等因素也会对字符常量存储产生影响。只有全面掌握这些知识，才能在实际编程中避免错误，充分发挥 C++ 的强大功能。