C / C++ 程序设计

语法基础、流程控制、函数、指针 · 共 10 讲

← 回首页

Lab01

🧩 核心概念

C/C++ 编程语言（C/C++ Programming Language） — 本课程使用的编程语言，用于编写源代码文件（如 .c / .cpp），是后续编译、运行、调试操作的对象。
在 VSCode 中编写代码（Coding in VScode） — 使用 VSCode 编辑器创建和编辑 C 源代码文件的操作，是编译运行流程的第一步。
编译并运行 C 代码（Compiling & Run the C code） — 将写好的 C 源代码通过编译器翻译为可执行程序并执行的操作流程，在 VSCode 环境下完成。
调试代码（Debugging the Code） — 在程序运行过程中定位和排查错误的过程，本讲以设置断点、单步执行、观察变量为主要手段。
断点（Break point） — 在源代码某一行设置的标记，程序运行到该行时会暂停，便于检查当前程序状态；可在 VSCode 中任意想要的位置设置（Setting break points where you like）。
在 VSCode 中设置断点（Setting break points in VScode） — 在 VSCode 编辑器界面内对指定代码行添加断点的具体操作。
在 Visual Studio 中设置断点（Setting break points in Visual Studio） — 在 Visual Studio 环境下设置断点的操作；本讲第 5、6 页标题使用此表述，与 VSCode 设置断点属于同类操作在不同 IDE 中的对应形式。
F5：停止/继续（F5: Stop） — 调试快捷键，按下 F5 使程序从暂停状态继续运行到下一个断点或结束（课件标注为 Stop，即控制程序停止在断点处/继续执行）。
F10：单步跳过（F10: Step over） — 调试快捷键，按下 F10 执行当前行代码并停在下一行；若当前行是函数调用，则不进入函数内部，而是把整个函数调用当作一步执行完。
局部变量监视窗口（Local Variable Watch Window） — 调试时用于实时查看当前作用域内局部变量取值的窗口，配合断点和单步执行观察变量变化。

🔗 概念之间的关系

C/C++ 编程语言 是整个 Lab 的操作对象：先有源代码，才谈得上编译运行和调试。
在 VSCode 中编写代码 是 编译并运行 C 代码 的前置步骤——没有源文件就无法编译。
编译并运行 C 代码 产生可执行程序，是 调试代码 的前提：只有程序能运行，才需要在运行中设断点排查逻辑错误。
断点是 调试代码 的核心手段；在 VSCode 中设置断点 与 在 Visual Studio 中设置断点 是同一调试机制在不同 IDE 下的具体实现，本讲以 VSCode 为主、Visual Studio 为对照。
F5（Stop） 与 F10（Step over） 是断点触发后的两种控制方式：F5 让程序继续跑到下一个断点，F10 让程序逐行前进；两者都依赖断点先使程序暂停。
局部变量监视窗口 依赖断点和 F10 单步执行才能发挥作用——程序暂停在断点处、逐行执行时，该窗口才显示当前局部变量的值。

⬅️ 承接前面的知识

本讲是 Lab01，为第一讲，无前置内容。本讲为后续内容打基础的方向：

C/C++ 编程语言 是后续所有 Lab 和理论课的语言基础。
编译并运行 C 代码 的流程是后续每次写程序、做实验的固定起点。
调试代码、断点、F5、F10、局部变量监视窗口 是后续排查程序错误的标准工具链，后续更复杂的程序调试都建立在本讲这些基本操作之上。

➡️ 后面会怎么用

C/C++ 编程语言：后续课程将在此基础上引入变量、数据类型、控制结构、函数等语法内容。
编译并运行 C 代码：后续每个 Lab 都需要重复此流程来验证程序是否正确。
调试代码 / 断点 / F5 / F10 / 局部变量监视窗口：后续遇到逻辑错误、数组越界、指针错误等问题时，将反复使用断点定位、单步跟踪、监视变量来排查；这是贯穿整门课程的通用调试技能。
VSCode 与 Visual Studio 的对照：后续可能在不同 IDE 环境下完成实验，本讲建立的两者操作对应关系可直接迁移。

Lab02-1

🧩 核心概念

转义字符（escape character） — 反斜杠 \，它让紧随其后的字符“逃离”屏幕打印，不被直接输出；当你想在字符串里插入换行、响铃等控制效果时使用。
转义序列（escape sequence） — 由反斜杠和后续字符组成的完整字符序列，如 \n；用于在 printf() 等输出中表示换行、响铃等不可见控制字符。
换行转义序列 \n（backslash n） — 在希望文本出现在新行处插入的两个字符；用于显式请求换行，因为 C 不会自动换行。
#define 预处理指令（#define preprocessor directive） — 用于在程序中引入常量的预处理指令；在编译前由预处理器处理。
常量（constant） — 通过 #define 引入、在预处理阶段被替换为固定值的标识符，如 UK_SPEED_LIMIT；用于避免在程序中多处硬编码同一个值。
预处理器（preprocessor） — 准备代码以供编译的环节；它把文件中所有常量出现处替换为对应值后再交给编译器。
转换符号（conversion symbol） — printf() 中以 % 开头的格式说明部分；用于指示要输出的数据类型。
转换字符（conversion character） — 转换符号中 % 后面的字符（如 d），表示要输出的数据类型为十进制整数；%d 用于整数，%f 用于 float，%c 用于 char，%s 用于字符串/字符数组。
变量声明（variable declaration） — 在程序中声明一组变量；声明后其对应值不确定，需通过实验观察。
变量初始化（variable initialisation） — 在声明变量的同时赋予初值；可在一条语句中“一次完成声明和初始化”。
整数数组的声明与初始化（Declaring and Initializing an Integer Array） — 声明长度为 5 的整数数组并用 5 个整数初始化；用于练习数组下标访问（如第 3 个元素）。
字符数组的声明与打印（Declaring and Printing a Character Array） — 声明字符数组并用两种方式初始化：char name[] = "white"; 与 char name[] = {'w','h','i','t','e'};；用 printf("%s", name); 打印并观察差异。
printf() 的使用次数约束（Use printf() only once / exactly four times） — 练习要求分别只用一次、恰好四次 printf()；用于训练用转义序列和空格排版控制输出。
垂直显示姓名（displays your name vertically） — 用一次 printf() 让姓名逐行显示；依赖 \n 实现换行。
星号矩形内两行姓名（names on two lines inside a rectangle of asterisks） — 用恰好四次 printf() 输出对齐的星号矩形；需要在正确位置插入空格（blanks）以保证对齐。
响铃转义序列（beep escape sequence） — 在姓名单行输出末尾让计算机发出蜂鸣；需从转义序列表中选取合适序列，效果依赖操作系统和计算机，有的会响有的不会。
%f 转换说明符（conversion specifier %f） — 用于打印 float 变量结果；配合变量初始化练习使用。
%c 转换说明符（conversion specifier %c） — 用于格式化并打印 char 值；配合字符变量声明与初始化练习使用。
%s 转换说明符（conversion specifier %s） — 用于打印字符数组/字符串；在字符数组两种初始化方式对比中使用。

🔗 概念之间的关系

转义字符 \ 是转义序列的组成部分：\ 单独只是“让后一个字符不被直接打印”的机制，\n、响铃序列等才是完整的转义序列；\n 是转义序列的一个具体特例。
#define 预处理指令引出常量：#define 是手段，常量 UK_SPEED_LIMIT 是结果；预处理器在编译前把所有该常量出现处替换为 70，因此常量依赖预处理阶段生效。
转换符号依赖转换字符来确定输出类型：% 是转换符号的引导，d 是转换字符；%d 表示十进制整数，%f、%c、%s 分别对应 float、char、字符串，是同一机制在不同数据类型上的推广。
变量声明与变量初始化是先后关系：先声明后使用会得到不确定值（Exercise 5 观察），初始化是在声明时直接给值（Exercise 6、7），后者是对前者的补充而非替代。
整数数组与字符数组的初始化方式不同：整数数组用一组整数初始化并按下标访问；字符数组既可用字符串字面量 "white" 初始化，也可用字符列表 {'w','h','i','t','e'} 初始化，后者是前者的逐字符展开形式，输出差异由此产生。
printf() 次数约束与转义序列、空格排版互相依赖：Exercise 2 用一次 printf() 实现垂直输出依赖 \n；Exercise 3 用四次 printf() 实现星号矩形对齐依赖空格插入；两者都是对输出格式的精确控制。

⬅️ 承接前面的知识

用到 Lab01 的结论：在 VSCode 中新建 C 项目、编译与运行 C 代码、设置断点调试；本讲 General Guidelines 明确要求按 Lab01 的说明打开新 C 项目并编译运行每个练习。
用到 Lecture01 的结论：本课程使用 C/C++ 语言、在 VSCode + 编译器环境下进行编程实践；本讲所有练习均在该环境下完成。
本讲为后续内容打基础：printf() 格式化输出、转义序列、#define 常量、变量声明与初始化、数组声明与初始化，都是后续 C 语言编程的基本构件。

➡️ 后面会怎么用

