内容简介

本书既系统全面又突出重点，作者从C++基础知识讲起，始终着眼于C++语言的编程实践，提供了大量实践示例和解决方案，包括如何更好地实现重用、如何有效地测试和调试等C++专业人员常用的一些技术与方法，还提供了一些鲜为人知的、能大大简化工作的C++语言特性；最后，还配有大量可重用的编码模式，并在附录中提供C++面试宝典作为开发人员的实用指南。

本书面向进阶C++的初学者，以及那些想把C++水平提高到专业水准的程序员和开发人员。

作品目录

译者序

前言

作者简介

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

第1章 C++快速入门.

1.1 C++基础

1.1.1 必不可少的"hello，world"

1.1.2 命名空间

1.1.3 变量

1.4 操作符

1.1.5 类型

1.1.6 条件语句

1.1.7 循环

1.1.8 数组

1.1.9 函数

1.1.10 结束语

1.2 C++进阶

1.2.1 指针和动态内存

1.2.2 C++中的字符串

1.2.3 引用

1.2.4 异常

1.2.5 const的多重用途

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

1.4 你的第一个实用的c十十程序

1.4.1 一个员工记录系统

1.4.2 employee类

1.4.3 database类

1.4.4 用户界面

1.4.5 对程序的评价

1.5 小结

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

2.2 编程设计的重要性

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

2.4 C++设计的两个原则

2.4.1 抽象

2.4.2 重用

2.5 设计一个象棋程序

2.5.1 需求

2.5.2 设计步骤

2.6 小结

第3章 基于对象的设计

3.1 面向对象的世界观

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

3.1.2 面向对象思想

3.1.3 身处对象世界中

3.1.4 对象关系

3.1.5 抽象

3.2 小结

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

4.1 重用代码

4.1.1 有关术语

4.1.2 决定是否重用代码

4.1.3 重用代码的策略

4.1.4 捆绑第三方应用

4.1.5 开源库

4.1.6 C++标准库

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

4.2.1 设计技术

4.2.2 设计模式

4.3 小结

第5章 重用设计

5.1 重用方法论

5.2 如何设计可重用的代码

5.2.1 使用抽象

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

重用

5.2.3 设计可用的接口

5.2.4 协调一般性和易用性

5.3 小结

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

6.1 为什么需要过程

6.2 软件生命期模型

6.2.1 分阶段模型和瀑布模型

6.2.2 螺旋方法

6.2.3 统一开发过程

6.3 软件工程方法论

6.3.1 极限编程(xp)

6.3.2 软件triage

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

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

6.4.2 汇总新思想

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

6.4.4 不要做叛逃者

6.5 小结

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

第7章 好的编码风格

7.1 为什么代码看上去要好

7.1.1 提前考虑

7.1.2 保持清晰

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

7.2 为代码加注释

7.2.1 写注释的原因

7.2.2 注释风格

7.2.3 本书中的注释

7.3 分解

7.3.1 通过重构来分解

7.3.2 根据设计来分解

7.3.3 本书中的分解

7.4 命名

7.4.1 选择一个好名字

7.4.2 命名约定

7.5 合理地使用语言特性

7.5.1 使用常量

7.5.2 利用const变量

7.5.3 使用引用而不是指针

7.5.4 使用定制异常

7.6 格式化

7.6.1 有关大括号对齐的争论

7.6.2 考虑空格和小括号

7.6.3 空格和制表符

7.7 风格方面的难题

7.8 小结

第8章 掌握类和对象

8.1 电子表格示例

8.2 编写类

8.2.1 类定义

8.2.2 定义方法

8.2.3 使用对象

8.3对象生命期

8.3.1 对象创建

8.3.2 对象撤销

8.3.3 对象赋值

8.3.4 区别复制和赋值

8.4 小结

第9章 精通类和对象

9.1 对象中的动态内存分配

9.1.1 spreadsheet类

9.1.2 用析构函数释放内存

9.1.3 处理复制和赋值

9.2 不同类型的数据成员

9.2.1 静态数据成员

9.2.2 const数据成员

9.2.3 引用数据成员

9.2.4 const引用数据成员

9.3 深入了解方法

9.3.1 静态方法

9.3.2 const方法

9.3.3 方法重载

9.3.4 默认参数

9.3.5 内联方法

9.4 嵌套类

9.5 友元

9.6 操作符重载

9.6.1 实现加法

9.6.2 重载算术操作符

9.6.3 重载比较操作符

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

9.7 方法和成员指针

9.8构建抽象类

9.9 小结

第10章 探索继承技术

10.1 使用继承构建类

10.1.1 扩展类

10.1.2 覆盖方法

10.2 继承以实现重用

10.2.1 类weatherprediction

10.2.2 在子类中增加功能

10.2.3 在子类中进行功能替换

10.3 考虑父类

10.3.1 父构造函数

10.3.2 父析构函数

10.3.3 引用父类的数据

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

强制转换

10.4 继承以实现多态

10.4.1 spreadsheet的返回结果

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

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

10.4.4 各个子类

10.4.5 充分利用多态

