Practical Programming

by Bruce Eckel, Chuck Allison, Chuck D. Allison

Best selling author Bruce Eckel has joined forces with Chuck Allison to write Thinking in C++, Volume 2, the sequel to the highly received and best selling Thinking in C++, Volume 1. Eckel is the master of teaching professional programmers how to quickly learn cutting edge topics in C++ that are glossed over in other C++ books. KEY TOPICS: In Thinking in C++, Volume 2, the authors cover the finer points of exception...

• Format: Paperback
• Language: English
• ISBN: 0130353132
• ISBN13: 9780130353139
• Release Date: December 2003
• Publisher: Pearson
• Length: 806 Pages
• Weight: 2.25 lbs.
• Dimensions: 1.7" x 7.1" x 9.3"

Customer Reviews

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.

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.

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

Defies the First Law of Technical Documentation

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.

Excellent followup to volume one

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++.