Appearance
第5章 基本数据类型
🎯 本章学习目标
读完本章，你将能够：
- ✅ 说出 C++ 一级要求掌握的 6 种基本数据类型及其占字节数
- ✅ 掌握 int 和 long long 的取值范围，知道什么时候该用 long long
- ✅ 理解整数溢出的概念和现象，能判断题目是否需要用 long long
- ✅ 区分 float 和 double，知道默认使用 double
- ✅ 理解小数是近似存储的，知道 0.1+0.2 不精确等于 0.3
- ✅ 掌握整数除法"截断小数"的特性，能预测 3/2 的结果
- ✅ 熟练使用 char 类型，记住三个关键 ASCII 码（'0'=48, 'A'=65, 'a'=97）
- ✅ 理解字符和整数的关系，能进行字符运算（如 'a'+1='b'）
- ✅ 掌握 bool 类型的两个值和"非 0 即真"规则
- ✅ 能根据题目需求选择合适的数据类型
🗺️ 本章知识图谱
第5章 基本数据类型
├── 一、数据类型是什么
│ └── 变量=盒子，类型=盒子型号（决定大小和装什么）
├── 二、整数型
│ ├── int：4字节，约±21亿
│ ├── 溢出：最大值+1绕回最小值
│ └── long long：8字节，约±920亿亿，大数加LL
├── 三、实数型（浮点型）
│ ├── float：4字节，6~7位有效数字
│ ├── double：8字节，15~16位有效数字（常用）
│ ├── 小数是近似存储（0.1+0.2≠0.3精确值）
│ └── 整数除法截断小数：3/2=1，3.0/2=1.5
├── 四、字符型 char
│ ├── 1字节，单引号，一个字符
│ ├── ASCII码：'0'=48, 'A'=65, 'a'=97
│ ├── 大小写差32：'a'-'A'=32
│ ├── 字符运算：'a'+1='b'
│ └── '0' ≠ 0（字符零 vs 整数零）
├── 五、布尔型 bool
│ ├── true/false（全小写）
│ ├── cout默认输出1/0
│ └── 非0即真
└── 六、类型大小汇总与选用
├── sizeof运算符
└── 选型建议：日常int、大数long long、小数double一、数据类型是什么？——C++ 的盒子有"固定大小"
生活中装东西要看容器：装零食有小密封袋，装书本有书包，装棉被有大号收纳箱。东西多大，就用多大的盒子。
C++ 的变量也是这个道理。每定义一个变量，计算机都会在内存里给它安排一个"小盒子"，而盒子的型号，就是数据类型。一级阶段要认识六种：
| 类型名 | 中文叫法 | 生活比喻 | 例子 | 占内存 |
|---|---|---|---|---|
int | 整型 | 普通书包，装日常整数 | 10、-3、0 | 4 字节 |
long long | 长整型 | 超大号收纳箱，装特别大的整数 | 100000000000 | 8 字节 |
float | 单精度浮点型 | 小水杯，装小数（精度一般） | 3.14f | 4 字节 |
double | 双精度浮点型 | 大量杯，装小数（精度高，最常用） | 3.14、1.5 | 8 字节 |
char | 字符型 | 单个格子，只放一个字符 | 'A'、'0'、'?' | 1 字节 |
bool | 布尔型 | 电灯开关，只有开/关两档 | true、false | 1 字节 |
📌 小提示：定义变量的完整语法是
类型名 变量名 = 值;，类型名必须写在最前面，这就是上一章学的"先声明、后使用"。
🍎 C++ 和其他语言的最大不同：C++ 的盒子出厂就定好了大小，一个
int盒子永远只有 4 字节，塞太大的数会"溢出"出错；而有些语言的盒子像橡皮筋口袋，多大的数都装得下。所以 C++ 程序员必须养成"选对盒子"的习惯——这正是本章的核心考点！
💡 什么是字节？
你可能会问："字节"是什么？为什么用它来衡量大小？
简单来说，计算机里存储数据的最小单位叫"位"（bit），每一位只能存 0 或 1，就像一个电灯开关——只有开和关两种状态。
8 个位组成一个"字节"（Byte），这是计算机里最常用的基本存储单位：
1 字节 = 8 位（bit）
1 KB = 1024 字节
1 MB = 1024 KB
1 GB = 1024 MB打个比方：位就像单个灯泡，字节就像 8 个灯泡排成一排——8 个灯泡的明灭组合可以表示 2⁸ = 256 种不同状态。所以 1 字节可以存 256 个不同的值，4 字节（int）可以存 2³² ≈ 42 亿个不同的值（分一半给负数，所以 int 范围约 ±21 亿）。
二、整数型：int 与 long long
2.1 int：最常用的整数盒子
int 是 integer（整数）的缩写，专门装没有小数点的数：班级人数、年龄、考试分数、温度……
cpp
int age = 10; // 正整数
int temp = -3; // 负整数
int count = 0; // 零也是整数int 占 4 个字节，也就是 32 个二进制位，其中一位用来表示正负，所以它能装的范围是：
int 的范围：约 -21 亿 ~ 21 亿（准确说是 -2³¹ ~ 2³¹-1，即 -2147483648 ~ 2147483647）
21 亿有多大？全世界人口约 80 亿，已经超过了；但一个学校的人数、一年的秒数（约 3153 万）都装得下。所以平时做题，整数用 int 基本够用。
2.2 溢出：盒子装不下会"撑爆" 🔥
如果硬把超过 21 亿的数塞进 int 盒子，会发生什么？——溢出（overflow），结果会错得离谱！
cpp
#include <iostream>
using namespace std;
int main() {
int a = 2147483647; // int 的最大值
cout << a << endl; // 2147483647（还装得下）
cout << a + 1 << endl; // -2147483648（溢出！最大值+1竟变成最小值）
return 0;
}🍎 小比喻：这就像老式里程表，数字走到 99999 之后再走一格，"咔哒"一下又回到 00000。int 盒子装满后再加 1，就会"绕回"最小的负数。在常见编译器上，
2147483647 + 1会得到-2147483648——在大多数常见编译器上会输出 -2147483648，但这是未定义行为，标准不保证任何结果。考试中判断‘int最大值+1’的结果，按常见编译器填写即可，但要记住这本质上是‘程序已出错’。
高频考点 🔥： 题目里出现"全国人口""几十亿""大数求和"等字眼，或者数据可能超过 21 亿，就要立刻警觉：int 装不下，必须用 long long！溢出题是选择题、程序阅读题的常客。
2.3 long long：超大号整数盒子
long long 占 8 个字节（64 位），能装的范围约是：
long long 的范围：约 ±9.2×10¹⁸（也就是 ±920 亿亿，天文数字级别）
什么样的数需要它？比如统计 1 到 100 亿的和、存一个身份证号那么长的数字：
cpp
#include <iostream>
using namespace std;
int main() {
long long big = 123456789012345LL; // 超大数，末尾加 LL 表示"这是 long long 数"
cout << big << endl; // 123456789012345
cout << big * 2 << endl; // 246913578024690，稳稳装下
return 0;
}⚠️ 易错点： 书写超大的整数常量时，建议在数字末尾加上
LL（两个大写或小写 L），明确告诉计算机"这是个 long long 大数"。例如100000000000LL。如果只写100000000000，某些编译器可能先按 int 处理，装不下就已经出错了。
整数选型口诀：日常整数用 int，超过 21 亿用 long long。
🔍 深度辨析：什么时候必须用 long long？
很多同学拿到题就写 int，结果答案错了才发现溢出了。教你几个判断信号：
| 题目场景 | 要不要用 long long | 原因 |
|---|---|---|
| 班级人数、年龄、分数 | ❌ 不用 | 一般几百、几十，int 绰绰有余 |
| 一年的天数、秒数 | ❌ 不用 | 一年约 3153 万秒，远小于 21 亿 |
| 全国/全球人口 | ✅ 要用 | 80 亿 > 21 亿 |
| 求 1 到 N 的和（N 很大） | ⚠️ 看情况 | N=10万时和约50亿，已超int；N=1万时约5000万，int够 |
| 两个 int 相乘 | ⚠️ 小心 | 两个 10 万相乘 = 100 亿，直接溢出 |
💡 保命技巧：做编程题时，如果拿不准会不会溢出，直接用 long long！大不了多占 4 个字节，现在的电脑完全不在乎。与其纠结"够不够"，不如直接用大盒子，保险。
三、实数型：float 与 double
3.1 小数在计算机里是"近似存储"
身高 1.45 米、体重 32.5 千克、圆周率 3.14159……带小数点的数，C++ 用浮点型来装：float 和 double。
这里有个重要观念：计算机存小数，存的是"近似值"。就像十进制没法把 1÷3 除尽（0.3333…），二进制也没法把 0.1 精确表示，只能存一个非常非常接近的数：
cpp
#include <iostream>
#include <iomanip>
using namespace std;
int main() {
double x = 0.1 + 0.2;
cout << x << endl; // 0.3（默认显示6位，看着正常）
cout << setprecision(17) << x << endl; // 0.30000000000000004（放大看，有微小误差）
return 0;
}易错点 ⚠️： 判断题如果说"计算机可以精确存储所有小数"——错误！小数是近似存储的，浮点运算可能出现极微小的误差。一级阶段知道这个现象即可，不需要深究原因。
3.2 float 与 double：精度大比拼
两种小数盒子的区别在于"能记多准"：
| 类型 | 占内存 | 有效数字 | 比喻 | 建议 |
|---|---|---|---|---|
float | 4 字节 | 6~7 位 | 小水杯，刻度粗略 | 少用 |
double | 8 字节 | 15~16 位 | 大量杯，刻度精细 | 默认就用它 |
cpp
float f = 3.14f; // float 常量末尾加 f
double d = 3.14; // 小数默认就是 double，最常用
cout << f << endl; // 3.14
cout << d << endl; // 3.14🍎 小比喻：float 像只能量到"毫米"的尺子，double 像能量到"微米"的尺子。量身高、算数学题，直接用 double 准没错，这也是考试和实际编程中最常用的小数类型。
3.3 整数盒子装小数：尾巴会被"砍光" ⚠️
如果你用 int 盒子去装小数，计算机会毫不留情地把小数部分整个砍掉（不是四舍五入，是直接截断）：
cpp
#include <iostream>
using namespace std;
int main() {
int a = 3.99;
cout << a << endl; // 3！小数部分 .99 被直接扔掉，不是 4
double b = 3 / 2; // 注意：3 和 2 都是整数，先按整数除法算
cout << b << endl; // 1！算出整数 1 后才放进 double，变成 1
double c = 3.0 / 2; // 3.0 是小数，小数参与运算，结果才是小数
cout << c << endl; // 1.5
return 0;
}易错点 ⚠️（超高频）：
double b = 3 / 2;输出的是 1 而不是 1.5！因为等号右边先算3 / 2，两个 int 相除按"整数除法"规则得到 1，再把 1 转成 1.0 放进 b。想得到 1.5，至少要有一个数写成小数（3.0 / 2或3 / 2.0）。整数除法的完整规则，第7章《运算符》会专门细讲，本章先记住：装小数要用 double，别用 int。
🧩 考点深挖：为什么 0.1 + 0.2 ≠ 0.3？
这是计算机界最著名的"冷知识"之一。原因其实很简单：
我们日常用的是十进制（逢十进一），而计算机用的是二进制（逢二进一）。
在十进制里，有些分数"除不尽"，比如 1/3 = 0.3333…… 只能写个近似值。
同样，在二进制里，也有很多小数"除不尽"，0.1 就是其中一个。把 0.1 转换成二进制，会得到一个无限循环的小数：
0.1（十进制）≈ 0.00011001100110011...（二进制，无限循环）计算机的存储空间有限（double 只有 64 位），没法存无限长的小数，只能存个近似值。所以 0.1 和 0.2 在计算机里都不是精确值，加起来自然也不会精确等于 0.3。
💡 考试怎么考？ 一级只考判断："计算机可以精确存储所有小数"——❌ 错误。知道"小数是近似存储"这个结论就够了，不需要推导二进制转换过程。
四、字符型 char：只装"一个字符"
4.1 字符必须用单引号
char 盒子专门装单个字符：一个字母、一个数字符号、一个标点。书写时要用英文单引号 ' ' 包起来：
cpp
char grade = 'A'; // 一个大写字母
char ch = 'b'; // 一个小写字母
char num = '0'; // 数字符号零（注意是字符，不是整数0）
char mark = '?'; // 一个标点符号
cout << grade << endl; // A两条铁律：
- char 只能装一个字符：
'AB'放了两个字符，一个char装不下（多字符常量虽然能编译、通常只警告，但值为实现定义）；一个汉字也装不进 char（汉字在计算机里占多个字节）。 - 必须用单引号，不能用双引号：
"A"是双引号包起来的字符串，不能放进 char 盒子，编译会报错！
易错点 ⚠️： 判断题"字符用双引号括起来，如
"A""——错误！字符用单引号'A'；双引号"A"是字符串（第8章输入输出还会见面）。口诀：字符单引号，字符串双引号。
4.2 字符的秘密：它本质上是一个编号（ASCII 码）（📚 拓展 · 超纲）
📚 拓展 · 超纲：ASCII 编码属于二级考纲，一级只要求"字符型
char的定义与使用"。了解即可，不必背诵码表。
计算机内部其实只认识数字，所以每个字符都对应一个编号，这套编号表叫 ASCII 码。一级需要记住三个常用编号：
| 字符 | ASCII 编号 | 说明 |
|---|---|---|
'0' | 48 | 数字字符从 48 开始：'1'=49、'2'=50…… |
'A' | 65 | 大写字母从 65 开始：'B'=66…… |
'a' | 97 | 小写字母从 97 开始：'b'=98…… |
💡 发现了吗？
'a' - 'A' = 97 - 65 = 32，同一个字母的小写比大写大 32，这个小规律考试偶尔会考到。
既然字符本质是编号，它就能和整数互相转换：
cpp
#include <iostream>
using namespace std;
int main() {
char c = 'A';
cout << c << endl; // A （char 盒子，输出字符本身）
cout << (int)c << endl; // 65 （(int) 把字符转成整数，看到编号）
int n = 97;
cout << (char)n << endl; // a （(char) 把整数转成字符）
return 0;
}4.3 趣味玩法：'a' + 1 得到 'b' 🔥
字符拿着编号参加运算，就能玩出"字母接龙"：
cpp
#include <iostream>
using namespace std;
int main() {
char c = 'a';
cout << (char)(c + 1) << endl; // b （'a'编号97，+1变98，转回字符是'b'）
cout << (char)(c + 2) << endl; // c
cout << (char)('A' + 3) << endl; // D
cout << '0' + 1 << endl; // 49 （注意！直接输出是编号49，不是'1'）
cout << (char)('0' + 1) << endl; // 1 （转回 char，才是字符'1'）
return 0;
}高频考点 🔥：
'0'和0是完全不同的两回事！
0是整数零，表示数量"没有"，数值就是 0；'0'是字符零，长相像数字，本质是编号 48。同理，
'9'不等于 9（它是 57），'A'不等于 A 这个变量。题目里看到带单引号的数字，一定要提醒自己："这是字符，它的值是 ASCII 编号！"
🧩 拓展（📚 超纲）：ASCII 码表的规律
ASCII 码表一共有 128 个字符（编号 0~127），不用全背，记住三个起点就能推导出一大片：
编号 48 → '0' → 数字字符（48~57，共10个）
编号 65 → 'A' → 大写字母（65~90，共26个）
编号 97 → 'a' → 小写字母（97~122，共26个）规律 1：同组字符是连续的。比如 'A'=65，'B'=66，'C'=67…… 'Z'=90。
规律 2：小写字母 = 大写字母 + 32。比如 'a' = 'A' + 32 = 97。
规律 3：数字字符的编号减去 '0' 的编号，就得到对应的整数值。比如：
'5' - '0' = 53 - 48 = 5（字符 5 转成整数 5）0 + '0' = 48→ 即字符 '0'（整数 0 转成字符 '0'）
这第三条规律在二级、三级的字符串处理题目中超级有用，先记下来以后会用到！
五、布尔型 bool：只会回答"真"和"假"
5.1 全世界只有两个布尔值
bool（布尔）型是最简单的类型，只有两个值：
| 值 | 含义 | 像什么 |
|---|---|---|
true | 真、对、条件成立 | 电灯开 |
false | 假、错、条件不成立 | 电灯关 |
cpp
bool passed = true; // 通过了
bool finished = false; // 还没完成注意：C++ 里 true 和 false 都是小写关键字，不能大写写成 True（这和有些语言不同，别记混）。
5.2 cout 输出 bool：默认显示 1 和 0
布尔值在内存里其实就是用整数表示的：true 相当于 1，false 相当于 0。所以用 cout 直接输出，看到的是数字：
cpp
#include <iostream>
using namespace std;
int main() {
bool flag = true;
cout << flag << endl; // 1 （默认输出数字 1）
cout << false << endl; // 0
cout << boolalpha << flag; // true（加 boolalpha，才输出单词 true）
return 0;
}易错点 ⚠️： 程序阅读题里
cout << true;输出的是 1，cout << false;输出的是 0！想输出单词 true/false，要先写boolalpha。考试默认情况一律按 1/0 判断。
5.3 非 0 即真
布尔值还有个重要脾气：凡是"非 0"的值，都当作真；只有 0 才是假：
cpp
#include <iostream>
using namespace std;
int main() {
bool a = 5; // 5 不是 0 → 当作 true
cout << a << endl; // 1
bool b = -1; // -1 也不是 0 → 也是 true！
cout << b << endl; // 1
bool c = 0; // 只有 0 → false
cout << c << endl; // 0
return 0;
}🍎 小比喻：bool 像一个验票员，只问"票上数字是不是 0"。是 0 就摆手（假），只要不是 0——不管是 1、5 还是 -100——统统放行（真）。这个规则下一章《三大基本结构》写 if 判断时会经常用到。
另外提前剧透：第7章会学到比较运算符（>、<、==、!= 等），它们的运算结果就是 bool 值。比如 3 > 2 成立，结果就是 true（输出 1）；3 < 2 不成立，结果就是 false（输出 0）。本章只要先认识 bool 这两个值、记住"非 0 即真"，下一章学分支结构时就能无缝衔接。
🔍 深度辨析：bool 类型的来源
"布尔"（bool）这个名字是为了纪念一位数学家——乔治·布尔（George Boole）。他在 19 世纪发明了"布尔代数"，专门研究"真"和"假"两种值的运算规律（与、或、非）。
一百多年后，计算机科学家发现这套数学体系完美适用于计算机——因为计算机的电路就是"通（真）"和"断（假）"两种状态。于是就用他的名字命名了布尔类型。
💡 冷知识：C 语言早期其实没有 bool 类型，直接用整数 0 和 1 表示真假。C++ 从 C 语言演化而来，保留了"非 0 即真"的传统，后来才新增了
bool关键字和true/false值。这也是为什么 bool 值和整数可以自由转换的历史原因。
六、类型大小对比与选用建议
6.1 用 sizeof 量一量盒子大小
C++ 提供了 sizeof(类型) 运算符，可以量出每种类型占几个字节：
cpp
#include <iostream>
using namespace std;
int main() {
cout << sizeof(int) << endl; // 4
cout << sizeof(long long) << endl; // 8
cout << sizeof(float) << endl; // 4
cout << sizeof(double) << endl; // 8
cout << sizeof(char) << endl; // 1
cout << sizeof(bool) << endl; // 1
return 0;
}6.2 一表汇总（必背）🔥
| 类型 | 占内存 | 装什么 | 范围 / 精度 | 选用建议 |
|---|---|---|---|---|
int | 4 字节 | 整数 | -2³¹~2³¹-1（约 ±21 亿） | 人数、年龄、分数等日常整数 |
long long | 8 字节 | 大整数 | 约 ±9.2×10¹⁸ | 超过 21 亿的大数、大数求和 |
float | 4 字节 | 小数 | 6~7 位有效数字 | 一般不用 |
double | 8 字节 | 小数 | 15~16 位有效数字 | 小数默认选它 |
char | 1 字节 | 单个字符 | 存 ASCII 编号（'A'=65 等） | 字母、数字符号、标点 |
bool | 1 字节 | 真假 | true(1) / false(0) | 条件、开关 |
高频考点 🔥： 这张表的"占内存"一列几乎是送分题：int 4、long long 8、float 4、double 8、char 1。记忆小窍门：盒子越大装得越多——8 字节的 long long 比 4 字节的 int 装得大，8 字节的 double 比 4 字节的 float 算得准。
💡 选型决策树
考试时拿到题，怎么快速决定用什么类型？按下面的流程图走：
题目需要存什么？
│
├─→ 只有"是/否"两种情况 → bool
│
├─→ 单个字母/符号 → char
│
├─→ 没有小数点的整数 → 数字大不大？
│ ├─ 不大（几百万以内）→ int
│ └─ 很大（几十亿以上）→ long long
│
└─→ 带小数点的数 → double（默认就用它，不用想 float）七、课堂综合演示
六种类型一次看齐，建议亲手敲一遍：
cpp
#include <iostream>
using namespace std;
int main() {
// 1. 整数
int age = 10;
long long stars = 100000000000LL;
cout << age << endl; // 10
cout << stars << endl; // 100000000000
// 2. 小数
double height = 1.45;
cout << height << endl; // 1.45
cout << 3 / 2 << endl; // 1（整数除法，尾巴砍光）
cout << 3.0 / 2 << endl; // 1.5（有小数参与）
// 3. 字符
char grade = 'A';
cout << grade << endl; // A
cout << (int)grade << endl; // 65
cout << (char)('a' + 1) << endl;// b
// 4. 布尔
bool ok = true;
cout << ok << endl; // 1
cout << (bool)(5) << endl; // 1（非0即真）
return 0;
}八、四大易错点汇总 ⚠️
| # | 易错点 | 错误写法 | 正确做法 |
|---|---|---|---|
| 1 | 大数忘记用 long long，int 溢出 | int x = 100000000000; | long long x = 100000000000LL; |
| 2 | 用整型变量装小数，尾巴被截断 | int x = 3.99;（得 3） | double x = 3.99; |
| 3 | 字符漏写单引号、误用双引号 | char c = "A";（报错） | char c = 'A'; |
| 4 | char 里塞多个字符 | char c = 'AB';（通常只警告，值为实现定义） | 一个 char 只放一个字符 |
另外再补三个"判断题刺客"：
'0'和0不是一回事（字符 '0' 的编号是 48）；cout << true;输出 1，不是单词 true；- 小数是近似存储，
0.1 + 0.2不完全等于 0.3。
九、深度专题（📚 拓展 · 超纲）：类型转换——不同类型的盒子怎么"打交道"
📚 拓展 · 超纲：数据类型的转换属于二级考纲。一级遇到"整数除法陷阱"时了解即可，不必深究转换规则。
考试里经常出现"int 和 double 一起运算会怎样""int 除以 int 为什么得 int"这种题。这一节把类型转换讲透。
9.1 什么是类型转换？
当不同类型的数据放在一起运算时，C++ 会自动把它们"变成同一种类型"再计算，这就叫隐式类型转换（也叫"自动类型转换"）。
🍎 生活比喻：就像你把橘子和苹果放进同一个袋子里称重——橘子不会变成苹果，但秤会用同一个单位（克）来告诉你总重量。类型转换就是"统一单位"的过程。
9.2 转换规则："小的"自动变"大的"
基本原则：在运算或赋值时，"表示能力较弱"的类型会自动转换成"表示能力较强"的类型（以能表示的范围和精度为准，并不单纯比字节数——例如 long long 会转换成 float，因为 float 能表示的范围更大，尽管它只有 4 字节；大整数转 float 时可能丢失精度）。
从小到大的顺序（一级要求掌握的）：
bool → char → int → long long → float → double
1B 1B 4B 8B 4B 8B| 运算组合 | 结果类型 | 例子 |
|---|---|---|
| int + int | int | 3 + 2 = 5（还是整数） |
| int + double | double | 3 + 2.5 = 5.5（int 自动升级成 double） |
| int * float | float | 3 * 2.0f = 6.0f |
| char + int | int | 'A' + 1 = 66（char 转成 ASCII 码的 int） |
| bool + int | int | true + 1 = 2（true 变 1，false 变 0） |
9.3 ⚠️ 最常考：整数除法陷阱
这是一级考试排名第一的易错点，几乎每张卷子都考！
cpp
int a = 5;
int b = 2;
cout << a / b << endl; // 输出 2，不是 2.5！为什么是 2？ 因为 a 和 b 都是 int，两个 int 相除，结果还是 int——小数部分直接被砍掉了（截断取整，不是四舍五入）。
怎么得到小数结果？ 至少让其中一个变成 double：
cpp
// 方法1：用 double 变量
double a = 5.0;
int b = 2;
cout << a / b << endl; // 输出 2.5
// 方法2：乘以 1.0 强制转 double
int sum = 5, n = 2;
cout << sum * 1.0 / n << endl; // 输出 2.5🔥 考试口诀：整型除以整型，结果还是整型（小数部分直接丢掉）。想要小数结果，必须至少有一个操作数是小数类型！
9.4 强制类型转换（显式转换）
除了自动转换，你也可以手动把一个值转成另一种类型，这叫强制类型转换。
写法：(目标类型)值 或 目标类型(值)
cpp
int x = 5;
double y = (double)x; // 把 int 的 x 强制转成 double
cout << y << endl; // 输出 5（但它现在是 double 类型了）
double pi = 3.14159;
int z = (int)pi; // 把 double 强制转成 int（小数被砍掉）
cout << z << endl; // 输出 3⚠️ 注意：把"大盒子"的值塞进"小盒子"（比如 double 转 int），会丢失精度——小数部分直接砍掉，不是四舍五入！
(int)3.99的结果是 3，不是 4。
9.5 类型转换三大考点总结 🔥
| 考点 | 题目特征 | 关键结论 |
|---|---|---|
| 整数除法 | 两个 int 相除问结果 | 结果是 int，小数被截断（不是四舍五入） |
| 混合运算 | int 和 double 一起算 | 结果是 double（小的自动升级成大的） |
| 强制转换 | (int)3.99 等于多少 | 等于 3（直接砍掉小数） |
十、📝 实战练习
练习题 1（单选题）
题目： 下列变量定义中，正确的是（ ）
- A.
char c = "A"; - B.
bool b = "true"; - C.
double pi = 3.14; - D.
char ch = 'AB';
🔑 点击查看答案与解析
答案： C
解析： A 字符用了双引号（双引号是字符串），编译报错；B 布尔值不能写成带引号的文字，应直接写 true；D 一个 char 只能装一个字符；C 用 double 装小数，完全正确。
练习题 2（单选题）
题目： int 类型能存放的整数范围约为（ ）
- A. -128 ~ 127
- B. -21 亿 ~ 21 亿
- C. ±9.2×10¹⁸
- D. 没有大小限制
🔑 点击查看答案与解析
答案： B
解析： int 占 4 字节，范围是 -2³¹~2³¹-1，约 ±21 亿；C 是 long long 的范围；D 是错误观念，C++ 整数有明确范围，超了会溢出。
练习题 3（单选题）
题目： 已知 char c = 'a';，则表达式 (char)(c + 1) 的值是（ ）
- A.
'a' - B.
'b' - C.
98 - D.
"b"
🔑 点击查看答案与解析
答案： B
解析： 'a' 的 ASCII 编号是 97，加 1 得 98，再用 (char) 转回字符，就是 'b'。注意：若不加 (char) 直接 cout << c + 1，输出的是数字 98。
练习题 4（判断题）
题目： 在 C++ 中，字符 '0' 和整数 0 是完全相同的，可以互换使用。（ ）
🔑 点击查看答案与解析
答案： ❌ 错误
解析： 0 是整数零，数值为 0；'0' 是字符，其 ASCII 编号为 48。两者类型不同、值也不同，不能画等号。
练习题 5（程序阅读题）
题目： 阅读程序，写出 5 行输出：
cpp
int a = 2147483647;
cout << a + 1 << endl;
cout << 3 / 2 << endl;
cout << 3.0 / 2 << endl;
cout << (int)'A' << endl;
cout << true << endl;🔑 点击查看答案与解析
答案：
-2147483648
1
1.5
65
1解析： ① int 最大值加 1 溢出，常见编译器上绕回最小值 -2147483648；② 两整数相除，小数部分被砍，得 1；③ 3.0 是小数，结果 1.5；④ 'A' 的 ASCII 编号是 65；⑤ bool 值 true 用 cout 默认输出 1。
练习题 6（单选题）
题目： 下列关于 C++ 数据类型的说法，正确的是（ ）
A. float 类型精度比 double 高 B. int 类型占 8 个字节 C. 小数在计算机中是精确存储的 D. char 类型占 1 个字节，只能存一个字符
🔑 点击查看答案与解析
答案： D
解析：
- A ❌：double（15~16位）比 float（6~7位）精度高；
- B ❌：int 占 4 字节，long long 才占 8 字节；
- C ❌：小数是近似存储的，不是精确的；
- D ✅：char 占 1 字节，只存一个字符，正确。
选 D。
练习题 7（程序阅读题）
题目： 以下代码的输出结果是（ ）
cpp
cout << (char)('A' + 5) << " " << ('Z' - 'A');A. F 25 B. E 25 C. F 26 D. E 26
🔑 点击查看答案与解析
答案： A
解析：
'A'编号 65，加 5 得 70，对应字符'F'；'Z'编号 90，'A'编号 65，90 - 65 = 25（注意：A 到 Z 共 26 个字母，但差值是 25）。
选 A。
练习题 8（判断题）
题目： long long 类型可以存放任意大的整数，永远不会溢出。（ ）
🔑 点击查看答案与解析
答案： ❌ 错误
解析： long long 虽然很大（约 ±920 亿亿），但也是有限的。只要数字足够大，long long 也会溢出。只不过它的范围比 int 大得多，日常做题基本碰不到上限。C++ 中没有"永远不会溢出"的整数类型。
练习题 9（程序阅读题）
题目： 下列代码输出几行 1？（ ）
cpp
cout << (bool)5 << endl;
cout << (bool)-3 << endl;
cout << (bool)0 << endl;
cout << (bool)true << endl;A. 1 行 B. 2 行 C. 3 行 D. 4 行
🔑 点击查看答案与解析
答案： C
解析： "非 0 即真"：
- 5 不是 0 → 真 → 输出 1 ✅
- -3 不是 0 → 真 → 输出 1 ✅
- 0 → 假 → 输出 0 ❌
- true 本身就是真 → 输出 1 ✅
共 3 行输出 1。选 C。
练习题 10（单选题）
题目： 以下表达式中，值为 1.5 的是（ ）
A. 3 / 2 B. 3.0 / 2 C. (int)(3.0 / 2) D. 3 / 2.0 的整数部分
🔑 点击查看答案与解析
答案： B
解析：
- A ❌：两个 int 相除，整数除法得 1；
- B ✅：3.0 是 double，和 2 运算时 2 自动转成 double，结果是 1.5；
- C ❌：(int) 强制转换为整数，小数被砍掉，得 1；
- D ❌：整数部分是 1。
选 B。
练习题 11（单选题）
题目： 有代码 int a = 7; double b = 2.0; cout << a / b << endl;，输出结果是（ ）
A. 3 B. 3.5 C. 3.0 D. 2
🔑 点击查看答案与解析
答案： B
解析： a 是 int（7），b 是 double（2.0）。两个不同类型一起运算时，小的自动升级成大的——int 的 a 会自动转成 double，然后两个 double 相除，结果是 double 类型的 3.5。
💡 口诀：整型遇小数，自动升小数。只要有一个操作数是 double，结果就是 double。
练习题 12（判断题）
题目： 判断：(int)(3.99) 的结果是 4，因为会四舍五入。（ ）
🔑 点击查看答案与解析
答案： ❌ 错误
解析： 强制类型转换 (int) 是直接砍掉小数部分，不是四舍五入。(int)(3.99) 的结果是 3，不是 4。
⚠️ 这是经典判断题陷阱！很多同学以为会四舍五入，实际是"截断取整"——直接把小数点后面的全部扔掉。
十一、📊 考点总结表
| 考点 | 重要程度 | 出题形式 |
|---|---|---|
| int 范围约 ±21 亿（-2³¹~2³¹-1），占 4 字节 | ⭐⭐⭐⭐⭐ | 选择/判断 |
| long long 范围约 ±9.2×10¹⁸，占 8 字节，大数用它 | ⭐⭐⭐⭐⭐ | 选择/程序阅读 |
| int 溢出：最大值加 1 结果出错（常见为 -2147483648） | ⭐⭐⭐⭐⭐ | 选择/程序阅读 |
| 大整数常量末尾加 LL | ⭐⭐⭐ | 判断/程序阅读 |
| float 6~7 位有效数字、double 15~16 位（8字节，常用） | ⭐⭐⭐⭐ | 选择/判断 |
小数近似存储，0.1+0.2 有微小误差（知道即可） | ⭐⭐ | 判断 |
int 装小数被截断：3.99 变 3、3/2 得 1 | ⭐⭐⭐⭐⭐ | 选择/程序阅读 |
| char 占 1 字节，只装单个字符，用单引号 | ⭐⭐⭐⭐⭐ | 选择/判断 |
双引号 "A" 是字符串，不能赋给 char | ⭐⭐⭐⭐ | 判断 |
| ASCII：'0'=48、'A'=65、'a'=97；大小写差 32 | ⭐⭐⭐⭐ | 选择/判断 |
字符与整数互转：(int)'A'=65、'a'+1='b' | ⭐⭐⭐⭐⭐ | 程序阅读 |
'0' 与 0 不同（48 vs 0） | ⭐⭐⭐⭐⭐ | 选择/判断 |
| bool 只有 true/false（小写），cout 默认输出 1/0 | ⭐⭐⭐⭐ | 选择/程序阅读 |
| 非 0 即真：5、-1 都为真，只有 0 为假 | ⭐⭐⭐⭐ | 判断/程序阅读 |
| 类型大小：int 4、long long 8、float 4、double 8、char 1、bool 1 | ⭐⭐⭐⭐ | 选择 |
| 选型决策：日常用int/大数long long/小数double | ⭐⭐⭐⭐⭐ | 编程 |
┌──────────────────────────────────────────────────────────────┐
│ ⭐ 第5章必背速记卡（基本数据类型） │
├──────────────────────────────────────────────────────────────┤
│ 1. 类型大小：int=4, long long=8, float=4, double=8, │
│ char=1, bool=1（字节） │
│ 2. int范围约±21亿；超过21亿用long long，大数末尾加LL │
│ 3. int溢出：最大值+1绕回最小值（类似里程表归零） │
│ 4. 小数默认用double（15~16位精度），float少用 │
│ 5. 小数是近似存储，0.1+0.2不精确等于0.3 │
│ 6. 整数除法截断小数：3/2=1，3.0/2=1.5 │
│ 7. char用单引号，一个字符；双引号是字符串 │
│ 8. ASCII必背：'0'=48, 'A'=65, 'a'=97 │
│ 9. 大小写差32：'a'-'A'=32 │
│ 10. '0'≠0（字符零是48，整数零是0） │
│ 11. 字符运算：'a'+1='b'；加完要用(char)转回字符 │
│ 12. bool只有true/false（全小写），cout默认输出1/0 │
│ 13. 非0即真：只要不是0都是真（包括负数！） │
│ 14. sizeof(类型)可测量类型占几个字节 │
│ 15. 选型口诀：日常int、大数long long、小数double │
└──────────────────────────────────────────────────────────────┘📖 下章预告：第6章我们将学习 C++ 的三大基本结构——顺序结构、分支结构（if/else）、循环结构（for/while）。这是编程的"骨架"，学会了它们，你就能让程序"自己做判断"、"自动重复做事"，真正开始解决实际问题了！