Tuesday, October 5, 1999

Updated MEC++ Errata; Talks at C++ World

Two topics:
- The MEC++ errata list has just been updated
- I'll be speaking at C++ World in Miami in December

I've just updated the errata page for More Effective C++. You'll find it
at http://www.aristeia.com/BookErrata/mec++-errata.html. I'd hoped to
include the latest changes in this mailing as a Mailing List Exclusive, but
I wasn't really set up for that. In the future, I'll try to organize my
bookkeeping so that when I update an errata list, I can include the changed
entries in the message that announces the updated list.

I've agreed to speak at the "C++ World" conference in Miami on December 2
and 3. For details, check out http://www.cwconference.com/. The talks I'm
going to give are described below. These are the descriptions I submitted
to the conference organizers, but the descriptions you'll see in brochures,
etc., will be shorter, because it's important that all conferences hack the
talk abstracts until they bear little resemblance to what the speaker
originally submitted. Ahem.

Real World C++ (Renamed "Succeeding with C++" at the behest of the
conference organizers. Don't ask.)

When Scott started consulting on C++ projects, he figured his biggest
challenges would center on the proper use of language features. He was
so naive. Over the years, he's discovered that the biggest obstacles to
success in C++ involve a little C++, a fair amount of
language-independent software engineering, and a healty dose of decent
management. This talk presents over a dozen specific guidelines that
Scott has found to significantly improve the chances of success on real
software projects in C++. Some guidelines focus on specific language
issues (e.g., casts, virtual destructors), while others focus on broader
matters (e.g., the need to embrace abstraction, the importance of
specifications, the need to develop staged releases). Compared to Meyers'
usual talks, this seminar is less intensively technical, but it covers a
broader array of issues, and it is definitely about C++ software

Implementing operator->*

Most C++ programmers know little about operator->*, but the topic is both
interesting and instructive. Especially interesting is the use of
templates, including member and partially specialized templates. This
talk begins with a review of how operator->* is generally used, then
proceeds to examine two different ways to implement it for smart pointer
classes. It ends with a tantalizing idea: smart pointers to members.

The Strange Tale of auto_ptr

auto_ptr is a smart pointer template in the standard library with the
simplest of conceptual specificatons: an auto_ptr is an object that acts
just like a pointer, except it deletes what it points to when it (the
auto_ptr) is destroyed. This simple description turns out to mask a
design challege of considerable proportions, one that required two
fundamental rewrites during standardization, and even the final
specification for auto_ptr has noteworthy flaws. (For example, some of
its intended uses won't compile.)

This talk describes the tortured path auto_ptr travelled from initial
concept to final specification, focusing on the design challenges that
made auto_ptr so difficult to pin down. Attendees can expect to learn
not just about auto_ptr, but also about how several features of C++ can
interact to make a seemingly simple class extremely difficult to design.

The material in the talk on operator->* is the same as that published in
the current issue of Dr. Dobbs Journal.