C++游戏编程入门 第4版PDF电子书下载

第1章 类型、变量与标准I/O：Lost Fortune 1

1.1 C＋＋简介 1

1.1.1 使用C＋＋编写游戏 1

1.1.2 生成可执行文件 2

1.1.3 错误处理 3

1.1.4 理解ISO标准 4

1.2 编写第一个C＋＋程序 4

1.2.1 Game Over程序简介 4

1.2.2 注释 5

1.2.3 使用空白字符 6

1.2.4 包含其他文件 6

1.2.5 定义main()函数 7

1.2.6 通过标准输出显示文本 7

1.2.7 语句的终止 8

1.2.8 从main()函数返回值 8

1.3 使用std名称空间 9

1.3.1 Game Over 2.0程序简介 9

1.3.2 使用using指令 10

1.3.3 Game Over 3.0程序简介 10

1.3.4 使用using声明 11

1.3.5 使用using的时机 11

1.4 使用算术运算符 12

1.4.1 Expensive Calculator程序简介 12

1.4.2 加法、减法与乘法 13

1.4.3 理解整型与浮点型除法 13

1.4.4 使用模除运算符 14

1.4.5 运算符的优先级 14

1.5 声明和初始化变量 14

1.5.1 Game Stats程序简介 14

1.5.2 基本类型 16

1.5.3 类型修饰符 16

1.5.4 变量声明 17

1.5.5 变量命名 18

1.5.6 变量的赋值 19

1.5.7 变量初始化 20

1.5.8 显示变量值 20

1.5.9 获取用户输入 20

1.5.10 为类型定义新名称 21

1.5.11 类型的选择 21

1.6 使用变量进行算术运算 21

1.6.1 Game Stats 2.0程序简介 22

1.6.2 修改变量值 23

1.6.3 使用组合赋值运算符 23

1.6.4 递增运算符与递减运算符 24

1.6.5 整数的溢出处理 25

1.7 使用常量 26

1.7.1 Game Stats 3.0程序简介 26

1.7.2 使用常量 27

1.7.3 使用枚举类型 27

1.8 Lost Fortune简介 28

1.8.1 创建程序 29

1.8.2 从玩家获取信息 30

1.8.3 讲故事 30

1.9 本章小结 31

1.10 问与答 32

1.11 问题讨论 33

1.12 习题 34

第2章 真值、分支与游戏循环：Guess My Number 35

2.1 理解真值 35

2.2 使用if语句 36

2.2.1 Score Rater程序简介 36

2.2.2 验证真与假 38

2.2.3 值的真与假 39

2.2.4 使用关系运算符 39

2.2.5 if语句的嵌套 40

2.3 使用else子句 40

2.3.1 Score Rater 2.0程序简介 41

2.3.2 两种创建分支的方法 42

2.4 使用带else子句的if语句序列 43

2.4.1 Score Rater 3.0程序简介 43

2.4.2 创建带else子句的if语句序列 44

2.5 使用switch语句 45

2.5.1 Menu Chooser程序简介 46

2.5.2 创建多路分支 48

2.6 使用while循环 48

2.6.1 Play Again游戏简介 48

2.6.2 使用while循环 49

2.7 使用do循环 50

2.7.1 Play Again 2.0程序简介 50

2.7.2 使用do循环 51

2.8 使用break和continue语句 52

2.8.1 Finicky Counter程序简介 52

2.8.2 创建while（true）循环 53

2.8.3 使用break语句退出循环 53

2.8.4 使用continue语句跳转到循环开始 54

2.8.5 使用break和continue的时机 54

2.9 使用逻辑运算符 54

2.9.1 Designers Network程序简介 55

2.9.2 使用逻辑与运算符 57

2.9.3 使用逻辑或运算符 58

2.9.4 使用逻辑非运算符 58

2.9.5 运算符的优先级 59

2.10 随机数的生成 60

2.10.1 Die Roller程序简介 60

2.10.2 调用rand()函数 61

2.10.3 为随机数生成器确定种子 61

2.10.4 在一定范围内计算 62

2.11 理解游戏主循环 63

2.12 Guess My Number游戏简介 64

2.12.1 采用游戏主循环 64

2.12.2 初始化游戏 65

2.12.3 创建游戏主循环 66

