第4章基础语法：标识符、关键字与变量

🎯 本章学习目标

读完本章，你将能够：

✅ 准确判断一个名字是不是合法的 C++ 标识符
✅ 说出常见的 C++ 关键字，知道 cout 不是关键字
✅ 区分字面常量和 const 命名常量，知道字符用单引号、字符串用双引号
✅ 理解"变量是贴了标签的盒子"，掌握声明、赋值、初始化的区别
✅ 知道变量的"作用"（作用范围）：从声明处生效，到所在大括号结束处失效
✅ 深刻理解赋值号 = 的含义（先算右边，再赋给左边）
✅ 读懂 x = x + 1 这类赋值语句的执行过程
✅ 知道"新值盖旧值"，能一步步追踪变量值的变化
✅ 认识自增 ++ 和自减 --，知道它们在循环中的作用
✅ 能用 cout 输出变量和简单表达式的值
✅ 写出符合规范的变量定义和简单计算程序

🗺️ 本章知识图谱

第4章 基础语法
├── 一、标识符：给"盒子"起的名字
│   ├── 命名规则（字母/数字/下划线，不能数字开头，区分大小写，不能是关键字）
│   └── 常见陷阱：减号 vs 下划线、数字开头、中文名字
├── 二、关键字：C++ 保留的"专用词"
│   ├── 一级常见关键字（int/double/char/if/else/for/while/return/const 等）
│   ├── cout/cin/endl 不是关键字（标准库对象）
│   └── true/false 全小写
├── 三、常量：固定不变的量
│   ├── 字面常量（整数、小数、字符' '、字符串" "）
│   └── const 命名常量（定义后不可改，习惯全大写）
├── 四、变量（重点）：贴了标签的盒子
│   ├── 声明 → 赋值 → 初始化
│   ├── 先声明类型、后使用
│   ├── 赋值号 =：先右后左，新值盖旧值
│   ├── 一条语句声明多个同类型变量
│   └── 未初始化 = 垃圾值
├── 五、表达式：能算出一个值的式子
├── 六、自增 ++ 与自减 --
│   ├── i++ 等价于 i = i + 1
│   └── 单独使用时前置后置效果一样
└── 七、变量输出：cout << 变量名

一、标识符：给"盒子"起的名字

程序里有很多东西需要起名字：变量要起名、函数要起名……这些由程序员自己起的名字，统称为标识符（identifier）。

打个比方：变量就像一个个贴了标签的盒子，盒子里装数据，标签上写的名字就是标识符。盒子乱放没关系，但标签上的名字必须符合"起名规范"，C++ 编译器才认得出来。

标识符命名规则 🔥

规则	正确示例 ✅	错误示例 ❌	错误原因
只能由字母、数字、下划线 `_` 组成	`name`、`age2`、`_score`	`my-name`	含有减号 `-`
不能以数字开头	`age1`、`a1`、`_2x`	`1age`	数字开头，编译器会以为是数字
不能包含空格	`student_name`	`student name`	空格会被当成两个词
*不能包含 `+ - /` 等特殊符号**	`count`、`total_sum`	`a+b`、`x*y`	符号有运算含义
区分大小写	`age` 和 `Age` 是两个变量	——	大小写不同，名字就不同
不能是关键字（见第二节）	`my_if`、`if1`	`if`、`int`	关键字是 C++ 的"专用词"

高频考点 🔥： "下列哪个是合法的 C++ 标识符？"是一级经典选择题。判断口诀：一看开头（不能是数字），二看字符（只能字母、数字、下划线），三看是不是关键字。1age、my-name、int、a b 是出镜率最高的四个错误选项。

易错点 ⚠️： 下划线 _ 是合法字符，所以 _name、student_name 都正确；但减号 - 不是，my-name 会被编译器理解成"my 减去 name"。下划线和减号长得像，考试时一定要睁大眼睛！

易错点 ⚠️： C++ 区分大小写：age、Age、AGE 是三个完全不同的盒子！编程题里变量名前后拼写大小写不一致，是新手最常见的"找不到变量"报错原因。

🔍 深度辨析：下划线开头的标识符

你可能注意到了，规则里说"下划线开头"是合法的，比如 _name、_score。那为什么平时很少有人这么写呢？

这是因为 C++ 标准库中有大量"以下划线开头"的内部名字（比如 _CSTD、_GLIBCXX），虽然你写 _name 语法上没问题，但容易和标准库的名字"撞车"。

