第3章编程规范

🎯 本章学习目标

读完本章，你将能够：

✅ 熟练写出 C++ 程序的完整框架（头文件 + 命名空间 + main + return 0）
✅ 理解大括号 { } 的作用，知道它必须成对出现，理解"复合语句"是什么
✅ 记住"每条语句末尾必须有分号"的铁律，分清哪些行不加
✅ 正确使用 // 单行注释和 /* */ 多行注释
✅ 养成良好的代码排版习惯：缩进、一行一语句、英文半角符号
✅ 看懂编译器报错信息，能快速定位漏分号、漏大括号、中文符号等常见错误
✅ 理解变量命名"见名知意"的重要性
✅ 独立写出符合规范、格式美观的简单 C++ 程序

🗺️ 本章知识图谱

第3章 编程规范
├── 一、为什么要学规范
│   └── 代码是写给人看的，也是写给机器读的
├── 二、程序框架（四件套）
│   ├── #include <iostream>：头文件（行尾无分号）
│   ├── using namespace std;：命名空间（有分号）
│   ├── int main()：主函数（程序入口）
│   └── return 0;：正常结束
├── 三、大括号 { }
│   ├── 作用：包裹代码块（一组语句的整体）
│   ├── 铁律：必须成对出现
│   ├── 复合语句：大括号包的语句整体算一条语句
│   └── 常见误区：C++ 靠大括号分组，不靠缩进
├── 四、分号 ;
│   ├── 作用：语句结束的标志
│   ├── 哪些要加：普通语句、定义语句、return等
│   ├── 哪些不加：#include、函数头、大括号本身
│   └── 易错：漏分号报错常指向下一行
├── 五、注释
│   ├── // 单行注释
│   ├── /* */ 多行注释（成对、不能嵌套）
│   └── 特点：不执行，给人看
├── 六、代码排版
│   ├── 大括号内缩进（推荐4空格/Tab）
│   ├── 一行一语句
│   ├── 英文半角符号
│   └── 适当空格（运算符两侧）
├── 七、常见编译错误
│   ├── 漏分号：expected ';'
│   ├── 漏大括号：expected '}'
│   ├── 中文符号：stray '\xxx'
│   └── 漏头文件：xxx was not declared
└── 八、命名好习惯：见名知意

一、为什么要学编程规范？

写代码就像写作文：字要工整、段落开头要空两格、标点要用对、一句话写完要加句号。作文写得乱，老师读不懂；代码写得乱，编译器直接"罢工"报错。

C++ 是一门讲究"仪式感"的语言：每个程序都有一套雷打不动的固定开场仪式，每条语句末尾都要盖一个"句号"（分号），一组代码要用大括号"围"起来。本章我们就把这些规矩一次性学透：

① 程序框架 —— 每个程序都一样的"固定开场仪式"
② 大括号 { } —— 把一组代码"围"起来，必须成对
③ 分号 ; —— 每条语句的"句号"，漏了必报错
④ 注释 —— // 和 /* */，写给人看的"小纸条"
⑤ 排版 —— 缩进对齐、一行一语句、英文半角符号
⑥ 看报错 —— 行号 + error，编译器其实在"指路"
⑦ 好习惯 —— 变量名见名知意（第4章详讲）

💡 核心认知： C++ 靠的是大括号 { } 来分组，缩进只是为了好看。打个比方：C++ 像在操场上画圈——圈（大括号）画到哪，队伍就围到哪；圈里的人站得整不整齐（缩进）只影响美观，不影响谁属于这个圈。

二、程序框架：雷打不动的"开场仪式" 🔥

2.1 第一个完整程序

先看一个最简单、也是考试中每个程序都要写的完整框架：

cpp

#include <iostream>          // ① 头文件：请进"输入输出工具箱"
using namespace std;         // ② 使用标准命名空间：工具用起来不用报全名
int main()                   // ③ 主函数：程序从这里开始执行
{
    cout << "你好，GESP！" << endl;   // ④ 输出一句话
    return 0;                // ⑤ 程序正常结束，向系统"交差"
}

运行结果：

你好，GESP！

2.2 逐行讲解：每一行都是"固定台词"

