C++编程思想PDF电子书下载

前言 1

第1章 对象的演化 1

1．1基本概念 1

1．1．1对象：特性+行为 1

1．1．2继承：类型关系 1

译者序 1

1．1．3多态性 2

1．1．4操作概念：OOP程序像什么 3

1．2为什么C++会成功 3

1．2．1较好的C 3

1．2．4系统更容易表达和理解 4

1．2．5“库”使你事半功倍 4

1．2．2采用渐进的学习方式 4

1．2．3运行效率 4

1．2．6错误处理 5

1．2．7大程序设计 5

1．3方法学介绍 5

1．3．1复杂性 5

1．3．2内部原则 6

1．3．3外部原则 6

1．3．4对象设计的五个阶段 9

1．3．6方法应当提供什么 10

1．3．5方法承诺什么 10

1．4起草：最小的方法 12

1．4．1前提 13

1．4．2高概念 14

1．4．3论述（treatment） 14

1．4．4结构化 14

1．4．5开发 16

1．4．6重写 17

1．4．7逻辑 17

1．5其他方法 17

1．5．1 Booch 18

1．5．2责任驱动的设计（RDD） 19

1．5．3对象建模技术（OMT） 19

1．6为向OOP转变而采取的策略 19

1．6．1逐步进入OOP 19

1．6．2管理障碍 20

1．7小结 21

第2章 数据抽象 22

2．1声明与定义 22

2．2一个袖珍C库 23

2．4什么是非正常 29

2．3放在一起：项目创建工具 29

2．5基本对象 30

2．6什么是对象 34

2．7抽象数据类型 35

2．8对象细节 35

2．9头文件形式 36

2．10嵌套结构 37

2．11小结 41

2．12练习 41

3．2 C++的存取控制 42

3．1设置限制 42

第3章 隐藏实现 42

3．3友元 44

3．3．1嵌套友元 45

3．3．2它是纯的吗 48

3．4对象布局 48

3．5类 48

3．5．1用存取控制来修改stash 50

3．5．2用存取控制来修改stack 51

3．6句柄类（handle classes） 51

3．6．1可见的实现部分 51

3．6．2减少重复编译 52

3．7小结 54

3．8练习 54

第4章 初始化与清除 55

4．1用构造函数确保初始化 55

4．2用析构函数确保清除 56

4．3 清除定义块 58

4．3．1 for循环 59

4．3．2空间分配 60

4．4含有构造函数和析构函数的stash 61

4．5含有构造函数和析构函数的stack 63

4．6集合初始化 65

4．7缺省构造函数 67

4．8小结 68

4．9练习 68

第5章 函数重载与缺省参数 69

5．1范围分解 69

5．1．1用返回值重载 70

5．1．2安全类型连接 70

5．2重载的例子 71

5．3缺省参数 74

5．4小结 81

5．5练习 82

第6章 输入输出流介绍 83

6．1为什么要用输入输出流 83

6．2解决输入输出流问题 86

6．2．1预先了解操作符重载 86

6．2．2插入符与提取符 87

6．2．3通常用法 88

6．2．4面向行的输入 90

6．3文件输入输出流 91

6．4输入输出流缓冲 93

6．5在输入输出流中查找 94

6．6 strstreams 96

6．6．1为用户分配的存储 96

6．6．2自动存储分配 98

6．7输出流格式化 100

6．7．1内部格式化数据 101

6．7．2例子 102

6．8格式化操纵算子 106

6．9建立操纵算子 108

6．10输入输出流实例 111

6．10．1代码生成 111

6．10．2一个简单的数据记录 117

6．12练习 123

6．11小结 123

第7章 常量 124

7．1值替代 124

7．1．1头文件里的const 124

7．1．2 const的安全性 125

7．1．3集合 126

7．1．4与C语言的区别 126

7．2．1指向const的指针 127

7．2．2 const指针 127

7．2指针 127

7．2．3赋值和类型检查 128

7．3函数参数和返回值 128

7．3．1传递const值 128

7．3．2返回const值 129

7．3．3传递和返回地址 131

7．4类 133

7．4．1类里的const和enum 133

7．4．2编译期间类里的常量 134

7．4．3 const对象和成员函数 136

7．4．4只读存储能力 139

7．5可变的（volatile） 140

7．7练习 141

7．6小结 141

第8章 内联函数 142

8．1预处理器的缺陷 142

8．2内联函数 144

8．2．1类内部的内联函数 145

8．2．2存取函数 146

8．3．1局限性 150

8．3．2赋值顺序 150

8．3内联函数和编译器 150

8．3．3在构造函数和析构函数里隐藏行为 151

8．4减少混乱 152

8．5预处理器的特点 153

8．6改进的错误检查 154

8．7小结 155

8．8练习 155

第9章 命名控制 157

9．1来自C语言中的静态成员 157

9．1．1函数内部的静态变量 157

9．1．2控制连接 160

9．2名字空间 161

9．1．3其他的存储类型指定符 161

9．2．1产生一个名字空间 162

9．2．2使用名字空间 163

9．3 C++中的静态成员 166

9．3．1定义静态数据成员的存储 166

9．3．2嵌套类和局部类 168

9．3．3静态成员函数 169

9．4静态初始化的依赖因素 171

9．6小结 174

9．7练习 174

9．5转换连接指定 174

第10章 引用和拷贝构造函数 176

10．1 C++中的指针 176

10．2 C++中的引用 176

10．2．1函数中的引用 177

10．2．2参数传递准则 178

10．3拷贝构造函数 179

10．3．1传值方式传递和返回 179

10．3．2拷贝构造函数 182

10．3．3缺省拷贝构造函数 187

10．3．4拷贝构造函数方法的选择 188