写法	合不合法	推不推荐	原因
`age`、`student_name`	✅	✅ 推荐	清晰、不会撞名
`_age`、`__name`	✅	❌ 不推荐	容易和标准库内部名冲突
`a1`、`x2`	✅	⚠️ 看情况	语法合法，但名字不够"见名知意"

考试选择题中，_name 这种写法是合法的（不会被选为错误选项），但实际编程中我们更推荐用有意义的普通名字。

二、关键字：C++ 保留的"专用词"

关键字（keyword，也叫保留字）是 C++ 语言事先规定好、有特殊含义的词，比如表示"整数类型"的 int、表示"如果"的 if。它们就像班级里"班长""学习委员"等职务称号，已经被占用了，同学起名时不能再用。

一级常见关键字一览表

分类	关键字	大致含义
基本数据类型	`int`、`double`、`char`、`bool`、`float`、`void`	整数、小数、字符、布尔、单精度小数、无类型
真假值	`true`、`false`	真、假（全小写）
常量修饰	`const`	定义不可修改的常量
分支判断	`if`、`else`	如果、否则
循环	`for`、`while`、`break`、`continue`	计数循环、条件循环、跳出、跳过
函数相关	`return`	函数返回
命名空间	`using`、`namespace`	引入、命名空间（搭配 `std` 使用）

C++ 的关键字有七十多个（不同标准略有增减），一级阶段认识表中这些就足够了。关键字有个明显特征：全部由小写字母组成。

高频考点 🔥（超级爱考）： cout 不是关键字！ 它是 C++ 标准库（std 命名空间）里提前准备好的一个"输出工具"的名字，就像教室里现成的投影仪——不是职务称号，但确实是个"现成的设施"。同理 cin、endl 也不是关键字。考试中"cout 是 C++ 的关键字"这一说法错误。

易错点 ⚠️： C++ 里表示真假的关键字是全小写的 true 和 false！写成 True、FALSE 反而不是关键字，编译器会报错。另外，关键字不能当变量名：int int; 这种写法编译器直接"翻脸"报错。

🧩 拓展：关键字 vs 标识符 vs 标准库名

很多同学分不清这三个概念，用一张表彻底说清：

概念	谁起的名字	能不能当变量名	举例
关键字	C++ 语言规定的	❌ 绝对不能	`int`、`if`、`for`、`return`
标识符	程序员自己起的	——（它本身就是变量名）	`age`、`score`、`my_sum`
标准库名	C++ 标准库提供的	⚠️ 语法上能，但不推荐	`cout`、`cin`、`endl`

💡 记忆口诀：关键字是"官职"（不能重名）；标识符是"你的名字"（你自己起的）；标准库名是"学校现成的设施"（不是官职，但也别乱占用）。

三、常量：固定不变的量

常量（constant）就是程序运行过程中固定不变的量，比如圆周率 3.14、一个班最多 100 人。常量分两种：

3.1 字面常量：直接写出来的数据

"字面常量"就是代码里直接写出来的数据本身，一眼就能看到它的值：

常量种类	例子	小提示
整数常量	`5`、`-3`、`100`	没有小数点
小数（浮点）常量	`3.14`、`0.5`、`-2.0`	带小数点
字符常量	`'A'`、`'9'`、`'+'`	单引号，里面只能有一个字符
字符串常量	`"hello"`、`"小明"`	双引号，里面是一串文字

易错点 ⚠️： 字符用单引号 'A'，字符串用双引号 "ABC"，千万别搞反！'AB'（单引号里放两个字符）不是标准的单字符写法——这类"多字符常量"在 C++ 里能编译（通常只警告），但值的含义由编译器决定、而且一个 char 根本装不下，所以考试和练习中都不要这样写。这对引号的区别，第5章讲数据类型时还会见面。

3.2 用 const 定义命名常量

如果一个数在程序里反复使用（比如全班人数 100），可以给它起个名字。C++ 提供了真正的常量——用关键字 const 定义：

cpp

const int N = 100;      // 定义常量 N，值固定为 100
const double PI = 3.14; // 定义常量 PI

const 的意思是"恒定的"。一旦用 const 定义，这个盒子就被"焊死"了，只能在定义时赋一次值，以后谁也别想改：

cpp

const int N = 100;
// N = 200;   // ❌ 编译报错！不能给常量赋值

🔥 对比记忆（考纲要求"了解即可"）：常量名习惯上全部大写（如 N、PI、MAX_SIZE），与普通变量区分开。看到全大写的名字，就表示"这个值从头到尾不会变"。

