- Paperback: 814 pages
- Publisher: Prentice Hall; 2nd edition (March 25, 2000)
- Language: English
- ISBN-10: 0139798099
- ISBN-13: 978-0139798092
- Product Dimensions: 6.9 x 1.6 x 9.2 inches
- Shipping Weight: 2.1 pounds (View shipping rates and policies)
- Average Customer Review: 108 customer reviews
- Amazon Best Sellers Rank: #347,631 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Thinking in C++, Vol. 1: Introduction to Standard C++, 2nd Edition 2nd Edition
Use the Amazon App to scan ISBNs and compare prices.
Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.
If you're a seller, Fulfillment by Amazon can help you increase your sales. We invite you to learn more about Fulfillment by Amazon .
Frequently bought together
Customers who bought this item also bought
Customers who viewed this item also viewed
Fully revised and beefed up with plenty of new material on today's Standard C++, the new edition of Bruce Eckel's Thinking in C++: Volume I is an excellent tutorial to mastering this rich (and sometimes daunting) programming language, filled with expert advice and written in a patient, knowledgeable style.
The effective presentation, along with dozens of helpful code examples, make this book a standout. The text first sets the stage for using C++ with a tour of what object-oriented programming is all about, as well as the software design life cycle. The author then delves into every aspect of C++, from basic keywords and programming principles to more advanced topics, like function and operator overloading, virtual inheritance, exception handling, namespaces, and templates. C++ is a complex language, and the author covers a lot of ground using today's Standard C++, but without getting bogged down in excessive detail.
The emphasis here is on practical programming, so there's basic advice on using header files, preprocessor directives, and namespaces to organize code effectively. Each chapter ends with exercises (usually about two dozen), and the entire text of the book is available on the accompanying CD-ROM. (So is the second volume, which tours Standard C++ classes and other advanced topics.)
Whether you have read the first edition of this book or not, there is much to mine from Thinking in C++. This new version continues to set a high standard as an approachable and thorough tutorial. --Richard Dragan
Topics covered: Introduction to objects, inheritance, composition, polymorphism, exception handling, analysis and design fundamentals, advantages of C++, transitioning from C, compiling and building programs, writing C++ functions, flow control, C++ operators, data types, casting, debugging tips, pointers to functions, designing reusable C++ classes, conditional compilation and header files, access specifiers, 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, virtual functions, abstract classes, introduction to templates, and iterators.
"This book is a tremendous achievement. You owe it to yourself to have a copy on your shelf. The chapter on iostreams is the most comprehensive and understandable treatment of that subject I've seen to date." Al Stevens Contributing Editor, Doctor Dobbs Journal
"Eckel's book is the only one to so clearly explain how to rethink program construction for object orientation. That the book is also an excellent tutorial on the ins and outs of C++ is an added bonus." Andrew Binstock, Editor, Unix Review
"Bruce continues to amaze me with his insight into C++, and Thinking in C++ is his best collection of ideas yet. If you want clear answers to difficult questions about C++, buy this outstanding book." Gary Entsminger Author, The Tao of Objects
"Thinking in C++ patiently and methodically explores the issues of when and how to use inlines, references, operator overloading, inheritance and dynamic objects, as well as advanced topics such as the proper use of templates, exceptions and multiple inheritance. The entire effort is woven in a fabric that includes Eckel's own philosophy of object and program design. A must for every C++ developer's bookshelf, Thinking in C++ is the one C++ book you must have if you're doing serious development with C++." Richard Male Shaw Contributing Editor, PC Magazine
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
However, this book has many important concepts for practicing programmers. Once you know the basic concepts, you'll be greatly helped in understanding the fine details in each of these. Together, Vol1 and Vol2 make a great read. What I like the most is that for all practical purposes, reading Vol1 and Vol2 will teach you a lot on C++, templates, exception and design patterns. Thus, it saves time as you don't need to dig out information from multiple books.
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).
The Good: Bruce does a terrific job going into gory detail on all aspects of this (let's just face it) complicated language. C++ has lot's of traps and ditches to offer compared to C# or Java, and if you plan to use a lot of the advanced concepts of the language, a helper like this book is almost indispensable. If you are coming from the C realm, this books is a real hit: Bruce constantly points out the subtle differences between C and C++, and also explains how C++ is a safer language than C in almost every facet. The book does a fairly decent job in going from the simpler to the more advanced concepts, though a few times he has to use constructs that will only be covered in later chapters (Bruce does point out these outlooks though appropriately). If you are really into learning a new language, the Exercises at the end of each chapter are a terrific way to learn the new concepts.
The Bad: The text within the chapters is not very well structured. If you later on try to find something, the prose form of the sections does not really help you doing that. Also, the Index is not that great either. Often times you are sent to pages that just marginally address the keyword, and the essential introduction or explanation of the keyword may not be in the index at all. My real gripe though is with the practicality of the examples. While I previously stated that the Examples by itself are a great way to learn the languate, a lot of his examples are just plain bad ideas how to code. I understand where Bruce is coming from, he tries to find examples for all the subtleties he just covered in the section. Nevertheless, he often asks for pretty bad things to be implemented. On principle, from my own personal experience a lot of the special cases of the language are hardly ever used in real life situations.
I do recommend this book, especially if you are coming from C. Just take the examples with a grain of salt. If you are a seasoned software developer, you can probably tell anyways which of the examples or techniques should not be used on the job.