行	代码	作用	生活类比
①	`#include <iostream>`	头文件。引入输入输出工具箱，有了它才能用 `cin`、`cout`	上手工课前先领工具箱
②	`using namespace std;`	使用标准命名空间，让 `cout` 等名字可以直接写	工具箱摆在桌上，不用每次跑仓库取
③	`int main()`	主函数，程序的入口，计算机从 `main` 的第一行开始执行	学校大门，所有参观都从这里进
④	`{ ... }`	函数体，大括号围起来的就是 main 要做的事	大门里面的校园
⑤	`return 0;`	告诉系统"程序顺利跑完啦"，一般写在 main 的最后	放学时向老师报告"任务完成"

高频考点 🔥： 每个 C++ 程序都有且只有一个 main 函数，程序从 main 开始执行；使用 cout、cin 必须先写 #include <iostream>；试中推荐写全的四个部分——头文件、命名空间、main 函数、return 0。严格来说，using namespace std; 和 return 0; 在语法上并非绝对必须，但一级考试中建议养成写全的习惯，既规范又避免因省略导致的其他问题。

易错点 ⚠️： ① #include <iostream> 这一行末尾没有分号（它是预处理指令，不是普通语句）；② using namespace std; 和 return 0; 末尾都有分号，别漏；③ main 后面的小括号 ( ) 不能丢。

🧩 考点深挖：为什么要有头文件？

你可能会问：为什么不能直接用 cout，非得写 #include <iostream> 呢？

打个比方 🧰：学校的劳动课上，你想用锯子、锤子做手工，但工具都锁在仓库里。你得先打一张领工具的申请单交给老师，老师才把工具箱给你。#include <iostream> 就是那张"申请单"——告诉编译器："我需要用 iostream 工具箱里的工具，请把它搬过来。"

C++ 标准库里有好多工具箱，每个工具箱负责不同的功能：

工具箱（头文件）	里面有什么工具	什么时候领
`<iostream>`	`cin`、`cout`、`endl`	要输入输出的时候
`<cstdio>`	`scanf`、`printf`	要用格式化输入输出的时候
`<cmath>`	数学函数（如 `sqrt` 开根号）	二级及以上会学到

一级阶段我们主要用前两个工具箱。用什么工具，就领什么箱子——这是 C++ 的"环保理念"：不用的工具不搬进来，程序更小巧高效。

三、大括号 { }：C++ 的"围墙" 🔥

3.1 大括号是干什么的

C++ 用大括号 { } 把一组代码"围"起来，表示它们是一个整体（叫做代码块）。函数体要用大括号，以后学的 if 分支、for/while 循环也要用大括号。

打个比方：大括号就像羊圈的栅栏——{ 是"开门放羊进去"，} 是"关门"，栅栏里的羊（语句）才是这一组的成员。有开门就必须有关门，所以大括号永远成对出现。

cpp

int main()
{                          // 左大括号：函数体开始
    cout << "第一行" << endl;
    cout << "第二行" << endl;
    return 0;
}                          // 右大括号：函数体结束

3.2 大括号的三条铁律

规则	说明
① 必须成对	有一个 `{` 就必须有一个 `}`，少一个编译器就报错
② 围起来的是一组	大括号里的语句属于同一个代码块（函数、分支、循环）
③ 缩进不影响分组	C++ 不靠缩进分组！大括号才决定分组；缩进只是为了好看易读

高频考点 🔥： C++ 用大括号 { } 包裹代码块；大括号必须成对出现。缩进不决定分组，大括号才决定分组——这是选择题最爱"挖坑"的地方。

易错点 ⚠️： 漏写右大括号 } 是初学者高频错误，编译器往往在程序最后一行才报错（如 expected '}' at end of input），意思是"文件都读完了，还没等到关门的 }"。看到这类报错，回头数一数大括号是不是成对。

3.3 复合语句：把一组语句当成一条语句 🔥

考纲要求掌握的基本语句里，有一个名字有点陌生——复合语句。其实很简单：用一对大括号 { } 把若干条语句"打包"起来，整体当作一条语句看待，这就叫复合语句（也叫"语句块""代码块"）。

cpp

{
    int a = 1;      // ┐
    int b = 2;      // ├─ 这三条语句被大括号"打包"成一条复合语句
    cout << a + b;  // ┘
}

它有什么用？最大的好处是可以放在只允许写一条语句的位置上。比如 if、for、while 后面本来只能跟一条语句，套上大括号后，就能让它们"一次管住一组语句"：

cpp

int x = 5;

// 没有大括号：只有紧挨着的第一条语句属于 if
if (x > 0)
    cout << "正数" << endl;   // ← 只属于 if
    cout << "结束" << endl;   // ← 不属于 if，条件真假都会执行！