💡 为什么要用 const 常量？直接写数字不行吗？

假设你写了一个计算圆面积的程序，里面写了 20 次 3.14。某天老师说"改成 3.14159 吧，更精确"，你就得改 20 次，还容易漏。但如果你定义了：

cpp

const double PI = 3.14;

要改精度时，只改一处就够了——这叫"一改全改"。这就是 const 常量的核心价值：提高可维护性。

对比项	直接写数字（"魔数"）	const 常量
修改时	要改很多处，容易漏	只改一处
可读性	看到数字不知道什么意思	`MAX_STUDENT` 一看就懂
安全性	可能被不小心改了	编译器保护，改了就报错

四、变量（重点）：贴了标签的盒子

变量（variable）就是存放数据的"盒子"，盒子上贴着名字标签，里面的数据可以随时更换——所以叫"变"量。

C++ 的规矩比别的语言更严格：盒子有不同的"型号"。装整数的盒子是 int 型，装小数的是 double 型……使用盒子之前，必须先声明它的型号，编译器才好给它安排合适大小的存储空间。这就是 C++ 著名的——先声明类型，再使用变量。

4.1 三步曲：声明 → 赋值 → 初始化

cpp

int age;        // ① 声明：我要一个 int 型号的盒子，标签叫 age
age = 10;       // ② 赋值：把整数 10 放进 age 这个盒子
int score = 95; // ③ 初始化：声明和赋值写在一起，一步到位

声明（declaration）：int age; —— 告诉编译器"有这么个盒子，型号 int，名字 age"。注意末尾的分号 ;，它是 C++ 语句的"句号"，一条语句结束必须写！
赋值（assignment）：age = 10; —— 用赋值号 = 把数据放进盒子。
初始化（initialization）：int score = 95; —— 声明的同时赋好初值，是最常用的写法。

🔥 高频考点： "C++ 变量必须先声明、后使用"——这是和不要求声明类型的语言最核心的区别。没声明就使用，编译器根本不认识这个名字，直接报错。

4.2 赋值号 `=`：把右边放进左边的盒子

读法：age = 10; 读作"把 10 赋值给 age"，不是"age 等于 10"。赋值号的含义是：把右边的值，放进左边的盒子里。

数学里 x = x + 1 不可能成立（x 怎么能等于 x 加 1 呢？），但在 C++ 中它完全合法：

cpp

int x = 5;
x = x + 1;      // 第一步：算右边 5 + 1 = 6；第二步：把 6 放进左边的 x

高频考点 🔥（程序阅读必考）： 看到 x = x + 1，按"先右后左"拆解：取出 x 的当前值 → 加 1 → 存回 x。它的作用就是让 x 增加 1（计数器的核心写法）。

4.3 变量可以反复赋值：新值盖旧值

盒子里的东西可以随时换，新数据放进去，旧数据就被覆盖了：

cpp

int age = 10;
age = 11;       // 重新赋值：旧值 10 被新值 11 盖掉
age = 12;       // 再盖一次：现在盒子里是 12

易错点 ⚠️： 程序阅读题中，变量每一步都要用它的最新值参与计算。上面 age 最后是 12，不是 10——"新值盖旧值"是最容易"看走眼"的地方。

4.4 一条语句声明多个同类型变量

如果几个盒子型号相同，可以在一条语句里一起声明，用逗号隔开：

cpp

int a, b, c;            // 一条语句声明三个 int 盒子
a = 1; b = 2; c = 3;    // 再分别赋值

int x = 1, y = 2;       // 也可以声明时就初始化

易错点 ⚠️（新手三大报错）：
不声明类型就使用！
cpp
age = 10;      // ❌ 编译器不认识 age：之前没有 int age;
声明了但没赋值就拿来用！ 局部变量刚声明时，盒子里是不确定的"垃圾值"：
cpp
int score;
cout << score;   // ⚠️ 输出什么完全说不准（可能是随机数、可能是 0，甚至程序崩溃）
忘写分号 ;！ C++ 每条语句末尾都要有分号，漏了编译器会报语法错误。

4.5 变量的"作用"：它从哪生，到哪"过期"

考纲对变量提出了"命名、定义、作用、初始化、赋值"五点要求，前面几点我们都见过了，最后这"作用"指的是变量的作用范围（也叫"作用域"）——这个盒子从哪儿开始能用，到哪儿就不能用了。

一级阶段只要记一条最简单的规则：

