Customer Reviews

Thinking in C++: Introduction to Standard C++, Volume One (2nd Edition) (Vol 1)

5 star:		(60)
4 star:		(14)
3 star:		(6)
2 star:		(6)
1 star:		(3)

 

 

Since I'm reviewing both "Accelerated C++" as well as "Thinking in C++", I thought I'd post the review on both book links.

There have already been excellent reviews of this book, but I would think the main reason people purchase these books is because they have an explicit purpose, which is to learn Standard C++. That being said, C++ is one of the most powerful and multi-faceted languages around, and no other language provides both high level abstractions and low level control in one programming language as C++.

Because of these features, it is often opinied that C++ is too complicated, large and takes too long to master. While there are some merits to this criticism, many important real world systems are being bult with C++ and professional developers need to master the fundamentals of C++ now. With that in mind, and after spending (or wasting) much money on various books proclaiming to teach C++ from the ground up, it was not until reading Konig and Moo's "Accelerated C++" and Eckel's "Thinking in C++" and in that order, that I finally "got it".

Why I emphasize "in that order" in the last paragraph, is due to the methodologies used to teach C++ by ACPP and TICPP, and due to this, its best to read ACPP first, then TICPP for the most effective learning. Here's my reasons:

ACPP teaches C++ in a top down fashion. What I mean by this, is that the higher level Standard Libraries are integrated right from the start to teach programming contructs such as looping, selection and decisions making using library facilities such as <vector>, <list>, and <map>. The Standard <string> is utilized from chapter zero, and relieves much of the burden of C strings and all the low level details one would have to know to use them properly. This can be especially burdensome to the beginner.

As important as the container classes are to the Standard library, are the algorithms used with them. ACPP ulitizes these as well, and from chapters 0 to 7, the student is taught to use the common algorthms such as sort(), copy(), find() and accumulate(). By teaching these features right from the beginning, the reader is able to write some non-trivial programs without having to wade through the typical and troublesome C features typically taught in other books. Thus, by the time the Reader reaches the second half of the book (chapters 8-16), s/he is ready to understand how to build their own user defined types, and other important topics such as pointers, memory management, classes, as well as object oriented and generic programming.

In contrast, TICPP teaches C++ from a more traditional bottom up approach. Throughout the book, the assumption is that the Reader is comming to C++ from a C background. For example, throughout the book starting from chapter 4, Eckel demonstrates a Stash and Stack application, developed first as a "better C", then throughout the book adds features to them such as grouping data structures with the functions that act on them in the form of classes. The concepts of constructors and destructors, function overloading and default arguments, using const and static effectively, inlining, namespaces, references, copy constructors, operator overloading, using new and delete for dynamic objects, etc. are all covered.

In my opinion, the last two chapters where virtual functions, abstract classes, and an introduction to templates and iterators are covered, is where the book really shines, as these chapters allow the book to finally culminate the benefits of true object oriented programming and give a solid introduction to generic programming in the form of templates and iterators. By this point, the Stash and Stack examples are utilizing pure virtual functions and iterating through containers in an STL-like fashion that is similar to the ones in the Standard Library.

The current trend in C++ is to favor the abstractions provided by the Standard Libraries when developing professional software, and ACPP exemplifies this attitude throughout the book. The lower level C-like aspects of C++ can and have caused much trouble in the form of memory leaks, buffer overruns, etc. Nevertheless, certain class of applications require the ability to get close to the metal, and C++ allows this ability without restrictions when necessary. Also, there are many (and some could argue that most C++ based systems out there still adhere to this) legacy systems where C++ is still being used as a "better C". TICPP is the book that will teach one how to make these programs more type safe, as well as migrating it to take advantage of more modern C++ idioms. And in Volume 2 of TICPP which just came out, Eckel and Allison cover the Standard Library in depth, as well as other professional methodologies such as RTTI, Multiple Inheritence, Design Patterns and Concurrent programming.

But by careful and methodical study of both books, and as is recommended by me, reading ACPP first then TICPP, one will learn C++ from the highest layer to the lower, then from the lower back up the higher and obtain a through knowledge of the basics of C++. One can then effectively study the more advanced books, such as by Meyers, Sutter, Stroupstrup, etc. and have the confidence to tackle professional C++ projects.

