C++ Common Knowledge: Essential Intermediate Programming

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.

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.

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.

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.

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.