变量从它被声明的那一行开始"生效"，到它所在的那一对大括号 } 结束处"失效"。

cpp

int main() {
    int a = 1;          // a 从这里开始生效
    {
        int b = 2;      // b 只在这对大括号里有效
        cout << a + b;  // 3（a 和 b 都能用）
    }
    cout << a;          // 1（a 还能用）
    // cout << b;       // ❌ 报错！出了大括号，b 已经"过期"了
    return 0;
}

高频考点 🔥：
"变量必须先声明、后使用"——在声明之前就使用它，编译器会报"未声明"的错误；
在两个不同的大括号里，可以放心地使用同名变量，它们互不干扰。

💡 理解小窍门：把一对大括号想成一个"房间"，变量就是房间里的东西——出了房间就找不到了。这也是为什么我们在 main 的 { } 里定义的变量，出了 main 就没人认识它了。

🧩 考点深挖：变量在内存中长什么样？

你可能好奇："变量的盒子"在计算机里到底是什么？

简单来说，计算机的内存（RAM）就像一排整齐的小抽屉，每个抽屉都有一个地址（门牌号）。当你写 int age = 10; 时，编译器做了三件事：

找一个空抽屉（大小刚好装下 int，通常 4 个字节）；
在抽屉上贴个标签 age（以后就用这个名字找抽屉）；
把数字 10 放进抽屉里。

内存抽屉：  [ 10 ]   ← 里面的值
地址：       0x..   ← 门牌号（一般不用关心）
标签：       age    ← 程序员用这个名字访问

💡 为什么要声明类型？ 因为不同类型占的抽屉大小不一样。int 占 4 个抽屉（4 字节），double 占 8 个抽屉。编译器得先知道型号，才能给你安排合适大小的空间。这就是 C++ "先声明类型、后使用"的根本原因。

🔍 程序阅读技巧："变量跟踪表"

做程序阅读题时，最怕的就是变量多了记不住当前值。教你一个"笨办法但超管用"——变量跟踪表：

每遇到一条赋值语句，就在草稿纸上更新对应变量的值，像下面这样：

题目： 写出下面程序执行后 a、b、c 的值。

cpp

int a = 3, b = 5, c = 0;
a = a + b;      // 第2行
b = a - b;      // 第3行
c = a * b;      // 第4行

解题：一步步填表

行号	a	b	c	说明
初始	3	5	0	初始化后的值
第2行	8	5	0	a = 3+5 = 8（a变了，b和c不变）
第3行	8	3	0	b = 8-5 = 3（b变了，a还是8）
第4行	8	3	24	c = 8×3 = 24

所以最终 a=8，b=3，c=24。

💡 心法：程序阅读题千万别"心算"，一定要一步步写下来。多画一张表，少错一道题。

⚠️🔥 深度辨析：未初始化的变量——盒子里的"垃圾值"

这是初学者最容易踩的坑，也是考试选择题最高频的考点之一。

问题：定义一个变量但不给它初始值，它里面是什么？

cpp

int x;          // 只定义，不初始化
cout << x;      // 会输出什么？

答案：输出的是一个不确定的随机数（俗称"垃圾值"garbage value）。

🍎 生活比喻：你买了个新盒子（定义变量），但你没往里面放东西（没初始化），盒子里留着上一个人用过的残留物——可能是半块橡皮、可能是一张小纸条、也可能什么都没有，总之不确定。

为什么会这样？

计算机的内存就像一大排盒子，不停地被各种程序使用、释放、再使用；
你定义变量时，操作系统给你分配了一个盒子，但它不会帮你清空（清空要花时间，效率低）；
所以盒子里留着上一次使用后剩下的值——这就是"垃圾值"。

考试三大考法 🔥

考法	题目套路	正确答案
判断	"定义 int x; 后 x 的值是 0"	❌ 错误，是不确定的垃圾值
选择	下面哪种写法是正确的？（选项包含未初始化就使用）	必须先赋值再使用
改错	程序输出奇怪的数字	检查变量是否初始化了

🏆 好习惯：定义变量的同时就初始化！ 哪怕你暂时不知道值是多少，也先写个 = 0 放着，用的时候再改。这样可以避免 90% 的"奇怪结果"问题。

💡 对比记忆：全局变量不初始化默认是 0（这个二级才学），但 一级考的都是局部变量——不初始化就是垃圾值！ 考试里看到"int x; 然后直接用"，第一反应就是"有问题！"

五、表达式：能算出一个值的式子