// 有大括号：两条语句打包成一条复合语句，整体都属于 if
if (x > 0) {
    cout << "正数" << endl;
    cout << "结束" << endl;
}

高频考点 🔥：
复合语句 = 大括号包起来的一组语句，整体算一条语句；
大括号里的每条语句末尾要有分号，但右大括号 } 后面通常不加分号（第3章第四节的判断题坑就出在这里）；
if、for、while 后面的大括号，作用就是把多条语句变成一条复合语句——这正是"哪怕只有一条语句也建议写大括号"的原因。

⚠️ 易错点： 复合语句内部定义的变量，出了这个大括号就"失效"了（详见第4章"变量的作用"），所以不同的大括号里可以放心地使用同名变量。

🔍 深度辨析：缩进 vs 大括号，到底谁说了算？

这是初学者最容易搞混的地方：在 C++ 里，缩进和大括号，谁决定"哪些语句是一组"？

答案是——大括号说了算，缩进只是排版习惯。看一个例子：

cpp

// 写法一：缩进乱、但大括号正确 —— 完全正确，能正常运行
if (x > 0) {
cout << "正数" << endl;
        cout << "结束" << endl;
}

// 写法二：缩进很整齐，但没写大括号 —— 只有第一条属于 if！
if (x > 0)
    cout << "正数" << endl;   // ← 属于 if
    cout << "结束" << endl;   // ← 不属于 if！条件真假都会执行

对比项	缩进（行首空格）	大括号 `{ }`
决定哪些语句是一组	❌ 不决定	✅ 决定
不写 / 不整齐	✅ 能运行（只是不好看）	❌ 会改变程序逻辑，甚至报错
主要作用	方便人阅读	告诉编译器"这些是一条复合语句"

💡 记忆口诀：C++ 是"画圈分组"——圈（大括号）画到哪里，哪里的人就是一组；站得齐不齐（缩进）只是好不好看的问题。

四、分号 ;：每条语句的"句号" 🔥

4.1 分号是语句结束的标志

中文里一句话写完要加"。"，C++ 里一条语句写完要加 ;（分号）。分号告诉编译器："这条命令说完了，可以执行下一条了。"

cpp

int a = 10;                // 定义变量，末尾分号
cout << a << endl;         // 输出语句，末尾分号
return 0;                  // return 语句，末尾分号

高频考点 🔥： C++ 中每条语句末尾必须有分号 ;。漏分号是初学者第一大编译错误！注意：#include <iostream>、int main()、大括号 { } 后面不加分号，普通语句后面必须加分号。

4.2 哪些行加分号、哪些不加

代码	末尾加不加分号	原因
`#include <iostream>`	❌ 不加	预处理指令，不是语句
`using namespace std;`	✅ 加	是一条语句
`int main()`	❌ 不加	函数头，后面跟大括号
`{` 和 `}`	❌ 不加	大括号本身不是语句
`int a = 10;`	✅ 加	定义语句
`cout << a;`	✅ 加	输出语句
`return 0;`	✅ 加	返回语句
`if (x > 0)`	❌ 不加	分支头，后面跟语句或大括号
`for (int i=1; i<=10; i++)`	❌ 不加	循环头，后面跟循环体

易错点 ⚠️： 漏分号时，编译器报错的位置常在下一行——因为它读到下一行开头才发现"上一句话怎么没结束"。比如第 5 行漏了分号，报错可能指向第 6 行，别怀疑自己看错了行号，往上一行找就对了。

🚨 判断题经典坑："大括号后面必须加分号"对不对？

答案： ❌ 错误！

大括号 { } 本身不是语句，它只是"把一组语句围起来"的符号，所以大括号后面不加分号。

✅ 正确：} 后面直接接下一行代码，没有分号
❌ 错误：}; （多写了分号，虽然有时不报错，但不规范）

唯一的例外是后面会学到的类和结构体的定义，那是后话，一级阶段你只要记住：大括号后面不加分号。

五、注释：写给人看的"小纸条" 🔥

5.1 什么是注释

注释（Comment）是写在代码里的说明文字，就像语文课本上的批注。注释是给人看的，编译器会直接跳过、绝不执行。

C++ 有两种注释：

类型	写法	说明
单行注释	`// 注释内容`	从 `//` 开始到本行结束都是注释，一级重点掌握
多行注释	`/* 注释内容 */`	`/` 和 `/` 之间可以跨好多行，常用于大段说明

cpp

#include <iostream>
using namespace std;

