C++20实践入门（第6版） 下载 pdf 百度网盘 epub 免费 2025 电子书 mobi 在线

本书讲解如何使用新推出的C++20编写程序。开篇介绍基础知识，此后抽丝剥茧地分析示例，助你华丽蜕变为高水平的C++程序员。本书呈现C++20的诸多新特性，如模块、概念、范围和太空飞船运算符等。即使不具备编程经验，你也可在本书的指引下，快速在一个较新的C++编译器上编写出真正可用的C++程序。

本书在示例程序的引导下演示所有重要概念，每章都提供习题，供读者巩固所学的知识，测验自己的水准。配书网站为所有示例和习题答案提供了可免费下载的代码。

本书针对C++语言的最新版本C++20做了全面更新，呈现现代C++的所有约定和最佳实践。还介绍C++标准库的元素，这些元素为C++20语言提供了必要支持。

主要内容：

●

开始使用C++20标准编写程序

●

使用C++进行模块化编程

●

使用数组、循环、指针、引用和字符串等

●

编写自己的函数、类型和运算符

●

了解面向对象编程的要素

●

使用重载、继承、虚函数和多态性

●

编写泛型函数和类模板，并使用概念让它们更安全

●

深入了解容器、算法和范围

●

使用自动类型推断、异常、移动语义、lambda表达式等

第1章 基本概念

1

1.1 现代C++

1

1.2 标准库

2

1.3 C++程序概念

3

1.3.1 源文件

3

1.3.2 注释和空白

3

1.3.3 标准库模块

4

1.3.4 函数

4

1.3.5 语句

5

1.3.6 数据的输入和输出

6

1.3.7 return语句

6

1.3.8 名称空间

6

1.3.9 名称和关键字

7

1.4 类和对象

7

1.5 模板

8

1.6 代码的表示样式和编程风格

8

1.7 创建可执行文件

9

1.8 过程化编程和面向对象编程

10

1.9 表示数字

11

1.9.1 二进制数

11

1.9.2 十六进制数

12

1.9.3 负的二进制数

13

1.9.4 八进制数

15

1.9.5 Big-Endian和Little-Endian系统

15

1.9.6 浮点数

16

1.10 表示字符

17

1.10.1 ASCII 码

18

1.10.2 UCS和Unicode

18

1.11 C++源字符

19

1.12 本章小结

20

1.13 练习

21

第2章 基本数据类型

23

2.1 变量、数据和数据类型

23

2.1.1 定义整型变量

24

2.1.2 零初始化

27

2.1.3 定义有固定值的变量

27

2.2 整型字面量

27

2.2.1 十进制整型字面量

27

2.2.2 十六进制的整型字面量

28

2.2.3 八进制的整型字面量

29

2.2.4 二进制的整型字面量

29

2.3 整数的计算

29

2.4 赋值运算

31

2.5 sizeof运算符

35

2.6 整数的递增和递减

35

2.7 定义浮点变量

37

2.8 浮点字面量

38

2.9 浮点数的计算

38

2.9.1 数学常量

38

2.9.2 数学函数

39

2.9.3 无效的浮点结果

42

2.9.4 缺点

43

2.10 混合的表达式和类型转换

43

2.11 显式类型转换

44

2.12 格式化字符串

47

2.13 确定数值的上下限

52

2.14 使用字符变量

54

2.15 auto关键字

56

2.16 本章小结

57

2.17 练习

57

第3章 处理基本数据类型

59

3.1 运算符的优先级和相关性

59

3.2 位运算符

61

3.2.1 移位运算符

61

3.2.2 位模式下的逻辑运算

64

3.3 变量的生存期

69

3.4 全局变量

70

3.5 枚举数据类型

73

3.6 数据类型的别名

76

3.7 本章小结

77

3.8 练习

78

第4章 决策

79

4.1 比较数据值

79

4.1.1 应用比较运算符

80

4.1.2 比较浮点数值

81

4.1.3 太空飞船运算符

82

4.2 if语句

84

4.2.1 嵌套的if语句

87

4.2.2 字符分类和转换

88

4.3 if-else语句

90

4.3.1 嵌套的if-else语句

91

4.3.2 理解嵌套的if语句

92

4.4 逻辑运算符

93

4.4.1 逻辑与运算符