表达式（expression），就是用数字、变量和运算符组合起来、能够算出一个值的式子。像搭积木一样，小块拼大块，最后总能拼出一个结果：

cpp

int a = 3, b = 5;
int c = a + b;          // a + b 是表达式，值为 8
cout << a + b << endl;  // 8：表达式也可以直接输出
cout << a * 2 - 1 << endl; // 5：3 * 2 - 1 = 5

单个的数字 5、单个的变量 a，其实也算表达式（最简单的表达式）。表达式的详细运算规则（优先级、整除、取余等）留到**第7章《运算符》**细讲。

六、自增 `++` 与自减 `--`：计数小能手

考纲要求本章认识两个特殊运算符：自增 ++ 和自减 --。

i++：让变量 i 的值加 1，等价于 i = i + 1;
i--：让变量 i 的值减 1，等价于 i = i - 1;

cpp

int i = 0;
i++;        // i 变成 1
i++;        // i 变成 2
i--;        // i 变成 1
cout << i << endl;   // 1

它们在循环计数中特别常用（比如"数数，从 1 数到 10"），第6章讲循环时会大量出现。

⚠️ 本章只做简单提示：++ 写在变量前面（++i）和后面（i++）在单独使用时效果一样，但如果混在表达式里（如 cout << i++;）会有细微差别。本章不要在表达式内部混用，老老实实单独写一行 i++; 即可，前置后置的区别第7章运算符细讲。

💡 为什么要有 ++？直接写 i = i + 1 不行吗？

完全可以！i++ 和 i = i + 1 效果完全一样。那为什么还要专门搞一个 ++ 运算符呢？

两个原因：

写起来更短：一个 ++ 顶 7 个字符（i = i + 1），程序员喜欢偷懒；
历史原因：C 语言的设计者发现"加 1"这个操作太常用了，于是专门设计了 ++ 运算符，甚至 C++ 语言的名字就来自这个 ++——意思是"C 的升级版"。

🤓 冷知识：C++ 为什么叫 C++？因为它是 C 语言的"加 1 升级版"，所以就在 C 后面加了个 ++。如果按这个逻辑，C 的下一代语言应该叫 C++++？其实并不存在一门叫 C++++ 的语言；如果真要给 C 的"下一代"起字母名，那应该是 D 语言（C 的后面是 D），但 D 与 C++ 是两种独立的语言，并非"C 的加 2 版"。

七、变量输出初体验：cout

定义好的变量，怎么看到盒子里装了什么？用输出流 cout，配合插入运算符 <<（像箭头一样，把数据"送"到屏幕上）：

cpp

#include <iostream>      // 引入输入输出工具库（第8章细讲）
using namespace std;     // 使用标准命名空间（第8章细讲）

int main() {
    int age = 10;
    cout << age;                 // 输出变量的值：10
    cout << age << endl;         // endl 表示换行
    cout << "年龄是" << age << "岁" << endl;  // 可以多段拼接输出
    return 0;
}

输出结果：

1010
年龄是10岁

📌 程序开头的 #include <iostream> 和 using namespace std; 是"固定开场白"，照抄即可，它们的来龙去脉在第8章《输入输出与头文件》详细讲解。本章只要记住：cout << 变量名; 就能把变量的值打印到屏幕上。

八、代码演示：本章知识点串起来

cpp

#include <iostream>
using namespace std;

int main() {
    // ===== 1. 声明、赋值、初始化 =====
    int age;            // 声明：先说明盒子型号
    age = 10;           // 赋值：把 10 放进去
    int score = 95;     // 初始化：声明 + 赋值一步到位
    cout << age << " " << score << endl;   // 10 95

    // ===== 2. 重新赋值：新值盖旧值 =====
    age = 11;
    cout << age << endl;    // 11

    // ===== 3. 赋值号 = 不是数学等号：先算右边，再赋给左边 =====
    int x = 5;
    x = x + 1;              // 右边 5+1=6，再把 6 放进 x
    cout << x << endl;      // 6

    // ===== 4. 一条语句声明多个同类型变量 =====
    int a, b, c;
    a = 1; b = 2; c = 3;
    int m = 7, n = 8;       // 声明时直接初始化
    cout << a + b + c << " " << m << " " << n << endl;  // 6 7 8

    // ===== 5. 区分大小写：age 和 Age 是两个盒子 =====
    int Age = 20;
    cout << age << " " << Age << endl;   // 11 20

    // ===== 6. const 常量：定义后不可修改 =====
    const int N = 100;
    const double PI = 3.14;
    cout << N << " " << PI << endl;      // 100 3.14
    // N = 200;          // ❌ 编译报错：不能给常量赋值

    // ===== 7. 自增 ++、自减 -- =====
    int i = 0;
    i++;                    // i = 1
    i++;                    // i = 2
    i--;                    // i = 1
    cout << i << endl;      // 1

    // ----- 以下代码都会报错，请勿取消注释，认识错误即可 -----
    // int 1age = 10;      // 标识符不能以数字开头
    // int if = 3;         // 关键字 if 不能做变量名
    // int z;
    // cout << z;          // z 未赋值，输出垃圾值（并可能报警告）

    return 0;
}

