Customer Reviews

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

5 star:		(26)
4 star:		(16)
3 star:		(0)
2 star:		(0)
1 star:		(2)

 

 

While Meyers' first book, _Effective C++_, described fundamental concepts of C++, this book covers substantially more advanced techniques. These are not the heavily-designed strategies described in _Design Patterns_ or _Advanced C++: Programming Styles and Idioms_, but more lightweight and fundamental C++ features, including the specifics of memory allocation, exception handling, stack-based classes, and operator overloading. These are features of C++ which can be ignored at first but soon become key everday programming elements and important design considerations once well understood.

The material covered here separates the casual or novice C++ hobbyist from the true programmer.

Yeah, Effective C++ is really a *must read* if you want to improve your current knowledge of C++. However, although interesting, I don't find this book a must because it explains things you will not probably use in your real life as a programmer. If you already have Effective C++, both Stroustup, and/or Coplien's "Advanced C++ Programming Styles and Idioms" and/or Murray's "C++ Strategies and Tactics", I don't think you should get it unless you do not sleep at nights or you want to know absolutely everything about C++. However, it is a good book, so if you are not concerned about money, get it and read it, but get first the other ones I said.

...this book is for you. Both "50 Specific Ways" and his second book "35 New Ways" have helped me bring my C++ programming up to the next level of understanding. After using C for more than 10 years and C++ for all but the first few of those years, there were still many small things that used to bug me. Problems with some of my constructors, strange constructs I'd discovered over the years but never 100% understood... Scott's books have not only cleared the field, but have brought to my attention many new things about objects and C++ I'd never previously considered.

One warning: I found that some items were too far above me when I first read through the books -- especially this second book, "35 New Ways..." However, once I'd finished reading the book, I started again right back at page 1, and my second (and 3rd, 4th...) reading made much more sense. There is a *lot* of helpful information packed into Scott's 85 items.

I recommend picking up both books at once, or, I believe a special edition is available with both books condensed into 1 volume.

This book differs from '50 ways' in two primary ways: First, it is much more up-to-date with respect to the C++ standard. Second, its topics tend to be of a more "strategic" than "tactical" nature and are discussed in greater depth.

Where it is similar is in the way that Meyers makes liberal use of example code to explain not just the "doctrine" but the nature of the problems which need to be overcome and the various less suitable alternative approaches.

As a c++ neophyte (but 20 year programmer), when I first read this book after having read its predecessor, I felt that it wasn't as useful or as immediately applicable. However, having acquired some months of experience putting to use the excellent advice of the first book, I find myself re-reading this book for more detailed discussions of the language and its use.

I would very much like to see a third volume from Meyers dealing solely with the new C++ Standard Template Library.

This is the sequel to the excellent ' Effective C++ ' by the same author. It covers more advanced and less general topics than it's predecessor. 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.

This is the sequel to Scott Meyers' classic "Effective C++". When it came out (in 1996) "More Effective C++" complemented the material in "Effective C++" very well. Since then, "Effective C++" has been fully updated (3rd ed., 2005), therefore the two books are, strictly speaking, no longer complementary. Since its first publication, "More Effective C++" has only been changed in minor ways, mainly through the addition of footnotes (some of which go against the advice in the main text, see Items 14, 18, 20, & 26).

The Good: as in his earlier volume, Meyers' writing is easygoing and occasionally funny, e.g. "If BookEntry's constructor throws an exception, pb will be the null pointer, so deleting it in the catch block does nothing except make you feel better about yourself." (Item 10). Despite the overlap with other books noted above (and below), some of the material is both important and not covered elsewhere, especially the stuff on proxy classes and efficiency. In the case of the latter, I really appreciated the table in Item 24 discussing the costs of virtual functions, multiple inheritance, virtual base classes, and RTTI. In a number of places, Meyers elucidates the established terminology of the C++ community. For example, the "return value optimization" you may have heard of amounts to returning constructor arguments instead of objects (Item 20). A notable exception to this terminological clarity is RAII: though he explains the concept, he does not mention the term itself. In typical "tips & tricks" fashion, Meyers presents a large number of useful tidbits of information, a few of which I mention below. Some of these are more or less obvious, but others are less straightforward: a) a sequence of conversions cannot contain more than one user-defined conversion (Item 5), b) postfix increment/decrement operators take an int argument (Item 6), c) passing a temporary object to a non-const reference parameter is not allowed for function calls, but it is for exceptions (Item 12), and d) creating a class template where the type template parameter apparently is never used can help you get separate copies of the static members when the template is instantiated for different types (Item 26).

