ed at advanced C++ developers who want to hone their
programming chops even further, Sutter's More Exceptional
C++ borrows the format of his earlier title, Exceptional C++, and
delivers some of today's best-available thinking on the language
in a handy and effective format. A compilation of the author's
own experience and research on the thornier aspects of C++, this
book will serve as a worthy resource for making sure you get the
most out of this powerful language.
The concise text covers a range of challenging topics in C++
without attempting to be comprehensive. Each "item" is presented
as a question to try and solve yourself before the author
presents his solution, plus additional detail as needed. For most
topics, Sutter ends by giving his advice on the best practices
(and gotchas to avoid).
Early sections concentrate on using Standard Template Library
(STL) container classes, like removing items effectively, and the
subtle differences between container types. Standout sections on
designing custom templates (using specialization techniques) and
exception-safe classes will help you do more with your own
classes. One entertaining problem here shows a number-guessing
game (Mastermind) built as efficiently as possible using STL code
(including expert-level use of generic functions to do much of
the work).
Several problems on copy-on-write (COW) semantics for more
efficient classes point out the issues surrounding code
optimization. (The author argues against a simplistic approach to
optimizing code, including an overreliance on inlining functions.
Several times he points out the difficulty of getting COW code to
work in multithreaded projects.)
There has been a debate in the C++ community for years about
whether it's possible to design truly "exception-safe" classes.
Sutter points out the difficulty with a precise analysis of the
issues surrounding exceptions and C++ constructors. Material on
the finer points of inheriting classes (including when to avoid
and when to use multiple inheritance in C++) will extend your
class design options. A good section here is the author's
explication of how to simulate COM/Java style interfaces in C++,
which isn't immediately obvious, even to experienced C++
developers.
Later sections delve into code maintenance issues, including
advice for using macros, typedefs, and namespaces. (Advice on
migrating existing C++ code into namespaces will help you combine
legacy code with other libraries.) A final appendix shows off
some benchmarks for optimizing strings using a variety of
techniques.
Intelligent, provocative, and demanding, More Exceptional C++
shows why C++ continues to be a rich, complex, and challenging
language. Armed with titles like this one, experienced C++
programmers can write better code and avoid pitfalls buried in
the outer edges of their favorite language. --Richard Dragan
Topics covered: Puzzles and solutions to advanced topics in C++,
using remove() and erase() for Standard Template Library (STL)
containers, custom templates with inheritance and traits, using
typename, containers used with pointers, the finer points of
vector, set, and s, potential problems with vector < bool >,
post and prefix operators used with functions, templates
overloading, explicit and partial template specialization (plus
function template overloading), using STL to implement Mastermind
(a number-guessing game), the finer points of inline functions,
lazy optimizations (including copy-on-write--COW--and semantics
for strings), iterators and references, gotchas in multithreaded
environments, designing exception-safe classes, constructor
failures and object lifetimes, uncaught exceptions (the pitfalls
of using uncaught_exception()), unmanaged pointers (in parameter
evaluation and auto_ptr); copy assignment, inheritance and
exception safety issues, multiple inheritance dos and don'ts, the
Siamese Twin problem, virtual functions, controlled polymorphism,
memory management issues with smart pointers (auto_ptr),
recursive declarations, how to simulate nested functions,
preprocessor macros, hints for initialization, forward
declarations, using typedef effectively, best practices for
namespaces (including code maintenance and migrating existing C++
code to namespaces), and appendices on advice for multithreaded
optimization.