零基础学C++【2025|PDF下载-Epub版本|mobi电子书|kindle百度云盘下载】

零基础学C++PDF格式电子书版下载

注意：本站所有压缩包均有解压码： 点击下载压缩包解压工具

前言1

第一篇 C＋＋基础1

第1章 C＋＋概述1

1.1 了解计算机1

1.1.1 计算机硬件1

1.1.2 计算机软件2

1.2 程序设计语言3

1.2.1 机器语言3

1.2.2 汇编语言4

1.2.3 高级语言4

1.2.4 数据结构和算法5

1.2.5 面向过程的程序设计（POP）5

1.2.6 面向对象的程序设计（OOP）6

1.3 C＋＋简介6

1.3.1 C＋＋语言发展历程6

1.3.2 C＋＋语言特点7

1.3.3 C＋＋程序开发基本过程7

1.4 C＋＋开发环境的搭建8

1.4.1 Visual C＋＋6开发环境简介8

1.4.2 开发步骤9

1.5 第一个C＋＋程序10

1.6 小结11

第2章 开始C＋＋之旅12

2.1 C＋＋程序的结构12

2.1.1 注释12

2.1.2 编译预处理与新旧标准13

2.1.3 主函数13

2.1.4 名称空间14

2.1.5 C＋＋语素15

2.2 变量与基本类型17

2.2.1 变量17

2.2.2 整型18

2.2.3 浮点型19

2.2.4 基本字符型19

2.2.5 宽字符型20

2.2.6 布尔型20

2.3 常量21

2.3.1 整型常量和浮点型常量21

2.3.2 字符型常量21

2.3.3 字符串常量23

2.3.4 符号常量24

2.3.5 枚举（Enum）常量25

2.4 运算符与表达式26

2.4.1 算术运算26

2.4.2 逻辑运算27

2.4.3 短路表达式28

2.4.4 关系运算28

2.4.5 大有文章：变量是否为“0”29

2.4.6 条件运算30

2.4.7 位运算30

2.4.8 赋值运算32

2.4.9 ＋＋和－－34

2.4.10 逗号表达式35

2.4.11 sizeof运算符与sizeof表达式35

2.4.12 运算符的优先级和结合性36

2.5 类型转换38

2.5.1 赋值转换38

2.5.2 表达式中的转换40

2.5.3 强制类型转换41

2.5.4 函数调用、传递参数时的类型转换42

2.6 流程控制语句42

2.6.1 if…else&选择结构42

2.6.2 switch结构44

2.6.3 if…else&结构和switch结构的比较47

2.6.4 for循环结构48

2.6.5 for循环结构嵌套49

2.6.6 while循环结构50

2.6.7 do&while循环结构51

2.6.8 循环语句的效率51

2.6.9 流程转向控制语句之break52

2.6.10 流程转向控制语句之continue52

2.6.11 自由转向语句goto53

2.6.12 程序中止函数exit（）54

2.7 小结54

第二篇 C＋＋过程开发55

第3章 数组和C风格字符串55

3.1 什么是数组55

3.2 一维数组56

3.2.1 一维数组的声明56

3.2.2 初始化一维数组57

3.2.3 一维数组应用举例58

3.2.4 数组操作注意事项58

3.3 C风格字符串59

3.3.1 C风格字符串的声明59

3.3.2 字符数组的cin和cout60

3.3.3 get（）函数和getline（）函数60

3.3.4 cin与get（）/getline（）函数的搭配问题62

3.3.5 访问C风格字符串中的某个元素62

3.3.6 C风格字符串处理函数63

3.4 多维数组65

3.4.1 声明一个多维数组65

3.4.2 初始化多维数组65

3.4.3 多维数组应用举例66

3.4.4 多维数组在内存中是如何排列元素的67

3.5 小结68

第4章 指针和引用69

4.1 指针的定义与使用69

4.1.1 声明一个指针变量69

4.1.2 初始化指针变量72

4.1.3 指向指针的指针72

4.1.4 指针赋值73

4.2 指针的运算74

4.2.1 指针与整数的加减74

4.2.2 同类型指针间的比较75

4.2.3 同类型指针相减75

4.3 动态内存分配76

4.3.1 使用new动态分配内存76

4.3.2 使用delete动态释放动态申请的内存76

4.3.3 使用new申请动态数组77