int main()
{
    // 这是单行注释：下面一行输出问候语
    cout << "你好，GESP！" << endl;

    /* 这是多行注释：
       中间可以写好几行，
       编译器全都跳过不执行 */
    cout << "加油！" << endl;   // 注释也可以跟在代码后面
    return 0;
}

运行结果：

你好，GESP！
加油！

5.2 注释的两个妙用

解释思路：考试编程题写注释，阅卷老师一眼看懂你的想法；
调试时"注释掉"代码：某行代码暂时不想让它运行，又舍不得删，就在行首加 //，程序就会跳过它。

cpp

// cout << "这句暂时不想输出" << endl;   // 加了 //，这行不执行
cout << "这句正常输出" << endl;

高频考点 🔥： C++ 单行注释用 //，多行注释用 /* ... */；注释不会被执行，只起说明作用。注意多行注释的 /* 和 */ 也要成对，且不能嵌套（/* 里面再写 /* 是不行的）。

易错点 ⚠️： C++ 中 # 开头的行是预处理指令（如 #include），不能当注释用！注释只认 // 和 /* ... */。

🧩 拓展：注释的"正确打开方式"

初学者常问："代码里写多少注释合适？"

情况	要不要写注释
很明显的代码（如 `int age = 10;`）	不用写，写了反而啰嗦
逻辑复杂、绕弯子的地方	一定要写，帮以后的自己看懂
编程题核心算法思路	建议写，阅卷老师更清楚你的思路

记住一个原则：注释解释"为什么这么写"，而不是"写了什么"。比如：

cpp

// ✅ 好注释：说明意图
sum += i;    // 把当前数累加进总和（求1到n的和）

// ❌ 差注释：等于没说
sum += i;    // sum 加上 i（废话，代码已经说了）

六、代码排版：让代码"会呼吸"

排版不影响程序运行（编译器不挑格式），但直接影响可读性和考试印象分。一级要求掌握四条：

6.1 四条排版规矩

规矩	规范写法 ✅	说明
① 大括号内缩进	大括号里的代码统一缩进（推荐 4 个空格）	像段落开头空两格，层级一目了然
② 一行一语句	每行只写一条语句	挤在一行像没标点的作文，难读又难找错
③ 符号英文半角	`; ( ) { } " " ,` 全用英文	中文符号 `；（）""，` 编译器不认识，必报错
④ 空格留呼吸	运算符两侧、逗号后适当加空格	`a = 1 + 2` 比 `a=1+2` 清爽得多

cpp

// ✅ 规范排版
int a = 1 + 2;             // 运算符两侧有空格
cout << a << endl;         // 输出：3

高频考点 🔥： C++ 中所有符号必须是英文半角：分号 ;、括号 ( )、大括号 { }、引号 " "、逗号 ,。不小心按出中文全角符号 ；（）""， 是初学者报错的重灾区！

易错点 ⚠️： 缩进在 C++ 里纯粹为了好看——不缩进程序也能运行，但代码会"挤成一团"难以阅读。考试时建议养成缩进习惯：大括号内的代码统一缩进 4 个空格（多数编辑器按一下 Tab 会自动缩进）。敲代码时全程保持英文输入法，这是个保命的好习惯！

💡 小技巧：输入法切换

写代码时最容易犯的低级错误就是不小心切到了中文输入法，敲出来的全是中文标点。教你两招：

设置默认英文输入法：把电脑的默认输入法改成"英语"，写中文注释时再手动切回来；
看光标形状：中文输入法的光标通常更粗、或者有"中"字图标，余光扫一眼就知道；
打了就编译：写几行就按一次 F11 编译，有错误早发现、早解决。

七、常见编译错误对照：学会看报错 🔥

7.1 编译器其实在"指路"

C++ 程序写完要先编译（翻译成计算机能懂的机器语言）。如果代码有问题，编译器会亮出红色报错，格式一般是：

文件名:行号: 错误类型: 错误说明
test.cpp:6:5: error: expected ';' before 'return'

别怕！这行字包含两个关键信息：

行号（6）：问题出在第 6 行附近（注意：漏分号时常指向下一行）；
error：错误类型和说明，哪怕英文看不懂，认出 error 这个词就知道是"出错了"。

7.2 一级四大高频错误对照表

