C

More Effective C++: 35 New Ways to Improve Your Programs and Designs

Format: Paperback
Author: Scott Meyers
ReleaseDate: 29 December, 1995
Publisher: Addison-Wesley Professional
Rating:

A good supplementary reference
. It provides even more explanation than the first book and they both have similar advantages: easy-readable, explained in detail, large and useful topics covered.

use the STL and string objects
If you benefited from the insight presented in that book, you may well want to follow up with a study of this text. Scott Meyers continues in the vein of his earlier successful "Effective C++". It assumes a general familiarity with C++, though not necessarily with all the obscure details. It continues in the style of the earlier book by collating useful advice garnered from the C++ community. Which is probably one of the largest groups of programmers in the world.

Two items in the book stand out for the sheer likelihood that you will find them useful. First, install the Standard Template Library on your machine. And whenever possible, call routines from it, instead of writing these yourself. Faster and safer. Those routines have been heavily debugged. STL routines implement many of the common data structures used in computing. Like hash tables, linked lists and sets.

Second, instead of using char*, try string objects. Far safer and thus easier to handle.

Just doing the above two practices can greatly benefit your code.

Worthy sequel to a great first book
It covers more advanced and less general topics than it's predecessor. This is the sequel to the excellent ' Effective C++ ' by the same author. While the first book gives you good programming style and techniques and points out how to use the language correctly, this one shows specific patterns and solutions to more narrowly defined problems. Examples of these include: smart pointers, proxy classes, lazy evaluation, double dispatching. The book also covers the new standard C++ features more in-depth and thus has a good treatment on exceptions and the new style of casting. Because the topics are less general than those from the previous book they are at the same time more controversial. Rules like 'make non-leaf classes abstract' are seldom followed in practice, even though Scott gives good reasons why one should. Another currently hot topic might be 'program in the future tense', which is perfectly sound at first glance, but eXtreme programming proponents might disagree and would want to word it a little less strong. The author sometimes drifts off on really esoteric tangents which seem unlikely to be relevant in the real world. Item 27 'requiring or prohibiting heap based objects' is such a chapter: while I can see that it might sometimes be useful to place such restrictions on classes the effort necessary to do so is just not worth it in my opinion. This is a case where a simple comment might be better than an overly complex class construct. Another point on the negative side is that the author has the unfortunate habit of introducing you to the wrong way of doing things first and almost convincing you of it and only then goes on to show the correct way. I dislike this from a learning psychological point of view, i. e. you should remember the correct way, not both or even worse just the wrong way.
Scott's writing is as usual clear, concise and oftentimes spiced with funny remarks. All in all a worthy sequel - buy it. .