4.3.4 不要使用或释放已经释放的内存块78

4.3.5 使用malloc和free动态申请内存78

4.3.6 动态内存申请并不一定成功80

4.4 指针和const80

4.4.1 禁止改写指针（常量指针或常指针）80

4.4.2 禁止改写间接引用81

4.4.3 既禁止改写指针，又禁止改写间接引用81

4.5 指针与数组81

4.5.1 数组名指针81

4.5.2 数组元素的指针形式83

4.5.3 指向数组的指针83

4.5.4 指针数组85

4.6 引用87

4.6.1 引用的声明88

4.6.2 引用的特点88

4.6.3 引用的使用限制89

4.6.4 其他要说明的问题89

4.7 小结90

第5章 结构、共用体和链表91

5.1 结构91

5.1.1 如何定义一个结构91

5.1.2 结构变量的声明和使用92

5.1.3 结构变量的初始化93

5.1.4 结构变量间是否可以相互赋值94

5.1.5 结构体变量的sizeof95

5.2 共用体96

5.2.1 共用体的定义97

5.2.2 共用体和结构的不同97

5.2.3 共用体变量的声明和初始化98

5.2.4 共用体使用举例99

5.2.5 共用体的sizeof100

5.3 结构数组和共用体数组101

5.3.1 结构数组的声明和初始化101

5.3.2 共用体数组的声明和初始化102

5.4 指向结构的指针103

5.4.1 声明一个结构指针103

5.4.2 结构指针的初始化103

5.4.3 使用指针访问结构成员105

5.5 链表106

5.5.1 链表的结构106

5.5.2 创建链表107

5.5.3 链表与数组的区别107

5.5.4 链表的遍历和查找108

5.5.5 链表的插入和删除109

5.6 小结113

第6章 用函数合理组织程序114

6.1 模块化带来的好处114

6.1.1 函数的调用过程114

6.1.2 抽象和封装115

6.1.3 实现一个函数115

6.2 函数定义116

6.2.1 函数头116

6.2.2 函数体117

6.2.3 函数定义补充说明117

6.3 函数声明119

6.3.1 为什么要进行函数声明119

6.3.2 如何声明一个函数120

6.3.3 分割程序文件120

6.4 函数调用122

6.4.1 形参和实参122

6.4.2 参数类型转换123

6.4.3 值传递123

6.4.4 指针传递124

6.4.5 引用传递125

6.4.6 对3种传递的补充126

6.4.7 缺省参数调用128

6.4.8 inline函数129

6.5 递归131

6.6 函数的重载132

6.6.1 何时使用函数重载133

6.6.2 如何实现函数重载133

6.6.3 陷阱：隐式转换导致重载函数出现二义性134

6.7 C＋＋如何使用内存134

6.7.1 自动存储（栈存储）135

6.7.2 静态存储（编译器预分配）137

6.8 作用域与可见域141

6.8.1 作用域142

6.8.2 可见域142

6.8.3 函数的作用域和可见域145

6.9 小结145

第7章 关于函数的高级专题147

7.1 内存使用错误剖析147

7.1.1 内存泄露147

7.1.2 野指针148

7.1.3 试图修改常量149

7.1.4 用错sizeof149

7.1.5 内存越界访问150

7.1.6 变量的初始化150

7.2 重申：函数参数传递和返回机制150

7.2.1 参数传递时的“副本”151

7.2.2 函数返回时的“副本”152

7.3 函数与指针154

7.3.1 指向函数的指针154

7.3.2 typedef155

7.3.3 通过函数指针将函数作为另一个函数的参数157

7.3.4 函数指针数组158

7.3.5 返回函数指针的函数159

7.3.6 带参主函数160

7.4 函数与数组161

7.4.1 数组名作函数参数161

7.4.2 通过指针得到多于I个的回传值163

7.5 函数与结构体、共用体及类对象164

7.5.1 3种参数调用164

7.5.2 3种返回机制166

7.6 函数编写的建议166

7.6.1 合理使用const166

7.6.2 检查输入参数的有效性167

7.6.3 函数返回类型的判断167

7.7 小结167

第三篇 面向对象的C＋＋169

第8章 面向对象技术基础169

8.1 面向对象基本概念169

8.1.1 类的概念169

8.1.2 类是分层的170

8.1.3 类和对象的关系170