错误类型	出错代码示例	编译器报错关键词	排查方法
漏分号	`int a = 10`（末尾没 `;`）	`expected ';'`	检查该行（及上一行）末尾是否有分号
漏大括号	少写一个 `}`	`expected '}'`	数一数 `{` 和 `}` 是否成对
中文符号	`cout<<"你好"；`（中文分号/引号）	`stray '\xxx'` 或一堆奇怪错误	检查输入法，全部改成英文半角符号
漏头文件	用了 `cout` 却没写 `#include <iostream>`	`'cout' was not declared`	在程序开头补上 `#include <iostream>`
名字拼错	`Cout << "hi";`（C大写了）	`'Cout' was not declared`	检查拼写，C++ 区分大小写

高频考点 🔥： 选择题常给一段代码问"哪里错了"——优先检查四件事：分号、大括号、英文符号、头文件。看到 expected ';' 找漏分号，看到 stray 找中文符号，看到 was not declared 找漏头文件或拼写错误。

易错点 ⚠️： 编译器报的行号是"它发现不对劲的地方"，不一定是"真正出错的地方"。漏分号、漏大括号时，报错位置常滞后一行甚至在文件末尾。技巧：从报错行往上看，重点检查上一行的结尾。

🔧 排错流程：遇到报错怎么办？

编译器报错了
    ↓
① 看第一条错误（后面的可能是连锁反应）
    ↓
② 看报错行号 → 跳到对应代码行
    ↓
③ 对照四大错误检查：
   ・漏分号？  → 看上一行末尾有没有 ;
   ・漏大括号？→ 数 { 和 } 是不是一样多
   ・中文符号？→ 看标点是不是中文的
   ・漏头文件？→ 有没有 #include <iostream>
   ・拼错了？ → 大小写、字母有没有写错
    ↓
④ 改完 → 重新编译 → 错误数减少了吗？
    ↓
⑤ 还有错 → 重复上面步骤
    ↓
⑥ 错误数为 0 → 🎉 成功！

💡 心法口诀：报错不可怕，它是在帮你找问题。先改第一条错，改完就编译，一步一步来，再复杂的错误也能解决。

八、命名好习惯：见名知意

变量、函数都要起名字。一级阶段先记住一条：名字要"见名知意"——

用途	✅ 好名字	❌ 坏名字
存年龄	`age`	`a`、`x1`
存总分	`total`	`bbb`
存成绩	`score`	`s`
存计数器	`count`	`c`
存最大值	`maxVal` 或 `max_value`	`m`

好名字就像书包上的姓名贴，别人（和以后的自己）一看就知道里面装的是什么。至于命名的完整规则（能用什么字符、不能用什么词），我们在第4章《基础语法：标识符、关键字与变量》 中详细讲解。

💡 上机小贴士： 文件名也要用英文和数字（如 score.cpp、test1.cpp），不用中文、空格和特殊符号；敲一会儿就按 Ctrl + S 保存；写几行就编译运行一次，看到结果正确再往下写——别一口气写完一大段再编译，那样一旦报错很难定位。

九、同一程序：规范写法 vs 不规范写法

下面用一个一级难度的小程序，把本章所有规矩串起来对比着看：

9.1 ✅ 规范写法

cpp

#include <iostream>          // 头文件，行尾无分号
using namespace std;         // 命名空间，行尾有分号

int main()                   // 主函数入口
{
    int score = 86;          // 定义成绩：缩进4格，运算符两侧有空格
    if (score >= 60)         // if 分支（第6章详讲）
    {
        cout << "成绩合格" << endl;    // 大括号内再缩进4格
    }
    cout << "查询结束" << endl;
    return 0;                // 交差：有分号
}

运行结果：

成绩合格
查询结束

9.2 ❌ 不规范写法（错误大集合）

cpp

#include <iostream>  
using namespace std              ← ② 行尾漏了分号
int main()
{                                ← ③ 左大括号后代码不缩进
int score = 86；                 ← ④ 行尾是中文分号"；"
   if (score >= 60)              ← ⑤ 缩进3格，随意
    {
        cout << "成绩合格" << endl
    }                            ← ⑥ cout 语句漏分号；右大括号勉强成对
cout（"查询结束"）               ← ⑦ 用了中文全角括号（ ）
    return 0;
}                                ← 若漏写这个 }，编译器在文件末尾报错

这份代码"满身是伤"：中文分号、中文括号直接触发编译错误；漏分号会报 expected ';'；漏头文件或头文件写错会报 cout 未声明。把符号、分号、大括号一一修正，才能得到上面的正确结果。

