基础数据类型¶
方法速览¶
| 任务 | 方法 | 口诀 |
|---|---|---|
| 字节数 | bool/char 1、short 2、int/float 4、long long/double 8 |
1-1-2-4-4-8-8 |
| n 位无符号范围 | \([0,\ 2^n - 1]\) | 全部给正数 |
| n 位有符号范围 | \([-2^{n-1},\ 2^{n-1}-1]\) | 负多一个 |
| 溢出估算 | int 约 \(2\times10^9\)，unsigned int 约 \(4\times10^9\)，long long 约 \(9\times10^{18}\) |
上亿就可能爆 int |
| 有效位数 | float 6~7 位、double 15~16 位 |
精度要高用 double |
| 浮点判等 | 不要用 ==，用 fabs(a-b) < eps |
浮点无相等 |
类型总表（字节/范围）¶
64 位环境下（CSP 比赛环境）：
| 类型 | 字节 | 位 | 范围 | 记忆锚点 |
|---|---|---|---|---|
bool |
1 | 8 | true / false |
布尔 |
char |
1 | 8 | \(-128 \sim 127\) | 一个字符 |
unsigned char |
1 | 8 | \(0 \sim 255\) | |
short |
2 | 16 | \(-32768 \sim 32767\) | 万级 |
unsigned short |
2 | 16 | \(0 \sim 65535\) | |
int |
4 | 32 | \(-2147483648 \sim 2147483647\) | 21 亿级 |
unsigned int |
4 | 32 | \(0 \sim 4294967295\) | 43 亿 |
long long |
8 | 64 | \(\pm 9.2\times10^{18}\) | 千万亿亿 |
unsigned long long |
8 | 64 | \(0 \sim 1.8\times10^{19}\) | |
float |
4 | 32 | 约 \(\pm 3.4\times10^{38}\)，6~7 位有效 | 单精度 |
double |
8 | 64 | 约 \(\pm 1.8\times10^{308}\)，15~16 位有效 | 双精度 |
基本数据类型只有上表这些（加 void）；string、数组、struct、union、指针都是构造/复合类型，不是基本类型。
记字节数的口诀：布字一、短二、整浮四、长长双八。
有符号与无符号¶
- 有符号（默认）：最高位是符号位，n 位范围 \([-2^{n-1},\ 2^{n-1}-1]\)——负数比正数多一个；
- 无符号（
unsigned）：最高位也是数值位，n 位范围 \([0,\ 2^n - 1]\)——同样字节数，正数上限翻倍再 +1；
以 8 位为例对齐记忆：
| 位数 | 有符号 | 无符号 |
|---|---|---|
| 8 | \(-128 \sim 127\) | \(0 \sim 255\) |
| 16 | \(-32768 \sim 32767\) | \(0 \sim 65535\) |
| 32 | \(-2147483648 \sim 2147483647\) | \(0 \sim 4294967295\) |
| 64 | \(\pm 9.2\times10^{18}\) | \(0 \sim 1.8\times10^{19}\) |
同类型混算规则：有符号与无符号混算时，有符号一方先转成无符号再算——-1 < 1u 会判成“假”（\(-1\) 转成巨大的无符号数），是经典陷阱。
有效位数¶
float 和 double 用二进制小数近似存储实数：
float尾数 24 位 → 约 \(6\sim7\) 位十进制有效数字；double尾数 53 位 → 约 \(15\sim16\) 位十进制有效数字。
两个直接后果：
- 大数吃小数：
float f = 123456789;→ 只剩约 7 位有效，存成123456792左右；float里给10000000.1加0.3，那0.3直接被吞掉； - 浮点不能判等：
0.1 + 0.2 == 0.3是假（二进制循环小数累积误差）——判等用fabs(a - b) < 1e-9。
例：0.1 + 0.2 在二进制下都是无限循环小数，存进去的值实为 \(0.30000000000000004\dots\)，与 0.3 的存储值不同 → == 判假。
练习题目¶
练习 1 · 字节数合计¶
题目
64 位环境下，short、int、long long 变量各定义一个，共占用（ ）个字节。
- A. \(12\)
- B. \(14\)
- C. \(24\)
- D. \(8\)
答案与解析
答案：B
口诀“布字一、短二、整浮四、长长双八”：\(2 + 4 + 8 = 14\)。
干扰项思路：A 把 int 记成 2 字节；C 全按 8 字节算；D 只数了最大的那个类型。
练习 2 · unsigned short 最大值¶
题目
16 位无符号整数（unsigned short）能表示的最大值是（ ）
- A. \(65535\)
- B. \(32767\)
- C. \(65536\)
- D. \(32768\)
答案与解析
答案：A
无符号范围 \([0,\ 2^{16}-1]\)，最大值 \(65535\)。
干扰项思路：B 是 16 位有符号的上限；C 忘了减 1（那是编码总数）；D 混用了有符号的界。
练习 3 · 字节数排序¶
题目
char、short、int、double 占用的字节数依次是（ ）
- A. \(1\)、\(2\)、\(4\)、\(8\)
- B. \(1\)、\(4\)、\(4\)、\(8\)
- C. \(2\)、\(2\)、\(4\)、\(8\)
- D. \(1\)、\(2\)、\(8\)、\(8\)
答案与解析
答案：A
口诀“布字一、短二、整浮四、长长双八”。
干扰项思路：B 把 short 记成 4；C 把 char 记成 2；D 把 int 记成 8。
练习 4 · bool 的大小¶
题目
sizeof(bool) 的值是（ ）
- A. \(0\)
- B. \(4\)
- C. 未定义
- D. \(1\)
答案与解析
答案：D
bool 占 1 字节——虽然逻辑上只需要 1 位，但内存最小寻址单位是字节。
练习 5 · 基本类型辨析¶
题目
下列属于 C++ 基本数据类型的是（ ）
- A.
int - B.
string - C.
struct - D.
vector
答案与解析
答案：A
int 是基本类型；string、vector 是库里的类模板实例，struct 是类型构造器——都不是基本类型。
练习 6 · short 范围¶
题目
16 位有符号短整型（short）的范围是（ ）
- A. \(-32767 \sim 32767\)
- B. \(-32768 \sim 32768\)
- C. \(-32768 \sim 32767\)
- D. \(0 \sim 65535\)
答案与解析
答案：C
\([-2^{15},\ 2^{15}-1]\)，负数多一个。D 是无符号的范围。
练习 7 · unsigned char¶
题目
unsigned char 能表示的范围是（ ）
- A. \(-128 \sim 127\)
- B. \(0 \sim 256\)
- C. \(0 \sim 255\)
- D. \(1 \sim 255\)
答案与解析
答案：C
8 位无符号 \([0,\ 2^8-1]\)。B 多算了一个（\(256\) 存不下）；A 是有符号范围。
练习 8 · long long 的量级¶
题目
long long 能表示的整数数量级约为（ ）
- A. \(2\times10^9\)
- B. \(4\times10^9\)
- C. \(9\times10^{15}\)
- D. \(9\times10^{18}\)
答案与解析
答案：D
\(2^{63}-1 = 9223372036854775807 \approx 9.2\times10^{18}\)。
干扰项思路：C 差了三个数量级（那是 \(10^{15}\)，只够 \(2^{53}\)——正好是 double 精确整数上限）。
练习 9 · int 存不下什么¶
题目
下列数值中，int 类型存不下的是（ ）
- A. \(1000000\)
- B. \(100000000\)
- C. \(2000000000\)
- D. \(3000000000\)
答案与解析
答案：D
int 上限 \(2147483647 \approx 2.1\times10^9\)：\(3\times10^9\) 超限，会溢出成负数；\(2\times10^9\) 恰好还在界内。
记忆锚点：上 10 亿的题，先想 long long。
练习 10 · unsigned int 的 0 下界¶
题目
unsigned int x = 0; --x; 执行后 x 的值是（ ）
- A. \(-1\)
- B. \(0\)
- C. \(4294967295\)
- D. 编译错误
答案与解析
答案：C
无符号数没有负数，\(0\) 减 \(1\) 回绕到最大值 \(2^{32}-1\)。
干扰项思路：A 按有符号想当然；这是无符号回绕的经典考法。
练习 11 · 有符号与无符号混算¶
题目
cout << ((-1) < 1u ? "less" : "not less"); 输出（ ）
- A.
less - B. 编译错误
- C.
not less - D. 未定义
答案与解析
答案：C
混算时 \(-1\) 转成无符号：\(1111\dots1_2 = 4294967295\)，比 1 大——判“not less”。
干扰项思路：A 忽略转换规则；有符号与无符号比较，先统一成无符号。
练习 12 · char 的数值身份¶
题目
char c = 'A'; cout << c + 1; 输出（ ）
- A.
B - B. \(66\)
- C.
A1 - D. 编译错误
答案与解析
答案：B
char 参与算术时先提升成 int：'A' = 65，\(65+1 = 66\)，按 int 输出 66。
干扰项思路：A 以为会自动转回字符输出；想输出 B 要写 char(c + 1)。
练习 13 · 溢出演算¶
题目
int x = 2147483647; x = x + 1; cout << x; 输出（ ）
- A. \(2147483648\)
- B. \(0\)
- C. \(-2147483648\)
- D. 编译错误
答案与解析
答案：C
\(2^{31}-1\) 加 1 溢出，补码位串变成 1000...0，按有符号解读为 \(-2^{31}\)——最大正数加 1 变最小负数。
练习 14 · 数组的 sizeof¶
题目
int a[5]; 则 sizeof(a) 的值是（ ）
- A. \(5\)
- B. \(20\)
- C. \(4\)
- D. \(40\)
答案与解析
答案：B
\(5 \times 4 = 20\) 字节。
干扰项思路：A 是元素个数不是字节；D 是 10 个 int 的数组。
练习 15 · 结构体的大小（对齐）¶
题目
struct S { int a; double b; }; 在 64 位环境下 sizeof(S) 的值是（ ）
- A. \(16\)
- B. \(12\)
- C. \(9\)
- D. \(8\)
答案与解析
答案：A
内存对齐：double 要从 8 的倍数地址开始，int 后面填充 4 字节，\(4 + 4 + 8 = 16\)。
干扰项思路：B 不对齐直接相加 \(4+8=12\)；C 连 double 占 8 字节都没记对；D 只算了 double 一个成员。
练习 16 · float 的有效位数¶
题目
float 的有效数字约为（ ）位。
- A. \(3\sim4\)
- B. \(6\sim7\)
- C. \(15\sim16\)
- D. 任意多位
答案与解析
答案：B
float 尾数 24 位二进制 \(\approx 2^{24} = 16777216\)，能精确区分约 \(1.7\times10^7\) 个值 → 十进制 \(6\sim7\) 位有效。
干扰项思路：C 是 double 的位数——两档位数是最常考的对照。
练习 17 · double 的有效位数¶
题目
double 的有效数字约为（ ）位。
- A. \(6\sim7\)
- B. \(9\sim10\)
- C. \(15\sim16\)
- D. \(30\sim31\)
答案与解析
答案：C
double 尾数 53 位，\(2^{53} \approx 9\times10^{15}\) → 十进制 \(15\sim16\) 位有效。
练习 18 · 浮点判等¶
题目
cout << ((0.1 + 0.2) == 0.3 ? "eq" : "neq"); 输出（ ）
- A.
eq - B.
neq - C. 编译错误
- D. 不确定
答案与解析
答案：B
\(0.1\)、\(0.2\) 在二进制下是无限循环小数，存入时有误差，\(0.1+0.2\) 的实际值是 \(0.30000000000000004\dots\)，与 0.3 的存储值不相等。
判等正解：fabs(a - b) < 1e-9。
练习 19 · 大数吃小数¶
题目
float f = 100000000; f = f + 1; 则 f（ ）
- A. 变为 \(100000001\)
- B. 变为 \(100000000.5\)
- C. 溢出为负数
- D. 不变，仍为 \(100000000\)
答案与解析
答案：D
float 只有约 7 位有效数字，1 亿是 9 位数——加 1 的变化远小于存储精度，被直接吞掉。
干扰项思路：A 按数学惯性算；这就是“大数吃小数”。
练习 20 · 选对类型存实数¶
题目
要精确比较 \(10^{15}\) 量级的两个整数，应使用的类型是（ ）
- A.
int - B.
float - C.
double - D.
long long
答案与解析
答案：D
整数比大小用整型：\(10^{15}\) 超 int，上 long long。
干扰项思路：C 的 double 虽然量级够（可到 \(10^{308}\)），但有效数字只有 \(15\sim16\) 位，\(10^{15}\) 量级只能保证个位级别精度——整数运算别用浮点。
练习 21 · float 与 double 字节数¶
题目
float 与 double 的字节数分别是（ ）
- A. \(4\) 和 \(8\)
- B. \(8\) 和 \(8\)
- C. \(4\) 和 \(4\)
- D. \(2\) 和 \(4\)
答案与解析
答案：A
单精度 4 字节、双精度 8 字节——“双”就是两倍存储。
练习 22 · 字符常量与字符串常量¶
题目
'a' 与 "a" 的区别，说法正确的是（ ）
- A. 完全相同，可互换
- B.
'a'占 2 字节，"a"占 1 字节 - C.
'a'是字符（1 字节），"a"是字符串（含'\0'共 2 字节） - D. 都是 1 字节
答案与解析
答案：C
单引号是 char 字面值；双引号是字符串字面值，末尾自动带 '\0'，sizeof("a") = 2。
练习 23 · string 的内容比较¶
题目
string a = "ab", b = "ab"; 则表达式 a == b（ ）
- A. 为假——比较的是两个对象的存储地址
- B. 为真——string 重载了
==，按字符内容比较 - C. 无法编译——string 不能用
==比较 - D. 结果不确定，取决于编译器实现
答案与解析
答案：B
string 把比较运算符重载为逐字符内容比较（长度不同直接判假，再逐字符比对），两个 "ab" 相等。
干扰项思路：A 是 C 风格 char* 的行为——指针比较内容相同也判假，这正是两类字符串最经典的区别。
练习 24 · void 的身份¶
题目
关于 void，说法正确的是（ ）
- A. 是一种基本类型，可定义变量
void x; - B. 是关键字，表示“无类型”，不能定义变量
- C. 占 1 字节
- D. 与
bool等价
答案与解析
答案：B
void 是关键字，用于函数无返回值、泛型指针 void* 等，但不能拿它定义变量。
练习 25 · 类型选择（竞赛场景）¶
题目
计算 \(n = 10^5\) 个不超过 \(10^9\) 的整数的总和，应使用的类型是（ ）
- A.
int - B.
unsigned int - C.
long long - D.
float
答案与解析
答案：C
总和最大 \(10^5 \times 10^9 = 10^{14}\)，远超 int 的 \(2.1\times10^9\)，必须 long long。
干扰项思路：A 每项存得下、总和存不下——溢出考法就藏在“求和”里。
练习 26 · 类型总复习¶
题目
下列说法错误的是（ ）
- A.
char占 1 字节 - B.
int与float都占 4 字节 - C.
long long与double都占 8 字节 - D.
bool占 4 字节，与 int 相同
答案与解析
答案：D
bool 占 1 字节。A、B、C 都对：字节数口诀“布字一、短二、整浮四、长长双八”。
历年真题¶
2019 年 · 第 3 题¶
题目
一个 \(32\) 位整型变量占用（ ）个字节。
- A. \(32\)
- B. \(4\)
- C. \(128\)
- D. \(8\)
答案与解析
答案：B
1 字节 = 8 位，\(32 \div 8 = 4\)。
2025 年 · 第 1 题¶
题目
一个 \(32\) 位无符号整数可以表示的最大值，最接近下列哪个选项？（ ）
- A. \(4\times10^9\)
- B. \(3\times10^{10}\)
- C. \(2\times10^9\)
- D. \(2\times10^{10}\)
答案与解析
答案：A
\(2^{32} - 1 = 4294967295 \approx 4.3\times10^9\)，最接近 \(4\times10^9\)。
易错
有符号 int 的上限是 \(2^{31}-1 \approx 2.1\times10^9\)（对应 C 选项的量级）；无符号把符号位也让给数值，直接翻倍。
2025 年 · 第 9 题¶
题目
下列关于 C++ string 类的说法，正确的是？（ ）
- A.
string对象的长度在创建后不能改变。 - B. 可以使用
+运算符直接连接一个string对象和一个char类型的字符。 - C.
string的length()和size()方法返回的值可能不同。 - D.
string对象必须以'\0'结尾，且这个结尾符计入length()。
答案与解析
答案：B
string 重载了 +（string+string、string+char、string+字符串字面值都合法）；A 长度可变；C 的 length()/size() 等价；D 描述的是 C 风格字符串——string 类自带长度管理，无 '\0' 概念。
易错小结¶
- 位 → 字节先除 8：32 位 = 4 字节，别把位数当字节数；
- 负数多一个：n 位有符号范围 \([-2^{n-1},\ 2^{n-1}-1]\)；无符号 \([0,\ 2^n-1]\)——“0 到 256”是错的，最大值要减 1；
- 量级判溢出：int 约 21 亿、unsigned int 约 43 亿、long long 约 \(9.2\times10^{18}\)——求和题先估总量级；
- 无符号回绕：
unsigned的 0 减 1 变最大值；有符号与无符号混算，有符号先转无符号； - float 6~7 位、double 15~16 位有效数字——浮点判等用
fabs(a-b)<eps，大数加小数会被吞； string不是基本类型，长度可变、无'\0'、length()=size()；- 字节数口诀：布字一、短二、整浮四、长长双八。