Customer Reviews

C++ Templates: The Complete Guide

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

 

 

This is a book that the C++ community has been in need of for several years, and it seems that an ideal team of authors has come together for this: Nicolai Josuttis again contributes the thoroughness and lucid writing that has made his earlier book _The C++ Standard Library_ such a pleasure to read, and David Vandevoorde contributes historical background about the evolution of C++ standard and its implementations that help to understand some of the peculiarities of how C++ works today and some of the directions it's likely to evolve in.

The book is divided into 4 parts. Part I gives a basic overview of the template mechanisms in C++ and part II goes into more detail on this. Part III applies templates to standard problems, while part IV covers more exotic uses of templates similar to what is discussed in Alexandrescu's _Modern C++ Design_. Even for a reasonably experienced template user like me, there were many details I learned even from the most fundamental part I.

This is a near perfect book (apart from a few apparent bugs in the code examples that hopefully will get corrected) that will greatly benefit any programmer who works with template based code.

Templates are increasingly becoming one of the most important
aspects of C++ programming, and are the central feature of the
most creative and innovative new C++ projects.

They are reasonably simple in concept, but in the effort to make
them behave "intuitively" for common cases, the actual rules that
describe what they do are hideously complicated. A guide for the
perplexed was sorely needed, and fortunately, has now appeared.

I'm no slouch at the subject myself, but I learned a few things
that I had no inkling of before, just on a casual reading of the
first few chapters. (Although the main thing I am learning once
again is just how insanely stupid C++ syntax is, and how awful
was the choice of angle brackets for template delimiters.) The
authors are experts on the subject, and the material is presented
clearly, with many examples, and above all correctly.

This is another must-have book for people who want to understand
all of C++. (Not that that's possible, except for perhaps half a
dozen people or so. I'll bet more people understand General
Relativity.)

Hi,

David Vandevoorde and Nicolai Josuttis write a definitive reference to C++ template implementations. This book comprises of four key sections including fundamental template implementations, in-depth template implementations, template designs, and advanced template designs (libraries). The authors are extremely thorough in their explanations of all essential template implementation techniques and provide an unprecedented in-depth analysis on C++ template parameters, arguments, specialization, and overloading. The analysis on these techniques is very valuable. One reason is because in most cases the authors include examples of implementations that do not work and then provide working solutions. For example, they discuss template argument deduction processes especially for template function overloading. There is even a chapter where they analyze C++ compilers and different template instantiation models. In C++ Templates: The Complete Guide, the authors discuss essential C++ template designs and implementation techniques and provide valuable analysis along with some of the more important topics, making this book a definitive reference to C++ template implementations.

In section three and four, Vandevoorde and Josuttis discuss and demonstrate powerful C++ designs utilizing C++ template techniques from previous sections. Topics and examples in these sections incorporate advanced C++ template designs and implementations similar to the foundation of the STL. One example is element binding as in std::pair.

I recommend C++ Templates: The Complete Guide to all real-world C++ programmers.

This book is encyclopedic. It will tell you everything about templates, both every detail at the language level and everything interesting someone has done with templates in the last 10 years. It even tells you furture changes that might happen to templates in 4-8 years when the C++ standard is revised. This last is useful to know, to keep in mind what templates cannot do, as sometimes it feels like templates can do anything. Though the writing is somewhat dry, it is always clean and to-the-point, and the authors have the highest reputations for accuracy and expertise.

The entire last 200 pages of this 500 page book, from Metaprograms on through the entire section on Advanced Applications, describe things software developers should look to libraries for. Smart pointers, generic functors, metaprogramming, etc., are all weak without a supporting library, and there are good libraries freely available. The book gives references to them, which is good, but it mainly tells you how to write similar things from scratch, which is somewhat useless except to the few hundred living people who write the libraries. Unless you were curious, that is.

The only technique I will be using myself in production code, as opposed to getting from quality libraries, is traits and policies. The book does spend 40 pages covering this, and it touches all the bases, but _Modern C++ Design_ has a much fuller coverage, which this book admits at the end of its section.

Although this book is excellent, and you will eventually want it to reach "guru" status as your understanding of templates grows, you may want _Modern C++ Design_ first, if your present interest is mainly in policy-based design and you prefer to start with applications rather than fundamentals. You may also want to consider the new _C++ Template Metaprogramming_ if your present interest is metaprogramming. But if you are looking for a solid, general grounding in everything templates can do and have been used to do, _C++ Templates: the Complete Guide_ is exactly what you are looking for.

This book covers the C++ template mechanism in depth, and, possibly more importantly, in readable prose.

I particularly liked the clarifications regarding overload resolution when function templates are involved and the discussion of various metaprogramming and traits techniques (such as SFINAE - "Substitution Failure Is Not An Error").

I also learned a few things that I didn't know about at all. For example, I didn't realize that template template parameters could have default values and that base class names can hide template parameters.