转义序列与 printf() 格式化：后续所有需要控制输出格式的程序都会用到 \n、%d、%f、%c、%s 等，是调试输出和结果展示的基础。
#define 常量：后续编写涉及固定参数（如速度上限、数组长度、阈值）的程序时，用常量集中管理，便于一处修改、全程序生效。
变量声明与初始化：后续所有变量使用场景都要求先声明、必要时初始化，避免不确定值导致的错误。
数组声明与初始化：后续处理一组同类型数据（如整数序列、字符串）时，数组是基本容器；字符数组的两种初始化差异会延伸到字符串处理相关内容。
printf() 次数与排版约束：训练精确控制输出，后续实验报告、结果展示、菜单界面等都需要类似能力。

Lab03

🧩 核心概念

运算符优先级（Operator Precedence） — 决定表达式中不同运算符计算顺序的规则；当表达式含多种运算符时，用它判断先算谁后算谁（如 * 高于 +）。
结合性（Associativity） — 决定同一优先级运算符从左到右还是从右到左计算；当多个同优先级运算符连续出现时用它确定求值方向（如赋值运算符从右到左）。
类型转换（Type Casting） — 将一种数据类型的值显式转换为另一种数据类型的操作；用 (类型) 强制改变运算中的数据类型（如 (int)3.8）。
自增和自减运算符（Increment and Decrement Operators） — 对变量进行加 1 或减 1 操作的一元运算符（++、--）；只作用于单个变量，用于简化计数类操作。
后缀（Postfix） — 自增/自减运算符放在变量之后，先使用变量原值再改变其值；如 y++ 表示先用 y 再加 1。
前缀（Prefix） — 自增/自减运算符放在变量之前，先改变变量值再使用；如 ++y 表示先加 1 再用 y。
赋值运算符（Assignment Operators） — 用于简化赋值语句的复合运算符（+=、-=、*=、/=）；把 variable = variable op (expression) 简写为 variable op= expression。
逻辑运算符（Logical Operators） — 用于执行与（AND）、或（OR）、非（NOT）逻辑运算的符号（&&、||、!）；用于组合或取反条件表达式。
最小字段宽度（Minimum Field Width） — printf() 中 % 与转换字符之间的数字，指定输出占用的最少位数；用于控制输出对齐与格式。
精度（Precision） — %f 转换中可指定的显示位数，控制浮点数小数点后显示多少位；用于格式化浮点输出。
一元运算符（Unary Operator） — 只作用于一个操作数的运算符；自增/自减即属此类，因此只能作用于变量而非变量组合。
#define 指令（#define Directive） — 预处理指令，用于定义常量（如 SECONDS_PER_HOUR、MINUTES_PER_HOUR）；在编译前进行文本替换，用于给常量命名。
ASCII 码（ASCII Code） — 字符与整数之间的编码对应关系（如 'A' 为 65）；用于理解字符参与运算时的数值行为。

🔗 概念之间的关系

运算符优先级与结合性共同决定表达式的求值顺序：优先级先决定「谁先算」，同优先级时再由结合性决定「从左还是从右」，二者缺一不可。
类型转换依赖运算符优先级才能正确书写：如 (int)3.8 + 3.3 与 (int)(3.8 + 3.3) 结果不同，强制转换符的优先级高于算术运算符。
自增/自减运算符是一元运算符，其优先级仅次于括号 ()，高于乘除；因此 xy++ 等价于 (x)(y++)。
前缀与后缀是自增/自减运算符的两种位置形式，位置不同导致「先改变还是先使用」的语义差异，是同一运算符的两种特例。
赋值运算符是普通赋值 = 的推广：variable op= expression 等价于 variable = variable op (expression)，本质是把二元运算与赋值合并。
逻辑运算符与运算符优先级配合使用：&&、||、! 各有优先级，且 ! 为一元运算符，需按优先级规则判断复合条件的求值顺序。

⬅️ 承接前面的知识

用到 Lab01 的结论：用 VSCode + 编译器创建、编译、运行 C/C++ 程序，以及设置断点调试——本讲每个 Exercise 都要求「先预测再编译运行」，正是 Lab01 工作流的延续。
用到 Lecture02 的结论：#include <stdio.h>、int main()、printf() 等第一个 C 程序的结构——Exercise 1 创建第一个 .cpp 文件即建立在此之上。
用到 Lecture02 的结论：预处理指令 #include 与 #define——Exercise 3 用 #define 定义 SECONDS_PER_HOUR 和 MINUTES_PER_HOUR。
用到 Lecture02 的结论：C 语言数据类型（int、double）与变量/常量——Exercise 4、5、14 中所有变量均声明为 int 或 double。
用到 Lecture02 的结论：字符与字符串（char、数组、字符串）——Exercise 12「Playing with strings」直接依赖此内容。
用到 Lecture02 的结论：基本 I/O 函数 printf() 及其格式说明符——Exercise 7 讨论 %d 的最小字段宽度与 %f 的精度。

➡️ 后面会怎么用

运算符优先级与结合性是后续所有表达式、条件判断、循环控制语句正确书写的基础，任何复杂表达式都依赖这两条规则。
类型转换在后续涉及整数与浮点混合运算、指针与地址、函数返回值类型匹配时反复使用。
自增/自减运算符是后续 for、while 循环中计数器更新的标准写法，也是理解数组下标遍历的前提。
赋值运算符的复合形式在后续循环累加、累乘、状态更新中大量出现。
逻辑运算符是后续 if、while、for 中构造复合条件的核心工具，直接支撑分支与循环逻辑。
最小字段宽度与精度在后续格式化输出表格、对齐数据、打印浮点结果时用于控制显示效果。

Lab04

🧩 核心概念

分支流控制语句（branching flow control statements） — 用于控制程序执行流程的语句，本讲特指 if/else 和 switch；当程序需要根据条件选择不同执行路径时使用。
循环（loops） — 用于重复执行代码块的语句，本讲包括 while、do while 和 for；当同一段逻辑需要反复执行时使用。
关系运算符（relational operators） — 用于比较两个值的运算符（如 <、>、== 等）；用来产生布尔结果，作为分支或循环的判断条件。
逻辑运算符（logical operators） — 用于组合或修改布尔表达式的运算符（如 &&、||、!）；当判断条件需要由多个关系表达式复合而成时使用。
if 语句（if statement） — 最基本的单分支控制语句；当只有一个条件需要判断、条件成立时执行对应代码块时使用（Exercise 1）。
if-else 语句（if-else statement） — 双分支控制语句；当条件成立与不成立需要分别执行不同代码块时使用（Exercise 1、Exercise 7）。
switch 语句（switch statement） — 多分支选择语句；当一个表达式的多个离散取值需要分别对应不同执行路径时使用（Exercise 1）。
条件表达式（conditional expressions） — 使用三元运算符 ? : 或 if-else 结构来表示条件赋值的表达式；用于把简单的二选一逻辑写成一行（Exercise 2）。
平方根（square root） — 数学运算，通过 sqrt() 函数计算给定非负实数的平方根；需包含 math.h 头文件，负数不被接受（Exercise 4）。
嵌套循环（nested loops） — 在一个循环内部包含另一个循环的编程结构；用于处理二维或需要多层重复的场景（Exercise 6）。
取余运算符（remainder operator） — 用 % 表示，用于计算两个数相除后的余数；常用来判断奇偶性（Exercise 7）。
while 循环（while loop） — 先判断条件、后执行循环体的循环；当循环次数不确定、依赖条件控制时使用（Exercise 5）。
for 循环（for loop） — 将初始化、条件判断、更新集中在一处的循环；当循环次数明确或需要计数控制时使用（Exercise 5、Exercise 6）。
do while 循环（do while loop） — 先执行循环体、后判断条件的循环；当循环体至少需要执行一次时使用（本讲第 1 页提及，与 while、for 并列）。

🔗 概念之间的关系

关系运算符和逻辑运算符是分支流控制语句与循环的判断基础：if/else、switch、while、for 的条件表达式都由它们构成。
if 语句是if-else 语句的特例：if-else 在 if 的基础上增加了条件不成立时的分支。
switch 语句可视为if-else 多分支的等价推广：当判断对象是同一个表达式的多个离散取值时，switch 比链式 if-else 更清晰。
条件表达式是if-else 语句的表达式化形式：z=(x<y)? x:y; 与 if(x<y) z=x; else z=y; 等价，前者适合简单二选一赋值。
while 循环与 for 循环可互相改写：for 把初始化、条件、更新集中书写，while 把三者分散在循环外与循环体内，二者在计数循环场景下等价。
嵌套循环是循环的组合形式：外层循环每执行一次，内层循环完整执行一轮，for 嵌套常用于打印二维图形（如 Exercise 6 的三角形）。

⬅️ 承接前面的知识

用到 Lecture 02 的 #include 预处理指令与 printf 基本输出：Exercise 4 要求 #include <math.h>，各练习均需用 printf 输出结果。
用到 Lecture 02 的变量与常量、数据类型：Exercise 3 的 depth、Celsius、Fahrenheit 均为变量，Exercise 5 的平方计算涉及数值类型。
用到 Lecture 03 的基本运算符（+、-、*、/）：Exercise 3 的温度公式 Celsius = 10 × depth + 20 与 Fahrenheit = 1.8 × Celsius + 32 直接使用四则运算。
用到 Lecture 03 的赋值运算符：Exercise 2 的 z=(x<y)? x:y; 与 Exercise 3 的公式计算均为赋值操作。
用到 Lecture 03 的 if … else … 与关系运算、逻辑运算：本讲 Exercise 1、Exercise 7 在此基础上展开分支与奇偶判断。
用到 Lab03 的 #define 定义常量：Exercise 3 的温度公式中常量定义方式与 Lab03 Exercise 3 一致。

