C++编程从入门到实践第二2版王石磊人民邮电出版社9787115539694

图书标准信息

• 作者 王石磊
• 出版社 人民邮电出版社
• 出版时间 2021-03
• 版次 2
• ISBN 9787115539694
• 定价 99.00元
• 装帧 平装
• 开本 其他
• 纸张 胶版纸
• 页数 380页
• 字数 658千字

【内容简介】

本书由浅入深地讲解了C++开发技术的核心内容，并通过具体实例演练了各个知识点在实践中的具体使用方法。全书共23章：第1～2章讲解了C++技术的基础知识，包括C++的重要特性和开发环境搭建；第3～7章分别讲解了C++语法、变量、常量、流程控制、运算符和表达式等知识；第8～11章分别讲解了输入、输出、函数、指针和复合类型的基本知识，包含了C++开发技术的重点和难点；第12～20章分别讲解了面向对象、类、继承、派生、多态、内存管理和异常等内容；第21～23章通过3个综合实例，介绍了C++技术在综合项目中的开发流程。全书内容循序渐进，以“范例演练”和“技术解惑”贯穿全书，引领读者全面掌握C++语言。
  本书不但适合C++的初学者，也适合有一定C++基础的读者，还可以作为大专院校相关专业师生的学习用书和培训学校的教材。

【作者简介】

王石磊，著名企业服务器事业部开发工程师，10多年C和C++开发经验，熟悉驱动开发、系统开发，参与研发了单位的著名的系统开发，这是中国首款自主研发的云数据中心操作系统，深度融合OpenStack，是开放、融合、安全的云数据中心操作系统，支持最广泛的异构资源管理和跨云整合。

【目录】

目　　录

第 1章　C++语言介绍　1

1.1　什么是C++　2

1.1.1　C++的发展历史　2

1.1.2　C++的优点和缺点　2

1.2　C++语言的现状　3

1.3　面向对象　4

1.4　标准库介绍　4

第 2章　搭建C++开发环境　5

2.1　使用Visual C++ 6.0　6

2.1.1　Visual C++ 6.0的特点　6

2.1.2　安装Visual C++ 6.0　6

2.2　使用Microsoft Visual Studio　9

2.2.1　Visual Studio 2017的

新功能　9

2.2.2　安装Microsoft Visual

Studio　2017　10

2.3　编写第 一个C++程序　12

2.3.1　使用Visual C++ 6.0

实现　13

2.3.2　使用Visual Studio　2017

实现　15

2.4　使用手机开发C++程序　17

2.4.1　GCC和C4droid　18

2.4.2　在手机中搭建C++开发

环境　18

2.4.3　在iPhone中使用

Mobile　C/C++　18

2.5　技术解惑　19

2.5.1　初学者经常不知道自己

该学什么　19

2.5.2　初学者需要知道的正确

观念　19

2.6　课后练习　19

第3章　C++语言开发基础　20

3.1　面向对象　21

3.1.1　两种对象的产生方式　21

3.1.2　C++面向对象编程的

流程　21

3.2　C++语言的程序结构　21

3.2.1　初识C++程序结构　21

3.2.2　看C++程序的文件组织　23

3.3　C++编码规范　24

3.3.1　养成良好的风格　24

3.3.2　必须使用的注释　24

3.3.3　代码也需要化妆　25

3.4　输入和输出　26

3.4.1　标准输入与输出对象　27

3.4.2　一个使用I/O库的程序　27

3.4.3　使用using声明命名空间　29

3.5　算法　30

3.5.1　算法的概念　30

3.5.2　流程图表示算法　31

3.5.3　计算机语言表示算法　32

3.6　技术解惑　33

3.6.1　C++是面向对象，C是面

向过程，那么这个对象和

过程是什么意思　33

3.6.2　面向对象和面向过程的

区别　33

3.6.3　学好C++的建议　34

3.7　课后练习　34

第4章　C++语言的基础语法　35

4.1　标识符　36

4.1.1　C++中的保留字　36

4.1.2　标识符的命名规则　36

4.2　数据类型　38

4.2.1　数字运算型　38

4.2.2　逻辑运算型　41

4.2.3　字符型和字符串　42

4.3　标准类型库　43

4.3.1　C++标准库介绍　43

4.3.2　标准库中的主要成员　44

4.4　技术解惑　45

4.4.1　C++的标识符长度的