8.2 C＋＋类的定义171

8.2.1 类定义的基本形式171

8.2.2 类定义示例172

8.2.3 class和struct173

8.3 C＋＋类的实现173

8.3.1 在类定义时定义成员函数173

8.3.2 在类定义的外部定义成员函数174

8.4 C＋＋类的使用175

8.4.1 声明一个对象175

8.4.2 对象的作用域、可见域和生存期176

8.5 对象的创建和撤销176

8.5.1 构造函数的作用177

8.5.2 构造函数可以有参数177

8.5.3 构造函数支持重载178

8.5.4 构造函数允许按参数缺省方式调用179

8.5.5 初始化表达式180

8.5.6 析构函数181

8.5.7 显式调用析构函数183

8.6 复制构造函数183

8.6.1 复制构造函数调用机制184

8.6.2 缺省复制构造函数带来的问题185

8.6.3 解决方案—显式定义复制构造函数187

8.6.4 关于构造函数和复制构造函数188

8.7 特殊数据成员189

8.7.1 const数据成员189

8.7.2 引用成员191

8.7.3 类对象成员193

8.7.4 特别说明197

8.7.5 static数据成员197

8.8 特殊函数成员199

8.8.1 静态成员函数199

8.8.2 const与成员函数201

8.9 对象的组织202

8.9.1 const对象202

8.9.2 指向对象的指针203

8.9.3 对象的大小204

8.9.4 this指针206

8.9.5 对象数组207

8.9.6 对象链表208

8.10 为对象动态分配内存208

8.10.1 使用new和delete为单个对象分配/释放动态内存208

8.10.2 使用new和delete为对象数组分配/释放动态空间209

8.10.3 malloc和free能否为对象动态申请内存210

8.11 小结211

第9章 关于对象的高级专题212

9.1 类作用域212

9.2 类定义的作用域与可见域213

9.3 对象的生存期、作用域和可见域216

9.3.1 先定义，后实例化216

9.3.2 对象内存释放与堆内存217

9.4 友元217

9.4.1 友元之非成员函数217

9.4.2 友元之成员函数219

9.4.3 友元函数的重载220

9.4.4 友元类220

9.4.5 友元是否破坏了封装性222

9.5 运算符重载222

9.5.1 运算符重载规则223

9.5.2 以成员函数形式重载运算符223

9.5.3 以友元函数形式重载运算符227

9.5.4 友员函数形式和成员函数形式的比较229

9.5.5 对运算符重载的补充说明231

9.6 运算符重载范例231

9.6.1 赋值运算符231

9.6.2 函数调用运算符234

9.6.3 下标运算符235

9.7 类型转换237

9.7.1 由其他类型向定义类的转换237

9.7.2 由自定义类型转换为其他类型239

9.7.3 隐式转换带来的二义性241

9.8 重载函数选择规则241

9.8.1 重载解析242

9.8.2 什么是完全匹配242

9.9 小结243

第10章 继承244

10.1 什么是继承244

10.1.1 简单示例244

10.1.2 继承的层次性246

10.2 派生类246

10.2.1 public派生与private派生246

10.2.2 protected成员与protected派生247

10.3 多基派生248

10.3.1 多基派生的声明和定义248

10.3.2 二义性问题248

10.3.3 解决方案250

10.4 虚基类250

10.4.1 共同基类带来的二义性250

10.4.2 解决方案251

10.4.3 虚基派生二义性与多基派生二义性不同253

10.5 派生类的构造函数和析构函数253

10.5.1 派生类的构造函数253

10.5.2 派生类的析构函数255

10.5.3 多基派生类的构造函数和析构函数256

10.5.4 虚基派生的构造函数和析构函数256

10.6 分清继承还是组合259

10.6.1 继承259

10.6.2 组合260

10.7 基类与派生类对象间的相互转换261

10.7.1 类型适应261

10.7.2 多基继承时的情况263

10.7.3 公共基类264

10.7.4 虚基类的情况266

10.8 小结266

第11章 多态268

11.1 多态与虚函数268

11.1.1 静态联编268

11.1.2 动态联编268

11.1.3 为什么需要虚函数268

11.1.4 虚函数的声明和定义271

11.2 虚函数的访问271

11.2.1 对象名访问272

11.2.2 指针访问272

11.2.3 引用访问273