➡️ 后面会怎么用

分支与循环是后续所有算法实现的控制骨架：排序、查找、递归、迭代等都需要 if/else、switch、while、for 组合。
嵌套循环是二维数组遍历、矩阵运算、图形打印的基础，后续处理二维数据结构时反复使用。
条件表达式在后续函数返回值、宏定义、简洁赋值场景中继续出现，是 C/C++ 代码风格的一部分。
sqrt() 与 math.h 是后续调用标准库数学函数的入口，后续会用到 pow()、fabs() 等同类函数。
取余运算符 % 在后续哈希、循环队列、进制转换、奇偶/整除判断中反复使用。
while 与 for 的等价改写能力为后续学习迭代器、范围 for（C++）以及算法复杂度分析打基础。

Lecture01

🧩 核心概念

迟交政策（Late Submission Policy） — 规定学生晚交作业时，根据晚交天数和原始分数 x 进行扣分或记零分的规则；周末和公共假日不计入迟交天数。
模块负责人（Module Leader） — 负责处理学生对评分异议的最终决策人，其决定为最终决定；学生有一周时间提出异议。
抄袭（Plagiarism） — 完全不可原谅的学术不端行为，包括提交相同或高度相似的报告，将面临零分及上报 Registry 记录。
共谋（Collusion） — 绝对禁止的学术不端行为，与抄袭并列，指学生之间未经允许的合作。
学术不端行为工作组（Academic Misconduct Working Group） — 负责处理严重作弊案件的学校官方机构。
学习成果（Learning Outcomes） — 模块目标中明确列出的，学生完成课程后应掌握的知识与技能，包括软件开发过程、C/C++ 编码、调试、测试、文档编写及面向对象设计。
输入设备（Input Devices） — 用于向计算机系统输入信息的硬件设备，如键盘、鼠标、扫描仪、网络摄像头。
输出设备（Output Devices） — 用于将计算机处理后的信息呈现给用户的硬件设备，如显示器、打印机、扬声器、耳机。
存储设备（Storage Devices） — 用于存储数据和信息的硬件设备，如 USB 闪存驱动器、光盘驱动器。
硬件（Hardware） — 用于执行必要计算的设备，包括中央处理器（CPU）、显示器、硬盘驱动器、存储卡、键盘、鼠标等。
软件（Software） — 一组指示计算机执行特定计算、操作或控制的指令，由程序模块组成，使我们能够用计算机解决问题。
操作系统（Operating System） — 一组特殊的计算机程序，控制用户与计算机硬件之间的交互并管理所有计算机资源，如 UNIX、Linux、DOS、Windows、MacOS。
应用软件（Application Software） — 为帮助计算机用户完成各种任务而开发的软件，如 Adobe Photoshop、Microsoft Office、Matlab、AutoCAD，甚至数字游戏。
编程（Programming） — 用程序员和计算机都能理解的语言告诉计算机做我们想做的事情。
集成开发环境（Integrated Development Environment, IDE） — 一种用于提供程序开发环境的应用程序，包括项目管理、代码编辑器（高亮语法错误）、调试支持、构建/运行任务等功能。
编译器（Compiler） — 一种计算机程序，将用某种编程语言写成的源代码（原始语言）转换成另一种编程语言（目标语言，如机器码）。
翻译器（Translator） — 讲义中作为类比概念出现，指将一种语言（如法语）转换为另一种语言（如中文）的工具，用于辅助理解编译器的作用。
Bug — 计算机程序或系统中存在的错误、缺陷或故障，该词源于历史上在计算机继电器中发现飞蛾的真实事件。
明确需求（Specify） — 软件开发流程的第一步，指确定和定义问题的需求与规格。
分析（Analyse） — 软件开发流程的第二步，指对已明确的问题进行深入分析和理解。
设计（Design） — 软件开发流程的第三步，指设计用于解决问题的算法或系统架构。
实现（Implement） — 软件开发流程的第四步，指将设计好的算法转化为实际的程序代码。
测试与验证（Test and verify） — 软件开发流程的第五步，指对完成的程序进行测试以确认其正确性和功能。
交付（Deliver） — 软件开发流程的第六步，指将完成的软件产品交付给客户或最终用户。
维护（Maintain） — 软件开发流程的第七步，指对已交付的程序进行后续的维护和更新。
算法（Algorithm） — 为解决某个问题而开发的一系列步骤；编写算法通常是问题求解过程中最困难的部分。
流程图（Flowchart） — 在算法设计中被推荐使用的一种图形化表示方法。
英里（MILE） — 用于与千米进行长度单位换算的英制长度单位。
千米（Kilo-Meter） — 用于与英里进行长度单位换算的公制长度单位。
语法错误（Syntax errors） — 代码违反了一条或多条 C 语言语法规则时发生的错误。
运行时错误（Run-time errors） — 程序指示计算机执行非法操作时发生的错误，如除以零或访问受限内存位置。
逻辑错误（Logic errors） — 程序遵循了有缺陷的算法时发生的错误。
十进制数字系统（Decimal number system） — 以 10 为基数的数字系统，使用数字 0 到 9。
数字信号（Digital signals） — 由两个离散状态（开/关）组成的信号。
位（Bit） — 源自 binary digit，是计算机中最小的数据/信息单位，表示 0 或 1。
字节（Byte） — 计算机中信息存储的基本测量单位，通常由 8 位组成，可表示 2^8 = 256 种状态。
八进制数字系统（Octal number system） — 以 8 为基数的数字系统，使用数字 0 到 7。
基数为 b 的计数系统（Number System of Base b） — 一种用基数 b 的幂次展开来表示数字的通用计数系统，形式为 a_n·b^n + a_{n-1}·b^{n-1} + … + a_0·b^0。
十进制系统（Decimal System） — 以 10 为基数的计数系统，比二进制更紧凑，更便于人类使用。
二进制系统（Binary System） — 以 2 为基数的计数系统，因计算机采用双态（开/关）技术而更适合计算机。
十六进制系统（Hexadecimal System） — 以 16 为基数的计数系统，每个十六进制数字恰好代表 4 个二进制位；一个字节 = 8 位二进制数 = 2 个十六进制数字。
低级语言（Low-Level Languages） — 针对特定机器架构的编程语言，如汇编语言和机器语言，更接近机器而非问题本身。
高级语言（High-level Languages） — 用于编写独立于执行它们的机器架构的程序的编程语言，如 Fortran、Pascal、C/C++、Ruby、Python 等。
面向对象编程（Object-Oriented Programming / OOP） — 一种引入到 C 语言中的编程特性，提供类以及抽象、封装、模块化、继承和多态等特性。
类（class） — 提供面向对象编程语言中常见特性的结构。
抽象（abstraction） — 面向对象编程语言中常见的特性之一。
封装（encapsulation） — 面向对象编程语言中常见的特性之一。
模块化（modularity） — 面向对象编程语言中常见的特性之一。
继承（inheritance） — 面向对象编程语言中常见的特性之一。
多态（polymorphism） — 面向对象编程语言中常见的特性之一。
对象（Object） — 一种由数据字段和方法及其交互组成的数据结构，用于设计应用程序和计算机程序。
面向过程编程（Procedure Oriented Programming） — 与 OOP 相对的编程范式，如 C、Basic 等。

🔗 概念之间的关系

硬件与软件共同构成计算机系统的两大类别；软件中的操作系统管理硬件资源，应用软件运行在操作系统之上，三者形成「硬件 → 操作系统 → 应用软件」的层级依赖。
编程是软件开发流程的核心活动；软件开发流程从明确需求到维护的七个步骤中，设计阶段产出算法，实现阶段将算法转化为代码，测试与验证阶段检验代码正确性。
算法是软件开发流程中「设计」步骤的核心产物，流程图是设计算法的推荐工具；算法设计完成后才进入实现（编码）阶段。
语法错误、运行时错误、逻辑错误是三类编程错误，分别对应代码违反语法规则、执行非法操作、算法本身有缺陷三种不同层面的问题。
数字信号（开/关两态）是二进制系统的物理基础；位是二进制的最小单位，字节由 8 位组成；十进制系统、二进制系统、八进制系统、十六进制系统都是基数为 b 的计数系统的特例，其中十六进制因每个数字恰好对应 4 个二进制位而成为二进制的便捷简写。
低级语言（汇编、机器语言）与高级语言（C/C++、Python 等）是编程语言的两大层级；C++ 是从 C 发展而来，引入了面向对象编程特性，包括类以及抽象、封装、模块化、继承、多态，其核心是对象；面向过程编程（如 C）与面向对象编程（如 C++）是两种不同的编程范式。

⬅️ 承接前面的知识

本讲是 RBE104TC 的第一讲，没有前置讲次。本讲为后续内容打基础的方式如下：

软件开发流程（Specify → Analyse → Design → Implement → Test → Deliver → Maintain）为后续所有编程实践提供方法论框架。
算法与流程图为后续学习具体算法设计（如排序、查找）奠定基础。
编程错误的分类（语法/运行时/逻辑）为后续调试（debugging）教学提供分类依据。
数字系统与进制转换为后续理解计算机内部数据表示（整数、浮点数、字符编码）奠定数学基础。
C/C++ 编程环境搭建（VS Code + MinGW/Xcode）为后续所有上机实验和课程作业提供工具基础。
C++ 与面向对象编程的引入为后续深入学习类、继承、多态等 OOP 特性做铺垫。