九、📝 实战练习

练习题 1（单选题）

题目： 下列选项中，合法的 C++ 标识符是（）

A. 2score B. my_name C. my-name D. int

🔑 点击查看答案与解析

答案： B

解析：

A ❌：以数字开头，违反"不能以数字开头"规则；
B ✅：由小写字母和下划线组成，合法；
C ❌：含有减号 -，标识符只能含字母、数字、下划线；
D ❌：int 是 C++ 的关键字（整数类型），不能做标识符。

选 B。

练习题 2（单选题）

题目： 下列关于 C++ 关键字的说法，正确的是（）

A. cout 是 C++ 的关键字 B. int 是 C++ 的关键字 C. True 是 C++ 的关键字 D. 关键字可以作为变量名使用

🔑 点击查看答案与解析

答案： B

解析：

A ❌：cout 是标准库 std 中预先定义好的输出对象名字，不是关键字；
B ✅：int 是表示整数类型的关键字；
C ❌：C++ 中布尔关键字是全小写的 true、false，True 不是关键字；
D ❌：关键字是语言保留的"专用词"，不能做变量名。

选 B。

练习题 3（程序阅读题）

题目： 运行下面的程序，输出结果是（）

cpp

int a = 3, b = 5;
a = a + b;
b = a - b;
cout << a << " " << b;

A. 3 5 B. 8 5 C. 8 3 D. 3 8

🔑 点击查看答案与解析

答案： C

解析： 按"先算右边、再赋左边"一步步走：

a = 3，b = 5；
a = a + b：右边 3 + 5 = 8，a 变成 8；
b = a - b：此时 a 已是 8，右边 8 − 5 = 3，b 变成 3；
输出 8 3。

每一步都要用变量的最新值计算——这正是程序阅读题最容易"看走眼"的地方。

选 C。

练习题 4（判断题）

题目： 在 C++ 中，int age; 声明变量后，age 中会自动存放 0；下面程序输出 0。（）

cpp

int age;
cout << age;

🔑 点击查看答案与解析

答案： ✗ 错误

解析： C++ 的局部变量声明后不会自动变成 0，盒子里是不确定的"垃圾值"，输出结果是一个乱七八糟的数（编译器通常还会给出警告）。变量必须先赋值、后使用，正确写法是 int age = 0; 或先 age = 0; 再输出。

练习题 5（判断题）

题目： 在 C++ 中，变量 score 和 Score 是同一个变量；const int N = 100; 之后再写 N = 200;，程序可以正常编译。（）

🔑 点击查看答案与解析

答案： ✗ 错误

解析： 这句话有两处错误：① C++ 标识符区分大小写，score 和 Score 是两个不同的变量；② const 定义的是真正常量，定义后不能再修改，写 N = 200; 编译器会直接报错。

练习题 6（单选题）

题目： 下列标识符中，全部合法的一组是（）

A. name、_age、sum123 B. 123abc、my-name、int C. a b、$money、if D. x*y、2good、cout

🔑 点击查看答案与解析

答案： A

解析：

A ✅：name（字母）、_age（下划线开头合法）、sum123（字母+数字）全部合法；
B ❌：123abc 数字开头、my-name 含减号、int 是关键字，全错；
C ❌：a b 含空格、$money 含美元符号（不合法）、if 是关键字；
D ❌：x*y 含乘号、2good 数字开头。cout 虽然合法（不是关键字），但其他两个错了。

选 A。

练习题 7（程序阅读题）

题目： 运行下面的程序，输出结果是（）

cpp

int x = 10, y = 20;
x = y;
y = x;
cout << x << " " << y;

A. 10 20 B. 20 10 C. 20 20 D. 10 10

🔑 点击查看答案与解析

答案： C

解析： 一步步走：