2.12.4 游戏结束 67

2.13 本章小结 67

2.14 问与答 68

2.15 问题讨论 69

2.16 习题 69

第3章 for循环、字符串与数组：Word Jumble 71

3.1 使用for循环 71

3.1.1 Counter程序简介 72

3.1.2 使用for循环计数 73

3.1.3 在for循环中使用空语句 74

3.1.4 for循环的嵌套 74

3.2 了解对象 75

3.3 使用string对象 77

3.3.1 String Tester程序简介 77

3.3.2 创建string对象 79

3.3.3 string对象的连接 79

3.3.4 使用size()成员函数 79

3.3.5 索引string对象 80

3.3.6 循环访问string对象 81

3.3.7 使用find()成员函数 81

3.3.8 使用erase()成员函数 82

3.3.9 使用empty()成员函数 83

3.4 使用数组 83

3.4.1 Hero’s Inventory程序简介 83

3.4.2 创建数组 85

3.4.3 数组的索引 86

3.4.4 使用数组元素的成员函数 87

3.4.5 数组边界 87

3.5 理解C风格字符串 88

3.6 使用多维数组 89

3.6.1 Tic-Tac-Toe Board程序简介 90

3.6.2 创建多维数组 91

3.6.3 多维数组的索引 92

3.7 Word Jumble程序简介 92

3.7.1 创建程序 93

3.7.2 选择单词 93

3.7.3 单词乱序 94

3.7.4 欢迎界面 95

3.7.5 进入游戏主循环 95

3.7.6 游戏结束 96

3.8 本章小结 96

3.9 问与答 97

3.10 问题讨论 99

3.11 习题 99

第4章 标准模板库：Hangman 100

4.1 标准模板库简介 100

4.2 使用vector 101

4.2.1 Hero’s Inventory 2.0程序简介 101

4.2.2 使用向量的准备工作 103

4.2.3 向量的声明 103

4.2.4 使用push back()成员函数 104

4.2.5 使用size()成员函数 104

4.2.6 向量的索引 105

4.2.7 调用元素的成员函数 105

4.2.8 使用pop＿back()成员函数 106

4.2.9 使用clear()成员函数 106

4.2.10 使用empty()成员函数 106

4.3 使用迭代器 107

4.3.1 Hero’s Inventory 3.0程序简介 107

4.3.2 迭代器的声明 109

4.3.3 循环访问向量 110

4.3.4 修改向量元素的值 111

4.3.5 访问向量元素的成员函数 112

4.3.6 使用向量的成员函数insert() 113

4.3.7 使用向量的成员函数erase() 113

4.4 使用算法 114

4.4.1 High Scores程序简介 114

4.4.2 使用算法的准备工作 116

4.4.3 使用find()算法 116

4.4.4 使用random＿shuffle()算法 117

4.4.5 使用sort()算法 117

4.5 理解向量的性能 118

4.5.1 向量的增长 118

4.5.2 元素的插入与删除 120

4.6 其他STL容器 120

4.7 对程序进行规划 121

4.7.1 使用伪代码 121

4.7.2 逐步细化 122

4.8 Hangman简介 123

4.8.1 游戏规划 123

4.8.2 创建程序 124

4.8.3 变量与常量的初始 124

4.8.4 进入游戏主循环 125

4.8.5 获取玩家的猜测 125

4.8.6 游戏结束 126

4.9 本章小结 127

4.10 问与答 128

4.11 问题讨论 129

4.12 习题 129

第5章 函数：Mad Lib 131

5.1 创建函数 131

5.1.1 Instructions程序简介 131

5.1.2 函数声明 132

5.1.3 函数定义 133

5.1.4 函数调用 134

5.1.5 理解抽象 134

5.2 使用形参和返回值 134

5.2.1 Yes or No程序简介 135

5.2.2 返回值 136

5.2.3 传递参数值 137

5.2.4 理解封装 138

5.3 理解软件重用 139

5.4 使用作用域 140

5.4.1 Scoping程序简介 140

5.4.2 使用独立的作用域 141

5.4.3 使用嵌套作用域 142

5.5 使用全局变量 144

5.5.1 Global Reach程序简介 144

5.5.2 声明全局变量 145

5.5.3 访问全局变量 145