Postscript - Though I advocate the above learning method for C++, I would like to add that the above two books presume a certain programming maturity, though one does not need to be a guru. A person with the experience typical of first year CS1 (and CS2) in a language like Java or Python (in fact, for a complete novice, I would recommend learning Python first) would be most suited to following the above presciption. Also recommened is to study a book about data stuctures and algorithms, which will provide the Reader with a solid understanding of the mechanisims that underly the STL (meaning the Standard Template Library which encompass the Containers, Iterators and Algorithms of the Standard C++ Library which was originally part of SGI's implementation).

-Don Kim

This book is highly recommended! I've been trying for a while to teach myself C++ and object-oriented programming. I have a strong background in both C and COBOL so structured programming is firmly etched in my brain and has proved to be a difficult programming approach to get past. This was the first book on the subject that caused me to go "Ah! Now I get it!" more than once. The first chapter alone was worth the price of the book as it thoroughly explained OOP in a clear and concise manner. I read this book in its entirety online before it was published. The book was so good that I went ahead and purchased it so that I would have a hardcopy of this invaluable text as well as the online version. If you are an adept programmer looking to jump onto the OOP bandwagon, I can't think of a better book to get you there. Forget the "Dummies" and "21 Days" type books and get this one. You'll be glad you did. No other programming book I've read has advanced my skills as far as this one. Many thanks to Bruce for providing the definitive C++ book.

If you have some programming experience (in any language) and would like to learn C++ then this is the book! I had some procedural programming experience in Fortran, Pascal and C. I now wanted to learn OOP with C++. This book exceeded my expectations! I highly recommend this book to any novice, advance, and expert programmers wishing to learn C++!

If you are new to programming (ie you never wrote a computer program) and would like to make C++ your first language then this book may be too advanced for you. Try "Object-Oriented Programming in C++" by Lafore. Lafore starts from ground zero in his book. Bruce Eckel assumes the reader of his book has some programming experience. Not a lot but some ...:)

I'm a Computer Science minor who mainly programmed in Pascal but had an object oriented background to some extent by programming on MUSHes (text based role playing games where anyone can create objects, and place code on them). Obviously the syntax was quite different, but some of the 'systems' coded on these games are quite complex, so I was at least somewhat prepared to learn the concepts of OOP.

