C++大学教程 第3版PDF|Epub|txt|kindle电子书版本网盘下载

C++大学教程 第3版PDF格式电子书版下载

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

第1章 由C迁移到C++1

1.1 概述1

1.2 C与C++的比较1

1.3 编译器如何识别C++程序1

目录1

1.4 预处理器如何识别环境2

1.5 新的注释风格2

1.6 永远不要假定（隐式地使用int类型）3

1.7 main（）的默认返回值3

1.8 声明与定义的区别4

1.9 函数声明中的形参名称4

1.10 函数定义中的形参名称4

1.13 函数参数的默认值5

1.11 所有的函数在调用前必须先声明5

1.12 空圆括号的含义5

1.14 初始化与赋值的区别6

1.15 放置变量声明的地方7

1.16 for循环内的变量声明8

1.17 标记名成为类型名8

1.18 C++与C中枚举类型的区别9

1.19 初始化全局变量10

1.20 数组初始化11

1.21 布尔类型11

1.22 void*指针12

1.24.1 所有的常量必须初始化13

1.23 使用O，而不是宏NULL13

1.24 关键字const13

1.24.2 将常量值的参数传递给函数的含义14

1.24.3 函数返回值为常量的含义14

1.24.4 const如何影响指针14

1.24.5 C++与C中字符数组的区别15

1.24.6 如何支持char const*类型的数组16

1.24.7 C以及C++处理const方式的区别16

1.24.8 使用const而不#define17

1.24.9 const变量的连接18

1.25 新的类型强制转换风格18

1.25.1 类型强制转换以及转换的区别18

1.25.3 static cast19

1.25.2 类型强制转换的一般格式19

1.25.4 reinterpret cast20

1.25.5 const cast20

1.25.6 您不会犯错21

1.26 C 以及C++关键字21

第2章 命名空间23

2.1 概述23

2.2 存在的问题23

2.3 如何创建命名空间24

2.4 作用域分解运算符25

2.5 如何访问命名空间的成员25

2.5.1 直接访问命名空间的成员25

2.5.2 using声明——访问命名空间成员的另一种方法26

2.5.3 using指令——访问命名空间成员的另一种方法27

2.6 小心避免不明确的情况28

2.7 无名的命名空间28

2.8 命名空间的别名29

2.9 Koenig查找规则30

第3章 输入／输出基础32

3.1 概述32

3.2 使用新函数的理由32

3.3 头文件——命名约定33

3.4 iostream头文件33

3.5 cout对象33

3.5.2 显式地限定cout对象34

3.5.1 插入运算符34

3.5.3 使用using声明来访问cout对象35

3.5.4 使用using指令来访问cout对象35

3.6 关于正确使用std命名空间的建议36

3.7 了解运算符的优先级37

3.8 输出格式37

3.9 cin对象37

3.10 检查文件是否结束39

第4章 引用变量42

4.1 概述42

4.2 存在的问题42

4.4 所有的引用都必须初始化44

4.5 引用的作用44

4.3 如何创建引用变量44

4.6 使用const限定引用45

4.7 何时不需要使用引用46

4.8 没有“常量引用”47

4.9 创建对指针的引用47

4.10 创建对数组的引用48

4.11 由函数返回引用49

第5章 动态内存分配51

5.1 概述51

5.2 如何为单个对象分配动态内存51

5.3 如何初始化基本类型52

5.4 空圆括号的含义52

5.6 如何为对象的数组分配空闲空间53

5.5 如何释放单个对象的空闲空间53

5.7 如何释放对象数组的空闲空间54

5.8 保持平衡55

59 如何使用new和delete在空闲存储区中存储字符串55

5.10 如何分配和删除多维数组57

5.11 命名该空间58

5.12 两个程序输出示例58

第6章 类61

6.1 概述61

6.2 C中的结构61

6.2.1 全局函数62

6.2.2 C存在的问题62

6.3.1 修订后的Circle抽象63

