C++高级编程PDF电子书下载

1.1 C++基础 1

1.1.1　必不可少的“Hello，World” 1

目录 1

译者序 1

前言 1

作者简介 1

第一部分 专业C++程序设计概述 1

第1章 C++快速入门 1

1.1.2　命名空间 4

1.1.3　变量 5

1.1.4　操作符 7

1.1.5　类型 9

1.1.6　条件语句 10

1.1.7　循环 13

1.1.9 函数 14

1.1.8　数组 14

1.1.10　结束语 15

1.2.1 指针和动态内存 16

1.2　C++进阶 16

1.2.2　C++中的字符串 18

1.2.3 引用 20

1.2.4 异常 21

1.2.5　const的多重用途 22

1.3　作为一种面向对象语言的C++ 23

1.4 你的第一个实用的C++程序 25

1.4.2　Employee类 26

1.4.1　一个员工记录系统 26

1.4.3　Database类 30

1.4.4　用户界面 34

1.5　小结 36

1.4.5　对程序的评价 36

2.1　什么是编程设计 37

第2章 设计专业的C++程序 37

2.2　编程设计的重要性 38

2.3 C++设计有什么不同之处 39

2.4.1 抽象 40

2.4　C++设计的两个原则 40

2.4.2　重用 41

2.5.2　设计步骤 43

2.5.1 需求 43

2.5　设计一个象棋程序 43

2.6　小结 47

3.1.1　我是在以过程性思维思考吗 48

3.1 面向对象的世界观 48

第3章 基于对象的设计 48

3.1.2　面向对象思想 49

3.1.3　身处对象世界中 51

3.1.4　对象关系 52

3.1.5　抽象 61

3.2　小结 63

4.1.1 有关术语 64

4.1 重用代码 64

第4章 基于库和模式的设计 64

4.1.2　决定是否重用代码 65

4.1.3　重用代码的策略 67

4.1.5 开源库 70

4.1.4　捆绑第三方应用 70

4.1.6 C++标准库 71

4.2.1　设计技术 81

4.2　利用模式和技术完成设计 81

4.2.2　设计模式 82

4.3　小结 83

5.1　重用方法论 84

第5章 重用设计 84

5.2.1 使用抽象 85

5.2　如何设计可重用的代码 85

5.2.2　适当地建立代码结构以优化重用 86

5.2.3 设计可用的接口 89

5.2.4　协调一般性和易用性 93

5.3　小结 94

6.1　为什么需要过程 95

第6章 充分利用软件工程方法 95

6.2.1　分阶段模型和瀑布模型 96

6.2　软件生命期模型 96

6.2.2　螺旋方法 98

6.2.3　统一开发过程 100

6.3.1　极限编程（XP） 101

6.3　软件工程方法论 101

6.4　建立自己的过程和方法论 104

6.3.2　软件triage 104

6.5　小结 105

6.4.4　不要做叛逃者 105

6.4.1 以开放的心态接纳新思想 105

6.4.2　汇总新思想 105

6.4.3　明确哪些可行，哪些不可行 105

7.1.2　保持清晰 107

7.1.1 提前考虑 107

第二部分 编写C++代码方式 107

第7章 好的编码风格 107

7.1 为什么代码看上去要好 107

7.2.1 写注释的原因 108

7.2　为代码加注释 108

7.1.3　好的代码风格包括哪些因素 108

7.2.2　注释风格 111

7.3.1 通过重构来分解 115

7.3　分解 115

7.2.3　本书中的注释 115

7.3.2　根据设计来分解 116

7.4.1 选择一个好名字 117

7.4　命名 117

7.3.3　本书中的分解 117

7.4.2　命名约定 118

7.5.1　使用常量 119

7.5　合理地使用语言特性 119

7.5.4　使用定制异常 120

7.5.3　使用引用而不是指针 120

7.5.2　利用const变量 120

7.6.1　有关大括号对齐的争论 121

7.6　格式化 121

7.7　风格方面的难题 122

7.6.3　空格和制表符 122

7.6.2　考虑空格和小括号 122

7.8　小结 123

8.2.1 类定义 124

8.2 编写类 124

第8章 掌握类和对象 124

8.1 电子表格示例 124

8.2.2　定义方法 127

8.2.3 使用对象 130

8.3.1 对象创建 131

8.3　对象生命期 131

8.3.2　对象撤销 140

8.3.3 对象赋值 141

8.3.4　区别复制和赋值 143

8.4 小结 144

9.1.1 Spreadsheet类 145

9.1 对象中的动态内存分配 145

第9章 精通类和对象 145

9.1.3　处理复制和赋值 147

9.1.2　用析构函数释放内存 147

9.2.1　静态数据成员 154

9.2 不同类型的数据成员 154

9.2.2　const数据成员 156