“min-length　&&

max-information”原则　45

4.4.2　字符和字符串的区别　45

4.4.3　C++中string类字符串和

C中char*/char[]型

字符串的差别　45

4.4.4　C++字符串和C字符串的

转换　45

4.4.5　C++字符串和字符串结束

标志　46

4.5　课后练习　46

第5章　变量和常量　47

5.1　变量　48

5.1.1　定义变量　48

5.1.2　声明变量　48

5.2　变量的作用域　49

5.2.1　作用域和生存期　49

5.2.2　作用域限定符　51

5.2.3　存储类型　51

5.2.4　C++变量初始化　53

5.3　常量　54

5.3.1　什么是常量　54

5.3.2　使用常量　55

5.4　使用C++ 11标准处理复杂的

类型　56

5.4.1　定义类型别名　56

5.4.2　使用auto实现类型推导　57

5.4.3　使用decltype推导类型　58

5.4.4　使用常量表达式　59

5.5　技术解惑　60

5.5.1　C++常量的命名是否需要

遵循一定的规范　60

5.5.2　在C++程序中用const还是

用#define定义常量　60

5.5.3　const是个很重要的

关键字，在使用时应该

注意哪些　60

5.5.4　关于全局变量的初始化，

C语言和C++是否有

区别　61

5.5.5　C/C++变量在内存中的

分布　61

5.5.6　静态变量的初始化顺序　61

5.6　课后练习　61

第6章　运算符和表达式　62

6.1　运算符和表达式详解　63

6.1.1　赋值运算符和赋值

表达式　63

6.1.2　算术运算符和算术

表达式　64

6.1.3　比较运算符和比较

表达式　66

6.1.4　逻辑运算符和逻辑

表达式　67

6.1.5　++/ 运算符和表达式　67

6.1.6　位运算符和位表达式　68

6.1.7　求字节数运算符和

求字节表达式　70

6.1.8　条件运算符和条件

表达式　72

6.1.9　逗号运算符和逗号

表达式　72

6.1.10　运算符的优先级和

结合性　73

6.2　类型转换　76

6.2.1　使用隐式转换　76

6.2.2　使用显式转换　77

6.3　技术解惑　81

6.3.1　避免运算结果溢出的

一个方案　81

6.3.2　运算符重载的权衡　81

6.3.3　运算符重载是对已有

运算符赋予多重含义　81

6.4　课后练习　82

第7章　流程控制语句　83

7.1　语句和语句块　84

7.1.1　最简单的语句　84

7.1.2　语句块　84

7.2　顺序结构　86

7.3　选择结构　86

7.3.1　单分支结构语句　87

7.3.2　双分支结构语句　87

7.3.3　使用多分支结构语句　90

7.4　循环结构详解　91

7.4.1　循环语句的形式　92

7.4.2　for语句循环　92

7.4.3　使用while语句　94

7.4.4　使用do-while语句　95

7.5　使用跳转语句　96

7.5.1　使用break语句　96

7.5.2　使用continue语句　97

7.5.3　使用goto语句　97

7.6　C++ 11新规范：基于范围的

for循环语句　98

7.7　技术解惑　99

7.7.1　循环中断的问题　99

7.7.2　分析循环语句的效率　100

7.7.3　几种循环语句的比较　100

7.7.4　C++中的for循环该

怎么读　100

7.7.5　一个C++循环结构

嵌套的问题　100

7.7.6　break语句和continue

语句的区别　101

7.8　课后练习　101

第8章　指针　102

8.1　指针的基本概念　103

8.2　定义指针　103

8.2.1　定义指针的方式　103

8.2.2　识别指针　104

8.2.3　指针的分类　104

8.3　指针的初始化　105

8.3.1　指针初始化时的类型　106

8.3.2　指针地址初始化　106

8.3.3　变量地址初始化　106

8.3.4　使用new分配内存单元　107

8.3.5　使用函数malloc分配

内存单元　107

8.4　指针运算　108

8.4.1　算术运算　108

8.4.2　关系运算　110

8.5　指针的指针　112

8.6　使用指针　113

8.6.1　指针赋值　114

8.6.2　使用“*”操作符　114

8.7　分析指针和引用的关系　115

8.8　特殊指针　117

8.8.1　void型指针　118

8.8.2　空指针　119

8.8.3　C++ 11：使用nullptr