After picking up a basic primer on C++ (Waite's C++ Primer Plus) and working through it, I discovered that while I'd learned the syntax, my understanding on how C++ operated on an object oriented level was still somewhat weak (which isn't to say that I didn't like the book, in fact I gave it 5 stars as a primer). This isn't that surprising for me, the normal way I learn is to get the details, do the work and at some point in the future _something_ will trigger a 'aha!' in me and understanding will come.

In Eckel's first descriptions of C++ as an Object Oriented language, that light came on. In particular, when he described how inheritance could be used to replace a switch statement. It was clearly stated and proved to be the norm throughout the book. Now I combine the two books, using Waite's for a first look at a concept, and following it up with Eckel for the 'understanding'.

It's hard to find a book that teaches you how to program or how to use your logic to write programss. this book describes the problem of programming in C++ in a complete different way than other c++ books. It doesn't list the keywords and the syntax of the language but rather introduce you to problems that any programmer using any language might face, and then give you the answer in C++. It was nice that you can write a C++ program just in the second chapter while understanding completely the meaning and the usage of keywords like "#include" and namespaces which you'll usually find in the last chapters of ordinary c++ books. so you'll get the feeling of how, why and where to use any part of c++ language not just knowing how to use it. Thanks to Bruce Eckel for providing the book completely online in his web site. that shows that he really cares to make people understand c++ programming not just making money out of publishing a book. I'll be more generous than him by buying the hardcopy of the book :-)

Thinking in C++ is an excellent introduction to C++ programming. As a fairly competent C programmer, I found his book to be clear and readable: focusing on the essentials and stepping you through C++ in an orderly and straightfoward fashion. I highly recommend it for any programmer looking to get into C++.

Mr. Eckel's text and example code rely heavily on the STL (aka the ANSI Standard C++ Library), which is an excellent idea. However, the text does little more than give you a flavor of what the STL is, and what it can do. The author promises that a second volume (Thinking in C++, 2nd. Editon, Volume 2) is in the works, which will delve deep into STL. He refers you to his website to see rough drafts of this planned text and a companion text (The Thinking in C++, 2nd. Edition, Volume 1 Annotated Solutions Guide by Chuck Allison).

Unfortunately, it appears that neither of these companion books will be published for at least a year. The text he supplies on the website is still (obviously) in very incomplete form.

This leaves me more than a little disappointed. If you buy this text, you'll find yourself (like me) returning to Amazon.com in a few days to find someone else's book on STL!

Below is an addendum (in late 2006) to my original review (above, from 2000)...

In the years since writing the original review, I have found few language tutorials which are as clear, easy to read and easy to learn-from as Mr. Eckels book. My admiration for the quality of the book as a whole therefore has increased over time. I would agree with comments by other reviewers that there are a few thin spots in the book, but they do not detract from the book's value: it is still my first recommended resource for any experienced developer looking to learn C++.

Also, a year or two after my initial review, Bruce Eckels came out with Volume 2, which covers the STL and other more advanced aspects of C++ in some depth, eliminating my concerns with the first volume's over lack of coverage of the STL.

Bruce Eckel, Thinking in C++ vol. I (Prentice Hall, 2000)

This is what so many other books about the process of programming C++ could have been. Eckel uses the most up-to- date C++ standards, the strictest programming techniques, and takes enough time to explain both the how and the why of the things that he's talking about in enough detail that the user, while perhaps needing to read certain sections two or three times to really get the gist of them, should have a thorough understanding of the subject by the time the reader has finished the section. This leads to a complete absence of the usual "here's what to do, don't worry about why you're doing it until we get to chapter X" found in most programming books. It also stresses programmers developing their own programming style, but imposes the strictures called for by the ANSI C++ standard. Sometimes too much freedom IS a bad thing, and that's the case with the vast majority of books on C++ programming. Individuality is important, but clarity of code is important, too.

The book has few shortcomings. The section on namespaces could be a little clearer considering a number of the prospective readers of this book are less familiar with them than they are with most of the other concepts covered here, for example. But the shortcomings are few and far between.

The most important thing about the book, though, is that Eckel uses the book's style and presentation as a physical model of abstraction, the most important move any programmer makes from a procedural language to an object-oriented language. The astute reader will pick up from Eckel's discussions of the philosophy of programming an understanding that not everything is about code, and that code is not the be-all and end-all of the programmer's job. A lot of it, especially in the design stages, is concept. Many of us in today's workforce, especially those who have spent whole careers doing nothing other than modifying existing code, forget that all too often. We're stuck in reactive environments, where the company believes that keeping things running is more important than improving them. A grounding in the design concepts presented here may allow more adept programmers to turn a reactive situation into a proactive one--being able to keep things running at the same time they're being made better. And that's how it should be. ****

Having used this book for three semesters to teach OOP and C++ programming, we are replacing it as the required reading. Feedback from the students has been dismal and most of the instructors have abandoned it except for reference, for which it serves poorly. Here's why:

The order that the topics are presented is not useful for either novices or experienced C programmers. Yes, there's a lot of material in there, but it is disconnected such that to teach a subject thoroughly requires tedious and non-intuitive jumping around in the book.

Also, the book does not cover all of the topics and language/library features that one would expect in a modern approach to C++ and OOP. To require two volumes to teach the rudiments of the language is an indication that something is wrong with the author's approach. If you have learned C++ from this book, you have not really learned C++.

Along the same lines, the author's style is long and drawn out. The two volumes probably could have been put into one (more effective) volume without all the distractions the author puts into the text. This, coupled with a change in the order of topic coverage and more contiguous focus on individual subjects, would make this a very useful book to learn C++ and OOP.

On a personal note, I have never liked the author's writing style in his previous books, though I respect his depth of knowledge and intent.

The title of the book is an apt description of the approach taken by Eckel as he steps through the basic features of C++ and object-oriented programming. Rather than show how programs are written in C++, he presents the sequence of ideas that led to the structures and some of the ways they are implemented. This approach is very similar to the one I adopted after my first few years of teaching C++.
For example, when I started teaching C++, my presentation of function overloading was simply an explanation of the different signatures based on the arguments to the function(s). However, it was not until I included some information on name mangling that the students really began understanding it. Another point that makes the features of C++ much more understandable is showing the students how the implicit passing of the this pointer is done when a member method is called.
In this area, Eckel shines as he describes much of the behind the scenes activity of the compiler and linker that makes it all work. The descriptions are complete and yet not overdone. I have been teaching C++ for over ten years and yet there were a few points that were presented in such a way that caused me to change my view of the language. Unless you are one of the top experts in the language, reading this book will teach you something new.
The group that will benefit most from the book are those who are migrating from C to C++. Eckel spends a great deal of time in pointing out the differences between C and C++, using descriptions and short code examples to demonstrate how things are done in both languages. Even if you are coding in C and have no plans to migrate to C++ just yet, the book will be of assistance. As I recently told one of my classes, C as a distinct language is rapidly being phased out. Even those who are now programming in C are probably compiling their code as C++ files to take advantage of the additional error checking. Eckel demonstrates the major advantages of compiling C using a C++ compiler and all C programmers should know these benefits.
Another group that will find this book of value is one that has come about only in the past few years. Java has recently become the language used in the computer science programs of colleges and universities. The first graduates with Java as the language of their full four years have started entering the job market. Therefore, there is a growing group of people who will be forced to make the migration from Java to C++. This is a much harder transition to make than from C++ to Java and this book is an ideal tool to smooth the process.
Eckel makes a major point about programming that is often lost in the rush to learn how to write code. Programs are thoughts represented in a specialized language. Before you can write well in a language, you need to be able to think well in that language. It is the kind of thinking he emphasizes and he is to be commended for doing so. This is a pedagogical strategy that works.

Published in Mathematics and Computer Education, reprinted with permission.

This book is really awesome -- and it truly deserves the five stars above. Until I read it I actually thought that there weren't any good books on C++ (which is definitely not an easy-to-learn language, not even for experienced programmers). Bruce Eckel achieves to explain all the language features very clearly, with lots and lots of good examples (though he is leaving out a few of the very advanced and rarely used features, such as multiple inheritance). He always keeps a down-to-earth, practical and easy-going style and a language which is really fun to read. It is quite clear that he actually believes in what he is telling you, and he doesn't hesitate to mention the downsides of the language as well. In short, he actually *cares*! He also explains internals like what the linker does, the difference between early and late binding and other stuff at just the right places and without losing his sense for practicality and conciseness. If you already have some experience programming and know some C, you will most probably love this book and have no difficulties in your transitioning to C++. The entire book, all source code and volume 2 of the book (which discusses advanced topics) is freely downloadable. Still the bucks on the book are wisely spent! I would love to attend one of this guy's seminars...