Rating:  - As essential as the first volume
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.
Rating:  - A great book for programmers
If you have programming experience, the Thinking in C++ series is a great way to learn C++.
Rating: - Excellent Book on C++
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.
Rating: - The best beginner/intermediate-level C++ book I've ever read
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.
Rating: - The only other C++ book you would need
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.
|