得到空指针　120

8.9　C++ 11：使用标准库函数

begin和end　120

8.10　技术解惑　121

8.10.1　指针的命名规范　121

8.10.2　指针和引用的区别　122

8.10.3　变量的实质　123

8.10.4　避免和解决野指针　123

8.10.5　常量指针常量和常量

引用常量　125

8.10.6　指针常量和引用常量的

对比　125

8.10.7　常量指针和常量引用的

对比　125

8.11　课后练习　126

第9章　数组、枚举、结构体和联合　127

9.1　使用数组　128

9.1.1　定义数组　128

9.1.2　高级数组　129

9.1.3　分析数组的完整性　130

9.2　动态数组　131

9.2.1　在堆上分配空间的

动态数组　131

9.2.2　在栈上分配空间的

“假动态”数组　132

9.3　字符数组　133

9.3.1　定义字符数组　133

9.3.2　字符数组和字符串指针

变量　134

9.4　数组初始化　135

9.4.1　定义时的初始化　135

9.4.2　初始化赋值语句　136

9.5　指针和数组　137

9.5.1　基本原理　137

9.5.2　指向数组的指针　137

9.5.3　指针数组　138

9.6　枚举　139

9.6.1　枚举基础　139

9.6.2　使用枚举　140

9.7　结构体　141

9.7.1　定义结构体　142

9.7.2　指向结构体的指针　142

9.7.3　使用结构体　143

9.8　联合　144

9.9　C++ 11新特性：数组的

替代品——array　145

9.10　技术解惑　146

9.10.1　字符数组和字符串的

区别　146

9.10.2　字符数组和字符串可以

相互转换　147

9.10.3　静态数组的速度快于

动态数组　147

9.10.4　Arrays与Vector的

区别　147

9.10.5　一道关于数组的

面试题　147

9.10.6　数组名不是指针　149

9.10.7　作为一个用户自定义

类型，其所占用内存

空间是多少　149

9.11　课后练习　150

第 10章　函数　151

10.1　函数基础　152

10.1.1　定义函数　152

10.1.2　函数分类　153

10.2　参数和返回值　158

10.2.1　什么是形参实参　158

10.2.2　使用数组作函数

参数　159

10.3　调用函数　160

10.3.1　单独调用　160

10.3.2　函数表达式　160

10.3.3　调用实参　161

10.3.4　参数传递　161

10.4　函数的基本操作　162

10.4.1　函数递归　162

10.4.2　指向函数的指针　163

10.4.3　将函数作为参数　164

10.5　技术解惑　165

10.5.1　用typedef定义一个函数

指针类型　165

10.5.2　const关键字在函数中的

作用　166

10.5.3　C++函数的内存分配

机制　167

10.5.4　主函数和子函数的

关系　167

10.5.5　函数声明和函数定义的

区别　168

10.5.6　使用全局变量的

注意事项　168

10.5.7　使用寄存器变量的

注意事项　168

10.5.8　自动变量的特点　169

10.6　课后练习　169

第 11章　输入和输出　170

11.1　使用iostream对象　171

11.1.1　库iostream的作用　171

11.1.2　标准的I/O接口　171

11.1.3　文件I/O　173

11.1.4　字符串I/O　174

11.2　输出　175

11.2.1　预定义类型输出　175

11.2.2　自定义类型输出　176

11.3　输入　177

11.3.1　预定义类型输入　177

11.3.2　自定义类型输入　177

11.4　输入/输出的格式化　178

11.4.1　使用ios类成员函数　179

11.4.2　使用操纵函数　180

11.5　文件操作　181

11.5.1　打开和关闭　181

11.5.2　随机读写　183

11.5.3　二进制文件　184

11.5.4　检测EOF　185

11.6　技术解惑　187

11.6.1　输入/输出时数的

进制问题　187

11.6.2　数据间隔　187

11.6.3　内存文件映射　188

11.6.4　get和put的值的

差异　188

11.6.5　使用控制符控制输出

格式　188

11.7　课后练习　189

第 12章　面向对象的类和对象　190

12.1　类　191

12.1.1　声明类　191

12.1.2　类的属性　192

12.1.3　类的方法　192

12.1.4　构造函数　193

12.1.5　析构函数　194

12.1.6　静态成员　195

12.1.7　友元　196

12.1.8　使用修饰符　198

12.2　对象　199