This book is a necessary resource for those writing generic libraries as some of today's techniques require a full understanding of the template mechanism. It is definitely going on my bookshelf with the rest of my favorite C and C++ books, and I highly recommend it to anyone interested in the C++ field.

(Note also, unlike Hyman Rosen, I actually *like* the syntax of C++ and as far as I'm concerned, angle brackets are as good a choice as anything else.)

This book is a natural for anyone who needs or wants to hone their skills using C++ Templates. Anyone with 15-minutes to spend can immediately pick up the book and begin writing their own templates in C++ even though this is not a traditional "step-by-step" learn-everything-in-a-day kind of book. The authors are recognized as experts on the topic in the C++ world. More importantly, they convey templates without the complexity perceived by the syntax that seems to scare people away from templates early on...while presenting templates in their full syntactic glory albeit with an easy, thorough and thoughful introduction that appropriately paces rather than brain-dumps.

I bought this book for the community bookshelf of our C++ programming department, but particularly for one colleague who struggled with the notion of using templates at all, much less, effectively. After a couple of hours, he was pestering everyone about all of the bits of code that we should be converting to templates. Viola, a success story!

The book very quickly gets to the point of dealing with templates. The first few chapters do away with unnecessary fluff and give you the tools to understand and implement templates. The book is amazingly concise without compromising the shared benefit of years of experience contained within by its authors.

Getting past the basics, the authors give us their insight into more details regarding templates and their use--both in code and even by convention in discourse regarding templates. One easily sees that their intent is in sharing the truth of templates in this book.

This is undoubtedly going to be the defacto-standard for books on the topic of C++ Templates.

This is the second book to buy after "the C++ programming language" book. Template is the "thing" right now in C++. On the other hand, in order to write a code that uses template correctly and effectively you really need to understand templates. This book is the only book out there that will help you understand how to write good code using templates. The best part about this book is that it not trying to tell that there is a magic tricks to use or some great solution, which by using it your programs will be better. It just gives you a great understanding of what really need an explanation. It also very well writing and organized.

Actually, the ONLY book on this topic, that covers the topic well actually... This book will be the bible in the topic, and it should .. Very well written packed with examples and how to's, etc... Great learning experience. For c++ people, you should read this book, and go right to Modern C++ Design. A very good combo. One of the best things about the book is that it had a section dedicated on some of the futures changes to this topic as templates are still fairly developing. You know what to expect if you are an architect.

I was initially a bit at a loss as to what you can say about this book. Both David and Nicolai are formidable authorities in the C++ language and established writers. Nicolai is well known for the "Standard C++ Library" and David wrote a wonderful book of solutions to the exercise problems posed in 3d edition of the "C++ language" by Bjarne Strustroup. Just their qualifications by themselves automatically reserve space on my IT bookshelf. That said, I have to say something about the book, so let me start with a little history. Template features were initially introduced into C++ a long time ago. Originally their usage was pretty much limited to their original purpose: creating generic containers. The biggest breakthrough for the template feature was probably their usage in generic programming research led by Alex Stepanov, which eventuated in the development of the Standard Template Library that we know and love. After that breakthrough more and more people started realizing the richness of the template feature, especially the fact that it can be used to perform both quantitative and "type" calculations at compile time. This resulted in great proliferation of C++ template programming, many tricks, techniques, libraries and approaches have formed, such as "template metaprogramming". These days no self-respecting (and hirable) C++ programmer can avoid knowing a certain amount about this topic. Many popular books have included introductions to template programming of varying quality. But no dedicated book was so far available; initially due to the lack of demand and later due to the newness of the field and lack of experience. But as the popularity of template programming increased I among many others started to feel a sharp pain due to a lack of one definitive guidebook on the subject.
This is where David and Nicolai's book comes in. The book is both a methodical textbook and an indispensable reference. The writing is very clear and well-paced, ideas are introduced in good order. The book was a pleasure.
In short: the template bible has been written. Study it.

Before this book, most C++ textbook were at most devoting one chapter on templates which clearly is not enough to cover a topic as complex as the C++ templates. The C++ Templates book is filling this void nicely and one of the coauthor of the book is the author of my favorite STL book The C++ Standard Library: A Tutorial and Reference. The book has 4 parts: The basics, templates in depth, templates and design and finally advanced applications. Personnally, I found the 2 last parts good but less interesting because I think that other books such as Modern C++ Design: Generic Programming and Design Patterns Applied do a better job to cover templates applications.

Where this book really shines is the first part that covers the C++ templates syntax very well. With a capricious syntax like the templates one, a good reference is essential. One example that come to my mind is when I was trying to declare a friend template function from a class template. That sounds like a simple thing to do but it is not. The syntax rules for this declaration are, to my opinion, far to be intuitive and hard to find in regular textbooks. With the help of this book I have finally been able to fix my friend template function declaration and make my compiler happy.