10.4.6 将来的考虑

10.5 多重继承

10.5.1 从多个类继承

10.5.2 命名冲突与二义基类

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

10.6.1 改变覆盖方法的特性

10.6.2 覆盖方法的特殊情况

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

10.6.4 关键字virtual的真相

10.6.5 运行时类型工具

10.6.6 非公共继承

10.6.7 虚基类

10.7 小结

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

11.1 模板概述

11.2 类模板

11.2.1 编写类模板

11.2.2 编译器如何处理模板

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

11.2.4模板参数

11.2.5 方法模板

11.2.6 模板类特殊化

11.2.7 从模板类派生子类

11.2.8 继承与特殊化的区别

11.3 函数模板

11.3.1 函数模板特殊化

11.3.2 函数模板的重载

11.3.3 类模板的友元函数模板

11.4 高级模板

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

11.4.2 模板类的部分特殊化

11.4，3 用重载模板函数部分特殊化

11.4.4 模板递归

11.5 小结

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

12.1 引用

12.1.1 引用变量

12.1.2 引用数据成员

12.1.3 引用参数

12.1.4 引用返回类型

12.1.5 采用引用还是指针

12.2 关键字疑点

12.2.1 关键字const

12.2.2 关键字static

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

12.3 类型与类型强制转换

12.3.1 typedef

12.3.2 类型强制转换

12.4 解析作用域

12.5 头文件

12.6 c实用工具

12.6.1 变量长度参数列表

12.6.2 预处理宏

12.7 小结第三部分 掌握C++高级特性

第13章 有效的内存管理

13.1 使用动态内存

13.1.1 如何描述内存

13.1.2 内存的分配与撤销

13.1.3 数组

13.1.4 使用指针

13.2 数组与指针的对应

13.2.1 数组即指针

13.2.2 指针并非都是数组

13.3 动态字符串

13.3.1 c风格的字符串

13.3.2 字符串直接量

13.3.3 C++的字符串类

13.4 低级的内存操作

13，4.1 指针运算

13.4.2 自定义内存管理

13.4.3 垃圾回收

13.4.4 对象池

13.4.5 函数指针

13.5 常见的内存陷阱

13.5.1 字符串空间分配不足

13.5.2 内存泄漏

13.5.3 二次删除与无效指针

13.5.4 访问越界指针

13.6 小结..

第14章 揭开C++ i／o的神秘

面纱

14.1 使用流

14.1.1 到底什么是流

14.1.2 流的源与目的

14.1.3 流输出

14.1.4 流输入

14.1.5 输入与输出对象

14.2 字符串流

14.3 文件流

14.3.1 使用seek()与tell()

14.3.2 链接流

14.4 双向i／o

14.5 国际化

14.5.1 宽字符

14.5.2 非西方字符集

14.5.3 本地化环境与方面

14.6 小结

第15章 处理错误

15.1 错误和异常

15.1.1 到底什么是异常

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

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

15.1.4 我们的建议

15.2 异常机制

15.2.1 抛出和捕获异常

15.2.2 异常类型

15.2.3 抛出和捕获多个异常

15.2.4 未捕获的异常

15.2.5 抛出列表

15.3 异常和多态

15.3.1 标准异常层次体系

15.3.2 按类层次捕获异常

15.3.3 编写自己的异常类

15.4 栈展开和清除

15.4.1 捕获、清除和重新抛出

15.4.2 使用智能指针

15.5 常见的错误处理问题

15.5.1 内存分配错误

15.5.2 构造函数中的错误

15.5.3 析构函数中的错误

15.6 综合

15.7 小结

第四部分 确保无错代码

第16章 重载C++操作符

16.1 操作符重载概述

16.1.1 为什么要重载操作符

16.1.2 操作符重载的限制

16.1.3 操作符重载中的选择

16.1.4 不应重载的操作符

16.1.5 可重载操作符小结

16.2 重载算术操作符

16.2.1 重载一元减和一元加

16.2.2 重载自增和自减

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

16.4 重载插入和析取操作符

16.5 重载下标操作符

16.5.1 利用operator[]提供只读

访问

16.5.2 非整数数组索引

16.6 重载函数调用操作符

16.? 重载解除引用操作符

16.7.1 实现operator

16.7.2 实现operator一]

16.7.3 到底什么是operator一]

16.8 编写转换操作符

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

16.8.2 布尔表达式的转换

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

16.9.1 new和delete究竟如何工作

16.9.2 重载operatornew和operator delete

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

16.10 小结

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

17.1 性能和效率概述

17.1.1 实现高效的两种方法

17.1.2 两类程序

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

17.2语言级效率

17.2.1 高效地处理对象

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

17.2.3 使用内联方法和函数

17.3 设计级效率

17.3.1 尽可能缓存

17.3.2 使用对象池

17.3.3 使用线程池

17.4 测评分析

17.5 小结

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

18.1 跨平台开发

18.1.1 体系结构问题

18.1.2 实现问题

18.1.3 特定于平台的特性

18.2 跨语言开发

18.2.1 混合c和C++

18.2.2 转换模式