94

4.4.2 逻辑或运算符

94

4.4.3 逻辑非运算符

95

4.4.4 组合逻辑运算符

95

4.4.5 对整数操作数应用逻辑运算符

97

4.4.6 对比逻辑运算符与位运算符

97

4.5 条件运算符

99

4.6 switch语句

100

4.7 语句块和变量作用域

106

4.8 本章小结

108

4.9 练习

108

第5章 数组和循环

111

5.1 数组

111

5.2 理解循环

113

5.3 for循环

113

5.4 避免幻数

115

5.5 用初始化列表定义数组的大小

117

5.6 确定数组的大小

117

5.7 用浮点数控制for循环

119

5.8 使用更复杂的for循环控制

表达式

120

5.9 基于范围的for循环

122

5.10 while循环

123

5.11 do-while循环

125

5.12 嵌套的循环

127

5.13 跳过循环迭代

129

5.14 循环的中断

131

5.15 使用无符号整数控制for循环

134

5.16 字符数组

135

5.17 多维数组

138

5.17.1 初始化多维数组

140

5.17.2 多维字符数组

141

5.18 在运行期间给数组分配内存

空间

143

5.19 数组的替代品

145

5.19.1 使用array

容器

145

5.19.2 使用std::vector

容器

150

5.20 本章小结

153

5.21 练习

154

第6章 指针和引用

157

6.1 什么是指针

157

6.2 地址运算符

159

6.3 间接运算符

160

6.4 为什么使用指针

161

6.5 char类型的指针

162

6.6 常量指针和指向常量的指针

165

6.7 指针和数组

167

6.7.1 指针的算术运算

168

6.7.2 使用数组名的指针表示法

170

6.8 动态内存分配

172

6.8.1 栈和自由存储区

172

6.8.2 运算符new和delete

173

6.8.3 数组的动态内存分配

174

6.9 通过指针选择成员

177

6.10 动态内存分配的危险

178

6.10.1 悬挂指针和多次释放

178

6.10.2 分配与释放的不匹配

178

6.10.3 内存泄漏

179

6.10.4 自由存储区的碎片

179

6.11 内存分配的黄金准则

180

6.12 原始指针和智能指针

180

6.12.1 使用unique_ptr

指针

181

6.12.2 使用shared_ptr

指针

184

6.13 理解引用

187

6.13.1 定义引用

187

6.13.2 在基于范围的for循环中

使用引用变量

188

6.14 本章小结

189

6.15 练习

190

第7章 操作字符串

191

7.1 更强大的string类

191

7.1.1 定义string对象

191

7.1.2 string对象的操作

195

7.1.3 访问字符串中的字符

198

7.1.4 访问子字符串

200

7.1.5 比较字符串

201

7.1.6 搜索字符串

207

7.1.7 修改字符串

213

7.1.8 对比std::string与

std::vector

217

7.2 将字符串转换为数字

217

7.3 国际字符串

218

7.3.1 存储wchar_t字符的字符串

218

7.3.2 包含Unicode字符串的对象

219

7.4 原始字符串字面量

219

7.5 本章小结

221

7.6 练习

221

第8章 定义函数

223

8.1 程序的分解

223

8.1.1 类中的函数

224

8.1.2 函数的特征

224

8.2 定义函数

224

8.2.1 函数体

226

8.2.2 返回值

227

8.2.3 函数声明

227

8.3 给函数传递实参

229

8.3.1 按值传递

229

8.3.2 按引用传递

236

8.4 默认实参值

242

8.5 main()函数的实参

244

8.6 从函数中返回值

245

8.6.1 返回指针

245

8.6.2 返回引用

249

8.6.3 对比返回值与输出参数

249

8.6.4 返回类型推断

250

8.7 静态变量

251

8.8 函数重载

252

8.8.1 重载和指针参数

254

8.8.2 重载和引用参数

254

8.8.3 重载和const参数

256

8.8.4 重载和默认实参值

257

8.9 递归

258

8.9.1 基本示例

258

8.9.2 递归算法

260

8.10 本章小结

265

8.11 练习

266

第9章 词汇类型

269

9.1 使用可选值

269

9.2 字符串视图：新的const string

引用

272

9.2.1 使用字符串视图函数参数

274

