Customer Reviews

Advanced C++ Programming Styles and Idioms

5 star:		(12)
4 star:		(6)
3 star:		(2)
2 star:		(0)
1 star:		(1)

 

 

It is a very good book, although a little dated. It explains a lot of items in <<effective c++>> and <<More effective c++>> in more details, it tells you how to do the things, and why to do in this way.

It discusses many idioms, which are the low level equivalences of patterns (see <<Design Patterns>>), for example, body/handle idiom is equivalent to bridge pattern, examplar is equivalent to prototype pattern, envelope/letter is related to state pattern, ... Orthodox Canonical class form is called "big three" in <<c++ faqs>> ... Overloading subscripting for class File and FileRef on page 51 gives the idea of proxy for distinguishing reads from writes presented in <<More effective c++>>, but <<More effective C++>> gives a more detailed discussion on limitations etc (it's normal since <<More>> appeared much later). It provides interesting discussion about difference of performance between different string implementations (p58 -- p65). It discusses relations between pointer to member functions, functors and virtual functions (2.10 and 5.6), and explains the power of polymorphism. It discusses "Dynamic inheritence" in chapter 10, which is not supported directely in C++ (related to state pattern).

Overall, this book provides a lot of original c++ ideas, which affected the later books as <<(More) Effective C++>> and <<Design patterns>> very much.

It is more like a book, while <<(More) effective c++>> and <<Design patterns>> are more like a reference. It contains exercises (no solutions) at the end of each chapter, while <<(More) effective c++>> and <<Design patterns>> do not.

Some discussions are interesting, but not completely correct (it is understandable because of its publishing year), for example, reference counting to implement string class, when shouldn't we use this idiom and how we can improve it? See further discussion of reference counting for string using flags "shared", "sharable" in <<More effective C++>>. Testing self assignment is a good thing, however, is it away necessary? No. You can simply allocate new memory before desallocate old memory, if you avoid self assignment test, you probably not only improve the performance of your code, but also make it exceptionally safe (see <<Exceptional C++>>)

It lacks discussion for new features as namespace, exceptions, which you can find in <<More effective c++>> and <<Exceptional c++: 47 puzzles>>, STL can be found in a very good book <<The C++ Standard Library : A Tutorial and Reference>> as well. It lacks new style cast , for example, const cast and mutable can be used to make to difference between logical constness and physical constness, but at the time the book was writen, they did not exist yet (see 2.9, page 26 -- 28).

Implicite type conversion (3.4)is no longer considered as a good thing for string, read Item 39 of <<Exceptional C++>> on page 162 to see why (think about what will happen with or without implicit type conversion: string s1, s2, s3; s1 = s2 - s3). Imaginary is not Complex (p 89) as circle is not ellipse (see <<C++ faqs>>).

Enough said, I can not give a complete description of this book here. Overall, it is a very good book, although it lacks some new features (read <<(More) effective C++>>, <<Design patterns>>, <<Exceptional C++>>, <<The C++ Standard Library : A Tutorial and Reference>> and <<C++ faqs>>) and pay attention for errors inside. Email me for further discussion: zlan@hotmail.com. Good luck and have fun!

This book is the best C++ book ever inked to paper. This book should not be read if you are a apprentice C++ programmer in training,The key here is that you MUST have a solid understanding of what classes can and cannot do, understanding of copy semantics, object identity(object equality vs equivalence), inheritance model and how polymorphism achieves its power through dynamic binding, understanding a neglected and overly under estimated constructs of horizonal access and vertical access between subclass users and class instantiate users with the ACL(Access Control List: public, protected, private, and usage of friend classes model), pointer/reference acrobatics and and a strong grounding in the IS-A, HAS-A, and USES-A models are you then ready for this book. The book will comb over the basics, but for really getting the most of this book, all of the above must truly be an after thought before plowing ahead. Coplien is a hard core systems architect, what is meant by systems is over a thousand programmers tangled in over hundreds of millions of lines of code and he has been responsible for reviewing the quality of these eystems even casual systems with smaller baselines so the expertise of the author is never to be questioned. His style and approach to teaching is that the basics of the c++ language are miscontrued. The perception is that a programmer needs only to get by with the basics constructs of the language to develop a systematic model, which is an unrealistic and self-damaging mindset. There are constructs in the language that you just have to know; advanced template design utilizing partial specialization, memory management internals,coverage on pointers to member functions, which is syntactically different from pointers to functions, advanced coverage on data abstraction. This book could be read by an aspiring programmer with the basics of the C++ language, but now that you may be more clear on what basics truly means, this book will guaranteed lead you to the path of mastery of its syntax, "you can do this, but do not ever to this" approach, real-world problem models with exacting code that is fantastically diagrammed and explained so that you see every construct of the language used and why it would be used, much in the style of how Bjarne Stoustroup patterns his teaching model: example given first, then follow with the abstract and general rule.This is the easiest read for any programming and design book that was ever an advanced book. A definite must buy or you will left out of the real power and surprisingly overlooked features that you just gotta' know!

Coplien has won many consensus thanks to this book and his "Multi-paradigm design". You can easily verify it looking at the bibliography of EVERY book on C++ written after 1991: you'll certainly find "Advanced C++ Programming Styles and Idioms". Many books have used it to expose tecniques. The best examples are both Meyers' "Effective" and "More effective" books. You can jump directly to the Recommended Readings sections to read the right acknowledgment to Coplien's book. You can then browse the items, and discover that some of them are revisitations and expansions of Coplien's ones).

