Customer Reviews

C++ Common Knowledge: Essential Intermediate Programming

5 star:		(13)
4 star:		(5)
3 star:		(1)
2 star:		(0)
1 star:		(0)

 

 

This book extracts the most important and widely used modern C++ concepts and organizes them into bite-sized chunks. Very succinct (it could be too short if you are an expert, you may prefer more exhaustive in-depth analyses). The language style is delight and some confusing concepts are presented in an accessible way, you will not feel dry. I finished reading it without any break in 8 hours, it's quite a pleasant experience.

The interesting feature of this book is that it emphasizes proper use of design patterns in C++ way (prototype, command, factory method, template method..., and item 3 gives an excellent reasoning why you should familiarize yourself with design patterns) and some C++ template techniques (explicit specialization, partial specialization, member templates, functors, embedded type info/typedefs, traits, policies..., and several simple template metaprogramming techniques: such as item 59 "SFINAE" and item 52 "Specializing for Type Information"). This is not a single incident, for example, the whole book "Modern C++ Design" by Andrei Alexandrescu is totally focusing on applying C++ template techniques to solve several design pattern issues.

No matter in which level are you, I believe you will deepen your understanding and sharpen your skills from another angle. If you are serious about improving your C++ skills, it's better to have this book in your reading list.

In this book, Stephen Dewhurst explains 63 individual issues that every intermediate and senior C++ programmer should understand. The topics range from the basic material that anyone programming in C++ should know ("Data Abstraction" and "Polymophism") to more advanced topics that a junior programmer might not grasp ("Template Argument Deduction" and "Generic Algorithms"). Along the way, he covers initialization vs. assignment, exception safety, class layout, and many more.

The only complaint I have about the book is a lack of depth on individual issues. In all fairness, Dewhurst explicitly states that this is his intent. He wanted the material to be short enough to bring someone up to a basic level of understanding quickly. With that in mind, This book serves as a good starter for familiarizing a junior programmer with more advanced topics. To really learn these issues well, the programmer will need supplemental material.

Most junior and intermediate C++ programmers would benefit from reading this book. Any item that you don't fully understand is an area where you need improvement. Senior-level C++ programmers might find this book interesting for reminding themselves where more junior programmers are likely to slip. It would also serve as a good reference to hand to a junior programmer to bring him or her up to speed quickly without spending a lot of time in explanation.

Despite my one complaint, I would recommend this book to most C++ programmers.

I didn't enjoy reading Stephen Dewhurst's earlier book, C++ Gotchas, very much because the approach of teaching by showing you what can go wrong bothers me. If you didn't know about some these particular gotchas before (by experience), does the vague understanding (that you get from reading about them) that they exist help protect you from them? Maybe. But trying to be aware of them all can just make you a more confused programmer; losing sight of your objective of good software design by trying to avoid all the pitfalls. We can learn form others' mistakes occasionally, but I think we can learn a lot more by being taught with examples of how to do it right in the first place. This second approach is taken by Dewhurst in C++ Common Knowledge. It was very enjoyable to read.

This is a great intermediate level text and reference for C++ programmers. It deals with many of the concepts of C++ programming that C++ programmers must understand on the way from being a beginner to making effective use of the language. It covers these concepts with clear examples and explanations in an increasing order of difficulty. This book belongs on almost every C++ programmer's bookshelf because, even if you know the material, the way it is presented in this book makes it easier to remember and review when needed. Highly recommended.

Yep, this is perilously close to supplanting Scott Meyers and Herb Sutter as the definitive book for propelling a neophyte C++ programmer towards competence.

On the face of it, this is yet another book on 'intermediate' C++, of which there have been many since the early 1990s. The book consists of a few dozen short pieces on how wrestle some complexity of C++ into behaving itself, such as the use of const, how to implement copy constructors and the assignment operator. Do we really need yet another one of these?

