Customer Reviews

Imperfect C++: Practical Solutions for Real-Life Programming

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

 

 

Nowhere else have I come across a resource containing so many full and effective answers to problems such as:

- how to do multidimensional arrays?
- how to skirt around the priblems of the (lack of a) C++ ABI?
- how to create (usable) strong types?
- how to safely and efficiently work with variable length memory requirements at function/block scope?
- how to understand the baleful nonsense that is C++'s ruleset for integral conversions and promotions and come up with decent extended integer classes?
- how to use master operations to write safe but fast code?
- how to write user-defined cast operations that operate correctly and safely?
- and on and on and on ...

I agree with a couple of the earlier reviewers that some bits could have been left out, but the rest of the book more than makes up for it, so it's still a five-star effort.

What really stands out more than anything else is that the author really does understand the issues, and really has encountered these problems in real work. Some other of the elite C++ set don't give this impression half as well ...

... and I even laughed along at most of his jokes.

This book is a fantastic source of C++ information, ranging from contract programming, through multi-threading issues, to shims, veneers, and bolt-ins. Haven't heard of the last three? Well, beyond the treatment of topics that are already in your vocabulary, Matthew thoroughly discusses inventions of his own (and/or refinements of existing techniques). I especially enjoyed parts two and three of the book, where the foundation from part one is put to real-world use. As this is, to a large extent, a practical guide to taming the beast that is C++, it fills a hole left open by many other (more theoretical) books. The author has quite a unique writing style, which reflects his colorful personality - resulting in a rewarding and fun read.

In a sea of C++ pop, Imperfect C++ stirs up the water with some soul.

It's nice to see a book covering intermediate-to-advanced C++ topics for real programmers. It's hard to find a book with so many crucial solutions for production development. No ivory tower drivel here - this book has industrial-strength techniques that will keep you on target. And this is more than just practical C++; this is a usable catalog of powerful software design tactics from someone who really knows. When you hit a wall (you know you will), chances are Matthew can help you over, around, or through - whatever it takes. (And the phraseology from a Brit living Down Under makes for some good entertainment :-).

-- Chuck Allison, Editor, The C++ Source

Aside from everyone has already mentioned, I found the footnotes to be most entertaining, the book is best read at a quiet afternoon with a cup of tea and BBQ.

Here is example on p.171

Reader hint: Anytime I refer to a solution as wonderfully elegant, you can be sure it's one that I 'think' I've invented.

Here is another one on p.383

They actually appreciated my honesty in coming clean. Lesson: always be honest; it can earn you friends in this industry where responsibility takers are few and far between.

I was very disappointed with this book.
The author gives a list of C++ imperfections, but most of them are due to his misunderstanding, rather than the deficiencies in C++ language. His references to imperfections of current compilers are also largely unfounded.
You will find in the book many topics from Sutter, Meyers, Stroustrup, and author provides the necessary references. But unlike the quoted books, author's treatment lacks depth and precision. Author gives plenty of bad advice, uses macros gratuitously (including Microsoft specific macros and types), and demonstrates some misunderstanding of the topics.
Everybody heard of RAII idiom, and practically every C++ book contains this subject, this one is no exception. But have you heard about RRID? No? - Right, because there is no such idiom, - author's invention demonstrates that he doesn't understand well resource acquisition and release. And this is not the only anti-idiom in the book.
If you have read Sutter, etc. books then you can safely skip on this one.

This is very different from the many 'intermediate C++' books that are on the market. If you've had your fill of reading about pimpls, use of const and which overloaded operators should be members, it's time to read 'Imperfect C++'.

Be warned, it does take a little while to get going, and the author has a rather unusual writing style, which can best be described as an informal hybrid of Aussie and British. And admittedly the opening part of the book covers material reminiscent of the likes of 'Effective C++', albeit with a stronger emphasis on optimisation.

But once it gets going, there's a whole new world opened up, rather remote from the rarefied atmosphere of more theoretical books. Imperfect C++ has a very 'in the trenches' feel, where you need to write programs that talk to C, and on a Windows platform. None of the book is about object oriented design as such, but has a library designer's appreciation for dealing with operating system quirks.

You know how lots of books have advice along the lines of "NEVER do this" or "ALWAYS do this"? Matthew Wilson takes great delight in providing examples where you might want to do the opposite, and covers a wide variety of topics, including defining a portable boolean, a NULL value, and C#/Pascal/Python-like properties.