对照记忆 🎯： 规范代码的六个特征——框架四件套齐全、大括号成对、语句末尾分号、符号英文半角、大括号内缩进、注释用 //。考试交卷前花 30 秒按这六条自查一遍，能挡掉大部分低级错误。

十、📝 实战练习

练习题 1（单选题）

题目： 在 C++ 中，一组语句（代码块）使用哪种方式来表示？（）

A. 行首的缩进（空格） B. 大括号 { } C. 行尾的分号 ; D. 小括号 ( )

🔑 点击查看答案与解析

答案： B

解析： C++ 用大括号 { } 包裹代码块；缩进只是为了好看，不决定分组；分号是语句结束符，小括号用于函数和运算。选 B。

练习题 2（单选题）

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

A. 每条语句末尾必须加分号 ; B. 大括号 { } 后面必须加分号 C. #include <iostream> 末尾必须加分号 D. 分号可以省略，编译器会自动补全

🔑 点击查看答案与解析

答案： A

解析： C++ 中每条语句末尾必须加分号；但大括号、int main()、#include 指令后面都不加分号；漏分号编译器不会帮忙，只会报错。选 A。

练习题 3（单选题）

题目： C++ 程序中，使用 cout 进行输出，必须在程序开头引入哪个头文件？（）

A. #include <stdio.h> B. #include <iostream> C. #include <string> D. 不需要引入任何头文件

🔑 点击查看答案与解析

答案： B

解析： cout、cin 都在 <iostream> 头文件中，漏写会报 'cout' was not declared。选 B。

练习题 4（单选题）

题目： 下列符号中，写在 C++ 代码里会导致编译错误的是（）

A. ;（英文分号） B. { }（英文大括号） C. ；（中文全角分号） D. //（单行注释）

🔑 点击查看答案与解析

答案： C

解析： C++ 代码中所有符号必须是英文半角，中文全角符号编译器不认识。;、{ }、// 都是合法符号。选 C。

练习题 5（单选题）

题目： 关于 C++ 中的注释，下列说法正确的是（）

A. 注释会被计算机执行，影响运行结果 B. 单行注释以 # 开头 C. 单行注释以 // 开头，注释内容不会被执行 D. 多行注释用 // ... // 包裹

🔑 点击查看答案与解析

答案： C

解析： C++ 单行注释用 //，多行注释用 /* ... */；注释给人看、不执行；# 是预处理指令开头，不是注释。选 C。

练习题 6（判断题）

题目： 在 C++ 中，只要大括号成对，大括号内的代码不缩进也能正常编译运行。（）

🔑 点击查看答案与解析

答案： √（正确）

解析： C++ 靠大括号分组，不靠缩进。不缩进程序照样能编译运行，但缩进能让代码清晰易读，是强烈推荐的好习惯。

练习题 7（判断题）

题目： 每个 C++ 程序可以有多个 main 函数，程序从第一行开始执行。（）

🔑 点击查看答案与解析

答案： ×（错误）

解析： 每个 C++ 程序有且仅有一个 main 函数，它是程序的入口，程序从 main 函数体内的第一条语句开始执行。

练习题 8（程序阅读题）

题目： 下面的程序有几处语法错误？请找出来。

cpp

#include <iostream>
using namespace std
int main()
{
    cout << "Hello" << endl
    return 0;
}

A. 1 处　　B. 2 处　　C. 3 处　　D. 4 处

🔑 点击查看答案与解析

答案： B（2 处）

解析：

第 2 行 using namespace std 末尾漏了分号，应该是 using namespace std;
第 5 行 cout << "Hello" << endl 末尾漏了分号，应该加 ;

两处都是漏分号错误。编译器可能会报很多条错误，但根源只有这两个。

练习题 9（判断题）

题目： 编译器报错说"第 8 行有错误"，那问题一定出在第 8 行。（）

🔑 点击查看答案与解析

答案： ❌ 错误

解析： 编译器报的行号是"它发现问题的地方"，不一定是"真正出错的地方"。比如漏分号的错误，编译器常常读到下一行才发现"上一句没说完"，所以报错行号会滞后一行。正确做法是：从报错行往上检查，重点看上一行的末尾。

练习题 10（判断题）

题目： /* ... */ 多行注释可以嵌套使用，也就是在 /* 和 */ 之间可以再写一对 /* */。（）

🔑 点击查看答案与解析

答案： ❌ 错误