x = 10，y = 20；
x = y;：把 y 的值（20）放进 x，x 变成 20（旧值 10 被覆盖）；
y = x;：把 x 的值（现在是 20）放进 y，y 变成 20；
输出 20 20。

这道题很容易误选 B（以为是交换）。注意：交换两个变量的值需要一个"临时盒子"做中转，直接互相赋值会导致第一个值被覆盖丢失。

选 C。

练习题 8（判断题）

题目： 'A' 和 "A" 是一样的，都是表示字符 A。（）

🔑 点击查看答案与解析

答案： ❌ 错误

解析： 'A' 是字符常量（单引号，一个字符），"A" 是字符串常量（双引号，一串文字，哪怕只有一个字符）。它们类型不同，存储方式也不同——字符串末尾会多一个"结束标记"。千万别搞混！

练习题 9（单选题）

题目： 关于 const 常量，下列说法正确的是（）

A. const 定义的常量可以在程序中随时修改 B. const int N = 100; 定义后，N = 200; 是合法的 C. 常量名习惯上全部大写，以便和普通变量区分 D. 常量必须用小写字母命名

🔑 点击查看答案与解析

答案： C

解析：

A ❌：const 定义的常量不能修改；
B ❌：给常量赋值会编译报错；
C ✅：常量名习惯全大写（如 N、PI、MAX_SIZE），这是编程约定；
D ❌：没有这个规定，只是习惯全大写。

选 C。

练习题 10（程序阅读题）

题目： 下面程序执行后，i 的值是多少？（）

cpp

int i = 5;
i++;
i++;
i--;
i = i + 3;

A. 8 B. 9 C. 10 D. 11

🔑 点击查看答案与解析

答案： B

解析： 用"变量跟踪表"一步步算，每步都用变量的最新值：

步骤	i 的值	说明
初始	5	`int i = 5;`
第1次 `i++`	6	加 1
第2次 `i++`	7	再加 1
`i--`	6	减 1
`i = i + 3`	9	6 + 3 = 9

所以最终 i 的值是 9，选 B。

💡 程序阅读题千万不要心算，把每一步的值写下来，就不会"看走眼"。

十、📊 考点总结表

考点	重要程度	出题形式	高频易错点
标识符命名规则	⭐⭐⭐⭐⭐	选择/判断	数字开头 `1age`、含 `-`、含空格
标识符区分大小写	⭐⭐⭐⭐	选择/判断/程序阅读	误以为 `age` 和 `Age` 是同一个
关键字	⭐⭐⭐⭐	选择/判断	误以为 `cout` 是关键字；`true` 全小写
变量必须先声明类型再使用	⭐⭐⭐⭐⭐	选择/判断/编程	忘写 `int`；与不声明类型的语言混淆
声明 / 赋值 / 初始化	⭐⭐⭐⭐⭐	编程	概念混淆；忘写分号 `;`
赋值号 `=` 的含义	⭐⭐⭐⭐⭐	程序阅读/编程	读不懂 `x = x + 1`；与 `==` 混淆（第7章讲）
重新赋值覆盖旧值	⭐⭐⭐⭐	程序阅读	计算时忘了用变量最新值
未初始化变量是垃圾值	⭐⭐⭐⭐	判断/编程	误以为声明后自动为 0
`const` 常量	⭐⭐⭐	选择/判断	误以为常量还能再赋值
字符/字符串常量引号	⭐⭐⭐	选择/判断	`'A'` 单引号、`"hi"` 双引号搞反
`++` / `--` 的作用	⭐⭐⭐	程序阅读	单独使用即加 1 / 减 1；前置后置第7章讲
变量跟踪表技巧	⭐⭐⭐⭐	程序阅读	心算出错，一定要动笔

┌──────────────────────────────────────────────────────────────┐
│                 ⭐ 第4章必背速记卡（基础语法）                   │
├──────────────────────────────────────────────────────────────┤
│  1. 标识符：字母/数字/下划线，不能数字开头，区分大小写         │
│  2. 标识符判断三步：看开头→看字符→看是不是关键字             │
│  3. 关键字是C++"专用词"，不能当变量名；cout不是关键字         │
│  4. true/false全小写；True、FALSE都不对                      │
│  5. 变量=贴标签的盒子；先声明类型，再使用                     │
│  6. 赋值号=：先算右边，再赋给左边；新值盖旧值                 │
│  7. x = x + 1 意思是x加1，不是数学等式                       │
│  8. 未初始化变量=垃圾值，一定要先赋值再用                     │
│  9. const常量定义后不能改；习惯全大写命名                     │
│ 10. 字符单引号'A'，字符串双引号"ABC"                         │
│ 11. i++ 等价于 i = i + 1；i-- 等价于 i = i - 1               │
│ 12. 程序阅读用"变量跟踪表"，一步步写下来，别心算              │
│ 13. 一条语句可声明多个同类型变量，用逗号隔开                  │
│ 14. 变量跟踪表：每步更新值，用最新值计算下一条语句            │
└──────────────────────────────────────────────────────────────┘