18.2.3 与c代码的链接

18.2.4 利用jni混合java和C++

18.2.5 C++与peri和shell脚本的混合

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

18.3 小结

第19章 熟练地测试

19.1 质量控制

19.1.1 谁来负责测试

19.1.2 bug的生命期

19.1.3 bug跟踪工具

19.2 单元测试

19.2.1 单元测试的方法

19.2.2 单元测试过程

19.2.3 实战单元测试

19.3 高级测试

19.3.1 集成测试

19.3.2 系统测试

19.3：3 回归测试

19.4 成功测试的提示

19.5 小结

第20章 征服调试

20.1 调试基本法则

20.2 bug分类

20.3 避免bug

20.4 找出bug的方法

20.4.1 错误日志

20.4.2 调试轨迹

20.4.3 断言

20.5 调试技术

20.s.1 再生bug

20.5.2 调试可再生bug

20.5.3 调试不可再生bug

20.5.4 调试内存问题

20.5.5 调试多线程程序

20.5.6 调试示例：文章引用

20.5.7 从articlecitations示例学到的教训

20.6 小结

第21章 深入stl：容器和迭代器

21，1 容器概述

21.1.1 元素需求

21.1.2 异常和错误检查

21.1.3 迭代器

21.2 顺序容器

21.2.1 vector

21.2.2 vector[bool]特殊化

21.2.3 deque

21.2.4 list

21.3 容器适配器

21.3.1 queue

21.3.2 priority_queue

2l 3.3 stack

21.4 关联容器

21.4.1 pair工具类

21.4.2 map

21.4.3 multimap

21，4.4 set

21.4.5 multiset

21.5 其他容器

21.5.1 数组作为stl容器

21.5.2 string作为sti容器

21.5.3 流作为stl容器

21.5.4 bitset

21.6 小结

第五部分 使用库和模式

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

22.1 算法概述

22.1.1 find()和find—汀()算法

22.1.2 accumulate()算法

22.2 函数对象

22.2.1 算术函数对象

22.2.2 比较函数对象

22.2.3 逻辑函数对象

22.2.4 函数对象适配器

22.2.5 编写自己的函数对象

22.3 算法细节

22.3.1 工具算法

22.3.2 非修改算法

22.3.3 修改算法

22.3.4 排序算法

22.3.5 集合算法

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

22.4.1 选民注册审计问题描述

22.4.2 auditvoterrolls()函数

22.4.3 getduplicates()函数

22.4.4 removenames函数对象

22.4.5 namelnlist函数对象

22.4.6 测试auditvoterrolls()函数

22.5 小结

第23章 定制和扩展stl

23.1 分配器

23.2 迭代器适配器

23.2.1 逆序迭代器

23.2.2 流迭代器

23.2.3 插入迭代器

23.3 扩展stl

23.3.1 为什么要扩展stl

23.3.2 编写stl算法

23.3.3 编写一个stl容器

23.4 小结

第24章 探讨分布式对象

24.1 分布式计算的魅力

24.1.1 分布以获得可扩展性

24.1.2 分布以获得可靠性

24.1.3 分布以获得集中性

24.1.4 分布式内容

24.1.5 分布式vs网络式

24.2 分布式对象

24.2.1 串行化和编组

24.2.2 远程过程调用

24.3 corba

24.3.1 接口定义语言—

24.3.2 实现类

24.3.3 使用对象

24.4 xml

24.4.1 xml陕速入门

24.4.2 xml作为一种分布式对象技术.

24.4.3 用C++生成和解析xml

24.4.4 xml验证

24.4.5 用xml构建分布式对象

24.4.6 soap(简单对象访问协议)

24.5 小结

第25章 结合技术和框架

25.1 “我想不起来如何”

25.1.1 编写一个类

25.1.2 派生一个现有类

25.1.3 抛出和捕获异常

25.1.4 读文件

25.1.5 写文件

25.1.6 编写模板类

25.2 还有更好的办法

25.2.1 带引用计数的智能指针

25.2.2 双重分派

25.2.3 混合类

25.3 面向对象框架

25.3.1 使用框架

25.3.2 模型—视图—控制器模式

25.4 小结

第26章 应用设计模式

26.1 单例模式

26.1.1 举例：日志机制

26.1.2 单例的实现

26.1.3 使用单例

26.2 工厂模式

26.2.1 举例：汽车工厂模拟

26.2.2 实现工厂

26.2.3 使用工厂

26.2.4 工厂的其他使用

26.3 代理模式

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

26.3.2 实现代理

26.3.3 使用代理

26.4 适配器模式

26.4.1 举例：适配一个xml库

26.4.2 适配器的实现

26.4.3 使用适配器

26.5 装饰器模式

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

26.5.2 装饰器的实现

26.5.3 使用装饰器

26.6 职责链模式

26.6.1 举例：事件处理

26.6.2 职责链的实现

26.6.3 使用职责链

26.7 观察者模式

26.7.1 举例：事件处理

26.7.2 实现观察者

26.7.3 使用观察者

26.8 小结

附录

附录A C++面试宝典

附录B 参考书目