11.2.4 类内访问274

11.2.5 在构造函数或析构函数中访问275

11.3 纯虚函数与抽象类276

11.3.1 纯虚函数的声明和定义276

11.3.2 抽象类277

11.3.3 另一种抽象类：类中只定义了protected型的构造函数280

11.3.4 延伸：构造函数能否为private型281

11.3.5 虚析构函数282

11.4 虚函数引入的二义性285

11.4.1 多基派生285

11.4.2 共同基类和虚继承287

11.5 重载、覆盖与隐藏289

11.5.1 重载289

11.5.2 覆盖289

11.5.3 隐藏290

11.6 小结291

第四篇 泛型编程293

第12章 模板293

12.1 为什么要定义模板293

12.1.1 类型参数化293

12.1.2 模板的定义295

12.2 函数模板296

12.2.1 函数模板的使用296

12.2.2 隐式实例化296

12.2.3 显式实例化297

12.2.4 特化298

12.2.5 重载299

12.2.6 优先级与执行顺序300

12.3 类模板302

12.3.1 定义类模板302

12.3.2 隐式实例化304

12.3.3 显式实例化304

12.3.4 显式特化304

12.3.5 部分特化305

12.3.6 重载和优先级306

12.4 模板的嵌套307

12.4.1 函数成员模板307

12.4.2 对象成员模板308

12.5 模板参数309

12.6 小结310

第13章 标准模板库（STL）311

13.1 理解STL311

13.1.1 容器311

13.1.2 适配器311

13.1.3 迭代器312

13.1.4 算法312

13.2 使用序列式容器312

13.2.1 序列式容器的创建和元素的访问312

13.2.2 所有容器都支持的特征314

13.2.3 序列式容器中元素的插入和删除314

13.2.4 vector容器319

13.2.5 deque容器319

13.2.6 list容器320

13.3 使用关联式容器320

13.3.1 set容器320

13.3.2 multiset容器321

13.3.3 map容器322

13.3.4 multimap容器323

13.4 关联式容器支持的成员函数操作324

13.4.1 元素的插入324

13.4.2 元素的删除327

13.4.3 元素的查找与访问329

13.5 迭代器330

13.5.1 理解迭代器本质330

13.5.2 迭代器类型331

13.5.3 为什么要定义这么多迭代器332

13.5.4 容器中定义的迭代器类型与5种类型的对应333

13.5.5 流迭代器333

13.5.6 迭代器失效335

13.6 泛型算法335

13.6.1 什么是函数对象335

13.6.2 算法分类336

13.7 适配器340

13.7.1 容器适配器341

13.7.2 迭代器适配器342

13.7.3 函数适配器344

13.8 小结345

第14章 输入输出和文件347

14.1 输入输出概述347

14.1.1 什么是文件347

14.1.2 流348

14.1.3 缓冲区349

14.1.4 重定向349

14.1.5 3种输入输出机制350

14.2 高层I/O351

14.2.1 标准输出函数printf351

14.2.2 标准输入函数scanf354

14.2.3 扫描集357

14.2.4 sprintf和sscanf函数358

14.2.5 fprintf口fscanf函数359

14.2.6 文件访问机制359

14.3 流类库363

14.3.1 流类库更安全、更高效363

14.3.2 流类库层次363

14.4 输出流367

14.4.1 操作符《367

14.4.2 其他ostream方法368

14.4.3 格式状态字369

14.4.4 格式控制值的默认值371

14.4.5 flag（）函数读取和设定格式状态字371

14.4.6 使用setf函数和unsetf函数设定格式关键字373

14.4.7 设置域宽375

14.4.8 填充字符376

14.4.9 浮点数输出和显示精度377

14.4.10 控制符378

14.5 输入流380

14.5.1 》操作符380

14.5.2 输入流与格式状态字381

14.5.3 输入流与域宽383

14.5.4 使用get函数读取单个字符383

14.5.5 使用get和getline函数读取C风格字符串386

14.5.6 其他istream方法387

14.6 流状态389

14.6.1 什么是流状态389

14.6.2 读取流状态389

14.6.3 管理流状态391

14.7 重载》和《392

14.7.1 插入符的重载392

14.7.2 抽取符的重载394

14.8 文件操作395

14.8.1 文件操作基本过程395

14.8.2 文件的打开395

