C++17入门经典第5版电子版高清版

编辑点评：计算机编程新手零基础自学入门书

C++入门书熟悉C++新发展的好书，基于最新的C++17主题编写，C++17入门经典第5版中详细的介绍了如何使用新的c++17编写程序，更新了标准库，现代约定，还有各章节练习题，非常的使用。

c17入门经典第5版pdf图片预览

内容简介

本书介绍如何使用最新的C++17编写程序。从基础知识讲起，通过详细分析示例，帮助读者成为能够自己编写程序的程序员。参考本书的内容，并安装最新的C++编译器，读者很快就能编写真正地C++程序。本书不需要读者有任何编程经验，因此在讲解所有语言概念时，均给出了可以工作的程序示例，并且全部章节都包含练习题，以帮助读者检测并联系自己学到的知识。本书为正文中的所有代码示例和练习题提供可下载的代码。

本书内容已针对C++语言的最新版本C++17做了全面更新，并且介绍了现代C++的约定和最佳实践，它们为C++17语言提供了必要的支持。

目录介绍

第1章基本概念 1

1.1现代C++ 1

1.2标准库 2

1.3C++程序概念 2

1.3.1源文件和头文件 3

1.3.2注释和空白 3

1.3.3预处理指令和标准库头文件 3

1.3.4函数 3

1.3.5语句 4

1.3.6数据的输入输出 4

1.3.7return语句 5

1.3.8名称空间 5

1.3.9名称和关键字 6

1.4类和对象 6

1.5模板 6

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

1.7创建可执行文件 7

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

1.9表示数字 9

1.9.1二进制数 9

1.9.2十六进制数 10

1.9.3负的二进制数 11

1.9.4八进制数 12

1.9.5Big-Endian和Little-Endian 12

1.9.6浮点数 13

1.10表示字符 14

1.10.1ASCII 码 14

1.10.2UCS和Unicode 14

1.11C++源字符 15

1.12本章小结 17

1.13练习 17

第2章基本数据类型 19

2.1变量、数据和数据类型 19

2.1.1定义整型变量 19

2.1.2零初始化 22

2.1.3定义有固定值的变量 22

2.2整型字面量 22

2.2.1十进制整型字面量 23

2.2.2十六进制的整型字面量 23

2.2.3八进制的整型字面量 24

2.2.4二进制的整型字面量 24

2.3整数的计算 24

2.4赋值运算 26

2.5sizeof运算符 29

2.6整数的递增和递减 30

2.7定义浮点变量 31

2.8浮点字面量 32

2.9浮点数的计算 32

2.9.1缺点 32

2.9.2无效的浮点结果 33

2.9.3数学函数 33

2.10输出流的格式化 35

2.11混合的表达式和类型转换 37

2.12显式类型转换 38

2.13确定数值的上下限 40

2.14使用字符变量 41

2.15auto关键字 42

2.16本章小结 43

2.17练习 43

第3章处理基本数据类型 45

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

3.2位运算符 46

3.2.1移位运算符 47

3.2.2位模式下的逻辑运算 49

3.3枚举数据类型 53

3.4数据类型的别名 55

3.5变量的生存期 56

3.6全局变量 56

3.7本章小结 59

3.8练习 59

第4章决策 61

4.1比较数据值 61

4.1.1应用比较运算符 62

4.1.2比较浮点数值 63

4.2if语句 63

4.2.1嵌套的if语句 65

4.2.2字符分类和转换 66

4.3if-else语句 68

4.3.1嵌套的if-else语句 69

4.3.2理解嵌套的if语句 70

4.4逻辑运算符 71

4.4.1逻辑与运算符 71

4.4.2逻辑或运算符 71

4.4.3逻辑非运算符 72

4.4.4组合逻辑运算符 72

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

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

4.5条件运算符 75

4.6switch语句 76

4.7语句块和变量作用域 81

4.8本章小结 82

4.9练习 83

第5章数组和循环 85

5.1数组 85

5.2理解循环 87

5.3for循环 87

5.4避免幻数 89

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

5.6确定数组的大小 90

5.7用浮点数控制for循环 91

5.8使用更复杂的for循环控制表达式 93

5.9基于范围的for循环 94

5.10while循环 95

5.11do-while循环 96

5.12嵌套的循环 98

5.13跳过循环迭代 100

5.14循环的中断 101

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