➡️ 后面会怎么用

软件开发流程将在后续课程中以具体项目形式反复实践，尤其是「设计算法 → 实现 → 测试」这一核心循环。
算法与流程图将在后续讲解具体算法（如排序、查找、递归）时作为标准设计工具使用。
三类编程错误将在后续调试实验中反复出现，学生需要能够区分并定位不同类型的错误。
数字系统与进制转换将在后续讲解数据类型（int、float、char）、位运算、内存表示时直接使用。
C/C++ 编程环境（VS Code + 编译器）将在整个模块的所有实验和课程作业中使用，且课程作业必须在 VS Code 中运行。
面向对象编程（类、抽象、封装、模块化、继承、多态）将在后续 C++ 教学中逐步展开，是模块学习成果中「object-oriented approach」的直接对应内容。
输入/输出/存储设备、硬件/软件、操作系统、应用软件等概念为理解计算机系统整体架构提供背景知识，后续编程实践中会间接涉及。

Lecture02

🧩 核心概念

预处理指令（Preprocessor directives） — 在程序被编译之前修改程序文本的命令，以 # 号开头；用于在编译前对源码做文本层面的处理。
头文件（Header file） — 由他人（或我们自己）预先定义好的文件，像工具箱一样为程序员提供有用的工具；用 #include 引入，避免重复从零编写函数。
标准库头文件（Standard header file） — 使用尖括号 < > 包含的头文件，通常由系统或编译器提供，如 <stdio.h>。
用户自定义头文件（User-defined header file） — 使用双引号 " " 包含的头文件，通常由程序员自己编写，如 "Myheader.h"。
宏定义（#define directive） — 通知预处理器将标识符 NAME 的每次使用替换为定义值的指令，语法为 #define NAME value。
标识符（Identifier） — 在 #define 中用来代表某个值的名字，程序语句不能改变其关联的值。
文本替换（Text replacement） — #define 指令通过替换指定文本来简化代码的过程；编译器实际看到的是替换后的文本。
main() 函数（The main() Function） — C 程序的入口函数，基本语法结构为 int main(void) { ... }；每个 C 程序中有且仅有一个。
软件入口（software entrance） — 指 C 程序从 main 函数开始执行这一特性。
软件出口（software exit） — 指 C 程序在 main 函数结束时终止这一特性。
整数（integer） — int main() 中 main 函数在执行完毕时返回给操作系统的值类型。
标志（flag） — 用于表明程序是否成功执行的返回值（如 return 0）；工程师借此判断程序执行状态。
数据类型（Data Types） — C 语言中用于定义数据种类的概念，常见示例包括 int、float、double、char、string。
短整型（short） — 占用 2 字节、取值范围为 -32,768 到 32,767 的整数数据类型。
无符号短整型（unsigned short） — 占用 2 字节、取值范围为 0 到 65535 的正整数数据类型。
整型（int） — 占用 2 或 4 字节的整数数据类型。
无符号整型（unsigned int） — 占用 2 或 4 字节的正整数数据类型。
长整型（long） — 占用 4 字节、取值范围为 -2,147,483,648 到 2,147,483,647 的整数数据类型。
无符号长整型（unsigned long） — 占用 4 字节、取值范围为 0 到 4,294,967,295 的正整数数据类型。
单精度实数（float） — 占用 4 字节、精度为 6 位数字的实数数据类型。
双精度实数（double） — 占用 8 字节、精度为 10 位数字的实数数据类型。
长双精度实数（long double） — 占用 12 字节、精度为 10 位数字的实数数据类型。
字符（char） — 占用 1 字节、取值范围为 -128 到 127 的数据类型；用于存储单个字符。
无符号字符（unsigned char） — 占用 1 字节、取值范围为 0 到 255 的正字符数据类型。
C 语言字符集（Character Set in C） — C 语言中字符的分类集合，包括字母（大写 A…Z、小写 a…z）、数字（0…9）、特殊字符（如 + = - / ! : ; 等）和空白字符（空格、制表符、回车）。
ASCII（American Standard Code for Information Interchange） — 美国信息交换标准代码，一种用 7 位二进制数表示字符的编码标准，由 ANSI 于 1963 年提出、1968 年定稿；共 2⁸=256 个编码。
ASCII Table（ASCII Table） — ASCII 码表，列出了十进制、十六进制、二进制、八进制数值与对应字符的对照表；展示了数字、大写字母、小写字母的 ASCII 码值范围及其顺序关系。
分号（Semicolon） — ; 在 C 语言中表示一条语句的结束。
逗号（Comma） — , 在 C 语言中表示表达式的分隔符。
冒号（Colon） — : 在 C 语言中表示 switch 分支的标识。
花括号（Brace Bracket） — {} 在 C 语言中表示代码块的标记。
圆括号（Bracket） — () 在 C 语言中用于函数参数或表达式分组。
方括号（Square Bracket） — [] 在 C 语言中用于定义数组或索引数组元素。
百分号（Percentage） — % 在 C 语言中表示格式化符号或求余运算。
C 语言关键字（Keywords in C） — 具有固定含义、必须小写、作为基本构建块的保留字；C 语言中约有 32 个关键字，如 break、case、char、const、do、else、float、for、if、int、return、sizeof、static、struct、typedef、union、void、while 等。
C 标准库函数（Standard Library Functions in C） — 由标准库提供、具有特殊含义但可被程序员重定义（不推荐）的函数；如 stdio.h 中的 printf、scanf，iostream 中的 cin、cout，math.h 中的 sin、cos、tan、log，time.h 中的 time 等。
用户自定义标识符（User-defined identifiers） — 由程序员定义的变量、函数和数组的名称；需遵循 C 语言命名规则。
标识符命名规则（Identifier naming rules） — 规定标识符首字符必须是字母或下划线，只能包含字母、数字、下划线，不能包含空格，不能以数字开头，不应超过 31 个字符；连字符 - 不可用，下划线 _ 可用。
描述性名称（Descriptive name） — 一种良好的变量命名习惯，要求名称能清晰表达变量或函数的用途；如 student_avg_score、StudentAvgScore（驼峰命名，用于类/结构体）、studentAvgScore（用于变量）。
变量（Variable） — 用于存储数据值的数据名称，在程序执行期间可以取不同的值，并与数据类型相关联；是一个命名的内存位置，用于存储（二进制）值，使用前必须先声明。
变量声明（Variable declarations） — 告诉编译器变量名并指定该变量将持有的数据类型；语法为 data_type name，如 int number;、char name;、double sum, total;。
常量（Constant） — 在 C 程序执行期间其值不能被改变的固定值；使用关键字 const 声明，如 const int a=7;、const float pi=3.141;、const char msg[]="warning";。
枚举常量（Enumeration Constant） — 一种常量，其第一个名称默认值为 0，后续名称依次递增；如 enum boolean {No, Yes}; 等价于 No=0、Yes=1；也可显式指定值，如 enum months {JAN=1, FEB, MAR, ...};。
变量初始化（Variable Initialization） — 在声明变量的同时为其赋初值，如 int a = 3;；也可先声明后赋值，如 float x; x = 3.2;。
字符（Character） — C 语言中由可打印或不可打印字符组成的数据，通常以 8 位（1 字节）整数存储；如 'A'、'2'、'#' 等。
数组（Array） — 相同类型数据元素的有序序列，即一排连续的内存单元；由固定数量、相同类型元素组成的连续存储结构，通过下标访问。
数组元素（array element） — 数组中通过索引（下标）访问的单个存储单元。
数组边界（array bounds） — 数组有效下标的范围，从 0 到元素个数减 1，超出该范围会引发越界错误。
越界访问（out-of-bounds access） — 访问数组范围之外的元素，编译器通常不报错但属于未定义行为；强烈建议不要这样做。
数组初始化（initialisation of the array） — 在声明数组时直接为其元素赋初值，此时可省略数组维度；如 int scores[]={1,2,3};、char name[]="Mike";。
字符串（string） — 以空字符 '\0' 结尾的字符数组。
空字符（NULL character / '\0'） — 用于标记字符串结束的特殊字符。
字符串库函数（string library functions） — 包含在 string.h 头文件中，用于处理字符串的标准函数集合；如 strlen(str) 求长度、strcmp(str1, str2) 逐字符比较、strcpy(str1, str2) 复制字符串。
C 风格字符串（C-style string） — 将字符序列视为以空字符（'\0'）结尾的 char 类型数组；如 char greeting[6] = {'H','e','l','l','o','\0'};。
C++ 风格字符串（C++-style string） — C++ 标准库引入的 string 类，用于处理字符序列的替代方式；需包含 <string> 头文件。
string 类（string class） — C++ 标准库中用于处理字符序列的类，需包含 <string> 头文件；声明方式类似普通变量，如 string str1;、string str2 = "Hello";、string str3("World");。
命名空间（namespace） — 用于区分不同工程师可能创建的同名函数的机制，例如标准头文件的命名空间是 std；如 std::cout、std::cin、std::string、std::endl。
C 风格注释（C style comment） — 使用 / / 进行注释，C 编译器会忽略注释行。
C++ 风格注释（C++ style comment） — 使用 // 进行注释，C/C++ 中可混合使用。
语句（statement） — 对计算机的指令，以分号（;）结尾，按从上到下的顺序执行；空白字符会被忽略。
赋值运算符（assignment operator） — 等号（=）在赋值语句中被称为赋值运算符；表达式先求值再赋给变量。
数学表达式（Math expressions） — 如 a、a + b、a % 10、a + c / d 等；通常只能出现在赋值语句右侧；运算符有优先级，* / 高于 + -。
标准输入函数（Standard input functions） — 用于从标准输入设备读取数据的函数类别，包括 getchar()（字符）、scanf()（各种类型）、gets()（字符串）。
标准输出函数（Standard output functions） — 用于向标准输出设备写入数据的函数类别，包括 putchar()（字符）、printf()（各种类型）、puts()（字符串）。
格式说明符（format specifiers） — printf() 中用于指定输出数据类型的占位符，如 %d（int）、%f（float）、%lf（double）、%c（char）、%s（string）。
printf() 对齐与精度控制 — %m.nf 表示右对齐（左侧补空格），%-m.nf 表示左对齐（右侧补空格）；n 表示小数点后位数；若实际整数位大于 m 则保留原位数。
标准输入设备（standard input device stdin） — scanf() 读取数据的来源，通常指键盘。
取地址符（ampersand (&)） — 在 scanf() 中用于指定变量的内存地址的符号；语法为 scanf("format specifier", &variable);。
标准输入（Standard Input） — 通常指键盘，在 C++ 中通过 cin 流对象和提取运算符 >> 来处理。
提取运算符（Extraction Operator） — C++ 中用于从输入流（如 cin）中提取数据的运算符 >>；后面必须跟存储数据的变量。
标准输出（Standard Output） — 默认指屏幕（显示器），在 C++ 中通过 cout 流对象和插入运算符 << 来访问。
插入运算符（Insertion Operator） — C++ 中用于向输出流（如 cout）插入数据的运算符 <<；可在一条语句中多次使用。
getline() — C++ 中用于读取整行字符串的函数，如 getline(cin, myFullName);。
endl — C++ 中的换行操纵符，如 cout << "Hello" << endl;。