9.2.3　引用数据成员 157

9.3.1　静态方法 158

9.3　深入了解方法 158

9.2.4　const引用数据成员 158

9.3.2　const方法 159

9.3.3　方法重载 161

9.3.4　默认参数 162

9.3.5　内联方法 163

9.4 嵌套类 164

9.6.1 实现加法 166

9.6　操作符重载 166

9.5 友元 166

9.6.2　重载算术操作符 170

9.6.3　重载比较操作符 172

9.7　方法和成员指针 174

9.6.4　利用操作符重载构建类型 174

9.8　构建抽象类 175

9.9　小结 178

10.1.1 扩展类 179

10.1　使用继承构建类 179

第10章 探索继承技术 179

10.1.2　覆盖方法 182

10.2.1 类WeatherPrediction 184

10.2　继承以实现重用 184

10.2.2　在子类中增加功能 185

10.3.1　父构造函数 187

10.3　考虑父类 187

10.2.3　在子类中进行功能替换 187

10.3.2　父析构函数 189

10.3.3　引用父类的数据 191

10.3.4　向上类型强制转换和向下类型强制转换 192

10.4.1　Spreadsheet的返回结果 193

10.4　继承以实现多态 193

10.4.3　电子表格单元格的基类 194

10.4.2　设计多态电子表格单元格 194

10.4.4　各个子类 196

10.4.5　充分利用多态 198

10.4.6　将来的考虑 199

10.5.1　从多个类继承 200

10.5　多重继承 200

10.5.2　命名冲突与二义基类 201

10.6.1 改变覆盖方法的特性 203

10.6　继承技术中有趣而隐蔽的问题 203

10.6.2　覆盖方法的特殊情况 206

10.6.3　复制构造函数与相等操作符 212

10.6.4　关键字virtual的真相 213

10.6.5　运行时类型工具 215

10.6.7 虚基类 217

10.6.6　非公共继承 217

10.7 小结 218

11.1　模板概述 219

第11章 利用模板编写通用代码 219

11.2.1　编写类模板 220

11.2　类模板 220

11.2.2　编译器如何处理模板 227

11.2.3　模板代码在文件之间的分布 228

11.2.4　模板参数 229

11.2.5　方法模板 231

11.2.6　模板类特殊化 235

11.2.7　从模板类派生子类 239

11.3　函数模板 240

11.2.8　继承与特殊化的区别 240

11.3.1 函数模板特殊化 241

11.3.2　函数模板的重载 242

11.3.3　类模板的友元函数模板 243

11.4.1 关于模板参数的更多知识 244

11.4　高级模板 244

11.4.2　模板类的部分特殊化 251

11.4.3　用重载模板函数部分特殊化 256

11.4.4　模板递归 257

11.5　小结 264

12.1.1　引用变量 265

12.1　引用 265

第12章 理解C++疑难问题 265

12.1.3　引用参数 267

12.1.2　引用数据成员 267

12.1.5　采用引用还是指针 268

12.1.4　引用返回类型 268

12.2.1 关键字const 270

12.2　关键字疑点 270

12.2.2　关键字static 273

12.3.1　typedef 276

12.3　类型与类型强制转换 276

12.2.3　非局部变量的初始化顺序 276

12.3.2　类型强制转换 277

12.4　解析作用域 281

12.5 头文件 282

12.6.1 变量长度参数列表 283

12.6　C实用工具 283

12.7　小结 285

12.6.2　预处理宏 285

13.1.1 如何描述内存 287

13.1 使用动态内存 287

第三部分 掌握C++高级特性 287

第13章 有效的内存管理 287

13.1.2 内存的分配与撤销 289

13.1.3　数组 291

13.1.4　使用指针 297

13.2.1　数组即指针 299

13.2　数组与指针的对应 299

13.3　动态字符串 300

13.2.2　指针并非都是数组 300

13.3.1 C风格的字符串 301

13.3.2　字符串直接量 302

13.3.3　C++的字符串类 303

13.4.1 指针运算 304

13.4　低级的内存操作 304

13.4.3　垃圾回收 305

13.4.2 自定义内存管理 305

13.4.5 函数指针 306

13.4.4 对象池 306

13.5.1 字符串空间分配不足 308

13.5　常见的内存陷阱 308

13.5.2 内存泄漏 309

13.5.3　二次删除与无效指针 311

13.6　小结 312

13.5.4　访问越界指针 312

14.1.2　流的源与目的 313

14.1.1 到底什么是流 313

第14章 揭开C++ I/O的神秘面纱 313

14.1 使用流 313

14.1.3 流输出 314

14.1.4　流输入 317

14.1.5　输入与输出对象 321

14.2　字符串流 323

14.3 文件流 324

14.3.1　使用seek（）与tell（） 325