解析： C++ 的多行注释不能嵌套。当编译器遇到第一个 /* 后，它会一直找最近的 */，找到就认为注释结束了。如果中间又写了 /*，编译器不会把它当"新的注释开始"，嵌套的结果就是注释提前结束，后面的代码会被当成正常语句来编译，大概率报错。

练习题 11（程序阅读题）

题目： 下面的程序要实现"输入两个整数，输出它们的和"。程序中有多处语法错误，请找出所有错误（找对几处算几处）。

cpp

#include iostream
using namespace std;

int mian()
{
    int a, b
    cin >> a >> b；
    cout << "a + b = " << a + b << endl
    return 0;
}

🔑 点击查看答案与解析

共有 5 处错误：

错误位置	错误类型	正确写法
第 1 行 `#include iostream`	头文件缺少尖括号	`#include <iostream>`
第 4 行 `int mian()`	主函数名写错（不是 mian）	`int main()`
第 6 行 `int a, b`	变量声明末尾漏分号	`int a, b;`
第 7 行 `>> b；`	分号是中文全角分号	改成英文分号 `;`
第 8 行 `<< endl`	cout 语句末尾漏分号	`<< endl;`

💡 找错技巧：从上到下逐行检查，重点看——
头文件有没有 <>
主函数是不是 main（很多人写成 mian）
每行末尾的分号有没有？是英文的吗？
大括号配对吗？

练习题 12（程序阅读题）

题目： 以下四个程序中，哪一个能正常编译运行并输出 Hello？（）

cpp

#include <iostream>
using namespace std;
int main()
{
    cout << "Hello" << endl;
    return 0;
}

cpp

#include <iostream>
using namespace std
int main()
{
    cout << "Hello" << endl;
    return 0;
}

cpp

#include iostream
using namespace std;
int main()
{
    cout << "Hello" << endl;
    return 0;
}

cpp

#include <iostream>
using namespace std;
int mian()
{
    cout << "Hello" << endl;
    return 0;
}

🔑 点击查看答案与解析

答案： A

解析：

A 正确 ✅：头文件有尖括号、有分号、主函数名是 main、cout 有分号，全都对。
B 错误：第 3 行 using namespace std 末尾漏了分号。
C 错误：第 1 行 #include iostream 头文件缺少尖括号，应该是 #include <iostream>。
D 错误：第 4 行 mian() 写错了，应该是 main()。

🔥 考试技巧：遇到"哪个程序正确"的选择题，用排除法最快——每个选项只找一个明显的错误就能排除掉。

十一、📊 考点总结表

考点	重要程度	出题形式	高频易错点
程序框架四件套（头文件/命名空间/main/return 0）	⭐⭐⭐⭐⭐	选择/编程	`#include` 行误加分号
大括号 `{ }` 成对、包裹代码块	⭐⭐⭐⭐⭐	选择/判断/编程	漏 `}`，误以为缩进决定分组
复合语句：大括号包的一组语句整体算一条	⭐⭐⭐⭐	选择/判断	不知道它是什么；与大括号分不开
每条语句末尾分号 `;`	⭐⭐⭐⭐⭐	选择/编程	漏分号（第一大报错），报错行常滞后
`//` 与 `/* */` 注释、注释不执行	⭐⭐⭐⭐	选择/判断	把 `#` 当注释；多行注释不能嵌套
英文半角符号	⭐⭐⭐⭐	选择/编程	中文 `；（）""` 导致编译错误
缩进对齐、一行一语句、空格	⭐⭐⭐	判断	以为不缩进会报错（实际只是不规范）
编译报错信息（行号 + error）	⭐⭐⭐⭐	选择/编程	不会对照报错关键词找原因
变量命名见名知意	⭐⭐	判断	命名规则细节留到第4章
先改第一条错误原则	⭐⭐⭐⭐	实操	看到一堆报错就慌了

┌──────────────────────────────────────────────────────────────┐
│                  ⭐ 第3章必背速记卡（编程规范）                  │
├──────────────────────────────────────────────────────────────┤
│  1. 程序框架四件套：#include + using namespace + main + return │
│  2. #include末尾无分号；using、return末尾有分号               │
│  3. 大括号{ }必须成对；代码块靠大括号不靠缩进                │
│  4. 复合语句：大括号包的一组语句，整体当作一条语句看待       │
│  5. 每条语句末尾分号；漏分号报错指向下一行                    │
│  6. 大括号本身不是语句，后面不加分号                          │
│  7. 单行注释 // ；多行注释 /* */（成对、不嵌套）              │
│  8. 注释不执行，给人看的；# 不是注释，是预处理指令开头        │
│  9. 所有符号必须英文半角；中文标点必报错                      │
│ 10. 缩进只是好看，不影响运行；推荐缩进4格或Tab                │
│ 11. 报错看第一条，行号往上找；漏分号/中文符号/漏大括号最常见  │
│ 12. 变量名见名知意：age、score、sum 比 a、b、c 好            │
└──────────────────────────────────────────────────────────────┘