Purists will almost certainly dislike the fairly heavy use of macros for some of the solutions here, you'll have to get used to the appearance of code with a plethora of underscores in. And the book assumes a reasonably high level of knowledge of C++. In particular, there's little hand holding. Entire class definitions are often provided, but you won't always get example application code to see it in action. This is a little unfortunate, particularly in the chapters where the author introduces his own idioms. It requires careful concentration to work out the physical layout of some of the solutions (e.g. are these free functions or member functions? In the same namespace or a different namespace?). On the other hand, some readers will no doubt welcome the vigorous thought that is required.

Overall, this is a very different, practical book to most of the C++ books out there, with a very high signal-to-noise ratio. Add it to your C++ recommended reading list.

With a very few exceptions - e.g. veneers (Chapter 21) - the contents of this book are just stunningly practical and useful.

Ever wanted to use C++ objects between binary components written in different compilers? (Chapter 8)

Ever needed *real* multidimensional arrays? (Chapter 33)

Did you think that C++ doesn't support efficient Properties, a la Delphi & C#? (Chapter 35)

Ever wanted to know about how to write non-trivial custom cast operators? (Chapter 19)

Want to know how static objects and multi-threading can co-exist? (Chapters 10 & 11)

Interest in applying Design by Contract principles to C++? (Chapter 1)

Need strong typedefs? (Chapter 18)

And the list goes on and on. And, being a fellow Brit, I can't help but warm to the author's sense of humour.

Buy one, and get one for your mum!

D.T.

This book deserves its five-star rating, although it's far from perfect.

I'd rate it as follows:

Part 1
Chap 1 - 8/10
Chap 2 - 7/10
Chap 3 - 6/10
Chap 4 - 8/10
Chap 5 - 7/10
Chap 6 - 7/10

Part 2
Chap 7 - 9/10
Chap 8 - 10/10
Chap 9 - 10/10
Chap 10 - 10/10
Chap 11 - 9/10
Chap 12 - 8/10

Part 3
Chap 13 - 7/10
Chap 14 - 8/10
Chap 15 - 7/10
Chap 16 - 6/10
Chap 17 - 7/10
Chap 18 - 8/10

Part 4
Chap 19 - 10/10
Chap 20 - 10/10
Chap 21 - 5/10
Chap 22 - 7/10
Chap 23 - 7/10

Part 5
Chap 24 - 7/10
Chap 25 - 10/10
Chap 26 - 7/10
Chap 27 - 10/10
Chap 28 - 8/10
Chap 29 - 10/10
Chap 30 - 8/10

Part 6
Chap 31 - 10/10
Chap 32 - 10/10
Chap 33 - 10/10
Chap 34 - 10/10
Chap 35 - 10/10

I think the author would have been better dropping, say, 10-20% of the material, especially the material on Veneers, fundamental type issues and RRID; boring and off the point, and felt like filler.

But where the book shines, it *really* shines, and well worth the cover price. The material on casts, shims, memory, arrays, properties, arithmetic types, and pretty much the whole of Part 2 (Threading, ABI, Statics, Dynamic Libraries) are not only outstanding in quality, breadth and detail, but are largely untouched by the 'leading lights' of the C++ pantheon. These are very hard subjects, and the author has truly made his mark with this material.

I'd say that the author is himself like C++: brilliant but imperfect. Let us hope that, like C++, he doesn't let a spotty start prevent him maturing into something better. He promises at the end to return with "Extended STL", in which we may hope that he touches the highs of Imperfect C++, without trawling the lows.

In short: buy it, you'll like it.

"Imperfect C++" was an amazing surprise to me when I read it a year ago, it was the first time I knew that there're so many imperfections in C++, a language I thought I knew quite well before; and it was the first time I knew that nearly all those imperfections could be circumvented, and circumvented pretty well.

As a C++ fan myself, I've been spending quite a portion of my free time on C++, and that is 6 years+. Among all the books I've read about C++, I think this one fill the right gap, that is, most of the C++ books focus on isolated tricks and techniques which, while interesting, often don't take real world constraints in consideration(such as performance, compile-time enforcements, flexibility).

I finished "Imperfect C++" last night, and it's definitely my "Book of the Month" (and last month, and the one before that). It is clearly written, and Wilson's hard won experience definitely shines through.

I liked the practical hands-on angle of the book, "Imperfect Practitioners", indeed, which is different from other books, and I look forward to Wilson's next book(s).

Perhaps, what impressed me the most was the way Wilson took common problems or ideas to their maximum logical consequences and implications. It is not common to actually think through all the possible implications of a particular design decision in terms of (mis-)use, efficiency, robustness and portability. Usually, one does what time permits and what works for the current project. Rarely, are the solutions so well thought out and robust to abuse.

From beginner C++ programmers to advanced demi-gurus, all will find something new in this book.

It is a worthy and valuable addition to any serious C++ developer's bookshelf.