Customer Reviews

Thinking in C++, Volume 2: Practical Programming

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

 

 

There are plenty of C++ books out there. When it comes down to it, one would really need two books on C++. Well, this is the second book you need; with the first one being any of many classics including the first volume of this book. Just when you think you have read or have a reference to all the C++ topics, Eckel and Allison come out with their continuation of a classic - volume two of Thinking in C++.

Exceptions, Templates, STL, Design Patterns, Multiple Inheritance, concurrency and parallel programming are just some of the main topics covered in this book. With the book being over 800 pages, one can imagine how deep each of these topics must have been covered. Exceptions grab you right off the bat. Just when you think you know all about exceptions, the authors throw you a curve ball with "Exception Specification", and how to handle the "unexpected". You are blown away by the true control that C++ gives you. .
Strings, along with examples given to depict the string class in full - as part of the standard template library (STL) of C++, begin the authors' discussion of the Standard Template Library. Vectors, sets, lists and many other features of the STL have their own dedicated section which talks about generic containers. The authors set the stage for STL by describing the containers as:

"Container classes are the solution to a specific kind of code reuse problem. ...A container class describes an object that holds other objects..."

The authors then continue on to cover the very important and broad topic in C++ - containers. Examples after examples are used to convey the details and the tricky parts of the C++ STL. The key by reading this chapter is to portray and teach efficient techniques to common problems using the generic container classes. Not only the reader can learn most of what s/he needs to know about containers in this book, a small introduction is also given to show how to actually write a generic container - a linked list. The example is simple, yet powerful in conveying to the reader the ins and outs of writing generic containers. Speaking of generic, generic algorithms are covered very well in this book. All of the algorithms currently in the C++ library are covered with an accompanying example for each one. A special attention is given to the use of function objects as the means of customizing these algorithms.

"A function object is an instance of a class that overloads operator(), the function call operator. This operator allows an object to be used with function call syntax"

Probably the simplest and the easiest definition of algorithm complexity theory is given in this book. The authors make the concept so easy to understand that even a non-programmer or mathematician can understand the reason and the complexity of complexity theory!
Templates are probably my favorite topics in this book. Next to the C++ template "bible" by Vaqndervoorde and Josuttis, this book is the best source for generic programming and templates. The authors cover the three main topics of templates well:
1) Templates with types as parameters
2) Templates with compile-time constant as values
3) Templates with other templates as values.
The authors start with small and simple examples and build on top of them. Templates are generally a difficult topics to cover and to convey, but the authors do a great job in depicting the examples and teaching the reader how templates work and to create powerful programs with them.
The advanced topics in this book (multiple inheritance, runtime type identification, design patterns, and concurrent programming) are my favorite topics. Multiple Inheritance is covered in depth, better than any other book that I have seen out there. The authors do caution the readers regarding the difficulties and the pitfalls of multiple inheritance, but they also explain with examples, pictures, etc... how a developer can overcome these difficulties (using upcast to resolve naming conflicts for example or avoiding the diamond-shaped inheritance tree).
Concurrency and concurrent programming is one of the more difficult things to do in C++. Threads are usually used to achieve such task, but it takes practice and lots of sleepless nights to debug threaded programs and resolve deadlock issues with threads. The advantages of threads (ability to run multiple tasks concurrently, very low context switching relative to processes, allow better code organization and the added convenience to the user specially for graphical user interface tasks) are depicted and shown thru a number of examples. The most important part of this section is how the authors use examples to show what the right way of doing something is as oppose to simply putting bunch of source code together to fill in the blank pages. The examples are priceless to me and very beneficial to any programmer.

All and all, Bruce Eckel and Chuck Allison did a great job putting this book together. The topics covered are very beneficial to any serious C++ programmer or anyone wishing to become one. I particularly like the examples and "how-to's" given throughout the book as they are a valuable source when I am stuck with a programming challenge.

Volume Two picks up where the first left off, without skipping a beat. It starts by covering exceptions and unit tests, both of which should see more use in the real world. It then goes onto cover the standard C++ library in more depth that the first book. He then covers templates in a chapter that he calls 'Templates in Depth'. Yes, the coverage is long, about one hundred pages, but I would rename the chapter 'Templates at a practical level', which is exactly the where the coverage should be left. Templates, like macros, can be overused and have had whole books that cover the topic. Eckel chooses, and I think wisely so, to cover the topical to the extent that it would help you write practical templates yourself and to be able to use template libraries such as the Standard Template Library (STL).

The STL is covered, well, in the two chapters that follow the template chapter. Once again the coverage is not absolutely complete because of the grand scope of the field. There are long books on the STL, but these chapters provide a pragmatic and thorough introduction which should serve for most practical purposes.

The final chapters cover advanced topics. Notable are the chapters on Design Patterns which are designs for templates and classes what are considered industry 'best practice'. So instead of redesigning the wheel you use a design pattern, where appropriate. If you get into design patterns you should also read the extremely popular Design Patterns book, now in it's 25th printing.

In the final chapters is also a discussion on multiple inheritance and threading. Both of which are covered at a pragmatic level and have whole books dedicated to the subject.

This is an excellent, and needed addition to the original Thinking in C++ book. Both of the books are written in an accessible style and cover the topics at a practical level without rat-holing. For aspiring C++ programmers there is probably no better set of books to read as an introduction to C++.

The First Law of Technical Documentation states that:
"The more complicated the subject, the less will be written about it, and the more likely there will be errors in what is written".

This explains why typical programming books will have fifteen pages on If statements, but only a paragraph that says that "Interrupts can be serviced".