5.5.4 隐藏全局变量 146

5.5.5 修改全局变量 146

5.5.6 尽量少使用全局变量 147

5.6 使用全局常量 147

5.7 使用默认参数 148

5.7.1 Give Me a Number程序简介 148

5.7.2 指定默认参数 149

5.7.3 为形参设置默认参数 150

5.7.4 重写默认参数 150

5.8 函数重载 151

5.8.1 Triple程序简介 151

5.8.2 创建重载函数 152

5.8.3 调用重载函数 153

5.9 内联函数 153

5.9.1 Taking Damage程序简介 153

5.9.2 函数内联的指定 155

5.9.3 调用内联函数 155

5.10 Mad Lib游戏简介 156

5.10.1 创建程序 156

5.10.2 main()函数 157

5.10.3 askText()函数 157

5.10.4 askNumber()函数 158

5.10.5 tellStory()函数 158

5.11 本章小结 159

5.12 问与答 160

5.13 问题讨论 161

5.14 习题 161

第6章 引用：Tic-Tac-Toe 162

6.1 使用引用 162

6.1.1 Referencing程序简介 162

6.1.2 创建引用 164

6.1.3 访问被引用的值 165

6.1.4 修改被引用的值 165

6.2 通过传递引用改变实参 166

6.2.1 Swap程序简介 166

6.2.2 按值传递参数 167

6.2.3 按引用传递参数 168

6.3 传递引用以提高效率 169

6.3.1 Inventory Displayer程序简介 169

6.3.2 引用传递的陷阱 170

6.3.3 以常量引用声明参数 171

6.3.4 传递常量引用 171

6.4 如何传递实参 172

6.5 返回引用 172

6.5.1 Inventory Referencer程序简介 172

6.5.2 返回一个引用 174

6.5.3 显示返回的引用的值 175

6.5.4 将返回的引用赋值给引用 175

6.5.5 将返回的引用赋值给变量 175

6.5.6 通过返回的引用修改对象 176

6.6 Tic-Tac-Toe游戏简介 176

6.6.1 游戏规划 177

6.6.2 创建程序 179

6.6.3 main()函数 179

6.6.4 instructions()函数 180

6.6.5 askYesNo()函数 181

6.6.6 askNumber()函数 181

6.6.7 humanPiece()函数 182

6.6.8 opponent()函数 182

6.6.9 displayBoard()函数 182

6.6.10 winner()函数 183

6.6.11 isLegal()函数 184

6.6.12 humanMove()函数 185

6.6.13 computerMove()函数 185

6.6.14 announceWinner()函数 188

6.7 本章小结 188

6.8 问与答 189

6.9 问题讨论 191

6.10 习题 191

第7章 指针：Tic-Tac-Toe 2.0 192

7.1 指针基础 192

7.1.1 Pointing程序简介 193

7.1.2 指针的声明 194

7.1.3 指针的初始化 195

7.1.4 将地址赋值给指针 195

7.1.5 指针的解引用 196

7.1.6 指针的重新赋值 197

7.1.7 使用对象的指针 198

7.2 指针和常量 199

7.2.1 使用常量指针 199

7.2.2 使用指向常量的指针 200

7.2.3 使用指向常量的常量指针 200

7.2.4 常量与指针小结 201

7.3 传递指针 202

7.3.1 Swap Pointer Version程序简介 202

7.3.2 值传递 204

7.3.3 传递常量指针 204

7.4 返回指针 205

7.4.1 Inventory Pointer程序简介 205

7.4.2 返回指针 207

7.4.3 使用返回的指针显示值 208

7.4.4 将返回的指针赋值给指针 208

7.4.5 将返回的指针指向的值赋值给变量 209

7.4.6 通过返回的指针修改对象 210

7.5 理解指针与数组的关系 210

7.5.1 Array Passer程序简介 211

7.5.2 将数组名用作常量指针 212

7.5.3 数组的传递与返回 213

7.6 Tic-Tac-Toe 2.0程序简介 214

7.7 本章小结 214

7.8 问与答 215

7.9 问题讨论 217

7.10 习题 217

第8章 类：Critter Caretaker 218

8.1 定义新类型 218

8.1.1 Simple Critter程序简介 218

8.1.2 定义一个类 220

8.1.3 成员函数的定义 221