🔗 概念之间的关系

预处理指令是 #include 和 #define 的上位概念：预处理指令在编译前修改程序文本，#include（引入头文件）和 #define（宏定义/文本替换）是两种最常用的预处理指令；#define 通过文本替换机制简化代码，而 #include 通过引入头文件复用已有工具。
main() 函数是 C 程序的入口和出口：每个 C 程序有且仅有一个 main 函数，程序从 main 开始执行（软件入口），到 main 结束终止（软件出口）；main 的返回值类型是 int，返回 0 作为标志表示程序成功执行。
数据类型是变量和常量的基础：变量声明必须指定数据类型（如 int、float、double、char），常量（const）也必须指定具体数据类型；数据类型决定了变量的取值范围（如 short 占 2 字节、int 占 2 或 4 字节、float 占 4 字节、double 占 8 字节）和可进行的操作。
字符是数组和字符串的构成单元：字符（char）以 8 位整数存储；数组是相同类型元素的有序序列；字符串是以空字符 '\0' 结尾的字符数组，即字符串是字符数组的特例。
C 风格字符串与 C++ 风格字符串是同一问题的两种解决方案：C 风格字符串用 char 数组 + '\0' 表示，C++ 风格字符串用 string 类表示；string 类属于 std 命名空间，需要 #include <string> 和 using namespace std;。
标准 I/O 函数依赖格式说明符和取地址符：printf() 使用格式说明符（%d、%f、%lf、%c、%s）指定输出类型；scanf() 使用相同的格式说明符，并额外需要取地址符 & 来指定变量的内存地址；C++ 的 cin/cout 用提取运算符 >> 和插入运算符 << 替代了 C 的 scanf/printf。

⬅️ 承接前面的知识

承接 Lab01：Lab01 中学习的 VSCode 编译、运行和调试 C 代码的操作，是本讲所有代码示例（如第一个 C 程序、printf/scanf 示例）能够实际运行和验证的基础。
承接 Lecture01：Lecture01 中介绍的课程概况、教师信息和 C/C++ 编程语言的基本定位，为本讲正式进入 C/C++ 编程基础（第一个 C 程序、数据类型、变量常量等）提供了背景。
本讲为后续内容打基础：本讲的数据类型（int、float、double、char）、变量声明与初始化、数组与字符串、标准 I/O 函数（printf/scanf、cin/cout）是后续所有 C/C++ 编程内容的基础；后续课程将在此基础上展开更复杂的程序结构、函数定义、指针、结构体等内容。

➡️ 后面会怎么用

数据类型与变量：后续课程将深入讲解类型转换、类型修饰符（如 signed/unsigned）、作用域与生命周期等；这些是编写任何 C/C++ 程序的基础。
数组与字符串：后续将学习多维数组、字符串处理算法、动态内存分配（如 malloc/free）以及 C++ 的 string 类更多方法；字符串处理是文本处理、数据解析等应用的核心。
标准 I/O 函数：printf/scanf 的格式说明符和对齐控制将在后续的格式化输出、文件读写（fprintf/fscanf）中进一步扩展；cin/cout 的流操作将在 C++ 面向对象编程中与类、运算符重载等结合。
预处理指令与宏：后续将学习条件编译（#ifdef/#ifndef）、头文件保护（#ifndef/#define/#endif）、带参数的宏等；这些是大型项目组织代码的必备工具。
命名空间：后续 C++ 课程中将深入讲解命名空间的定义、嵌套、别名以及 using 声明的各种用法；这是 C++ 标准库使用和大型项目开发的基础。
注释与编码风格：后续课程和实验中将持续强调良好的编码风格（描述性命名、适当注释、语句结构清晰），这直接影响代码的可读性和可维护性。

Lecture03

🧩 核心概念

基本运算（Basic Operations） — C 语言用标准符号实现基本数学功能的运算符：乘法 *、除法 /、减法 -、加法 +；常量和变量都可以参与这些运算。
取模运算符（Modulo Operator，%） — 返回除法余数的运算符；5/3 得 1，5%3 得 2。用于取余、判断整除等场景。
绑定强度 / 优先级（Bindings / Precedence） — 描述不同运算执行先后顺序的规则，如乘法 * 强于加法 +；建议用括号 () 确保期望的运算顺序。
赋值运算符（Assignment Operator） — 用 = 把值赋给变量；支持简写形式 var op= value，如 i += 2 等价于 i = i + 2，-=、*=、/= 同理。
一元运算符（Unary Operators） — 只作用于一个变量的运算符，包括取正 +（a = +3）、取负 -（b = -a）和逻辑非 !（!c，真变假、假变真）。
自增运算符（Increment Operator，++） — 使变量值加 1 的运算符，写作 ++；i++ 等价于 i = i + 1。
自减运算符（Decrement Operator，--） — 使变量值减 1 的运算符，写作 --；i-- 等价于 i = i - 1。
前置操作（Pre Operation） — 运算符写在变量之前，如 ++i、--i；先执行自增/自减，再使用变量的值。
后置操作（Post Operation） — 运算符写在变量之后，如 i++、i--；先使用变量的值，再执行自增/自减。
关系运算（Relational Operations） — 用于比较表达式的运算，结果为真或假。
关系运算符（Relational Operators） — 比较两个值大小或相等关系的运算符：<、<=、!=、==、>、>=。
if … else … 语句（if … else … statement） — 根据条件表达式的真假，选择执行两个代码块之一的条件控制语句；常与关系运算配合做二选一判断。
逻辑运算（Logical Operations） — 用于组合或反转布尔表达式的运算，处理无法用单一数值分类的复杂条件（如「青少年」定义为年龄介于 14 和 35 之间）。
逻辑与（Logical "and"，&&） — 当且仅当两个操作数都为真时结果才为真。
逻辑或（Logical "or"，||） — 当至少一个操作数为真时结果就为真。
逻辑非（Logical "Not"，!） — 对单个操作数取反的逻辑运算，仍是「一元运算符」。
逻辑运算符优先级（Logical Operators with Precedence） — 在混合逻辑表达式中，&& 的优先级高于 ||，因此先算 && 再算 ||；如 a || b && c 等价于 a || (b && c)。
运算符优先级（Operator Precedence） — 决定表达式中不同运算符计算顺序的规则；从低到高依次为：赋值 → 逻辑或 → 逻辑与 → 关系 → 算术 → 一元 → 括号。
运算符的一般优先级（General Priorities of Operators） — 对各类运算符优先级的系统性总结，从高到低：括号 () → 一元 ++ -- ! → 算术 - + / → 关系 < > <= >= → 逻辑 || && → 赋值 = += =；再次强调「始终用 () 确保期望的运算顺序」。
数据类型（Data Type） — 定义数据的种类，决定其存储方式和占用字节数：int（2 或 4 字节）、float（4 字节）、double（8 字节）、char（1 字节，如 '0'=48、'A'=65）。
整数除法（Integer Division） — 两个整数相除时，结果被截断为整数的运算规则；如 24/10 得 int(2.4) = 2。
类型转换（Type Conversion） — 将一种数据类型改变为另一种数据类型的过程，分为隐式转换和显式转换两种。
隐式转换（Implicit Conversion） — 当表达式中混合不同数据类型时，编译器自动将较低精度类型转换为较高精度类型再运算的机制；规则是「先算表达式，再赋值」。
显式转换（Explicit Conversion） — 通过强制类型转换运算符强制指定数据类型，从而忽略隐式转换规则的方法。
强制类型转换运算符（Cast Operator） — 用于显式转换数据类型，如 (int)1.2；不改变变量中存储的值，仅改变计算时的类型；注意它是向下取整（floor），不是四舍五入。
函数（Function） — 数学中表示从变量到值的映射关系，包含参数（arguments）和返回值（return value）；C 编程中函数类似数学函数，接收变量作为参数并可返回结果，但必须为每个变量指定数据类型。