Reading this book completely changed my view of C++, and, indeed, of any programming language. It traces a clear path that lead from a "normal" use of the language to a well-conscious use of each of his potentialities (those available in 1991, at least). Just look at the functors section to understand what a gem is this book, this is one of the most mind-expanding examples of the book. And if you did not understand what ADT are before, you'll gain a fine and solid account here. This just to quote a couple of examples.

Eleven years are a lot, and the language have undergone major expansions, especially since the ANSI draft on 1996-97. However, this doesn't take anything away from the value of the book, after all you can always learn namespaces from any other modern book. It's not a case that this is one of the most quoted books in the C++ literature.

Many have said it, and I can only confirm that this book should have a stable place on each C++ developer's bookshelf (together with Stroustrup, Meyers, Koeing, Allison and Murray).

This book is quite old now, but the material covered in the book does not suffer from its age, because the book is not supposed to be a language reference.

The book starts with some words of wisdom on the basics of the language, for example spending just long enough talking about inheritence and polymorphism to get to the heart of the issue. There are some of the simpler idioms introduced earlier in the book (virtual constructors, reference counts, handle-bodies) and then the book moves towards more advanced material, including multiple dispatch, and the best discussion of the prototype pattern ("exemplars") that I have seen in any book.

If you're looking for a way into "pattern oriented programming", and you found "Design Patterns" completely unreadable, this is a good book to get you started on some concrete examples.

This book will take the reader where they thought C++ could never go. Though some idioms are dated (the book was written before RTTI and STL were added to the standard) it is nonetheless a thought provoking and invaluable book. Many of the ideas presented actually(! ) make the reader think and wrestle with before they are fully grasped. A must for any intermediate/advanced C++ programmer. When finished you will definitely have a stronger appreciation of the power of C++. I'm not sure if Microsofts COM came before this book but if it didn't then they sure swiped alot of ideas from it!

This book still turns up in the recommended reading of nearly every important book on C++ out there, which is pretty remarkable given it was published in the early 90s. Clearly, lots of smart people think it's important, then. But has it been influential? Are the techniques outlined here being used by programmers now? In some ways, yes. In others, the C++ community has marched off in entirely the opposite direction.

The material that has endured is handle/envelope classes (more commonly called pimpls these days) and the discussion of object orientation and polymorphism that covers the different techniques for inheritance versus composition and public versus private inheritance well.

The rest of the book is an attempt to turn C++ into something between Smalltalk and CLOS. There is some extremely clever stuff going on here, but as you might expect, it's not a terribly comfortable fit for C++. Nonetheless, there's a whole bunch of interesting ideas: multiple dispatch, prototype-style object creation, dynamic reloading of classes and garbage collection.

However, I doubt that many people are using these ideas in their C++ code. Arguably, this book's spiritual successor is Andrei Alexandrescu's 'Modern C++ Design', published about a decade later. If you look in there, you'll see the new advanced C++ is a long way from Smalltalk. By the use of template metaprogramming, as much as possible is done at compile time, not run time. Conversely, at least some the ideas are an integral part, not of C++, but Java.

So it's not a book for everyday programming, but if you want to see in which interesting directions C++ can be pushed, this is a unique resource.

I read this book about 15 years ago. It was the third book I read on the subject, and after I read it, I did not need another C++ text until template metaprogramming became 'all the rage'.

What you'll find in this book are examples which illustrate the motivation for key C++ language features, with both the historical context reaching back into K&R C programming, and the new benefits afforded by an object-oriented approach.

If you think you are a C++ programmer, and do not recognize the term "orthodox canonical form", then I suggest you pick up a used copy of this text and read it cover-to-cover.

As far as I'm concerned, if you're interested in actually writing software using C++, and are conversant with object-oriented programming, this book will provide a broad foundation upon which you can build well-engineered solutions.

I came to C++ with about 8 years of K&R C and 4 years of Smalltalk-like object-oriented programming. This book was all I needed to synthesize a practical understanding of C++.

This is not a book for beginners, but rather for those already well-versed in programming. For a beginner's book, I recommend Thinking in C++ by Bruce Eckel.

Despite the fact that this book has been written 20 years ago, it is still relevant. It helped me look at and write code from a whole new perspective. Even coding in .NET, I find its later chapters helpful.

among freinds we refer to this book as mind-expanding, as, one can't pick it up without having to make room for a new concept and facet each time

If you do any C++ programming, whether you're a novice or an expert, this book is a definite "must" for your library. This book is not specific to any compiler or operating system, so you can use it no matter what your environment is. But what's most important is that it covers every aspect of C++ programming that's even the least-bit complicated. I've been programming C++ for over five years, and EVERY time I've wanted to figure out how to do something in C++, not only was I able to find a clear description, but sample code as well.