5.16字符数组 104

5.17多维数组 107

5.17.1初始化多维数组 108

5.17.2多维字符数组 110

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

5.19数组的替代品 112

5.19.1使用array容器 113

5.19.2使用std::vector容器 116

5.20本章小结 119

5.21练习 120

第6章指针和引用 121

6.1什么是指针 121

6.2地址运算符 123

6.3间接运算符 124

6.4为什么使用指针 125

6.5char类型的指针 125

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

6.7指针和数组 130

6.7.1指针的算术运算 130

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

6.8动态内存分配 133

6.8.1栈和自由存储区 134

6.8.2运算符new和delete 134

6.8.3数组的动态内存分配 135

6.9通过指针选择成员 138

6.10动态内存分配的危险 138

6.10.1悬挂指针和多次释放 138

6.10.2分配与释放的不匹配 139

6.10.3内存泄漏 139

6.10.4自由存储区的碎片 139

6.11内存分配的黄金准则 140

6.12原始指针和智能指针 140

6.12.1使用unique_ptr指针 141

6.12.2使用shared_ptr指针 143

6.13理解引用 146

6.13.1定义引用 146

6.13.2在基于范围的for循环中使用引用变量 147

6.14本章小结 148

6.15练习 148

第7章操作字符串 151

7.1更强大的string类 151

7.1.1定义string对象 151

7.1.2string对象的操作 154

7.1.3访问字符串中的字符 157

7.1.4访问子字符串 158

7.1.5比较字符串 158

7.1.6搜索字符串 162

7.1.7修改字符串 167

7.1.8对比std::string与std::vector 170

7.2将字符串转换为数字 171

7.3字符串流 171

7.4 字符串 172

7.4.1存储wchar_t字符的字符串 172

7.4.2包含Unicode字符串的对象 173

7.5原始字符串字面量 173

7.6本章小结 174

7.7练习 175

第8章定义函数 177

8.1程序的分解 177

8.1.1类中的函数 177

8.1.2函数的特征 178

8.2定义函数 178

8.2.1函数体 179

8.2.2返回值 180

8.2.3函数声明 181

8.3给函数传送实参 182

8.3.1按值传送 182

8.3.2按引用传送 187

8.3.3字符串视图：新的const string引用 192

8.4默认实参值 194

8.5main()函数的实参 196

8.6从函数中返回值 196

8.6.1返回指针 197

8.6.2返回引用 199

8.6.3对比返回值与输出参数 200

8.6.4返回类型推断 200

8.6.5使用可选值 201

8.7静态变量 203

8.8内联函数 204

8.9函数重载 204

8.9.1重载和指针参数 206

8.9.2重载和引用参数 206

8.9.3重载和const参数 207

8.9.4重载和默认实参值 208

8.10递归 209

8.10.1基本示例 209

8.10.2递归算法 210

8.11本章小结 215

8.12练习 216

第9章函数模板 219

9.1函数模板 219

9.2创建函数模板的实例 220

9.3模板类型参数 221

9.4显式指定模板实参 221

9.5函数模板的特例 222

9.6函数模板和重载 222

9.7带有多个参数的函数模板 224

9.8模板的返回类型推断 225

9.8.1decltype和拖尾返回类型 225

9.8.2对比decltype(auto)、拖尾decltype()与auto 226

9.9模板参数的默认值 226

9.10非类型的模板参数 227

9.11本章小结 229

9.12练习 229

第10章程序文件和预处理指令 231

10.1理解转换单元 231

10.1.1单一定义规则 231

10.1.2程序文件和链接 232

10.1.3确定名称的链接属性 232

10.1.4外部函数 233

10.1.5外部变量 233

10.1.6内部名称 235

10.2预处理源代码 236

10.3定义预处理宏 236

10.3.1定义类似于函数的宏 238

10.3.2取消宏的定义 239

10.4包含头文件 240

10.4.1防止重复头文件的内容 240

10.4.2 个头文件 241

10.5名称空间 242

10.5.1全局名称空间 242

10.5.2定义名称空间 242

10.5.3应用using声明 244

10.5.4函数和名称空间 244

10.5.5未命名的名称空间 246

10.5.6嵌套的名称空间 247

10.5.7名称空间的别名 248

10.6逻辑预处理指令 248

10.6.1逻辑#if指令 248

10.6.2测试指定标识符的值 249