📖 下章预告：第4章我们将深入学习 C++ 的基础语法——标识符、关键字、常量、变量、表达式……这些是编程的"字母和单词"，学会了它们，你就能开始给"盒子"起名字、装数据了。

第3章 编程规范 ​

🎯 本章学习目标 ​

🗺️ 本章知识图谱 ​

一、为什么要学编程规范？ ​

二、程序框架：雷打不动的"开场仪式" 🔥 ​

2.1 第一个完整程序 ​

2.2 逐行讲解：每一行都是"固定台词" ​

🧩 考点深挖：为什么要有头文件？ ​

三、大括号 { }：C++ 的"围墙" 🔥 ​

3.1 大括号是干什么的 ​

3.2 大括号的三条铁律 ​

3.3 复合语句：把一组语句当成一条语句 🔥 ​

🔍 深度辨析：缩进 vs 大括号，到底谁说了算？ ​

四、分号 ;：每条语句的"句号" 🔥 ​

4.1 分号是语句结束的标志 ​

4.2 哪些行加分号、哪些不加 ​

🚨 判断题经典坑："大括号后面必须加分号"对不对？ ​

五、注释：写给人看的"小纸条" 🔥 ​

5.1 什么是注释 ​

5.2 注释的两个妙用 ​

🧩 拓展：注释的"正确打开方式" ​

六、代码排版：让代码"会呼吸" ​

6.1 四条排版规矩 ​

💡 小技巧：输入法切换 ​

七、常见编译错误对照：学会看报错 🔥 ​

7.1 编译器其实在"指路" ​

7.2 一级四大高频错误对照表 ​

🔧 排错流程：遇到报错怎么办？ ​

八、命名好习惯：见名知意 ​

九、同一程序：规范写法 vs 不规范写法 ​

9.1 ✅ 规范写法 ​

9.2 ❌ 不规范写法（错误大集合） ​

十、📝 实战练习 ​

练习题 1（单选题） ​

练习题 2（单选题） ​

练习题 3（单选题） ​

练习题 4（单选题） ​

练习题 5（单选题） ​

练习题 6（判断题） ​

练习题 7（判断题） ​

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

练习题 9（判断题） ​

练习题 10（判断题） ​

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

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

十一、📊 考点总结表 ​

第3章编程规范

🎯 本章学习目标

🗺️ 本章知识图谱

一、为什么要学编程规范？

二、程序框架：雷打不动的"开场仪式" 🔥

2.1 第一个完整程序

2.2 逐行讲解：每一行都是"固定台词"

🧩 考点深挖：为什么要有头文件？

三、大括号 { }：C++ 的"围墙" 🔥

3.1 大括号是干什么的

3.2 大括号的三条铁律

3.3 复合语句：把一组语句当成一条语句 🔥

🔍 深度辨析：缩进 vs 大括号，到底谁说了算？

四、分号 ;：每条语句的"句号" 🔥

4.1 分号是语句结束的标志

4.2 哪些行加分号、哪些不加

🚨 判断题经典坑："大括号后面必须加分号"对不对？

五、注释：写给人看的"小纸条" 🔥

5.1 什么是注释

5.2 注释的两个妙用

🧩 拓展：注释的"正确打开方式"

六、代码排版：让代码"会呼吸"

6.1 四条排版规矩

💡 小技巧：输入法切换

七、常见编译错误对照：学会看报错 🔥

7.1 编译器其实在"指路"

7.2 一级四大高频错误对照表

🔧 排错流程：遇到报错怎么办？

八、命名好习惯：见名知意

九、同一程序：规范写法 vs 不规范写法

9.1 ✅ 规范写法

9.2 ❌ 不规范写法（错误大集合）

十、📝 实战练习

练习题 1（单选题）

练习题 2（单选题）

练习题 3（单选题）

练习题 4（单选题）

练习题 5（单选题）

练习题 6（判断题）

练习题 7（判断题）

练习题 8（程序阅读题）

练习题 9（判断题）

练习题 10（判断题）

练习题 11（程序阅读题）

练习题 12（程序阅读题）

十一、📊 考点总结表