But this manages to stand out from the crowd. It covers more basic material such as references and the new cast operators. There's a very nice section on pointers to members. It's also very handy for people coming from other languages, such as Java, particularly as it highlights areas where C++ differs from Java, e.g. name lookup and hiding rules. However, some material assumes knowledge of the handle/pimpl idiom which is normally covered in other intermediate books.

There's also an emphasis on higher level abstractions, general object oriented design principles, like the Hollywood principle, and separate items on design patterns (command, template, prototype).

And nearly half the book is on templates. And it's a very thorough and systematic coverage, including traits, policies and some metaprogramming (e.g. SFINAE). I was very impressed with this part of the book, it is very effective at demystifying a part of the language that even the better introductory books can fail to enlighten fully.

The only negative of this book is that, subjectwise, there is a fair amount of overlap with the author's previous book, C++ Gotchas. If you've already got that, you may find yourself skimming the first half of this one (and it's not a huge book). However, the excellent template section is all new. Nonetheless, you might want to knock a star and a half off my rating.

In short, this is an excellent, well-organised book with clear coverage of beginners topics all the way up to OO principles like those found in Robert C. Martin's Agile Software Development.

A virtue of Dewhurst's book is its brevity. He's condensed into 63 items guidelines that promise to be useful to many C++ programmers. Naturally, you're expected to already be conversant with the basics. You can write and compile a C++ program. But rather than produce a huge tome, he offers tips that are 3 to 4 pages long. Pragmatic and quick advice. The tips are also random access. You can pick an item and it rarely depends on earlier items.

This does mean that there is a slight grab-bag ambience. When you read a typical book on coding, it is often necessarily linear. Dewhurst has a different emphasis.

The items are also not that difficult. Deliberately so. Dewhurst avoids the more intricate but relatively rarely used aspects of C++. Nothing on template metaprogramming, for example.

Sadly, many developers will probably pass this book by because they think they are too "advanced" or "expert" for a book with this title.

I've never met a developer who wouldn't get enough out of it to make it worth the modest price. As one of the other reviewers noted, there's a lot in here that _should_ be common knowledge but really isn't. Or maybe you used to know it but forgot?

Besides, C++ has changed a lot over the years, particularly in new ways people have discovered that you can (or should) use the language. Are you sure you're as familiar as you should be with templates, design patterns, and modern idioms?

If you still think you're too experienced to need it, then consider that this is the best "quick reference" for experienced developers that I've found to date. It's nice to find so many of those "intermediate-level" facts in one place without having to search my core reference collection of about 5 volumes. This will be the first place I look from now on.

If nothing else, this is really a good book to make new-hires read, or to refer others to when they have questions.

Those features in a very readable book make this one an essential.

I was already a very productive C++ programmer when I first saw this book, so I didn't think it would be of much help. I was pleasantly surprised, however, by the wealth of information that this little book contains. Any casual or professional C++ programmer should have this book as a reference. It is not encyclopedic, but that is its main strength: it tells you exactly what you need to know and no more. After reading it I found myself structuring my code better and reusing more code (especially by utilizing templates more appropriately). Additionally, the book is very clear about the terminology of the C++ language so my communication with other developers improved. A must-have.

A nice book, with lots of good knowledge. Would be better if bigger of course, but such books are preferred small, I think.

I liked all parts of templates - subject not covered well in other books, Meyers, Sutter, Alexadrescu - and polymorphism also.

Good book on the shelf. Better book on the desk.

This book fills a glaring gap, for something that explains the complex parts of C++ in straightforward terms, and leaves one fully armed with the right nomenclature.

It's not so much that it teaches you new parts of the language, more that it arms you with the right handle on the terminology and insight into the details.

Highly recommended.

The book "C++ Common Knowledge" by Stephen Dewhurst is in the same category as Scott Meyers' "Effective C++" series and Herb Sutter's "Exceptional C++" series. This means that it too discusses tips & tricks on the C++ programming language. It also means that Dewhurst's volume isn't simply yet another book on C++; rather, it is a high-quality work that deserves to be read and recommended. Its level is intermediate, implying (contra Dewhurst) that it should be read after Meyers' "Effective C++".

The Good: Dewhurst's writing is generally pretty clear and occasionally eccentric. That's a good thing, since it means that he is far from bland. A few examples: we should avoid old-style casts "like the plague", function pointers are "passé", using a global variable is a "disreputable and dangerous coding practice", while an array is a "kind of (mathematically and morally) degenerate container". Moving on to the quality of the explanations: Dewhurst is good when discussing traditional C++ topics. He touches upon issues that are more-or-less straightforward, though not really trivial, e.g. "we may not convert a pointer to pointer to non-const to a pointer to pointer to const" (Item 8) or "When looking up the name of a function in a function call expression, the compiler will also examine namespaces that contain the types of the function call's arguments." (Item 25). He's even better when discussing design patterns, showing a remarkable ability to condense some of them into easy-to-remember one-liners (e.g. "When a function object is used as a callback, that's an instance of the Command pattern.", Item 19). Where he really shines is in the last one third of the book, which is devoted to template issues. To his credit, Dewhurst has applied his considerable expositional talents to topics that are often considered difficult or esoteric. He provides a brief but valuable introduction to template metaprogramming, showing that properties of a type can be deduced from a specialization (Item 52) or using the SFINAE mechanism (Item 59). Another impressive Item is the one on traits classes (Item 54): this was (to me, at least) clearer than Meyers' Item 47 on the same topic, probably because Dewhurst does not focus on the STL iterator_traits but discusses a general traits class. Throughout the text, Dewhurst is very good at splitting material into manageable chunks. One example out of many: when introducing policies, instead of just jumping in, he first devotes an Item to template template parameters. Once he's got that out of the way, the reader is in a position to focus on what is really new and interesting about policy decisions in generic design.

The Bad: as mentioned in the author's preface, the expert reviewers of the manuscript felt that at least some of the template-related Items didn't really qualify as "common knowledge". I agree, but with a twist: I think the problem lies not with including these topics in an easy-to-use distilled form but rather with the book's title. Moving on to another aspect of what constitutes "C++ common knowledge": this book was published in 2005 so it would be unfair to expect Dewhurst to e.g. favor lambdas over traditional functors. However, 2005 was not 1998, so it would have made sense to discuss at least some of the topics included in the TR1 (Technical Report 1) document. For example, Dewhurst has an Item on smart pointers, but says nothing about std::tr1::shared_ptr. Still on the theme of "common knowledge": in some cases Dewhurst tends to employ idiosyncratic (i.e., uncommon) terminology. He uses the term "anonymous namespaces" for what are usually called "unnamed namespaces" (§7.3.1.1 in the C++ standard); similarly, he gives "temporaries" (§12.2 in the standard) a more suggestive name, calling them "anonymous temporaries"; finally he uses the term "infix" matter-of-factly, though this does not appear anywhere in the standard (and no, I'm not suffering from standarditis: these terms are also absent from the majority of the good C++ books out there). On a completely different note, I enjoy funny index entries as much as the next guy (e.g. "Fire safety advice, 50", "Managers, gratuitous swipe at, 10", or "QWAN (Quality Without A Name), 90"), but I would have liked them even more if they hadn't been at the expense of useful entries: for example, there are no entries on the mutable keyword, on the preprocessor, on the default constructor, or on the pimpl idiom -- incidentally, the last two concepts are used but not really introduced anywhere in the text. This, along with the facts that the Items are not grouped into chapters and there's no "Things to remember" section or something similar, makes it somewhat difficult to use Dewhurst's book as a reference.

In a nutshell, this is a very good book which should be used to complement (but not substitute for) Scott Meyers' "Effective C++". On the one hand, it is slightly more compact (and therefore a little more difficult) than Meyers' volume; on the other hand, it does contain considerably more material on templates and its explanations are for the most part lucid. All in all, four and a half stars.

Alex Gezerlis