🔗 概念之间的关系

基本运算 → 取模运算符：取模 % 是基本运算的补充，/ 给出商的整数部分，% 给出余数，二者配合才能完整描述整数除法。
基本运算 → 绑定强度/优先级 → 运算符优先级：绑定强度先解释「乘法强于加法」这一局部规则，再推广为覆盖赋值、逻辑、关系、算术、一元、括号的完整优先级体系。
一元运算符 → 自增/自减 → 前置/后置操作：自增 ++、自减 -- 是一元运算符的特例；前置与后置是它们的两种执行时机，区别在于「先改后用」还是「先用后改」。
关系运算 → if … else … → 逻辑运算：关系运算产生真假值供 if…else… 做二选一判断；当条件无法用单一比较表达（如 14 < age ≤ 35）时，就需要逻辑运算 &&、||、! 把多个关系表达式组合起来。
逻辑运算 → 逻辑运算符优先级 → 运算符优先级：&& 高于 || 是逻辑运算内部的优先级规则，它是整个运算符优先级体系中的一个层级。
数据类型 → 整数除法 → 隐式转换 → 显式转换：不同数据类型参与运算引出整数除法截断问题，编译器按「低精度转高精度」自动处理即隐式转换；当隐式规则难以记忆或需强制指定时，用 cast 运算符做显式转换，显式转换是隐式转换的替代手段。
函数：把前面所有运算符组合成可复用的计算单元，是运算符的封装与推广。

⬅️ 承接前面的知识

用到《Lecture02》的「Your First C Program」结构：本讲所有示例都沿用 #include <stdio.h>、int main() { … return 0; } 的框架。
用到《Lecture02》的预处理指令 #include 与 #define：第 17 页用 #define LEAGLAGE 18 定义常量，第 46 页用 #define PI 3.1416。
用到《Lecture02》的变量与常量概念：第 4 页示例中 const int b=7 演示常量不可被修改（b = a-1 报错）。
用到《Lecture02》的基本 I/O 函数：printf 与 scanf（如 scanf("%d",&your_age)）贯穿全讲示例。
用到《Lecture02》的数据类型与字符串/字符知识：第 31 页的 int、float、double、char 表格承接第 2 讲的数据类型介绍，并指出 char 本质是小整数。
用到《Lab01》《Lab02-1》的编译运行与调试流程：示例代码需在 VSCode 中编译运行验证。

➡️ 后面会怎么用

运算符与优先级是后续所有表达式求值、条件判断、循环控制（while、for）的基础，写错优先级是常见 bug 来源。
前置/后置自增自减在后续循环（如 for(i=0;i<n;i++)）和指针运算中反复出现，理解「先改后用/先用后改」是关键。
关系运算与 if…else… 是后续分支结构（switch、嵌套 if）和循环条件的前置知识。
逻辑运算与短路求值是后续复杂条件判断、循环终止条件的基础。
类型转换（隐式/显式） 在后续函数传参、指针、数组下标、浮点与整数混合计算中持续使用；cast 运算符在内存操作、位运算中尤为重要。
函数是本讲末尾引出的新主题，后续将展开函数的定义、声明、参数传递、返回值、作用域与递归等内容，是模块化编程的核心。

Lecture04

🧩 核心概念

基本运算符（Basic Operations） — C 提供的标准数学符号运算符：乘法 *、除法 /、减法 -、加法 +；用于对常量和变量进行基本数学运算。
取模运算符（Modulo Operators，%） — 返回除法运算余数的运算符；用于求余数，如 5%3 得 2。
绑定强度/优先级（Bindings / Precedence） — 不同运算符在表达式中具有不同的结合强度，例如乘法强于加法；用于决定表达式的计算顺序，建议用括号确保期望结果。
赋值运算符（Assignment Operator） — 用于给变量赋值的运算符，包含简写形式 +=、-=、*=、/=；简写形式为 var op= value。
一元运算符（Unary operators） — 仅包含一个变量的运算符，包括取正 +、取负 - 和逻辑非 !；用于对单个变量进行操作。
算术运算符（Arithmetic operators） — 用于执行基本数学运算的运算符，如加法 + 和减法 -。
自增运算符（Increment operator，++） — 将变量的值增加 1 的运算符；i++ 等价于 i = i + 1。
自减运算符（Decrement operator，--） — 将变量的值减少 1 的运算符；i-- 等价于 i = i - 1。
前置运算（Pre operation） — 运算符位于变量之前的运算，如 ++i 和 --i；先执行自增/自减，再使用变量值。
后置运算（Post operation） — 运算符位于变量之后的运算，如 i++ 和 i--；先使用变量值，再执行自增/自减。
关系运算（Relational operations） — 用于比较表达式的运算，包含 <、<=、!=、==、>、>= 等运算符。
赋值运算（Assignment operation） — 将值赋给变量的运算，使用单个等号 =；与关系运算 == 完全不同。
关系运算符（Relational Operators） — 用于比较两个值之间大小或相等关系的运算符，包括 <、<=、!=、==、>、>=。
if ... else ... 语句（if ... else ... statement） — 根据条件表达式的真假，选择执行两个不同代码块之一的条件控制语句。
逻辑操作（Logical Operations） — 将关系运算符与 if...else... 语句结合，用于处理具有多个复杂状态或范围判断的运算。
逻辑与（Logical "and"，&&） — 当且仅当两个操作数都为真时，结果才为真的逻辑运算符。
逻辑或（Logical "or"，||） — 只要两个操作数中有一个为真，结果就为真的逻辑运算符。
逻辑非（Logical "Not"，!） — 对单个操作数进行取反的逻辑运算符，属于一元运算符。
运算符优先级（Operator Precedence） — 决定表达式中不同运算符计算顺序的规则，通常算术运算符优先级高于关系运算符，关系运算符高于赋值运算符。
逻辑与运算符（Logical AND operator，&&） — 一种逻辑运算符，其优先级高于逻辑或运算符。
逻辑或运算符（Logical OR operator，||） — 一种逻辑运算符，其优先级低于逻辑与运算符。
优先级（Precedence） — 决定表达式中运算符计算顺序的规则。
括号（Parenthesis，()） — 在运算符优先级中拥有最高优先级的符号，用于强制改变运算顺序。
一元运算符（Unary Operators） — 作用于单个操作数的运算符，优先级仅次于括号。
算术运算符（Arithmetic Operators） — 用于执行基本数学运算的运算符，优先级低于关系运算符。
关系运算符（Relational Operators） — 用于比较两个值的运算符，优先级低于算术运算符。
赋值运算符（Assignment Operators） — 用于将值赋给变量的运算符，在所有运算符中优先级最低。
隐式转换（Implicit Conversion） — 当表达式中混合了不同数据类型时，编译器自动进行的类型转换。
显式转换（Explicit Conversion） — 程序员通过代码明确指定的类型转换。
类型转换（Type Conversion） — 将一种数据类型改变为另一种类型的过程。
字符型（char） — 一种本质上属于小整数值的数据类型，可用于数学运算。
强制类型转换运算符（cast operator） — 一种显式转换语法，用于强制将变量的数据类型转换为指定类型，且不改变变量中存储的原始值；注意它是向下取整（floor operation），不是四舍五入。
函数（function） — 在数学中表示从变量到值的映射关系，在 C 语言中类似，接受变量作为参数并可返回结果，但必须指定每个变量的数据类型。
函数语法（Syntax） — 定义 C 语言函数的标准格式，包含返回数据类型、函数名、参数列表（含参数数据类型）以及函数体。
圆柱体积函数（cylinder volume function） — 一个具体 C 语言函数示例，接收高度和半径作为参数，计算并返回圆柱体体积。
函数返回值（return value） — 函数执行完毕后返回给调用者的结果，其数据类型需与函数定义时声明的返回类型一致。

🔗 概念之间的关系

基本运算符是算术运算的基础，取模运算符（%） 是除法运算符 / 的补充——/ 给出商，% 给出余数，二者配合才能完整描述整数除法。
绑定强度/优先级决定了多个运算符共存时的计算顺序，它是运算符优先级这一总规则在基本运算层面的体现；括号是优先级最高的符号，可强制改变顺序。
赋值运算符的简写形式（+= 等）是「先运算再赋值」的语法糖，其本质依赖算术运算符；而赋值运算（=） 与关系运算（==） 是两种完全不同的操作，前者写值，后者比较值。
一元运算符包含取正、取负、逻辑非 !；其中 ! 同时属于逻辑运算符，说明逻辑非是一元运算与逻辑运算的交集。自增/自减运算符也是一元运算符，按位置分为前置运算和后置运算，二者执行时机不同。
关系运算符产生真假结果，是 if ... else ... 语句的条件来源；逻辑运算符（&&、||、!） 把多个关系表达式组合起来，用于处理逻辑操作中「多个复杂状态或范围判断」的情形，是关系运算在复杂条件下的推广。
类型转换分为隐式转换和显式转换：隐式转换在混合类型表达式或赋值时自动发生，显式转换通过强制类型转换运算符手动指定；函数的返回值类型必须与声明一致，这依赖类型转换规则来保证参数与返回值的数据类型匹配。