9.2.2 合适的动机

274

9.3 span：新的向量或数组引用

275

9.3.1 span与视图

276

9.3.2 const元素的span

277

9.3.3 固定大小的span

278

9.4 本章小结

278

9.5 练习

278

第10章 函数模板

281

10.1 函数模板

281

10.2 创建函数模板的实例

282

10.3 模板类型参数

283

10.4 显式指定模板实参

284

10.5 函数模板的特化

284

10.6 函数模板和重载

285

10.7 带有多个参数的函数模板

286

10.8 模板的返回类型推断

287

10.9 模板参数的默认值

289

10.10 非类型的模板参数

290

10.11 缩写的函数模板

293

10.12 本章小结

294

10.13 练习

294

第11章 模块和名称空间

297

11.1 模块

297

11.1.1 第一个模块

298

11.1.2 导出块

300

11.1.3 将接口与实现分开

301

11.1.4 可达性与可见性

305

11.1.5 导出import声明

306

11.1.6 管理较大的模块

307

11.1.7 全局模块片段

310

11.2 名称空间

311

11.2.1 全局名称空间

311

11.2.2 定义名称空间

311

11.2.3 嵌套名称空间

313

11.2.4 名称空间和模块

314

11.2.5 函数和名称空间

315

11.2.6 使用指令和声明

316

11.2.7 名称空间别名

318

11.3 本章小结

318

11.4 练习

319

第12章 定义自己的数据类型

321

12.1 类和面向对象编程

321

12.1.1 封装

322

12.1.2 继承

325

12.1.3 多态性

326

12.2 术语

326

12.3 定义类

327

12.4 构造函数

329

12.4.1 默认构造函数

329

12.4.2 定义类的构造函数

330

12.4.3 使用default关键字

331

12.4.4 在类的外部定义函数

332

12.4.5 默认构造函数的参数值

333

12.4.6 使用成员初始化列表

333

12.4.7 使用explicit关键字

334

12.4.8 委托构造函数

336

12.4.9 副本构造函数

337

12.5 访问私有类成员

340

12.6 this指针

342

12.7 const对象和const成员函数

343

12.7.1 const成员函数

344

12.7.2 const正确性

345

12.7.3 重载const

346

12.7.4 常量的强制转换

348

12.7.5 使用mutable关键字

348

12.8 友元

349

12.8.1 类的友元函数

349

12.8.2 友元类

351

12.9 类的对象数组

351

12.10 类对象的大小

353

12.11 类的静态成员

353

12.11.1 静态成员变量

354

12.11.2 访问静态成员变量

356

12.11.3 静态常量

357

12.11.4 类类型的静态成员变量

358

12.11.5 静态成员函数

358

12.12 析构函数

359

12.13 使用指针作为类成员

361

12.14 嵌套类

374

12.15 本章小结

378

12.16 练习

379

第13章 运算符重载

381

13.1 为类实现运算符

381

13.1.1 运算符重载

382

13.1.2 实现重载运算符

382

13.1.3 非成员运算符函数

384

13.1.4 提供对运算符的全部支持

384

13.2 可以重载的运算符

386

13.3 运算符函数习语

388

13.4 为输出流重载

394

13.5 重载算术运算符

396

13.6 成员与非成员函数

400

13.7 重载一元运算符

402

13.8 重载递增和递减运算符

403

13.9 重载下标运算符

404

13.10 函数对象

409

13.11 重载类型转换

410

13.12 重载赋值运算符

411

13.12.1 实现复制赋值运算符

411

13.12.2 复制赋值运算符与副本

构造函数

415

13.12.3 赋值不同类型

415

13.13 本章小结

416

13.14 练习

416

第14章 继承

419

14.1 类和面向对象编程

419

14.2 类的继承

420

14.2.1 继承和聚合

421

14.2.2 派生类

422

14.3 把类的成员声明为protected

424

14.4 派生类成员的访问级别

424

14.4.1 在类层次结构中使用访问

修饰符

425

14.4.2 在类层次结构中选择访问

修饰符

426

14.4.3 改变继承成员的访问修饰符

427

14.5 派生类中的构造函数

428

14.5.1 派生类中的副本构造函数

431

14.5.2 派生类中的默认构造函数

432

14.5.3 继承构造函数