12.2.1　定义对象　199

12.2.2　对象数组　200

12.2.3　对象指针　201

12.2.4　使用this指针　201

12.3　C++ 11标准的新变化　203

12.3.1　定义一个类内初始值　203

12.3.2　使用initializer_list

处理多个实参　204

12.4　技术解惑　208

12.4.1　浅复制和深复制　208

12.4.2　构造函数的错误认识和

正确认识　209

12.4.3　保护性析构函数的

作用　209

12.5　课后练习　210

第 13章　命名空间和作用域　211

13.1　命名空间基础　212

13.1.1　命名空间介绍　212

13.1.2　定义命名空间　212

13.2　使用命名空间　214

13.2.1　使用域限定符　214

13.2.2　使用using指令　215

13.2.3　使用using声明　216

13.2.4　使用别名　216

13.3　作用域　217

13.3.1　与作用域相关的概念　217

13.3.2　作用域的分类　218

13.4　技术解惑　220

13.4.1　using指令与using

声明的比较　220

13.4.2　为什么需要命名空间　220

13.4.3　命名空间的作用　221

13.4.4　C++中头文件的使用

方法　222

13.5　课后练习　222

第 14章　继承和派生　223

14.1　继承与派生基础　224

14.2　C++的继承机制　224

14.2.1　定义继承　224

14.2.2　派生类的继承方式　226

14.2.3　公有派生和私有派生　227

14.3　派生类　228

14.3.1　使用基类　228

14.3.2　使用派生　228

14.3.3　构造函数　230

14.3.4　析构函数　232

14.3.5　使用同名函数　233

14.3.6　使用同名属性　235

14.4　单重继承和多重继承　236

14.4.1　单重继承　236

14.4.2　多重继承　236

14.4.3　多重继承下的构造

函数和析构函数　237

14.5　虚继承和虚基类　239

14.5.1　虚基类介绍　240

14.5.2　使用虚基类　240

14.6　技术解惑　241

14.6.1　通过虚继承解决二义性

问题　241

14.6.2　使用C++虚基类的

注意事项　242

14.6.3　虚基类的子对象的

初始化　243

14.6.4　允许派生类中的成员名与

基类中的成员名相同　243

14.7　课后练习　243

第 15章　多态　244

15.1　什么是多态　245

15.2　宏多态　245

15.3　虚函数　246

15.3.1　虚函数基础　246

15.3.2　纯虚函数　248

15.4　抽象类　249

15.4.1　什么是抽象类　249

15.4.2　抽象类的派生　249

15.5　运算符重载和函数重载　251

15.5.1　运算符重载基础　251

15.5.2　重载一元运算符　251

15.5.3　重载二元运算符　252

15.5.4　参数类型不同的重载　253

15.6　流的重载　254

15.6.1　流插入重载　254

15.6.2　流提取重载　255

15.7　覆盖　257

15.7.1　覆盖函数　257

15.7.2　覆盖变量　258

15.8　技术解惑　259

15.8.1　重载、覆盖和隐藏的

区别　259

15.8.2　在重载运算符时要权衡

实施的必要性　260

15.8.3　为什么需要函数重载　260

15.8.4　重载函数的调用匹配　260

15.8.5　另一种虚方法查找

方案　261

15.8.6　两种重载方法的比较　262

15.9　课后练习　262

第 16章　使用模板　263

16.1　模板基础　264

16.2　类模板　265

16.2.1　什么是类模板　265

16.2.2　定义类模板　265

16.2.3　使用类模板　266

16.2.4　类模板的派生　268

16.2.5　类模板和模板类的

区别　268

16.3　函数模板　270

16.3.1　定义函数模板　270

16.3.2　使用函数模板　271

16.3.3　模板实例化　271

16.3.4　模板组合　273

16.4　技术解惑　273

16.4.1　在函数模板中使用多个

类型参数时要避免类型

参数的二义性　273

16.4.2　函数模板和模板函数的

区别　274

16.4.3　函数模板和类模板的

区别　274

16.4.4　仿函数的用处　275

16.5　课后练习　275

第 17章　异常处理　276

17.1　什么是异常处理　277

17.2　C++的异常处理　277

17.2.1　使用throw抛出异常　277

17.2.2　使用raise抛出异常　279

17.2.3　使用try catch异常

捕获　279

17.2.4　异常处理中的构造和

析构　281