14.8.3 取消文件和流的关联397

14.8.4 文件的读写398

14.8.5 文本文件的读写399

14.8.6 二进制文件的读写399

14.8.7 文件定位指针和随机读取400

14.9 字符串流402

14.9.1 strstream类族402

14.9.2 sstream类族405

14.10 小结408

第15章 名称空间409

15.1 什么是名称空间409

15.1.1 名称空间范例409

15.1.2 定义名称空间410

15.2 实体的作用域与可见域411

15.2.1 实体可见域411

15.2.2 可见域的扩展412

15.2.3 using声明机制413

15.2.4 using声明带来的多重声明问题（二义性）415

15.2.5 空间内的“屏蔽”415

15.2.6 先声明，后使用416

15.3 名称空间的作用域与可见性417

15.3.1 名称空间的定义策略417

15.3.2 推荐用法419

15.3.3 名称空间嵌套421

15.3.4 using编译指令422

15.3.5 未命名的名称空间423

15.4 对名称空间的思考423

15.5 小结424

第16章 异常和错误425

16.1 编码时的防错425

16.1.1 调用abort函数或exit函数425

16.1.2 返回错误标志426

16.2 异常机制427

16.2.1 关键字throw428

16.2.2 异常处理程序429

16.2.3 自定义异常对象432

16.2.4 有继承关系的类异常433

16.2.5 terminate函数和set_erminate函数434

16.2.6 unexpected函数与set_unexpected函数435

16.2.7 标准异常436

16.2.8 对unexpected函数的补充438

16.3 异常发生时的内存管理440

16.3.1 堆栈解退440

16.3.2 异常处理机制和函数的不同441

16.3.3 构造函数中抛出异常442

16.3.4 内存泄露443

16.3.5 析构函数中可否抛出异常444

16.4 auto_ptr类445

16.4.1 使用auto_ptr类445

16.4.2 关于auto_ptr的若干问题446

16.5 小结447

第17章 RTTI和类型转换操作符448

17.1 RTTI机制448

17.1.1 dynamic_cast操作符448

17.1.2 typeinfo类和typeid操作符450

17.1.3 补充说明451

17.2 类型转换操作符451

17.2.1 const_cast操作符451

17.2.2 static_cast操作符452

17.2.3 reinterpret_cast操作符452

17.3 小结453

第18章 string类454

18.1 为什么要使用string类454

18.2 声明一个字符串454

18.3 字符串的输入输出455

18.4 string类功能457

18.4.1 string字符串和C风格字符串的转换457

18.4.2 赋值和清空457

18.4.3 元素删除457

18.4.4 元素追加与相加458

18.4.5 元素插入458

18.4.6 大小和容量459

18.4.7 元素存取459

18.4.8 字符串比较459

18.4.9 提取子串459

18.4.10 搜索与查找459

18.5 小结460

第19章 编码风格461

19.1 程序的排版461

19.1.1 注释461

19.1.2 空行的用法462

19.1.3 代码行462

19.1.4 空格462

19.1.5 缩进与对齐463

19.1.6 ＆和*的位置463

19.2 命名规则463

19.2.1 Windows风格和UNIX风格463

19.2.2 如何对程序实体命名463

19.3 项目文件的组织464

19.3.1 模块划分464

19.3.2 头文件464

19.3.3 定义文件465

19.3.4 目录结构465

19.4 小结465

第20章 程序编译466

20.1 程序的编译流程466

20.2 预处理467

20.2.1 头文件包含467

20.2.2 宏468

20.2.3 条件编译469

20.2.4 ＃ifdef、＃ifndef与重复包含470

20.2.5 使用const代替＃define定义常量471

20.2.6 inline与＃define的比较471

20.3 VC6调试入门472

20.3.1 断点的设置与去除472

20.3.2 条件断点473

20.3.3 数据断点473

20.3.4 消息断点473

20.3.5 观察视图Watch473

20.3.6 内存视图Memory474

20.3.7 变量视图Variables474

20.3.8 寄存器视图Registers474

20.3.9 调用堆栈视图Call Stack474

20.3.10 反汇编视图Disassembly474

20.3.11 进程控制475

20.4 其他调试手段475

20.4.1 Debug模式和Release模式475

20.4.2 assert宏475

20.4.3 偷懒的办法：输出字符串475

20.5 小结476