433

14.6 继承中的析构函数

434

14.7 重复的成员变量名

436

14.8 重复的成员函数名

436

14.9 多重继承

437

14.9.1 多个基类

437

14.9.2 继承成员的模糊性

438

14.9.3 重复继承

442

14.9.4 虚基类

442

14.10 在相关的类类型之间转换

443

14.11 本章小结

444

14.12 练习

444

第15章 多态性

447

15.1 理解多态性

447

15.1.1 使用基类指针

447

15.1.2 调用继承的函数

449

15.1.3 虚函数

452

15.1.4 虚函数中的默认实参值

459

15.1.5 通过引用调用虚函数

460

15.1.6 多态集合

461

15.1.7 通过指针释放对象

462

15.1.8 在指针和类对象之间转换

464

15.1.9 动态强制转换

465

15.1.10 调用虚函数的基类版本

468

15.1.11 在构造函数或析构函数中

调用虚函数

469

15.2 多态性引发的成本

471

15.3 确定动态类型

472

15.4 纯虚函数

475

15.4.1 抽象类

476

15.4.2 用作接口的抽象类

478

15.5 本章小结

481

15.6 练习

481

第16章 运行时错误和异常

483

16.1 处理错误

483

16.2 理解异常

484

16.2.1 抛出异常

485

16.2.2 异常处理过程

486

16.2.3 导致抛出异常的代码

487

16.2.4 嵌套的try块

488

16.3 用类对象作为异常

489

16.3.1 匹配catch处理程序和异常

491

16.3.2 用基类处理程序捕获派生类

异常

493

16.4 重新抛出异常

495

16.5 未处理的异常

497

16.6 捕获所有的异常

498

16.7 不抛出异常的函数

500

16.7.1 noexcept限定符

500

16.7.2 异常和析构函数

501

16.8 异常和资源泄露

501

16.8.1 资源获取即初始化

503

16.8.2 用于动态内存的标准RAII类

505

16.9 标准库异常

506

16.9.1 异常类的定义

507

16.9.2 使用标准异常

508

16.10 本章小结

512

16.11 练习

512

第17章 类模板

515

17.1 理解类模板

515

17.2 定义类模板

516

17.2.1 模板类型参数

517

17.2.2 简单的类模板

518

17.3 定义类模板的成员函数

519

17.3.1 构造函数模板

519

17.3.2 析构函数模板

520

17.3.3 下标运算符模板

520

17.3.4 赋值运算符模板

522

17.4 创建类模板的实例

526

17.5 测试数组类模板

527

17.6 非类型的类模板参数

530

17.6.1 带有非类型参数的成员函数的

模板

531

17.6.2 非类型参数的实参

534

17.6.3 对比非类型模板实参与构造

函数实参

535

17.7 模板参数的默认值

536

17.8 类模板实参推断

536

17.9 类模板特化

538

17.9.1 定义类模板特化

538

17.9.2 部分模板特化

539

17.10 带有嵌套类的类模板

540

17.11 依赖名称的麻烦问题

546

17.12 本章小结

550

17.13 练习

551

第18章 移动语义

555

18.1 lvalue和rvalue

555

18.2 移动对象

557

18.3 显式移动对象

563

18.3.1 只能移动的类型

563

18.3.2 移动对象的继续使用

564

18.4 看似矛盾的情况

565

18.4.1 std::move()并不移动任何东西

565

18.4.2 rvalue引用是一个lvalue

566

18.5 继续探讨函数定义

566

18.5.1 按rvalue引用传递

566

18.5.2 按值传递

568

18.5.3 按值返回

570

18.6 继续讨论定义移动成员

572

18.6.1 总是添加noexcept

572

18.6.2 “移动后交换”技术

575

18.7 特殊成员函数

577

18.7.1 默认移动成员

578

18.7.2 5的规则

578

18.7.3 0的规则

579

18.8 本章小结

580

18.9 练习

580

第19章 头等函数

583

19.1 函数指针

583

19.1.1 定义函数指针

584

19.1.2 高阶函数的回调函数

586

19.1.3 函数指针的类型别名

588

19.2 函数对象

589

19.2.1 基本的函数对象

589

19.2.2 标准函数对象

591

19.2.3 参数化函数对象

592