17.3　C++的异常处理总结　282

17.4　技术解惑　284

17.4.1　编写软件的目标　284

17.4.2　关于C++关键字new的

异常处理　284

17.4.3　C++语言异常处理和

结构化异常处理有

什么区别　285

17.4.4　C++抛出异常不捕获，

程序的空间会释放吗　285

17.4.5　throw抛出异常的

特点　286

17.4.6　关于C++异常处理的

体会　286

17.4.7　慎用catch(...)　286

17.4.8　慎用继承体系里的

类作为catch的参数　287

17.4.9　对象析构函数被调用的

3种场合　287

17.4.10　不要在异常处理体系中

寄希望于类型转换　287

17.4.11　是否有C++异常处理

体系捕获不到的东西　288

17.4.12　set_unexpected函数的

用处　288

17.4.13　不要让异常逃离析构

函数　289

17.5　课后练习　289

第 18章　内存管理　290

18.1　内存分类　291

18.2　栈内存管理　291

18.2.1　申请栈内存　291

18.2.2　使用栈内存　292

18.2.3　释放栈内存　294

18.2.4　改变内存大小　294

18.3　堆内存管理　295

18.3.1　申请堆内存　295

18.3.2　使用堆内存　296

18.3.3　释放堆内存　296

18.3.4　改变内存大小　297

18.4　技术解惑　298

18.4.1　堆和栈的区别　298

18.4.2　常见的内存错误及其

对策　299

18.4.3　防止发生溢出错误　300

18.5　课后练习　300

第 19章　预处理　301

19.1　预处理基础　302

19.1.1　什么是预处理　302

19.1.2　C++中的预处理　302

19.2　使用宏时的常见陷阱　308

19.3　技术解惑　309

19.3.1　预处理的未来　309

19.3.2　两者的意义　310

19.3.3　一个初学者的问题　310

19.4　课后练习　310

第 20章　错误和调试　311

20.1　什么是错误　312

20.1.1　Bug的由来　312

20.1.2　程序设计方面的解释　312

20.2　常见的错误分析　312

20.3　程序调试常见错误　317

20.4　C++编程中的调试技巧　322

20.4.1　调试标记　322

20.4.2　运行期间调试标记　322

20.4.3　把变量和表达式转换成

字符串　323

20.4.4　C++语言的assert()　323

20.5　技术解惑　323

20.5.1　编写规范易懂的代码　323

20.5.2　编写安全可靠的代码　324

20.5.3　Visual C++调试技术　326

20.5.4　常见的非语法错误　328

第 21章　初入江湖——图书借阅系统的

实现过程　329

21.1　项目要求　330

21.2　需求分析　330

21.3　系统具体实现　330

21.3.1　数据结构设计　331

21.3.2　系统主文件rent.cpp　331

21.3.3　菜单处理文件

mainfunction.h　332

21.3.4　函数定义文件

subfunction.h　332

21.3.5　菜单处理实现文件

mainfunction.cpp　333

21.3.6　功能函数实现文件

subfunction.cpp　337

第 22章　开始闯关——C++实现网络

应用项目　353

22.1　项目要求　354

22.1.1　客户机/服务器模式

介绍　354

22.1.2　客户机/服务器模式的

运作流程　355

22.2　实现原理　355

22.2.1　什么是Winsocket编程

接口　355

22.2.2　Winsocket中的函数　355

22.3　具体实现　360

22.3.1　客户端和服务器端的

公用文件　360

22.3.2　实现服务器端　363

22.3.3　实现客户端　364

第 23章　开始闯关——C++实现游戏

项目　366

23.1　计算机游戏基础　367

23.1.1　游戏的基本流程　367

23.1.2　游戏元素　367

23.1.3　游戏层次　368

23.2　项目分析　368

23.2.1　游戏的角色　368

23.2.2　游戏界面表现　369

23.3　具体实现　369

23.3.1　实现相关位图　369

23.3.2　变量与函数　369

23.3.3　实现全屏　371

23.3.4　类初始化　371

23.3.5　实现具体显示界面　372

23.3.6　信息提示　374

23.3.7　与时间段相关的操作　374

23.3.8　键盘操作　375

23.3.9　我方发射子弹　376

23.3.10　敌机出现　378

23.3.11　敌机发射子弹　378

23.3.12　敌机子弹移动　378

23.3.13　火力实现　379