⬅️ 承接前面的知识

用到 Lecture02 的「预处理器指令 #include、#define」：本讲 #define LEAGLAGE 18、#define PI 3.1416 以及所有 #include <stdio.h> 均沿用该结论。
用到 Lecture02 的「基本 I/O 函数」：本讲 printf、scanf 的用法（如 scanf("%d",&your_age)、printf("The answer is: %f\n", answer)）直接承接第 2 讲的输入输出函数。
用到 Lecture02 的「数据类型（int、float、double、char）」：本讲第 31 页的数据类型表和第 33 页起的类型转换，全部建立在对这些类型存储方式的理解之上。
用到 Lecture02 的「变量与常量」：本讲 const int b=7 不可修改、int a=3+5 变量赋值等，沿用第 2 讲变量与常量的定义。
用到 Lecture03 之前 Lab03 的「#define 定义常量」：本讲 #define LEAGLAGE 18 与 Lab03 中用 #define 定义 SECONDS_PER_HOUR、MINUTES_PER_HOUR 的做法一致。

➡️ 后面会怎么用

运算符与优先级是后续所有表达式求值的基础，后续讲循环（for/while）条件、数组下标计算、指针运算时都会反复用到优先级与括号规则。
if ... else ... 与逻辑运算是后续分支结构、循环控制（如 while (i < n && flag)）的直接前提，也是实现复杂条件判断的标准工具。
类型转换（隐式/显式）在后续函数传参、数组与指针运算、浮点与整型混合计算中会频繁出现，尤其是强制类型转换在内存解释、指针类型转换中的应用。
函数是本讲末尾引出的核心概念，后续课程将围绕函数的定义、声明、参数传递（值传递/地址传递）、返回值、递归等展开，是模块化编程的起点。
自增/自减与前置/后置的区别在后续循环（如 for(i=0;i<n;i++)）和指针遍历中会直接影响程序正确性，是常见的易错点。

Lecture05

🧩 核心概念

函数（Function） — 执行特定任务的代码块；能执行操作（如 printf() 显示数据）或提供值（如 sqrt() 计算平方根）。在C语言中，模块（modules）就叫函数。
模块（Modules） — 计算机程序中用于解决现实问题、更小且易于管理的代码片段；在C语言中被称为函数。
高级抽象（High-level abstraction） — 允许我们轻松使用各种函数，而无需理解其内部复杂工作原理的机制；是使用函数的首要理由。
数学头文件（math.h） — 提供基础数学运算函数的头文件，如 acos(x) 返回 arccos(x)、atan(x) 返回 arctan(x)、exp(x) 返回 eˣ、pow(x,y) 返回 xʸ、sqrt(x) 返回 √x。
字符处理头文件（ctype.h） — 包含用于测试和操作字符数据的函数的头文件，如 isdigit(x)、isalpha(x)、isalnum(x)、islower(x)、toupper(x)。
用户自定义函数（User-defined Functions） — 程序员自己编写的、用于执行单一明确任务的函数；函数名应反映该任务。
函数原型（Function prototype） — 在函数定义前声明函数名称、返回类型和参数类型的语句，如 int square(int);。
函数声明（Declare the function / Function declaration） — 类似声明变量，确定函数返回值类型和接收参数类型；告知编译器函数名、参数和返回值类型，使编译器能检查变量类型匹配；无返回值时用 void。
函数定义（Define the function / Function definition） — 编写函数具体实现代码，包含输入参数和返回操作；提供实际代码（函数体）并为该代码分配内存。
函数调用（Call / Use the function） — 在程序中实际使用已定义函数的过程，如 square(x)、square(1)、square(3+5)。
函数分类（Function Classification） — 根据是否需要返回值将函数分为两类：无返回值（用 void，如 void printHello()）和有返回值（类型可为 int、float、double、char，但不能直接返回数组）。
返回语句（return statement） — 用于提供函数返回值并终止函数执行的语句；返回值应与函数类型一致，否则发生自动类型转换（隐式数据类型转换），可能造成信息丢失。
形式参数（Formal arguments / parameters） — 函数定义中用于接收传入值的变量；是函数私有的（private），仅在函数内部有效。
实际参数（Actual arguments） — 函数调用时实际传递给函数的常量或变量值，如 5 和 25。
求值顺序（Order of evaluation） — 函数调用中参数表达式被计算的先后次序，在C语言中未定义；因此必须确保结果与求值顺序无关。
临时变量（Temporary variable） — 用于存储中间计算结果，以消除求值顺序歧义的变量，如 a = add(x); b = add(y); x = multiply(a-b);。
全局变量（Global variable） — 在函数外部声明的变量，在整个程序中可见，在整个程序执行期间保留其值（占用内存）；程序开始时创建，整个程序结束时清理。
局部变量（Local variable） — 在函数内部（代码块内部）声明的变量，仅在函数内部可见，其作用域被限制在对应的块内；函数开始时创建，函数终止时清理。
作用域（Scope） — 变量在程序中可见性的范围或区间。
块作用域（Block scope） — 在任意复合语句（{...}）开头之后声明的变量，其作用域限制在该块内；块内局部变量会隐藏同名的外部变量（它们不是同一个变量）。
文件作用域（File scope） — 声明在所有函数外部的变量所处的作用域，可在文件中的任何位置被调用。
按值调用（Call by value） — C语言中函数调用时传递数据副本的机制，函数无法修改原始变量的值；如需模拟按引用调用，可将返回值重新赋给原变量。
递归（Recursion） — 一个函数调用自身的编程技术；经典示例是阶乘函数。
阶乘函数（Factorial function） — 定义为 0!=1 且 n!=n*(n-1)! 的经典递归示例函数，即 n! = n×(n-1)×(n-2)×…×1。
C预处理器（C Preprocessor） — 编译过程中概念上独立的第一步，负责文件包含和宏替换等预处理操作。
文件包含（File inclusion） — 通过 #include 指令将指定文件内容插入到源文件中的预处理操作；"" 表示在源程序所在位置查找文件，<> 表示遵循实现定义的规则查找文件。
宏替换（Macro substitution） — 通过 #define 指令将名称替换为指定文本的预处理操作，如 #define max(A, B) ((A)>(B)? (A):(B))；也可用 define 产生一个"函数"，以避免函数调用开销。
头文件（Header Files） — 存放函数声明（.h文件）的文件，与存放函数定义的 .c 文件分离，用于模块化管理；如 math.h 含数学函数原型、stdio.h 含输入/输出函数原型、string.h 含字符串函数原型。
库文件（Library file） — 存放已编译好的实际函数代码的文件，在链接阶段被使用；编译器链接器将库中代码链接到程序中被调用的函数。
随机数生成器（Random Number Generator） — C语言中用于生成随机数的机制，核心函数为 rand()，生成 0 到 RAND_MAX（定义在 <stdlib.h> 中的常量）之间的整数。
伪随机序列（Pseudo random sequence） — 由 srand() 设置种子后，rand() 生成的看似随机但实际可预测的数列。
种子（seed） — 用于初始化伪随机数生成器的起始值，改变它会改变生成的随机数序列；相同种子总是产生相同的看似随机的序列。
随机序列（random sequence） — 由随机数生成器产生的一组数值，在相同种子下会产生相同的序列。
系统时钟时间（Current System Clock time） — 通过 time(0) 获取的当前系统时间值，常用作随机数生成的种子。
随机数种子（Seed for rand()） — 传递给 srand() 函数的值，用于初始化 rand() 函数的随机数生成器。

🔗 概念之间的关系

函数是模块在C语言中的具体实现形式；用户自定义函数是函数中由程序员自行编写的一类，与库函数相对。
函数原型/函数声明、函数定义、函数调用构成函数使用的三步配方（recipe）：声明告知编译器接口，定义提供实现并分配内存，调用实际执行；声明必须放在 main() 之前，否则编译器不知道如何处理。
形式参数与实际参数通过按值调用机制连接：调用时实际参数的值被复制给形式参数，因此函数内修改形式参数不影响原始变量；求值顺序未定义的问题通过引入临时变量解决。
作用域统摄全局变量（文件作用域，整个程序可见）与局部变量（块作用域，仅块内可见）；块作用域是局部变量作用域规则的具体体现，块内同名变量会隐藏外部变量。
递归是函数调用的一种特殊形式（函数调用自身），阶乘函数是递归的经典特例；递归依赖返回语句逐层返回结果。
C预处理器通过文件包含和宏替换支撑头文件与库文件的模块化组织；随机数生成器依赖 <stdlib.h>（rand()、srand()、RAND_MAX）和 <time.h>（time(0)）提供的种子来产生伪随机序列。

⬅️ 承接前面的知识

用到第02讲的"描述性命名"结论：函数名应反映其任务（第11页明确回顾 Lecture 02 的 descriptive name）。
用到第02讲的 return 语句结论：return 不仅提供值，还标志函数终止（第17页明确"Recall from Lecture 02"）。
用到第02讲的头文件/预处理指令知识：#include、#define 在第02讲已作为常用预处理指令介绍，本讲深化为文件包含与宏替换。
用到第02讲的 printf()、scanf()、std::cin、std::cout：作为已用过的预定义函数例子（第8页）。
用到第03/04讲的运算符与表达式：函数调用中可放置表达式（如 x=multiply(x+y)），并涉及求值顺序问题。
用到第03/04讲的数据类型与类型转换：返回值类型不一致时发生自动转换（隐式数据类型转换），可能信息丢失（第22–23页）。
用到第04讲的流程控制（for 循环）：递归示例中提到"可以用 for 循环解决"，随机数生成示例用 for 循环输出。