6.3 初识封装63

6.3.2 必须支持常量对象64

6.4 结构与类64

6.5 类的用途65

6.6 类的组件65

6.7 如何编写类定义65

6.7.1 类声明与类定义66

6.7.2 关于输入／输出类69

6.8 数据隐藏的原则69

6.9 访问限定符71

6.9.1 private关键字72

6.9.4 选择编码风格73

6.9.3 protected关键字73

6.9.2 public关键字73

6.10 模块化并实现隐藏74

6.10.1 如何模块化75

6.10.2 用户的任务77

6.10.3 本节小结77

6.11 如何通过实例来访问类成员77

6.12 内联函数79

6.12.1 内联函数的含义80

6.12.2 内联函数与宏的对比80

6.12.3 使得内联函数对编译器有效80

6.12.5 内联函数的连接81

6.12.6 如何编写全局成员内联函数81

6.12.4 放置内联函数的地方81

6.12.7 如何编写类成员内联函数82

6.12.8 隐式内联和显式内联的比较84

6.13 mutable关键字84

6.14 如何显示类的内容85

6.15 类中的枚举类型87

6.15.1 使用枚举的原因88

6.1 5.2 私有枚举88

6.1 5.3 公有枚举90

6.15.4 “Enum Hack”的作用91

7.1 概述94

7.2 构造函数的定义94

第7章 构造函数和析构函数94

7.2.1 语法规则95

7.2.2 何时不调用构造函数95

7.2.3 编译器提供的默认构造函数96

7.2.4 默认的构造函数：普遍定义97

7.2.5 初始化常量对象98

7.2.6 构造函数重载98

7.2.7 不能直接调用构造函数100

7.3 析构函数的定义101

7.3.1 编译器提供的析构函数101

7.3.2 析构函数的作用101

7.3.3 编写您自己的析构函数102

7.3.4 语法规则102

7.5 如何实例化类并向构造函数传递参数103

7.4 如何实例化类并调用默认构造函数103

7.6 如何阻止使用默认构造函数的实例化104

7.7 隐式类型转换106

7.8 复制构造函数109

7.8.1 默认复制构造函数110

7.8.2 复制构造函数的语法111

7.8.3 复制构造函数的数量111

7.8.4 浅复制与深复制111

7.8.5 编写您自己的复制构造函数112

7.8.6 如何阻止对象复制114

7.9 函数风格的强制转换115

7.11 基／成员初始化列表118

7.10 初始化与赋值118

7.11.1 默认初始化120

7.11.2 强制使用基／成员初始化列表120

7.11.3 另一种初始化调用的情况121

7.12 关于指针123

7.13 形参名与类成员名123

7.14 非静态数据成员的初始化顺序123

7.15 基本类型的数组作为非静态数据成员125

7.16 用户自定义类型数组作为非静态数据成员125

7.17 如何创建用户自定义实例的数组126

7.18 如何声明常量数据成员数组128

7.19 如何在空闲存储区中创建用户自定义类型128

7.21 调用new时的语法129

7.20 如何在空闲存储区中创建用户自定义类型的数组129

第8章 类的其他特征134

8.1 概述134

8.2 this指针134

8.2.1 解引用this指针来复制调用对象136

8.2.2 解引用this指针以允许链接函数137

8.3 静态类数据成员139

8.3.1 在类的定义中初始化静态类数据成员142

8.3.2 静态成员函数143

8.3.3 用于生成随机数的类145

8.3.4 Die类145

8.3.5 Dice类147

8.4 类的大小151

8.5 友元函数152

8.5.1 类如何授权一个函数作为它的友元函数152

8.5.2 成员函数和非成员函数153

8.5.3 使用非成员非友元函数替代友元函数155

8.5.4 在命名空间中声明类的友元函数156

8.6 友元类158

8.7 类的封装162

8.8 运算符转换函数169

8.8.1 用途169

8.8.2 语法170

8.9 类成员指针171