Bruce does a masterful job of building the readers up so they are able to gradually yet thoroughly assimilate the subject matter. Thanks to years of putting on seminars and taking comments from readers, he teaches in useful and productive increments without overwhelming the readers. His examples are well thought out and useful. He actually responds to questions and comments. Please don't spam him, he seems like a genuinely nice guy! I look forward to taking one of his seminars in person.

Bruce Eckel has an amazing ability to break down complex topics and make them easy to understand without simplifying or compromising the concepts themselves. Together, both volumes of Thinking in C++ make for the best crash course in C++ programming I've ever seen. Not only do they teach the fundamentals of the language itself and the standard template library, but they manage to imbue readers with excellent programming practices along the way. The Thinking in C++ series serves as an outstanding primer for practical C++ programming or as preparation for more advanced studies.

I do have one caveat, but it's unrelated to the actual content of the book. Both volumes are printed using extremely thin, flimsy paper. Despite weighing in at a lengthy 806 pages, Practical Programming is never-the-less about two-thirds the size of a number of 600-700 page volumes on my shelves. This wouldn't be a serious complaint, except it throws into question the long-term durability of the book as a reference manual. On the bright side, this edition of the Thinking in C++ series has some of the best cover artwork I've ever seen in a computer-related text.

A very nice coverage of various topics in C++ are presented in this
book. The chapter on templates could be best described as a summary
for Josuttis and Vandervoorde book on C++ Templates and Aexanderscu
Modern C++ design with enough practical examples. Templates could be a
complicated topic in C++, but Eckle and Alison present the topic in an
easy to understand manner.

The coverage of design patterns is also very interesting and loaded
with very useful examples. Of course not all patterns are covered, but
those which the authors cover do so excellently. Covered patterns
include Command, Strategy, Visitory, Singleton (very clever
implementations), Observer, Visitor, Proxy, and perhaps more.

No C++ programmer should discard this book. It's really very rich in
examples, unusual advanced techniques, and plenty of wisdom. The
advanced C++ programmer does not need Volume 1 of the book to enjoy
this one.

It is valuable to have a text with plenty of examples and good explanations. I think it could have a more comprehensive index.

After introducing the core of C++ in volume 1, this books covers the rest, including IO streams, exceptions, multiple inheritance, and runtime type inference (although C++'s capabilities are rather puny in the latter regard).

However, the real meat of the book are the chapters on templates and the Standard Template Library. The authors have shown great skill in taking in the voluminous literature of C++ templates and boiling it down into comprehensive yet comprehensible coverage. As you get further into the C++ literature, you will keep on finding stuff that you first saw covered in this book, even in material aimed squarely at the advanced practitioner. Starting from using templates as simple type safe containers, they demystify the angle bracket syntax, and even have a section on the current C++ bleeding edge: template metaprogramming. They do a pretty good job at demystifying and motivating it, too.

The authors then introduce the STL, that particular application of templates that provides a wide ranging set of containers that any modern language is expected to provide. Containers are only half the story with the STL, though, and the authors also cover the algorithms that give the STL its unique generic flavour and which facilitate a quintessentially C++ish (i.e. a bit verbose, ugly and scary-looking) form of functional programming.

There's also substantial coverage of threading, a subject that gets very little play in most of the C++ canon, and is well worth a look, although it's very similar to that found in Thinking in Java.

Also, the authors introduce design patterns. I have to say that, like every book that wants to teach you a programming language and design patterns between two covers, the design patterns section is not as successful as it could be and I did not find much new insight or pedagogical inspiration. Buy this book for its coverage of templates and the STL, then get a book devoted to design patterns - Head First Design Patterns and Design Patterns Explained are the ones I normally recommended.

All told, I felt the writing was marginally less good than in volume 1. I don't know what the division of labour was between Bruce Eckel and co-author Chuck Allison, but the writing is not quite as clear as in the previous volume. There were a couple of 'huh?' moments for me, where the authors skirt around complicated issues, involving function name mangling, and where the word 'template' is necessary. Fortunately, there are other books that can clear this sort of thing up.

That's a minor quibble, though. For most of the 800 pages, this is as good as the first volume, and that's very good indeed.

Bruce Eckel, Thinking in C++, vol. 2 (Mindview, 2004)


I was a big, big fan of Volume I of this two-volume set. I first read it four or five years ago, and it was a big part of the foundation that helped me to understand why some of the newer pieces of the C++ architecture are useful (read "newer" as "when I was your age, boy, we had to walk to school, `cause we didn't have none of them new-fangled templates to ride on!"). It took me a while to get round to reading the second volume. It's more of the same, but different. Volume 2 seems more like a reference book, and far more of it is devoted to bleeding-edge (at the time) concepts than was vol. 1--design patterns, threading, that sort of thing. Of course, these days, they're all relatively common (thanks in no small part to Microsoft having already implemented most of this stuff in .NET), so this one's better thought of as a refresher course, or a book for people like me who are hopelessly backed up trying to keep pace with the Joneses (or the Redmonds). ***

This book is a must! It is not that visually appealing but in pair with the Vol. 1 it is a mandatory book that will help you featuring out all the brighter and dustier corners of C++. The text is quite clear and the examples very appropriate. It is written with a nice scientific background and the author doesn't limit himself to just expose all the C++ features.

This is a fabulous book for learning
the advanced capabilities of C++ so you
can be as expressive and creative as you
want when developing projects in C++.

I could not have completed my C++ project
at work if I had not had this book.

This is a terrific book.