14.4 双向I/O 327

14.3.2　链接流 327

14.5.2　非西方字符集 329

14.5.1　宽字符 329

14.5 国际化 329

14.5.3　本地化环境与方面 330

14.6　小结 332

15.1.1　到底什么是异常 333

15.1　错误和异常 333

第15章 处理错误 333

15.1.2　C++中的异常为什么好 334

15.2　异常机制 335

15.1.4　我们的建议 335

15.1.3　C++中的异常为什么不好 335

15.2.1　抛出和捕获异常 336

15.2.2　异常类型 338

15.2.3　抛出和捕获多个异常 339

15.2.4　未捕获的异常 342

15.2.5　抛出列表 343

15.3.1 标准异常层次体系 346

15.3　异常和多态 346

15.3.2　按类层次捕获异常 348

15.3.3　编写自己的异常类 349

15.4　栈展开和清除 351

15.4.2　使用智能指针 353

15.4.1　捕获、清除和重新抛出 353

15.5.1　内存分配错误 354

15.5　常见的错误处理问题 354

15.5.2　构造函数中的错误 356

15.6　综合 357

15.5.3　析构函数中的错误 357

15.7　小结 359

16.1　操作符重载概述 361

第16章 重载C++操作符 361

第四部分　确保无错代码 361

16.1.3　操作符重载中的选择 362

16.1.2　操作符重载的限制 362

16.1.1 为什么要重载操作符 362

16.1.5　可重载操作符小结 364

16.1.4　不应重载的操作符 364

16.2.1　重载一元减和一元加 367

16.2　重载算术操作符 367

16.2.2　重载自增和自减 368

16.4　重载插入和析取操作符 369

16.3　重载位操作符和二元逻辑操作符 369

16.5　重载下标操作符 371

16.5.1 利用operator［ ］提供只读访问 373

16.6　重载函数调用操作符 375

16.5.2　非整数数组索引 375

16.7　重载解除引用操作符 377

16.7.1 实现operator＊ 378

16.7.3　到底什么是operator－＞＊ 379

16.7.2　实现operator－＞ 379

1 6.8编写转换操作符 380

16.8.1 转换操作符的二义性问题 381

16.8.2 布尔表达式的转换 382

16.9　重载内存分配和撤销操作符 383

16.9.1　new和delete究竟如何工作 384

16.9.2 重载operator new和operator delete 385

16.9.3　重载带额外参数的operator new和operator delete 387

16.10　小结 389

17.1.2　两类程序 390

17.1.1 实现高效的两种方法 390

第17章 编写高效的C++程序 390

17.1　性能和效率概述 390

17.2　语言级效率 391

17.1.3　C++是一种低效语言吗 391

17.2.1 高效地处理对象 392

17.2.2　不要过度使用高开销的语言特性 394

17.2.3　使用内联方法和函数 395

17.3.1　尽可能缓存 396

17.3　设计级效率 396

17.3.2　使用对象池 397

17.4　测评分析 402

17.3.3　使用线程池 402

17.5　小结 410

18.1.1　体系结构问题 411

18.1　跨平台开发 411

第18章 开发跨平台和跨语言的应用 411

18.1.2　实现问题 413

18.1.3　特定于平台的特性 414

18.2.2　转换模式 415

18.2.1 混合C和C++ 415

18.2　跨语言开发 415

18.2.3 与C代码的链接 418

18.2.4 利用JNI混合Java和C++ 419

18.2.5 C++与Perl和Shell脚本的混合 421

18.3　小结 424

18.2.6 C++与汇编代码的混合 424

19.1.2　bug的生命期 425

19.1.1　谁来负责测试 425

第19章 熟练地测试 425

19.1　质量控制 425

19.1.3　bug跟踪工具 427

19.2.1 单元测试的方法 428

19.2　单元测试 428

19.2.2　单元测试过程 429

19.2.3　实战单元测试 431

19.3.1 集成测试 439

19.3　高级测试 439

19.3.2 系统测试 440

19.4　成功测试的提示 441

19.3.3 回归测试 441

19.5 小结 442

20.3　避免bug 443

20.2　bug分类 443

第20章 征服调试 443

20.1 调试基本法则 443

20.4.1　错误日志 444

20.4　找出bug的方法 444

20.4.2　调试轨迹 445

20.4.3　断言 455

20.5.2　调试可再生bug 456

20.5.1 再生bug 456

20.5　调试技术 456

20.5.4　调试内存问题 457

20.5.3　调试不可再生bug 457

20.5.6　调试示例：文章引用 461

20.5.5　调试多线程程序 461

20.6　小结 472

20.5.7 从ArticleCitations示例学到的教训 472

21.1　容器概述 473

第21章 深入STL：容器和迭代器 473

21.1.2　异常和错误检查 474