8.9.1 全局函数指针171

8.9.3 使用指向非静态成员函数的指针调用函数172

8.9.2 指向非静态类成员函数的指针172

8.9.4 指向静态类成员函数的指针173

第9章 异常处理174

9.1 概述174

9.2 如何抛出异常174

9.3 如何捕获异常174

9.4 catch代码块的匹配处理176

9.5 异常处理的一个简单示例176

9.6 释放堆栈177

9.7 如果调用new失败怎么办177

9.8 如何防止new抛出异常178

9.9 异常的传播179

9.10 如何处理指向空闲空间的指针181

9.11 不能销毁还没有创建的对象184

9.12 重新抛出对象184

9.13 从子对象成员中捕获抛出的异常184

9.14 function-try-blocks185

9.15 子对象成员和指针的混合使用187

9.16 对象的局部结构189

9.17 编写异常-安全代码190

9.17.1 堆栈中的简单对象190

9.17.2 堆栈中的对象数组191

9.17.3 空闲存储区中的简单对象191

9.17.4 再论空闲存储区中的简单对象192

9.17.5 空闲存储区中的对象数组193

9.17.6 再论空闲存储区中的对象数组195

9.18 析构函数和异常处理196

9.19 异常规范196

9.20 出错条件197

9.20.1 意外错误198

9.20.2 终止错误198

9.21 编译器如何对待异常规范198

9.22 为类定义operator new（）函数199

第10章 函数重载203

10.1 概述203

10.2 几个关于函数重载的示例203

10.5 const限定参数按指针传递204

10.3 忽略返回类型204

10.4 const限定参数按值传递204

10.6 const限定参数按引用传递205

10.7 可变成员函数和常量成员函数205

10.8 重载决议206

10.9 根据指针类型重载207

10.10 名称重整207

10.10.1 如何避免名称重整208

10.10.2 类型-安全连接209

10.11 运算符函数重载210

10.11.1 运算符优先级表211

10.11.3 默认参数213

10.11.4 C++自带的运算符213

10.11.2 重载运算符的命名213

10.11.5 不能改变优先级214

10.11.6 不能改变“Narity”214

10.11.7 不能改变结合性214

10.11.8 成员函数与非成员函数214

10.11.9 至少支持一个类实例215

10.11.10 中缀表示法和函数表示法215

10.11.11 二元成员函数和隐式类型转换216

10.11.12 多次重载或者允许隐式类型转换218

10.11.13 运算符的重载219

10.11.14 赋值运算符220

10.11.15 函数调用运算符223

10.11.16 下标运算符225

10.11.17 间接成员运算符226

10.11.18 复合赋值运算符229

10.11.19 目增运算符和自减运算符231

10.11.20 重载逗号运算符233

10.11.21 重载逻辑与和逻辑或运算符233

10.11.22 重载插入运算符234

10.11.23 运算符小结235

第11章 继承238

11.1 概述238

11.2 内存中的派生类实例238

11.3 使用继承创建is-a关系238

11.4 如何定义派生类239

11.6 关键字protected240

11.5 再论结构和类240

11.7 访问特权241

11.8 基类“存取器”函数242

11.9 修改继承访问243

11.10 函数隐藏245

11.11 派生类成员函数如何调用基类成员函数248

11.12 管理函数249

11.12.1 如何编写管理函数250

11.12.2 派生类到基类的标准转换254

11.12.3 隐藏非成员函数255

11.12.4 不要对数组进行向上类型转换257

11.13 多态性257

11.14 多态性和虚函数262

11.14.1 友好的程序代码和不友好的程序代码263

11.14.2 重写虚函数263

11.14.3 虚析构函数265

11.14.4 从基类的构造函数中调用虚函数266

11.15 抽象基类266

11.15.1 再论关于贷款的示例267

11.15.2 关于虚函数的异常规范267

11.16 里氏代换原则268

11.17 多重继承270

11.17.1 虚基类273