10．4指向成员的指针（简称成员指针） 190

10．5小结 192

10．6练习 193

第11章 运算符重载 194

11．1警告和确信 194

11．2语法 194

11．3可重载的运算符 195

11．3．1一元运算符 195

11．3．2二元运算符 199

11．3．3参数和返回值 210

11．3．4与众不同的运算符 211

11．4非成员运算符 214

11．3．5不能重载的运算符 214

11．5重载赋值符 216

11．6自动类型转换 226

11．6．1构造函数转换 226

11．6．2运算符转换 227

11．6．3一个理想的例子：strings 229

11．6．4自动类型转换的缺陷 230

11．7小结 232

11．8练习 233

第12章 动态对象创建 234

12．1对象创建 234

12．1．1 C从堆中获取存储单元的方法 235

12．1．3运算符delete 236

12．1．2运算符new 236

12．1．4一个简单的例子 237

12．1．5内存管理的开销 237

12．2重新设计前面的例子 238

12．2．1仅从堆中创建string类 238

12．2．2 stash指针 239

12．2．3 stack例子 242

12．3用于数组的new和delete 244

12．4用完内存 245

12．5．1重载全局new和delete 246

12．5重载new和delete 246

12．5．2为一个类重载new和delete 248

12．5．3为数组重载new和delete 250

12．5．4构造函数调用 251

12．5．5对象放置 252

12．6小结 253

12．7练习 254

第13章 继承和组合 255

13．1组合语法 255

13．2继承语法 256

13．3．2在初始化表达式表中的内置类型 258

13．3构造函数的初始化表达式表 258

13．3．1成员对象初始化 258

13．4组合和继承的联合 259

13．4．1构造函数和析构函数的次序 260

13．4．2名字隐藏 261

13．4．3非自动继承的函数 262

13．5组合与继承的选择 263

13．5．1子类型设置 265

13．5．2专门化 267

13．5．3私有继承 268

13．6保护 269

13．7多重继承 270

13．8渐增式开发 270

13．9向上映射 270

13．9．1为什么“向上映射” 271

13．9．2组合与继承 272

13．9．3指针和引用的向上映射 273

13．9．4危机 273

13．10小结 273

13．11练习 273

14．1向上映射 274

第14章 多态和虚函数 274

14．2问题 275

14．3虚函数 276

14．4 C++如何实现晚捆绑 279

14．4．1存放类型信息 280

14．4．2对虚函数作图 281

14．4．3撩开面纱 282

14．4．4安装vpointer 283

14．4．5对象是不同的 283

14．5为什么需要虚函数 284

14．7继承和VTABLE 288

14．8．1构造函数调用次序 291

14．6抽象基类和纯虚函数 291

14．8虚函数和构造函数 291

14．8．2虚函数在构造函数中的行为 292

14．9析构函数和虚拟析构函数 292

14．10小结 294

14．11练习 294

第15章 模板和包容器类 295

15．1包容器和循环子 295

15．2模板综述 297

15．2．2 Smalltalk方法 298

15．2．1 C方法 298

15．3模板的语法 299

15．2．3模板方法 299

15．3．1非内联函数定义 300

15．3．2栈模板（the stack as a template） 301

15．3．3模板中的常量 303

15．4 stash stack模板 304

15．4．1所有权问题 305

15．4．2 stash模板 305

15．4．3 stack模板 310

15．5．1栈上的字符串 313

15．5字符串和整型 313

15．5．2整型 314

15．6向量 315

15．6．1“无穷”向量 315

15．6．2集合 318

15．6．3关联数组 320

15．7模板和继承 323

15．7．1设计和效率 326

15．7．2防止模板膨胀 327

15．8多态性和包容器 328

15．9包容器类型 331

15．10．1存储分配系统 332

15．10函数模板 332

15．10．2为tstack提供函数 335

15．10．3成员函数模板 337

15．11控制实例 337

15．12小结 339

15．13练习 339

第16章 多重继承 340

16．1概述 340

16．3向上映射的二义性 341

16．2子对象重叠 341

16．4虚基类 342

16．4．1“最晚辈派生”类和虚基初始化 343

16．4．2使用缺省构造函数向虚基“警告” 345

16．5开销 346

16．6向上映射 347

16．7避免MI 354

16．8修复接口 355

16．9小结 358

16．10练习 359

17．1 C语言的出错处理 360

第17章 异常处理 360

17．2抛出异常 362

17．3异常捕获 362

17．3．1 try块 362

17．3．2异常处理器 363

17．3．3异常规格说明 364

17．3．4更好的异常规格说明 366

17．3．5捕获所有异常 366

17．3．6异常的重新抛出 366

17．3．7未被捕获的异常 367

17．4清除 368

17．5构造函数 371

17．6异常匹配 375

17．7标准异常 376

17．8含有异常的程序设计 377

17．8．1何时避免异常 377

17．8．2异常的典型使用 378

17．9开销 380

17．10小结 380

17．11练习 380

18．2什么是RTTI 382

18．1例子——shape 382

第18章 运行时类型识别 382

18．3语法细节 386

18．3．1对于内部类型的typeid() 386

18．3．2产生合适的类型名字 386

18．3．3非多态类型 387

18．3．4映射到中间级 387

18．3．5 void指针 388

18．3．6用模板来使用RTTI 388

18．4引用 389

18．5多重继承 390

18．6合理使用RTTI 391

18．7 RTTI的机制及花费 394

18．8创建我们自己的RTTI 395

18．9新的映射语法 398

18．9．1 static_cast 399

18．9．2 const_cast 400

18．9．3 reinterpret_cast 401

18．10小结 403

18．11练习 403

附录A 其他性能 404

附录B 编程准则 409

附录C 模拟虚构造函数 415