19.3 lambda表达式

593

19.3.1 定义lambda表达式

593

19.3.2 命名lambda闭包

594

19.3.3 向函数模板传递lambda

表达式

595

19.3.4 泛型lambda

596

19.3.5 捕获子句

596

19.4 std::function模板

600

19.5 本章小结

602

19.6 练习

603

第20章 容器与算法

605

20.1 容器

605

20.1.1 顺序容器

606

20.1.2 栈和队列

608

20.1.3 关联容器

610

20.2 迭代器

617

20.2.1 迭代器设计模式

617

20.2.2 标准库容器的迭代器

618

20.2.3 数组的迭代器

626

20.3 算法

627

20.3.1 第一个示例

627

20.3.2 寻找元素

629

20.3.3 处理多个输出值

630

20.3.4 删除-擦除技术

632

20.3.5 排序

634

20.3.6 并行算法

635

20.3.7 范围与视图

635

20.4 视图与范围

637

20.5 本章小结

641

20.6 练习

642

第21章 受约束的模板和概念

645

21.1 无约束模板

645

21.2 受约束的模板

646

21.3 概念

648

21.3.1 概念定义和表达式

648

21.3.2 requires表达式

649

21.3.3 断言类型建模了一个概念

653

21.3.4 标准概念

653

21.4 requires子句

654

21.5　简写表示法

655

21.6 受约束的函数模板

656

21.7　受约束的类模板

657

21.8 基于约束的特化

659

21.9 约束auto

661

21.10 本章小结

662

21.11 练习

662

Ivor Horton从数学系毕业，却被信息技术领域工作量少、回报高的前景所吸引。虽然现实证明，工作量大，回报相对一般，但是他与计算机一直相伴到今天。在不同的时期，他参与过编程、系统设计、咨询以及相当复杂的项目的管理和实施工作。

Ivor有多年工程设计和制造控制系统的设计和实施经验。他使用多种编程语言开发过在不同场景中很实用的应用程序，并教会一些科学家和工程师如何使用编程语言开发一些实用的程序。他目前出版的图书涉及C、C 和Java等编程语言。当他没有在撰写编程图书或者为他人提供咨询服务时，他会去钓鱼或旅行，享受生活。

Peter Van Weert是一名软件工程师，主要兴趣和专长是应用软件开发、编程语言、算法和数据结构。他在鲁汶大学以毕业生荣誉获得计算机科学硕士学位，并得到了考试委员会的祝贺。2010年，他在鲁汶大学的声明式编程语言和人工智能研究组完成了博士论文，主题是基于规则的编程语言的设计和高效编译。在攻读博士期间，他担任面向对象编程(Java)、软件分析与设计以及声明式编程的助教。

暂无出版社相关信息，正在全力查找中！

暂无相关书籍摘录，正在全力查找中！

在线阅读地址：C++20实践入门（第6版）在线阅读

在线听书地址：C++20实践入门（第6版）在线收听

在线购买地址：C++20实践入门（第6版）在线购买

暂无原文赏析，正在全力查找中！

书籍介绍

本书讲解如何使用新推出的C++20编写程序。开篇介绍基础知识，此后抽丝剥茧地分析示例，助你华丽蜕变为高水平的C++程序员。本书呈现C++20的诸多新特性，如模块、概念、范围和太空飞船运算符等。即使不具备编程经验，你也可在本书的指引下，快速在一个较新的C++编译器上编写出真正可用的C++程序。

本书在示例程序的引导下演示所有重要概念，每章都提供习题，供读者巩固所学的知识，测验自己的水准。配书网站为所有示例和习题答案提供了可免费下载的代码。

本书针对C++语言的最新版本C++20做了全面更新，呈现现代C++的所有约定和最佳实践。还介绍C++标准库的元素，这些元素为C++20语言提供了必要支持。

主要内容：

●

开始使用C++20标准编写程序

●

使用C++进行模块化编程

●

使用数组、循环、指针、引用和字符串等

●

编写自己的函数、类型和运算符

●

了解面向对象编程的要素

●

使用重载、继承、虚函数和多态性

●

编写泛型函数和类模板，并使用概念让它们更安全

●

深入了解容器、算法和范围

●

使用自动类型推断、异常、移动语义、lambda表达式等