21.1.1 元素需求 474

21.1.3 迭代器 475

21.2.1 vector 476

21.2　顺序容器 476

21.2.2　vector＜bool＞特殊化 492

21.2.4　list 493

21.2.3　deque 493

21.3.1 queue 496

21.3　容器适配器 496

21.3.2　priority_queue 499

21.3.3 stack 502

21.4.1　pair工具类 503

21.4　关联容器 503

21.4.2 map 504

21.4.3 multimap 511

21.4.4 set 515

21.4.5　multiset 517

21.5　其他容器 517

21.5.1 数组作为STL容器 517

21.5.2　string作为STL容器 518

21.5.3　流作为STL容器 519

21.5.4　bitset 519

21.6　小结 524

第五部分　使用库和模式 525

第22章 掌握STL算法和函数对象 525

22.1 算法概述 525

22.1.1　find（）和find_if（）算法 526

22.1.2　accumulate（）算法 528

22.2.1　算术函数对象 529

22.2　函数对象 529

22.2.2 比较函数对象 530

22.2.3　逻辑函数对象 531

22.2.4　函数对象适配器 531

22.2.5　编写自己的函数对象 534

22.3　算法细节 535

22.3.1 工具算法 536

22.3.2　非修改算法 536

22.3.3　修改算法 542

22.3.4 排序算法 545

22.3.5 集合算法 547

22.4.1 选民注册审计问题描述 549

22.4.2　auditVoterRolls（）函数 549

22.4　算法和函数对象示例：选民注册审计 549

22.4.3　getDuplicates（）函数 550

22.4.4　RemoveNames函数对象 551

22.4.5 NameInList函数对象 552

22.4.6　测试auditVoterRolls（）函数 553

22.5　小结 554

第23章 定制和扩展STL 555

23.1 分配器 555

23.2　迭代器适配器 556

23.2.1　逆序迭代器 556

23.2.2 流迭代器 557

23.2.3　插入迭代器 557

23.3.1 为什么要扩展STL 559

23.3.2　编写STL算法 559

23.3 扩展STL 559

23.3.3　编写一个STL容器 561

23.4　小结 587

24.1 分布式计算的魅力 588

24.1.1 分布以获得可扩展性 588

第24章 探讨分布式对象 588

24.1.4　分布式内容 589

24.1.3 分布以获得集中性 589

24.1.5　分布式vs网络式 589

24.1.2　分布以获得可靠性 589

24.2　分布式对象 590

24.2.1　串行化和编组 590

24.2.2　远程过程调用 593

24.3　CORBA 595

24.3.1　接口定义语言 595

24.3.2　实现类 597

24.3.3 使用对象 598

24.4　XML 602

24.4.1　XML快速入门 602

24.4.2　XML作为一种分布式对象技术 604

24.4.3 用C++生成和解析XML 604

24.4.4　XML验证 612

24.4.5　用XML构建分布式对象 613

24.4.6　SOAP（简单对象访问协议） 616

24.5　小结 618

25.1 “我想不起来如何…” 619

25.1.1 ……编写一个类 619

第25章 结合技术和框架 619

25.1.2　……派生一个现有类 621

25.1.3　……抛出和捕获异常 622

25.1.4 ……读文件 622

25.1.5　……写文件 623

25.1.6　……编写模板类 623

25.2　还有更好的办法 625

25.2.1　带引用计数的智能指针 625

25.2.2 双重分派 630

25.2.3　混合类 635

25.3　面向对象框架 637

25.3.1 使用框架 637

25.3.2　模型-视图-控制器模式 638

25.4　小结 639

26.1 单例模式 640

26.1.1　举例：日志机制 640

第26章 应用设计模式 640

26.1.2　单例的实现 641

26.1.3　使用单例 645

26.2　工厂模式 646

26.2.1　举例：汽车工厂模拟 646

26.2.2　实现工厂 648

26.2.3　使用工厂 650

26.2.4 工厂的其他使用 651

26.3.1　举例：隐藏网络连通性问题 652

26.3.2　实现代理 652

26.3 代理模式 652

26.4　适配器模式 653

26.4.1 举例：适配一个XML库 653

26.3.3　使用代理 653

26.4.2　适配器的实现 654

26.4.3　使用适配器 657

26.5　装饰器模式 658

26.5.1 举例：定义网页中的样式 658

26.5.2　装饰器的实现 659

26.5.3　使用装饰器 660

26.6.1　举例：事件处理 661

26.6.2　职责链的实现 661

26.6　职责链模式 661

26.6.3　使用职责链 662

26.7　观察者模式 662

26.7.1　举例：事件处理 663

26.7.2　实现观察者 663

26.7.3　使用观察者 664

26.8　小结 665

附录 666

附录A C++面试宝典 666

附录B 参考书目 681