《程序设计基础（C++）》是一本重点讲解程序设计基础的C++程序设计教材。本书以面向过程程序设计为主线，将内容分为引言、顺序结构程序设计、选择结构程序设计、循环结构程序设计、数组与C++字符串程序设计、函数设计等章节，全面、细致地讲解了学习程序设计基础所需的知识与技能。本书不同于其他C++程序设计教材的最大特点是将笔墨放在了代码设计与实现上，最典型的表现就是循环结构程序设计这一章所占比例远高于其他教材。本书根据循环迭代内部关系，将有关循环的代码细分为不同类型，并从易到难依次讲解，进而帮助初学者规划学习路径、更好地掌握循环设计能力。此外，本书的另一大特点是通过丰富的代码示例讲解程序设计的思路与技巧，从不同角度、以不同难度阐述了在编程基础阶段进行循环设计的相关事项。

罗迅，副教授，现任职湖南师范大学，兼任大学生程序设计竞赛集训队主教练，率队获得ICPC区域赛金奖3项、CCPC分站赛金奖1项、其他等级奖项累计数十项；曾编写教材《C++程序设计教程（第二版）》《C语言程序设计》《C++程序设计教程习题答案和实验指导（第二版）》。

第1 章 引言·····························································································································1
1.1 程序与程序设计语言·········································································································1
1.2 C++语言························································································································1
1.3 C++语言初印象···············································································································2
第2 章 顺序结构程序设计········································································································5
2.1 一个小例子·····················································································································5
2.2 顺序结构程序设计的前置语法知识 ······················································································6
2.2.1 数据类型···············································································································6
2.2.2 变量与变量定义······································································································7
2.2.3 字面值··················································································································8
2.2.4 表达式与算术表达式································································································8
2.3 顺序结构程序设计············································································································9
2.3.1 输出语句···············································································································9
2.3.2 输入语句··············································································································10
2.3.3 赋值表达式与赋值语句····························································································10
2.3.4 顺序结构简要设计··································································································11
2.3.5 程序错误类别········································································································14
2.3.6 一种简单的调试方法·······························································································15
2.3.7 代码书写风格与规范·······························································································16
2.3.8 交互风格··············································································································17
2.4 额外的语法知识点···········································································································17
2.4.1 两个单目前缀运算符·······························································································17
2.4.2 转型操作··············································································································18
2.5 AI 拓展 ·························································································································19
2.6 练习题··························································································································19
第3 章 选择结构程序设计·······································································································20
3.1 一个小例子····················································································································20
3.2 选择结构程序设计的前置语法知识 ·····················································································21
3.2.1 关系表达式与布尔类型····························································································21
3.2.2 逻辑运算符与逻辑表达式·························································································21
3.3 选择结构程序设计···········································································································23
3.3.1 双分支选择语句·····································································································23
3.3.2 多分支选择语句·····································································································24
3.3.3 单分支选择语句·····································································································25
3.3.4 选择结构简要设计··································································································25
3.3.5 复杂选择结构设计与伪代码······················································································29
3.3.6 判定性思维初步使用·······························································································33
3.4 额外的知识点·················································································································35
3.4.1 复合语句··············································································································35
3.4.2 局部变量··············································································································35
3.4.3 代码可读性强调—缩进、空行、注释······································································36
3.4.4 乘方与秦九韶公式··································································································36
3.5 AI 拓展 ·························································································································36
3.6 练习题··························································································································37
第4 章 循环结构程序设计·······································································································38
4.1 一个小例子····················································································································38
4.2 循环结构程序设计的前置语法知识 ·····················································································39
4.2.1 循环语句概览········································································································39
4.2.2 自增、自减运算符··································································································39
4.3 for 循环及其初步使用 ······································································································39
4.4 for-if 模式设计················································································································45
4.4.1 for-if 模式设计初步实现···························································································45
4.4.2 break 与continue·····································································································49
4.4.3 for-if-break 更多设计·······························································································51
4.4.4 实数判零与for-if 解方程··························································································56
4.5 循环设计的递推思维········································································································58
4.5.1 基本递推思维········································································································58
4.5.2 循环输入与递推求解·······························································································62
4.5.3 初始化与更复杂的递推求解······················································································64
4.5.4 复杂逻辑判断········································································································68
4.6 while 循环设计···············································································································71
4.6.1 while 循环设计初步实现···························································································71
4.6.2 while(1)-if-break 设计·······························································································72
4.6.3 经典级数求和········································································································72
4.6.4 剥黏数位与循环设计·······························································································75
4.7 额外的知识点·················································································································80
4.7.1 浮点数字面值的写法·······························································································80
4.7.2 复合赋值运算符·····································································································80
4.8 AI 拓展 ·························································································································80
4.9 练习题··························································································································81
第5 章 数组与C++字符串程序设计························································································83
5.1 一个小例子····················································································································83
5.2 数组与C++字符串程序设计的前置语法知识 ········································································85
5.2.1 数组的定义与初始化·······························································································85
5.2.2 数组元素的使用·····································································································86
5.2.3 数组的I/O 与拷贝···································································································86
5.2.4 两个术语（容量与长度）·························································································87
5.3 数组程序设计·················································································································88
5.3.1 数组程序设计初步实现····························································································88
5.3.2 数组性质的判断·····································································································96
5.3.3 数组若干理论与操作·····························································································102
5.3.4 数组的更多用法···································································································111
5.4 二维数组·····················································································································118
5.4.1 二维数组的定义与初始化·······················································································118
5.4.2 二维数组简单程序设计··························································································119
5.5 字符串························································································································120
5.5.1 字符类型与ASCII 码·····························································································120
5.5.2 字符类型的I/O ····································································································121
5.5.3 C++字符串的定义与初始化····················································································122
5.5.4 字符串基本操作···································································································123
5.5.5 字符串程序设计···································································································125
5.5.6 空格处理与while 循环处理分段结构········································································132
5.6 额外的知识点···············································································································145
5.6.1 转义字符············································································································145
5.6.2 断言··················································································································146
5.7 AI 拓展 ·······················································································································147
5.8 练习题························································································································147
第6 章 函数设计···················································································································148
6.1 两个小例子··················································································································148
6.2 函数设计相关事项·········································································································152
6.3 函数体设计··················································································································153
6.3.1 函数体设计初步实现·····························································································153
6.3.2 数组作形参·········································································································155
6.3.3 字符串作形参······································································································157
6.4 函数的复杂参数设计······································································································158
6.4.1 引用类型作形参之一·····························································································158
6.4.2 引用类型作形参之二及const 关键字·········································································160
6.4.3 数组与地址作形参································································································161
6.5 函数的复杂return 设计 ··································································································163
6.5.1 基础return 设计····································································································163
6.5.2 复杂return 设计····································································································164
6.5.3 输出参数············································································································165
6.6 结构化/模块化设计········································································································167
6.7 递归函数设计···············································································································170
6.8 库函数的简单使用·········································································································175
6.9 练习题························································································································176
第7 章 结构体设计···············································································································177
7.1 结构体设计的前置语法知识 ····························································································177
7.1.1 结构体类型的定义································································································177
7.1.2 结构体变量的定义与初始化····················································································178
7.1.3 结构体的基本操作································································································178
7.2 结构体程序设计············································································································179
第8 章 指针与简单链表设计·································································································183
8.1 指针与简单链表设计的前置语法知识················································································183
8.1.1 地址与指针·········································································································183
8.1.2 指针的基本操作···································································································184
8.1.3 动态内存分配与释放·····························································································185
8.2 指针运算方法···············································································································186
8.2.1 指针相关类型表示方法··························································································186
8.2.2 指针相关操作表示方法··························································································187
8.2.3 两个操作示例······································································································188
8.3 链表···························································································································189
8.3.1 链表初步············································································································189
8.3.2 链表遍历············································································································190
8.3.3 链表创建············································································································191
8.3.4 链表插入············································································································194
8.3.5 链表删除············································································································195
8.3.6 链表释放············································································································196
第9 章 C++面向过程的其他基础语法知识············································································199
9.1 数据类型·····················································································································199
9.1.1 整型··················································································································199
9.1.2 扩展整型············································································································200
9.1.3 浮点型···············································································································200
9.2 运算符与表达式············································································································200
9.2.1 表达式运算顺序···································································································201
9.2.2 赋值运算符·········································································································202
9.2.3 自增运算符·········································································································204
9.2.4 移位运算符·········································································································205
9.2.5 位逻辑运算符······································································································205
9.2.6 条件运算符·········································································································207
9.2.7 逗号运算符·········································································································207
9.2.8 逻辑运算符的短路规则与特殊的估值顺序··································································208
9.3 语句···························································································································209
9.3.1 switch 语句··········································································································209
9.3.2 do-while 语句·······································································································210
9.3.3 for 循环的语法与for-range 循环···············································································211
9.3.4 goto 语句············································································································212
9.4 函数与宏·····················································································································213
9.4.1 作用域···············································································································213
9.4.2 生存周期············································································································214
9.4.3 宏·····················································································································215
9.5 文件与编译单元············································································································216
9.6 AI 拓展 ·······················································································································217