10.6.3多个代码选择 249

10.6.4标准的预处理宏 250

10.6.5检查头文件是否可用 251

10.7调试方法 251

10.7.1集成调试器 252

10.7.2调试中的预处理指令 252

10.7.3使用assert()宏 254

10.8静态断言 255

10.9本章小结 257

10.10练习 257

第11章定义自己的数据类型 259

11.1类和面向对象编程 259

11.1.1封装 260

11.1.2继承 262

11.1.3多态性 263

11.2术语 263

11.3定义类 264

11.4构造函数 265

11.4.1默认构造函数 265

11.4.2定义类的构造函数 266

11.4.3使用default关键字 267

11.4.4在类的外部定义函数和构造函数 267

11.4.5默认构造函数的参数值 268

11.4.6使用成员初始化列表 269

11.4.7使用explicit关键字 269

11.4.8委托构造函数 271

11.4.9副本构造函数 272

11.5访问私有类成员 273

11.6this指针 274

11.7const对象和const成员函数 275

11.7.1const成员函数 276

11.7.2const正确性 277

11.7.3重载const 277

11.7.4常量的强制转换 279

11.7.5使用mutable关键字 279

11.8友元 280

11.8.1类的友元函数 280

11.8.2友元类 281

11.9类的对象数组 282

11.10类对象的大小 283

11.11类的静态成员 283

11.11.1静态成员变量 283

11.11.2访问静态成员变量 286

11.11.3静态常量 286

11.11.4类类型的静态成员变量 287

11.11.5静态成员函数 288

11.12析构函数 288

11.13使用指针作为类成员 290

11.14嵌套类 299

11.15本章小结 302

11.16练习 303

第12章运算符重载 305

12.1为类实现运算符 305

12.1.1运算符重载 305

12.1.2实现重载运算符 306

12.1.3非成员运算符函数 307

12.1.4提供对运算符的全部支持 308

12.1.5在类中实现所有的比较运算符 309

12.2可以重载的运算符 311

12.3运算符函数习语 313

12.4为输出流重载<<运算符 313

12.5重载算术运算符 315

12.6成员与非成员函数 318

12.7重载一元运算符 320

12.8重载递增和递减运算符 321

12.9重载下标运算符 322

12.10函数对象 326

12.11重载类型转换 326

12.12重载赋值运算符 327

12.12.1实现复制赋值运算符 328

12.12.2复制赋值运算符与副本构造函数 330

12.12.3赋值不同类型 330

12.13本章小结 331

12.14练习 331

第13章继承 333

13.1类和面向对象编程 333

13.2类的继承 334

13.2.1继承和聚合 335

13.2.2派生类 335

13.3把类的成员声明为protected 337

13.4派生类成员的访问级别 338

13.4.1在类层次结构中使用访问修饰符 338

13.4.2在类层次结构中选择访问修饰符 339

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

13.5派生类中的构造函数 341

13.5.1派生类中的副本构造函数 343

13.5.2派生类中的默认构造函数 344

13.5.3继承构造函数 344

13.6继承中的析构函数 345

13.7重复的成员变量名 347

13.8重复的成员函数名 347

13.9多重继承 348

13.9.1多个基类 348

13.9.2继承成员的模糊性 349

13.9.3重复继承 352

13.9.4虚基类 353

13.10在相关的类类型之间转换 353

13.11本章小结 354

13.12练习 354

第14章多态性 355

14.1理解多态性 355

14.1.1使用基类指针 355

14.1.2调用继承的函数 357

14.1.3虚函数 359

14.1.4虚函数中的默认实参值 365

14.1.5通过引用调用虚函数 366

14.1.6多态集合 366

14.1.7通过指针释放对象 367

14.1.8在指针和类对象之间转换 369

14.1.9动态强制转换 370

14.1.10调用虚函数的基类版本 373

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

调用虚函数 374

14.2多态性引发的成本 375

14.3确定动态类型 376

14.4纯虚函数 378

14.4.1抽象类 379

14.4.2用作接口的抽象类 381

14.5本章小结 382

14.6练习 383

第15章运行时和异常 385

15.1处理 385

15.2理解异常 386

15.2.1抛出异常 386

15.2.2异常处理过程 388

15.2.3导致抛出异常的代码 389

15.2.4嵌套的try块 389

15.3用类对象作为异常 392

