 |
More Exceptional C++: 40 Engineering Puzzles, Programming Problems, and Solutions View Larger Image | Herb Sutter
Addison-Wesley, Paperback, Published December 2001, 279 pages, ISBN 020170434X | List Price: $44.99
Our Price: $34.95
You Save: $10.04 (22% Off)
| | | Availability: Out-Of-Stock |
Be the First to Write a Review and tell the world about this title!People who purchase this book frequently purchase: - Exceptional C++: 47 Engineering Puzzles, Programming Problems, and Exception-Safety Solutions (C++ in Depth); Herb Sutter, $34.95, 22% Off!
- Exceptional C++ Style: 40 New Engineering Puzzles, Programming Problems, and Solutions; Herb Sutter, $34.95, 22% Off!
- C++ Coding Standards: 101 Rules, Guidelines, and Best Practices; Herb Sutter, et al, $34.95, 22% Off!
- Effective C++: 55 Specific Ways to Improve Your Programs and Designs, 3rd Edition; Scott Meyers, $38.95, 22% Off!
Books on similar topics, in best-seller order:Books from the same publisher, in best-seller order:
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 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 classdesign, 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++ promotes the practical and pragmatic understanding of the language while
showing you how to write exceptional code in C++.
Table
of Contents
Foreword.
Preface.
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).
Miscellaneous Topics.
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).
Afterword.
Appendixes,
Appendix A. Optimizations That Aren't
(In a Multithreaded World).
Appendix B. Test Results for Single- versus
Multi-Thread-Safe String Implementations.
Bibliography.
Index.
|
|