The Bad: in my opinion, after reading a detailed introductory book the main three things a C++ programmer needs practice with and further instruction on are: a) condensed lore on object-oriented programming, including design idioms and patterns, b) templates, encompassing template metaprogramming, and c) the Standard Template Library, meaning its containers, iterators, and algorithms. (With the coming of the new standard I guess one should add multithreading to this list). The problem is, this book was published in 1996, when all three of these concepts were new(ish) (e.g. Meyers discusses Singleton but he doesn't call it that) so they do not get the treatment they deserve here. Today, Meyers' own "Effective C++, 3rd edition" (2005) does a fine job of discussing templates in more detail as well as introducing a few design patterns. Even more information on these subjects, broken down into bite-sized chunks, can be found in Steve Dewhurst's "C++ Common Knowledge" (2005) and Herb Sutter's "Exceptional C++" (2000). Finally, Meyers' own "Effective STL" contains advice on the STL that is considerably broader and more detailed than what is included in the present tome. The book's time-dependence is obvious in other ways, too, ranging from trivial matters (e.g. in Item 28 the two classes derived from MusicProduct are CD and... Cassette), to topics that are now irrelevant at best (e.g. what to do if your compiler doesn't support new-style casts or the explicit keyword), and even including fundamental issues (e.g. so much attention to auto_ptr seems misplaced today, when we have access to things like shared_ptr and unique_ptr). Finally, in contradistinction to "Effective C++", most Items in "More Effective C++" do not end with a "Summary" section. Given that they are also longer, this interferes with the reader's ability to quickly bring to mind each Item's lessons.

In a nutshell, I believe that this book is no longer the best "third book" on C++ (the first one being a solid introduction like the "C++ Primer" and the second one being none other than "Effective C++, 3rd edition"). It looks like the niche that this book filled when it came out has been taken over by more recent volumes, including Meyers' other works. With C++0x on the horizon and the barrage of new editions about to appear, this will only become more so. However, Meyers' writing is very good and his advice is authoritative, so I definitely did not regret reading this volume.

Alex Gezerlis

After being a very satisfied reader of the first volume, I bought this second as well. And I'm even more satisfied with this book. There are fewer items than the first volume, but I found they are exactly those items you're looking for after reading a C++ big manual and the first Meyers' book.

The section on exceptions is a very appreciable collection on exceptions topics, difficult to find elsewhere, unless you're a constant reader of C++ Report (where they held a monthly column on the subject).

The section on efficiency is a niece and useful read that let you meet some important consideration as the famous 80-20 rule (a.k.a. 90-10 rule, the "make the common case faster" pattern, and so on) or the Lazy Evaluation tecnique (I've used it extensively since I'm involved on big proportions projects that need this kind of savings).
A special mention goes on the item about the costs of virtual functions, polymorphism and RTTI features. This is about the best account I've found on the subject. The only other one I can think about is Dattatri's in "C++: Effective Object-Oriented Software Construction". You won't believe it, but I've red Dattatri's just a week before I've been specifically asked for this very same topic during an important job interview. Luckily.

The section on Techniques is a source of pure gems: item after item I've discovered how well and widely these topics can be treated. Some will find they are taken from Coplien's book. And that's true. But here they are expanded and more clearly explained.

The last section also will bring some knowledge that will prove to be useful whenever you'll be involved in software design. They well add to those on the first volume.

A very worth buying, and a very worth read, on my opinion.

This is a good book with covers 35 more guidelines for improving your programs. The book is actually longer than the book "More effective C++" because the items being discussed are more complex.

This book takes a different approach to "Effective C++" -- while "Effective C++" focusses on good-style guidelines, this book has a wider agenda, for example it explains a bunch of idioms (such as multiplke dispatch, smart pointers, reference counting, and the singleton pattern).

The book is a solid followup to "Effective C++", but is probably not as essential as that book.

I didn't expect this to be as good as the first book since we can assume the best 50 ideas went into the original, but I still found it to be useful. What I like about both books is that the ideas are enumerated so that I can easily find them again. There are lots of books with good ideas that I can never find again because I discovered them in some obscure chapter that I can't identify anymore.

Just as well written as the original Effective C++, More Effective C++ contains a fine collection of C++ techniques. It is quite a bit more advanced than the original so it will be most useful to software architectures and hardcore C++ developers.

The items on efficiency are excellent and many of them apply to languages other than C++. His discussion on requiring heap-based objects for objects that "delete this" is thought provoking. I actually ran into a related bug soon after reading the item.

Like usual, Meyers does an excellent job of building each item from the ground up. This is particularly true in the item on Reference Counting, where he keeps the String class example as simple as possible until more details are needed.

Anyone who has a solid grasp on C++ and wants to bring their skills to the next level should check out this book.