15.3.1匹配catch处理程序和异常 393

15.3.2用基类处理程序捕获派生类异常 394

15.4重新抛出异常 396

15.5未处理的异常 398

15.6捕获所有的异常 399

15.7不抛出异常的函数 400

15.7.1noexcept限定符 400

15.7.2异常和析构函数 401

15.8异常和资源泄漏 401

15.8.1资源获取即初始化 403

15.8.2用于动态内存的标准RAII类 404

15.9标准库异常 405

15.9.1异常类的定义 406

15.9.2使用标准异常 407

15.10本章小结 409

15.11练习 410

第16章类模板 413

16.1理解类模板 413

16.2定义类模板 414

16.2.1模板参数 414

16.2.2简单的类模板 415

16.3定义类模板的成员函数 416

16.3.1构造函数模板 416

16.3.2析构函数模板 417

16.3.3下标运算符模板 417

16.3.4赋值运算符模板 419

16.4创建类模板的实例 422

16.5非类型的类模板参数 426

16.5.1带有非类型参数的成员函数的模板 427

16.5.2非类型参数的实参 431

16.5.3对比非类型模板实参与构造函数实参 431

16.6模板参数的默认值 432

16.7模板的显式实例化 432

16.8类模板特化 433

16.8.1定义类模板特化 433

16.8.2部分模板特化 433

16.8.3从多个部分特化中选择 434

16.9在类模板中使用static_assert() 434

16.10类模板的友元 435

16.11带有嵌套类的类模板 436

16.11.1栈成员的函数模板 438

16.11.2消除依赖名称的歧义 441

16.12本章小结 443

16.13练习 443

第17章移动语义 445

17.1lvalue和rvalue 445

17.2移动对象 447

17.2.1传统方法 449

17.2.2定义移动成员 449

17.3显式移动对象 452

17.3.1只能移动的类型 452

17.3.2移动对象的继续使用 453

17.4看似矛盾的情况 454

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

17.4.2rvalue引用是一个lvalue 454

17.5继续探讨函数定义 455

17.5.1按rvalue引用传送 455

17.5.2按值传送的归来 456

17.5.3按值返回 458

17.6继续讨论定义移动成员 459

17.6.1总是添加noexcept 459

17.6.2“移动后交换”技术 462

17.7特殊成员函数 463

17.7.1默认移动成员 464

17.7.25的规则 464

17.7.30的规则 465

17.8本章小结 466

17.9练习 466

第18章头等函数 467

18.1函数指针 467

18.1.1定义函数指针 467

18.1.2高阶函数的回调函数 469

18.1.3函数指针的类型别名 471

18.2函数对象 472

18.2.1基本的函数对象 472

18.2.2标准函数对象 473

18.2.3参数化函数对象 474

18.3lambda表达式 475

18.3.1定义lambda表达式 475

18.3.2命名lambda闭包 476

18.3.3向函数模板传送lambda表达式 476

18.3.4捕获子句 477

18.4std::function<>模板 481

18.5本章小结 482

18.6练习 483

第19章容器与算法 485

19.1容器 485

19.1.1顺序容器 485

19.1.2栈和队列 488

19.1.3集合 489

19.1.4映射 491

19.2迭代器 494

19.2.1迭代器设计模式 495

19.2.2标准库容器的迭代器 496

19.2.3数组的迭代器 502

19.3算法 503

19.3.1 个示例 503

19.3.2寻找元素 504

19.3.3输出多个值 505

19.3.4删除-擦除技术 507

19.3.5排序 507

19.3.6并行算法 508

19.4本章小结 508

19.5练习 509

作者介绍

Ivor Horton是世界著名计算机图书作家，独立顾问，帮助无数程序员步入编程殿堂。他曾在IBM工作多年，以优异成绩拥有数学学士学位。他的资历包括：使用大多数语言（如在多种机器上使用汇编语言和高级语言）进行编程，实时编程，设计和实现实时闭环工业控制系统。Horton拥有丰富的面向工程师和科学家的编程教学经验（教学内容包括C，C、Fortran，PL/1，APL等）。同时，他还是机械、加工和电子CAD系统、机械CAM系统和DNC/CNC系统方面的专家。

 

文件目录

/bk41.net共享/入门经典
| ├──C++17入门经典_Ivor Horton & Peter Van Weert_zhelper-search.pdf 185.0MB