c++编程惯用法——高级程序员常用方法和技巧(PDF)

在本书中，C++专家Rob Murray就与我们分享了他宝贵的经验和建议，以帮助初中级C++程序员得到进一步的提高。 作者大量采用了实际开发中的代码来作为示例，向读者展示了那些有用的编程策略，并对那些有害的做法进行了警示。为了帮助读者更好地理解，在书中的每一章结束前，在该章中被介绍过的主要内容都被放到了一个列表中，此外，书中还给出了一些问题来激励读者们进行更多的思考和讨论。 




本书在一开始就向我们讲解了如何为我们的设计选择正确的抽象，提示我们注意抽象和实现之间的区别—然后，我们就将学到如何将己得到的抽象转化成一个(或多个)C++中的类，期间进行的讨论所涵盖的范围上至高层的设计策略，下至底层的接口和实现细节。


对于C++中新增的模板特性，通过从基础开始到逐步地接触实际应用中的示例，Rob Murray向我们展示了其空前的洞察力。作者同时也向我们展示了多种特定的技巧，以使我们的程序更快、重用性更高，并且更健壮。异常是C++中另外一个新增的特性，对于何时该使用它，何时不该使用它，Murray也向我们给出了他的建议-在本书的最后，我们还可以学到如何将一个项目从C移植到C++之上，书中对该过程的讨论不但包括了其中可能出现的技术问题，也包括了使用技术的“人”的问题。

【C++编程惯用法——高级程序员常用方法和技巧 图书目录】 
代译者序                  
   序                  
   第0章  简介                  
     0. 1  关于示例代码                  
     0. 2  本书的组织                  
     0. 3  问题                  
     0. 4  语言规则                  
   第1章  抽象                  
     1. 1  有关电话号码的抽象模型                  
     1. 2  抽象模型间的关系                  
     1. 3  请考虑边界条件                  
     1. 4  使用CRC卡片来辅助设计                  
     1. 5  小结                  
     1. 6  问题                  
   第2章  类                  
     2. 1  构造函数                  
     2. 2  赋值                  
     2. 3  公用数据                  
     2. 4  隐式类型转换                  
     2. 5  操作符重载：成员或非成员?                  
     2. 6  重载. 缺省值以及省略符                  
     2. 7  Const                  
     2. 8  返回值为引用                  
     2. 9  静态对象的构造                  
     2. 10  小结                  
     2. 11  问题                  
   第3章  句柄                  
     3. 1  一个String类                  
     3. 2  使用计数器来避免多份拷贝                  
     3. 3  避免进行重编译：Cheshire Cat                  
     3. 4  使用句柄来隐藏设计                  
     3. 5  多种实现                  
     3. 6  作为对象的句柄                  
     3. 7  综述                  
     3. 8  小结                  
     3. 9  问题                  
   第4章  继承                  
     4. 1  is-a关系                  
     4. 2  公有继承                  
     4. 3  私有继承                  
     4. 4  保护型继承                  
     4. 5  与基类抽象的一致性                  
     4. 6  纯虚函数                  
     4. 7  有关继承的细节和陷阱                  
     4. 8  小结                  
     4. 9  问题                  
   第5章  多重继承                  
     5. 1  作为交集的多重继承                  
     5. 2  虚基类                  
     5. 3  一些有关多重继承的细节问题                  
     5. 4  小结                  
     5. 5  问题                  
   第6章  考虑继承的设计                  
     6. 1  被保护的接口                  
     6. 2  我们的设计是否应该考虑到继承?                  
     6. 3  一些为继承所做的设计的例子                  
     6. 4  结论                  
     6. 5  小结                  
     6. 6  问题                  
   第7章  模板                  
     7. 1  模板类Pair                  
     7. 2  一些有关模板的细节                  
     7. 3  模板的实例化                  
     7. 4  智能指针                  
     7. 5  作为模板参数的表达式                  
     7. 6  模板函数                  
     7. 7  小结                  
     7. 8  问题                  
   第8章  模板的高级用法                  
     8. 1  使用了模板的容器类                  
     8. 2  示例：Block                  
     8. 3  有关Block的设计细节                  
     8. 4  带有迭代器的容器：List                  
     8. 5  迭代器的设计细节                  
     8. 6  性能上的考虑                  
     8. 7  对模板参数的限制                  
     8. 8  模板特化                  
     8. 9  小结                  
     8. 10  问题                  
   第9章  重用                  
     9. 1  发现和获得                  
     9. 2  健壮性                  
     9. 3  内存管理                  
     9. 4  可选的内存分配方案                  
     9. 5  传递参数给operatornew                  
     9. 6  管理外部资源                  
     9. 7  寻找有关内存的bug                  
     9. 8  名字冲突                  
     9. 9  性能                  
     9. 10  不要去猜想, 而应该度量!                  
     9. 11  算法                  
     9. 12  动态内存分配中的瓶颈                  
     9. 13  内嵌                  
     9. 14  Tiemann法则                  
     9. 15  小结                  
     9. 16  问题                  
   第10章  异常                  
     10. 1  一个负面的声明                  
     10. 2  为什么需要异常?                  
     10. 3  一个异常的例子                  
     10. 4  异常只应该用来表述异常情况                  
     10. 5  理解异常                  
     10. 6  责任评估                  
     10. 7  设计异常对象                  
     10. 8  小结                  
     10. 9  问题                  
   第11章  向C++移植                  
     11. 1  选择使用C++                  
     11. 2  采用C++                  
     11. 3  设计和实现                  
     11. 4  开发一个坚实的基础                  
     11. 5  相关的思考                  
     11. 6  小结                  
     11. 7  问题