➡️ 后面会怎么用

函数声明与定义的分离将在第06讲延伸到跨多个文件拆分函数（第34页明确"We will learn how to split functions across multiple files in Lecture 06"）。
头文件与库文件的模块化组织是后续大型程序、多文件工程的基础，自定义头文件与库的编写会继续深化。
按值调用的限制（无法修改原始变量）为后续学习指针/按引用传递埋下伏笔，是理解C语言参数传递机制的关键。
递归作为算法设计技术，将在后续数据结构与算法内容（如树、分治）中反复使用。
随机数生成（rand()、srand()、time(0)）在仿真、游戏、预测等场景中直接应用，是后续实验与项目的常用工具。
变量作用域规则是理解程序生命周期、内存管理以及后续静态变量、存储类等内容的前提。

Lecture06

🧩 核心概念

头文件（Header file） — 包含函数声明和宏定义，用于在多个源文件之间共享代码的文件；本讲用来把自定义函数的声明抽出来供多个 .c 文件复用。
多源文件拆分（multiple source files） — 把一个大项目拆成多个 .c 源文件分别管理；用于大型项目管理、代码复用、便于维护和修 bug。
源代码文件（Source file） — 包含程序实际执行代码（如函数定义）的文件，通常以 .c 或 .cpp 为扩展名。
函数原型（Prototype） — 对函数的声明，告诉编译器函数的名称、返回类型和参数类型，但不包含函数体；放在头文件里。
函数定义（Definition） — 函数的实际实现，包含函数体的具体代码逻辑；放在源文件里。
命令行（Command line） — 一种基于文本的界面，用户通过输入命令来与操作系统或编译器进行交互；本讲用 gcc -o test test.c myHeader.c 或 gcc -o test *.c 编译多个文件。
tasks.json — VSCode 的编译任务配置文件；多文件编译时需把 ${file} 替换为 "-I${workspaceFolder}" 和 "${workspaceFolder}/*.c"。
数组（Array） — C语言中一组具有相同类型和相同名称的元素集合，元素在内存中顺序排列，可用索引以任意顺序访问；常用于批量存储同类型数据。
索引（Index） — 用于访问数组元素的整数，范围从0到N-1（N为数组长度）。
数组越界（outside of the array bounds） — 访问超出数组声明长度的元素（如 my_array[10]），可能导致运行时错误，是否报错取决于编译器。
声明与初始化数组（Declaring and Initializing Arrays） — 需指定每个元素的类型和元素个数；可用循环或声明时初始化，且初始化必须从第0个元素开始，不能跳过前面元素只初始化中间某个。
遍历数组元素（Iterating through Array Elements） — 用 for 循环依次访问数组每个元素；访问越界元素是错误行为，需小心。
字符数组与字符串（Arrays and Strings） — 字符数组可用单个字符初始化，也可用字符串字面量初始化；字符串是以空字符 '\0' 结尾的特殊字符数组。
空字符（NULL character '\0'） — 字符串结尾的特殊字符，用于标记字符数组的结束。
二维数组（Two Dimensional Arrays） — 使用两个下标（行索引和列索引）构造的数组，按 [row_index][col_index] 组织数据，常用于表示矩阵或表格（如城市距离表）。
行优先访问（Row first） — 使用 array_name[i-1][j-1] 形式访问二维数组中第 i 行第 j 列元素的方式。
嵌套循环（Nested Loops） — 一种循环结构，外层循环每执行一次，内层循环都会完整执行一遍，常用于给二维数组赋值。
三维数组（Three-dimensional array） — 一种看起来像"一叠表格"的数组，例如 float table[3][5][2]；需要3层嵌套循环处理所有元素。
指针（Pointer） — 一种用于存储另一个变量地址的变量，类似于家庭住址；其类型由所指向变量的类型决定（float 指针必须指向 float 变量，int 指针必须指向 int 变量）。
指针声明（Pointer Declaration） — 声明时需指定其指向的变量类型；int a 与 int a 等价，int* 是与 int 不同的数据类型；不同数据类型的指针占用相同字节数（都存地址），但必须区分类型因为不同类型长度不同。
取地址运算符（address operator &） — 放置在变量前以获取该变量地址的运算符；scanf() 用它确定把输入值存到内存哪里。
格式说明符 %p — 用于打印地址的格式说明符。
*解引用运算符（dereference operator ）* — 用于获取指针所指向变量值的运算符；pAge 是 pAge 所指向地址处存储的值。
赋值（assignment） — 将地址赋给指针的操作，要求变量类型与指针类型兼容。
解引用（de-referencing） — 使用 运算符查找指针所指向位置存储的值；pArray 给出 pArray 中保存的地址处存储的值。
未初始化指针（uninitialised pointer） — 声明后未赋予有效内存地址的指针，对其解引用会导致运行时错误；它含随机值，会向未知位置写值，可能覆盖数据或代码。
常量指针（constant pointer） — 在C语言中，数组名被视为指向数组首元素的常量指针；arr 等价于 &arr[0]。
指针递增（Incrementing ++） — 使指针指向内存中下一个同类型数据元素的地址操作；移动的字节数等于该变量类型的字节数。
指针递减（Decrementing --） — 使指针指向内存中上一个同类型数据元素的地址操作。
优先级（precedence） — 决定表达式中运算符计算顺序的规则；C/C++ 中大多数运算符从左向右结合，只有单目运算符和赋值运算符从右向左结合。
后缀递增（post-increment） — p++ 等价于 (p++)，先取当前地址的值，再将指针移动到下一个地址。
*(p)++** — 先取当前地址的值，再给该值加1（不移动指针）。
指针相减（Pointer Subtraction / Differencing） — 通过两个指针相减来确定数组中两个元素相隔多少个元素的操作；地址差除以元素大小得到元素个数。
数组名（Array Name） — 数组名本身即是指向该数组第一个元素的指针（地址）；但数组名不是变量，所以 array++ 非法，而指针是变量，ptr++ 合法。
按值调用（Call by Value） — 将变量中存储的值复制后传递给函数，函数内部无法改变该变量本身的值；形参为普通变量，函数内修改的是传入值的副本。
按引用调用（Call by Reference） — 通过指针允许在一个函数中访问并修改在另一个函数中声明的变量；形参为指针，函数内通过解引用修改了原变量的值。

🔗 概念之间的关系

头文件 → 函数原型 / 函数定义：头文件里放的是函数原型（声明），源文件里放的是函数定义（实现），两者分离才能让多个源文件共享同一份声明。
多源文件拆分 → 命令行编译 / tasks.json：一旦代码拆成多个源文件，编译方式就必须从单文件升级为多文件，命令行用 *.c 通配，VSCode 则改 tasks.json。
数组 → 二维数组 → 三维数组：一维数组是基础，二维数组是"数组的数组"（表格），三维数组是"一叠表格"，维度逐层推广，处理时嵌套循环层数也随之增加。
数组 → 指针：数组名本身是指向首元素的常量指针，因此数组和指针天然关联；但数组名不是变量（不能 array++），指针是变量（可以 ptr++），这是两者的关键区别。
指针 → 取地址运算符 / 解引用运算符：指针存地址（用 & 获取），用 解引用取值，& 和 是一对互逆操作。
指针 → 按引用调用：指针让函数能通过地址访问并修改另一个函数中的变量，从而把"按值调用"升级为"按引用调用"。

⬅️ 承接前面的知识

用到第2讲的 #include 预处理指令：本讲创建自定义头文件时，正是把 #include 从"引入官方头文件"扩展到"引入自己写的头文件"。
用到第2讲的字符与字符串概念：本讲第14页"Arrays and Strings"直接建立在第2讲字符/字符串知识上，进一步说明字符串是以 '\0' 结尾的字符数组。
用到第5讲的函数定义与函数调用：本讲"函数原型 vs 函数定义"、"按值调用 vs 按引用调用"都依赖第5讲已学的函数定义、调用、变量作用域知识。
用到第5讲的 C 预处理器：自定义头文件本质上是预处理器的应用，承接第5讲预处理器内容。
用到第3/4讲的运算符与类型转换：本讲指针的 ++/--、*、&、优先级、类型兼容性都建立在第3/4讲运算符与类型转换基础上。
用到第4讲的循环与分支：本讲遍历数组用 for 循环、二维数组赋值用嵌套循环，直接复用第4讲循环结构。

➡️ 后面会怎么用

指针与数组的关系是后续学习动态内存分配（malloc/free）、字符串处理函数、指针数组与数组指针的基础。
按引用调用是后续函数返回多个值、在函数内修改调用者变量、传递大数组避免拷贝的标准手段。
多文件编译与头文件是后续模块化编程、大型项目组织、防止重复包含（include guard）的起点。
二维/多维数组在后续矩阵运算、图像处理、表格数据处理中反复出现。
指针运算（++/--/相减）是后续链表、树等数据结构遍历与操作的核心机制。
未初始化指针的警告是后续内存安全、段错误调试的重要前置知识。