More Exceptional C++: 40 New Engineering Puzzles, Programming Problems, and Solutions / Edition 1by Herb Sutter
Pub. Date: 12/17/2001
Organized in a practical problem-and-solution format, More Exceptional C++ picks up where the widely acclaimed Exceptional C++ leaves off, providing successful strategies for solving real-world problems in C++. Drawing from years of in-the-trenches experience, Herb Sutter provides tested techniques and practical solutions for/b>/i>/b>/i>… See more details below
Organized in a practical problem-and-solution format, More Exceptional C++ picks up where the widely acclaimed Exceptional C++ leaves off, providing successful strategies for solving real-world problems in C++. Drawing from years of in-the-trenches experience, Herb Sutter provides tested techniques and practical solutions for programmers designing modern software systems with C++, from small projects to enterprise applications.
Built around forty programming puzzles, More Exceptional C++ helps you understand the rules and issues critical to successful software design and development in C++. New themes included in this sequel place a strong emphasis on generic programming, memory management, and using the C++ standard library, including coverage of important techniques like traits and predicates. Also included are guidelines and considerations to remember when using standard containers and algorithms--topics rarely covered in-depth in other sources.
Readers will find solutions to such important questions as:
- What pitfalls might you encounter when using std::map and std::set, and how can you safely avoid them?
- What kinds of predicates are safe to use with the STL, what kinds aren't, and why?
- What techniques are available for writing powerful generic template code that can change its own behavior based on the capabilities of the types it's given to work with?
- When and how should you optimize your code? Why can (and do) fancy optimizations get us into trouble? And how can some of these answers change if you're writing multithread-safe code?
- Does exception safety affect class design, or can it be retrofitted in as an afterthought?
- How can you avoid the Siamese Twin problem when combining inheritance-based libraries from different vendors?
- How can you safely use auto_ptr, and then use common design patterns to adapt it to avoid common pitfalls? Can you use auto_ptr as a class member? What must you know before you elect to use it that way?
- Plus one of the most frequently recurring questions about modern C++: When and how should you use namespaces, anyway?
A must-have for the serious programmer, More Exceptional C++ provides a thorough and pragmatic understanding of the language while showing you how to write exceptional code in C++.
Table of Contents
Generic Programming and the C++ Standard Library.
Item 1: Switching Streams (2 / 10).
Item 2: Predicates, Part 1: What remove() Removes (4 / 10).
Item 3: Predicates, Part 2: Matters of State (7 / 10).
Item 4: Extensible Templates: Via Inheritance or Traits? (7 / 10).
Item 5: Typename (7 / 10).
Item 6: Containers, Pointers, and Containers That Aren't (5 / 10).
Item 7: Using Vector and Deque (3 / 10).
Item 8: Using Set and Map (5 / 10).
Item 9: Equivalent Code? (5 / 10).
Item 10: Template Specialization and Overloading (6 / 10).
Item 11: Mastermind (8 / 10).
Optimization and Performance.
Item 12: Inline (4 / 10).
Item 13: Lazy Optimization, Part 1: A Plain Old String (2 / 10).
Item 14: Lazy Optimization, Part 2: Introducing Laziness (3 / 10).
Item 15: Lazy Optimization, Part 3: Iterators and References (6 / 10).
Item 16: Lazy Optimization, Part 4: Multi-Threaded Environments (8 / 10).
Exception Safety Issues and Techniques.
Item 17: Constructor Failures, Part 1: Object Lifetimes (4 / 10).
Item 18: Constructor Failures, Part 2: Absorption? (7 / 10).
Item 19: Uncaught Exceptions (6 / 10).
Item 20: An Unmanaged Pointer Problem, Part 1: Parameter Evaluation (6 / 10).
Item 21: An Unmanaged Pointer Problem, Part 2: What About auto_ptr? (8 / 10).
Item 22: Exception-Safe Class Design, Part 1: Copy Assignment (7 / 10).
Item 23: Exception-Safe Class Design, Part 2: Inheritance (6 / 10).
Inheritance and Polymorphism.
Item 24: Why Multiple Inheritance? (6 / 10).
Item 25: Emulating Multiple Inheritance (5 / 10).
Item 26: Multiple Inheritance and the Siamese Twin Problem (4 / 10).
Item 27: (Im)pure Virtual Functions (7 / 10).
Item 28: Controlled Polymorphism (3 / 10).
Memory and Resource Management.
Item 29: Using auto_ptr (5 / 10).
Item 30: Smart Pointer Members, Part 1: A Problem with auto_ptr (5 / 10).
Item 31: Smart Pointer Members, Part 2: Toward a ValuePtr (6 / 10).
Free Functions and Macros.
Item 32: Recursive Declarations (6 / 10).
Item 33: Simulating Nested Functions (5 / 10).
Item 34: Preprocessor Macros (4 / 10).
Item 35: #Definition (4 / 10).
Item 36: Initialization (3 / 10).
Item 37: Forward Declarations (3 / 10).
Item 38: Typedef (3 / 10).
Item 39: Namespaces, Part 1: Using-Declarations and Using-Directives (2 / 10).
Item 40: Namespaces, Part 2: Migrating to Namespaces (4 / 10).
Appendix A. Optimizations That Aren't (In a Multithreaded World).
Appendix B. Test Results for Single- versus Multi-Thread-Safe String Implementations.
and post it to your social network
Most Helpful Customer Reviews
See all customer reviews >