📖 下章预告：第5章我们将学习 C++ 的基本数据类型——整型 int、浮点型 double、字符型 char、布尔型 bool……这些就是"盒子的型号"，不同型号装不同的东西，占的空间也不一样。学会了数据类型，你就能精确地控制每个盒子的大小和用途了。

第4章 基础语法：标识符、关键字与变量 ​

🎯 本章学习目标 ​

🗺️ 本章知识图谱 ​

一、标识符：给"盒子"起的名字 ​

标识符命名规则 🔥 ​

🔍 深度辨析：下划线开头的标识符 ​

二、关键字：C++ 保留的"专用词" ​

一级常见关键字一览表 ​

🧩 拓展：关键字 vs 标识符 vs 标准库名 ​

三、常量：固定不变的量 ​

3.1 字面常量：直接写出来的数据 ​

3.2 用 const 定义命名常量 ​

💡 为什么要用 const 常量？直接写数字不行吗？ ​

四、变量（重点）：贴了标签的盒子 ​

4.1 三步曲：声明 → 赋值 → 初始化 ​

4.2 赋值号 =：把右边放进左边的盒子 ​

4.3 变量可以反复赋值：新值盖旧值 ​

4.4 一条语句声明多个同类型变量 ​

4.5 变量的"作用"：它从哪生，到哪"过期" ​

🧩 考点深挖：变量在内存中长什么样？ ​

🔍 程序阅读技巧："变量跟踪表" ​

⚠️🔥 深度辨析：未初始化的变量——盒子里的"垃圾值" ​

五、表达式：能算出一个值的式子 ​

六、自增 ++ 与自减 --：计数小能手 ​

💡 为什么要有 ++？直接写 i = i + 1 不行吗？ ​

七、变量输出初体验：cout ​

八、代码演示：本章知识点串起来 ​

九、📝 实战练习 ​

练习题 1（单选题） ​

练习题 2（单选题） ​

练习题 3（程序阅读题） ​

练习题 4（判断题） ​

练习题 5（判断题） ​

练习题 6（单选题） ​

练习题 7（程序阅读题） ​

练习题 8（判断题） ​

练习题 9（单选题） ​

练习题 10（程序阅读题） ​

十、📊 考点总结表 ​

第4章基础语法：标识符、关键字与变量

🎯 本章学习目标

🗺️ 本章知识图谱

一、标识符：给"盒子"起的名字

标识符命名规则 🔥

🔍 深度辨析：下划线开头的标识符

二、关键字：C++ 保留的"专用词"

一级常见关键字一览表

🧩 拓展：关键字 vs 标识符 vs 标准库名

三、常量：固定不变的量

3.1 字面常量：直接写出来的数据

3.2 用 const 定义命名常量

💡 为什么要用 const 常量？直接写数字不行吗？

四、变量（重点）：贴了标签的盒子

4.1 三步曲：声明 → 赋值 → 初始化

4.2 赋值号 `=`：把右边放进左边的盒子

4.3 变量可以反复赋值：新值盖旧值

4.4 一条语句声明多个同类型变量

4.5 变量的"作用"：它从哪生，到哪"过期"

🧩 考点深挖：变量在内存中长什么样？

🔍 程序阅读技巧："变量跟踪表"

⚠️🔥 深度辨析：未初始化的变量——盒子里的"垃圾值"

五、表达式：能算出一个值的式子

六、自增 `++` 与自减 `--`：计数小能手

💡 为什么要有 ++？直接写 i = i + 1 不行吗？

七、变量输出初体验：cout

八、代码演示：本章知识点串起来

九、📝 实战练习

练习题 1（单选题）

练习题 2（单选题）

练习题 3（程序阅读题）

练习题 4（判断题）

练习题 5（判断题）

练习题 6（单选题）

练习题 7（程序阅读题）

练习题 8（判断题）

练习题 9（单选题）

练习题 10（程序阅读题）

十、📊 考点总结表