11.17.2 初始化虚基类274

12.1 概述278

12.2 函数模板278

第12章 模板278

12.2.1 不使用宏的原因279

12.2.2 如何编写函数模板280

12.2.3 优化代码281

12.2.4 在何处使用函数模板282

12.2.5 针对不同的参数类型进行实例化283

12.2.6 显式地指定类型284

12.2.7 默认的函数参数285

12.2.8 完全特殊化函数模板286

12.2.9 如何调用特殊化的函数288

12.2.10 对特殊化和重载的选择291

12.2.11 特殊化greater（）函数模板294

12.3 类模板297

12.3.1 如何定义类模板297

12.3.2 在类定义之外定义成员298

12.3.3 实例化类模板299

12.3.4 另一个模板的模板实例化299

12.3.5 默认模板参数300

12.3.6 在类模板中声明另一个友元类301

12.3.7 在类模板中声明友元函数301

12.3.8 特殊化类模板307

12.3.9 在类模板中嵌入类模板313

12.3.10 从类模板中派生新类315

12.4 非类型模板参数317

12.4.1 默认的模板参数和特殊化318

12.4.2 关于使用非类型模板参数的有趣示例320

12.5 成员模板322

12.6 模板模式326

12.7 关键字typename329

第13章 运行时类型信息332

13.1 概述332

13.2 动态转型态332

13.3 动态转型态是如何工作的333

13.4 关键字typeid335

14.2 实例std::cerr和std::clog341

14.3 如何格式化输出341

14.1 概述341

第14章 输出流341

14.3.1 位格式标志342

14.3.2 如何打开位格式标志343

14.3.3 如何以合适的基数显示整数345

14.3.4 如何显示整数的基数设置347

14.3.5 如何显示整数的符号347

14.3.6 如何将输出显示为大写字母348

14.3.7 如何显示字符349

1413.8 如何设置输出字段宽度350

14.3.9 如何指定填充字符351

14.3.10 如何指定字段对齐352

14.3.11 如何格式化浮点型数值353

14.4 如何显示bool类型357

14.5 如何显示地址358

14.6 如何输出到内存缓冲区359

14.6.1 成员函数ostream::flush（）360

14.6.2 预定义的stdio和iostream流的混合使用360

第15章 输入流362

15.1 概述362

15.2 如何检查错误362

15.2.1 错误报告标志362

15.2.2 访问成员函数363

15.2.3 直接测试iostream对象364

15.2.4 成员函数std::basic_ios::clear（）366

15.2.5 如何清空输入流的缓冲区368

15.3 字符输入370

15.3.2 限制输入字符的个数372

15.3.1 使用提取运算符实现对字符串的输入372

15.3.3 使用std::istream::getline（）实现字符串输入374

第16章 操纵符376

16.1 概述376

16.2 操纵符的格式376

16.3 一些简单的操纵符377

16.4 不带参数调用的内置操纵符380

16.5 使用带有一个参数的操纵符381

16.6 使用带有一个参数的内置操纵符383

第17章 文件输入／输出385

17.1 概述385

17.2 文件输入／输出类385

17.3.1 文件名参数386

17.3 文件输出386

17.3.3 验证文件是否打开387

17.3.4 关闭打开的文件387

17.3.2 文件模式参数387

17.3.5 输出磁盘文件示例388

17.4 文件输入389

17.5 文件位置标记390

17.6 文件更新391

17.7 二进制模式392

17.8 未格式化的输出394

17.9 未格式化的输入396

17.10 重定向I/O397

18.2 string类400

第18章 string类与标准模板库400

18.1 概述400

18.3 标准模板库404

18.3.1 std::vector类404

18.3.2 迭代器407

18.3.3 迭代器的类型408

18.3.4 基于string的I/O414

18.3.5 标准模板库中的算法417

18.3.6 标准模板库的主要容器423

18.3.7 比较对象423

附录A 参考书目429

附录B C++准则431