8.1.4 对象的实例化 221

8.1.5 数据成员的访问 221

8.1.6 成员函数的调用 222

8.2 使用构造函数 222

8.2.1 Constructor Critter程序简介 223

8.2.2 构造函数的声明与定义 224

8.2.3 构造函数的自动调用 225

8.3 设置成员访问级别 225

8.3.1 Private Critter程序简介 226

8.3.2 指定公有与私有访问级别 227

8.3.3 定义访问器成员函数 228

8.3.4 定义常量成员函数 229

8.4 使用静态数据成员与静态成员函数 230

8.4.1 Static Critter程序简介 230

8.4.2 声明与初始化静态数据成员 232

8.4.3 访问静态数据成员 232

8.4.4 声明与定义静态成员函数 233

8.4.5 调用静态成员函数 233

8.5 Critter Caretaker游戏简介 234

8.5.1 游戏规划 235

8.5.2 规划伪代码 236

8.5.3 Critter类 236

8.5.4 main()函数 239

8.6 本章小结 240

8.7 问与答 241

8.8 问题讨论 243

8.9 习题 243

第9章 高级类与动态内存：Game Lobby 244

9.1 使用聚合体 244

9.1.1 Critter Farm程序简介 244

9.1.2 使用对象数据成员 247

9.1.3 使用容器数据成员 247

9.2 使用友元函数与运算符重载 248

9.2.1 Friend Critter程序简介 249

9.2.2 创建友元函数 250

9.2.3 运算符重载 251

9.3 动态分配内存 252

9.3.1 Heap程序简介 252

9.3.2 使用new运算符 254

9.3.3 避免内存泄漏 256

9.4 使用数据成员与堆 257

9.4.1 Heap Data Member程序简介 258

9.4.2 声明指向堆中值的指针数据成员 260

9.4.3 声明与定义析构函数 261

9.4.4 声明与定义拷贝构造函数 262

9.4.5 赋值运算符的重载 265

9.5 Game Lobby程序简介 267

9.5.1 Player类 268

9.5.2 Lobby类 269

9.5.3 Lobby::AddPlayer()成员函数 271

9.5.4 Lobby::RemovePlayer()成员函数 272

9.5.5 Lobby::Clear()成员函数 274

9.5.6 operator＜＜()成员函数 274

9.5.7 main()函数 275

9.6 本章小结 275

9.7 问与答 276

9.8 问题讨论 278

9.9 习题 278

第10章 继承与多态：Blackjack 279

10.1 继承简介 279

10.1.1 Simple Boss程序简介 280

10.1.2 从基类派生 282

10.1.3 从派生类实例化对象 283

10.1.4 使用继承成员 283

10.2 继承访问权的控制 284

10.2.1 Simple Boss 2.0程序简介 284

10.2.2 对类成员使用访问修饰符 286

10.2.3 使用访问修饰符修饰派生类 286

10.3 调用与重写基类成员函数 287

10.3.1 Overriding Boss程序简介 287

10.3.2 调用基类构造函数 289

10.3.3 声明虚基类成员函数 290

10.3.4 重写虚基类成员函数 290

10.3.5 调用基类成员函数 291

10.4 在派生类中使用重载赋值运算符与拷贝构造函数 292

10.5 多态简介 292

10.5.1 Polymorphic Bad Guy程序简介 293

10.5.2 使用基类指针指向派生类对象 295

10.5.3 定义虚析构函数 296

10.6 使用抽象类 297

10.6.1 Abstract Creature程序简介 297

10.6.2 声明纯虚函数 299

10.6.3 从抽象类派生类 299

10.7 Blackjack游戏简介 300

10.7.1 类的设计 301

10.7.2 规划游戏的逻辑 304

10.7.3 Card类 304

10.7.4 Hand类 306

10.7.5 GenericPlayer类 308

10.7.6 Player类 309

10.7.7 House类 311

10.7.8 Deck类 312

10.7.9 Game类 314

10.7.10 main()函数 317

10.8 本章小结 319

10.9 问与答 320

10.10 问题讨论 321

10.11 习题 321

附录A 创建第一个C＋＋程序 323

附录B 运算符优先级 329

附录C 关键字 331

附录D ASCII字符表 333

附录E 转义序列 335