Customer Reviews

Programming: Principles and Practice Using C++

5 star:		(23)
4 star:		(3)
3 star:		(5)
2 star:		(3)
1 star:		(2)

 

 

For some reasons, I had expected a book on reflections on Stroustrup's philosophy of C++ programming aimed at experienced practitioners. I was quite surprised by the heft of the book, but much more so by the content. It's a book for non-programmers or beginners to teach them how to program with C++ as the vehicle and it's structured for use as a textbook for a first year college course.

Physically, the book is massive, weighing in at over 1200 pages. It is printed on good quality semi-glossy paper and the extensive use of color will remind some of the Deitel & Deitel series, at least superficially.

The prospective student will probably benefit from a comparison of this book to the existing leading tutorial books. The leaders, by popularity or quality, are (in no specific order): Lippman, Lajoie, & Moo's C++ Primer (4th Edition), Eckel's Thinking in C++: Introduction to Standard C++, Volume One (2nd Edition) (Vol 1) and Thinking in C++, Volume 2: Practical Programming, Dietel & Deitel's C++ How to Program (6th Edition), Koenig & Moo's Accelerated C++: Practical Programming by Example (C++ In-Depth Series), Lippman's Essential C++ (C++ In-Depth Series), and Prata's C++ Primer Plus (5th Edition). These all share the common purpose of teaching the C++ language, so an effort is made to cover the features and concepts, with examples that were constructed to illustrate them. This is NOT Stroustrup's approach.

Stroustrup isn't trying to teach the C++ language. He's teaching how to program. C++ is the tool he uses to do so. This isn't a subtle difference. It's the difference between teaching you about a wrench and making up fake car parts to fix with the wrench and teaching you auto repair and giving you a wrench to do so. You still learn the tool as you go along, but it's a side effect.

The overall direction of the book is to teach students how to program solutions to real problems in a way that one would in the real world. Things that other books consider "extraneous to illustrating the principle" aren't swept under the carpet. Inputs are validated. Code is tested. Errors are detected. Exceptions are thrown and caught. They're not incidental details, they're part of the solution, and that's how Stroustrup presents them. Yet, these "details" don't detract from the readability or understandability of the code. In fact, they preempt the stream of "but what about..." questions that students will inevitable have when presented incomplete toy code.

Chapters 6 and 7 are gems. They develop an expression evaluator, walking the student through a tokenizer, parser, and interpreter without bogging the student down with deep theory that will be learned in later courses and is unnecessary to get started (though many will be inspired to go read up on it). Besides showing some interesting and useful techniques, understanding an expression evaluator goes a long way toward understanding programming languages in general.

The discussion on containers and iterators explains how one would go about designing them, not just using them. Once the development of a vector-like container is described, the other standard containers are presented for the student to use. No time is wasted trying to teach data structures, for which other classes and books already exist. The same applies to sorts and other basic algorithms. The standard ones are presented for immediate use by the student.

There are chapters on basic I/O, GUI and graphics (using FLTK), data formatting, and numerical programming (this is my least favorite). There is also some cursory coverage of upcoming C++ features as they are found in boost, such as regular expressions. Because this book deliberately targets beginners, you won't find advanced topics like template metaprogramming. There are entire books (three of them!) dedicated to that.

Finally, there is some brief discussion of the history of C++, on its own and in the context of the evolution of programming languages in general. I would have enjoyed more of this.

If I were to teach a course, this book would be my first choice. A disciplined self-learner would also be well served by this book.

However, it does not try to target those who already know how to program and wish to migrate to C++, though they would doubtless find this book interesting and well written. For them, I would recommend "Accelerated C++" or "Essential C++" to bring them up to speed quickly or ""C++ Primer" to study the language more in depth. For those coming from a language that is conceptually different from C++, the two "Thinking in C++" volumes do a good job of aiding in the paradigm shift. I am deliberately omitting non-tutorial books like the "Effective C++" and "Exceptional C++" series, though they are certainly essential.

Everyone -- beginner and migrating expert -- should avoid C++ How to Program (6th Edition). Notwithstanding the pretty presentation, this book teaches abysmal programming practices, such as blatant and amateurish violations of the Liskov Substitutability Principle.

Naturally, every C++ programmer should own The C++ Programming Language: Special Edition (3rd Edition) and C++ in a Nutshell is a marvelous one-stop reference.

As a side note, there is a long running debate over which language is most suitable for teaching an introduction to programming. C++ is usually one of the first to be eliminated. This book puts C++ back in the running and and shows that it's more about the teacher than it is about the language.

I had just finished reading Herbert Schildt's book C++: The Complete Reference and had resolved not to read another door stop before devoting much more time to practising the new techniques I had learned. Then I got wind of Bjarne Stroustrup's new book for beginners: Programming Principles and Practice Using C++. Now Dr Stroustrup occupies a very elevated position in the panoply of C++ deities; his words are cast in stone and he is often referred to as "the creator" of C++ (read: he invented it). Most programming tutorials have shortcomings of one kind or another, so I was intrigued to discover what sort of a job BS had done. I was not disappointed.

Firstly, his approach is not to treat learning C++ as a purely language-technical issue, but to talk about programming as a means to the solving of problems, and use C++ (the most versatile and widely used programming language we have) as a vehicle to do this.

After a dedication to Lawrence Petersen, his collaborator on this project, there is an interesting chapter concerning the place of computer systems in modern life.

Programming is introduced in the conventional way with the simplest concepts, then the learning curve becomes progressively steeper (a feature which is required of a reasonably complete introduction to the subject, even given the 1264 pages of this book).

BS uses several techniques that I had not seen before. All the code is printed in a bold typeface in blue. That makes it easier to distinguish code terms from other, possibly similar words within the body text. He does not use unnecessary spaces in his code. This helps to clarify where spaces are actually required by the syntax as opposed to merely beautifying the code. It also allows more characters per line, but the downside is that the code tends to look more crowded.

Nearly every chapter ends with a set of drills (short exercises), a review of all the new material introduced in the chapter, a list of the new terms, a very comprehensive and well thought out set of more substantial exercises and a postscript giving final thoughts. If students were to take on these exercises in a conscientious way I have no doubt that the learning curve would be flattened to a great extent and they would rapidly gain proficiency in programming.

Having prepared the ground thoroughly, BS raises the level of activity by introducing programming techniques which produce graphical output, and devotes 160 pages in five chapters to it. An independently produced lightweight graphical user interface package called FLTK has to be downloaded and installed for this purpose (its free of charge). FLTK was chosen partly because it is a cross-platform system (cross platform functionality being one of BS's hobby horses, although one which is justified). I found this part of the book a bit tedious, mainly because I am not greatly interested in graphics at present and partly because I did not have the time to play with the system sufficiently.

Two thirds of the way through the book is a refreshing and fascinating chapter dealing with the history of programming and some of the personalities involved; something I had not thought of investigating in any detail before. Colour photographs are another feature of this book which adds to its appeal.

An important theme of the book is the idea that its all too easy to make mistakes when programming, but there are ways to mitigate this. BS owns up and highlights many mistakes he made (some of them deliberate, for pedagogical reasons) when writing programs for the book. I find that both endearing and encouraging. Major sections deal with debugging and system testing, including the recording of run-time.

The last chapter is an introduction to the C programming language. I was very pleased to see that since you cannot go very far in the world of C++ without tripping over branches of C code, and it helps a lot if you can understand it. There are five appendices which provide useful reference material and some extra ideas for anyone who has stayed the course.

The book is supported by some excellent web pages with supporting material including an errata list and well designed tutorial materials for teachers.

I found this book generally very revealing and rate it not only excellent, but inspiring. It provides the means to become a good programmer if you are prepared to do the work, and the encouragement to do so.

I agree with Hubert above. This book is great for the "advanced beginner". I too have been through several of the shorter, more to the point, "teach yourself C++"-style books. I am glad that I did those first. I am totally self-taught and unfortunately have no mentor to ask anything. This is the first book that has spent any time on data validation and parsing and has introduced catching errors as part of the bigger picture rather that a discrete subject. This is the way it should be be done.

Chapters 6 introduces parsing. This has been the missing link for me. As soon as you start writing anything beyond the simplest of programs you run into the problem of needing to validate and make sense of user input. You always just knew that there had to be a "standard" way of doing this because the problem is so fundamental, however, the answer is not obvious. I developed a far simpler "home-grown" parser for an ip address calculator program I wrote but using token objects is FAR superior. (which makes me wonder about how many other things I know nothing about) It is not simple and I spent a lot of time reading and trying to truly internalize the chapter and doing the exercises. However, I do wish that more of the answers were published on his site for those of us working at home alone without the benefit of a professor.

Also, graphics and GUIs are given some coverage. This is also unusual for a beginner book. None of the others that I have does this. I think it is important to show that C++ is graphics friendly early on otherwise the ignorant get the impression that only newer languages like VB can handle such things.

So, basically I see this book as a cornerstone in your self-education. It you are working alone it is going to take some time and effort to plow through this monster. (Especially if you do the in-chapter exercises and problems.) But it is a very good book and will likely serve as a nice gateway to more advanced books on the subject.

This is the best introduction to C++ I've read (and I've read a few, including Accelerated C++ and C++ Primer). For a start the book is beautifully presented with color used liberally throughout and even color photographs in places. There are also plenty of pictures and diagrams to illustrate techniques.

It's big at over 1200 pages. But the text is not dense so you can actually read chapters fairly quickly. There are 4 parts as follows:

1. Basics
2. Input and Output
3. Data and algorithms
4. Broadening the view

Part one contains the fundamentals of C++ and also describes designing a parser to calculate arbitrary expressions. This is surprisingly complex, involving tokenizing a grammar.

The I/O section is excellent because it describes how to design GUI classes and also how to use the real-world FLTK GUI library to produce windowed programs. Of course it also describes traditional text mode programming using iostreams.

Part 3 contains an excellent chapter on designing a vector class, then discusses how the STL vector template solves a lot of the problems. This is a theme of the book - Stroustrup attempts to explain the underlying reasons why things work the way they do, rather than let the reader rely on "magic".

The book describes a lot of good techniques like RAII, regexes (using boost and which will also be in the next C++0x standard) and exception handling. The goal is to give the reader the skills to be able to create robust modern C++ programs that can be used by other people. Hence the emphasis on correct exception-safe code.

Part 4 discusses numeric programming and embedded programming. These are interesting chapters but possibly niche. There is also a chapter on test harnesses and unit testing, which is something a lot of intro books leave out. There are also a couple of "trivia" chapters related to the history of programming which I found very interesting.

So, in summary I'd say this book is an excellent resource for the beginning C++ programmer (or even an existing one who needs a refresher).

I'm an "advanced beginner" (and a self-learner and English is not my first language).

By "advanced beginner" I mean I've read 4 beginner's books, so I'm at last almost comfortable with elementary things such as function, class, object, loop, nested loops, pointer, recursion, libraries, etc. (By almost comfortable I mean I'm not afraid any more)

I would not recommend this book to a total beginner, at least not to the below average beginner I was, because he probably would have been left mystified or bewildered by this book. But I would definitely recommend it to an "advanced beginner" or a gifted beginner or a beginner who have access to some kind of teacher or mentor.

I like books that are clear, concise, accurate, technical, and especially who aren't afraid to introduce what may seems to be complex subject (because if it is done step by step and clearly the complexity fades away). This book meets all these requirements. I mean one of the first program is a parser, a PARSER! what a wonderful thing to learn at the beginning of your programming career. You learn about grammar and parsing and stream before page 200 (I'm actually at the beginning of chapter 7, that is page 219)

Wonderful book, thank you Professor Stroustrup.

Bjarne Stroustrup was a guest lecturer at my intro to C++ class (ENGR 112) at Texas A&M University. He would come in 3-4 lectures a month and teach us. He is a very fun and interesting person to be around as well as easy to talk to. Very humble despite the feats his invention created.

Back in 2006, he was still writing this book and using my class as a testing ground for it. We'd have to go to the copy store every week or two to get the next chapter. Sometimes the chapters were error free...sometimes not. We were very vocal about grammar and compile errors using his code line-by-line. Regardless, this is quality material. The only reason why I'd by this book again is so that I don't have to lug around a 4" binder full of loose-leaf paper.

I had tried all throughout high school to learn C++. Everything I did failed, but his material and my main professor got me going. This book proves that if you are going to learn C++, you got to learn from its father. I just wish there was a Kindle edition. Big reference books aren't as easy to read as something like a Kindle.

Different from other fine technical books in terms of heft and its use of color, Professor Stroustrup has achieved a remarkable balance of both accessibility and accuracy.

As other reviewers have noted, this book is not musings on the evolution of C++ nor is it meant as a means to transition to C++ from some other language. Instead, it starts from a tabula rasa and teaches programming concepts using C++ as the medium of expression. (He even explains what a screen cursor is. :-))

I've been using C++ since 1992 and it's the language I chose for our company's major project back in 1999, a decision that proved to be prudent as the application has grown in complexity over the years. In spite of my long C++ experience, I'm still finding gems in this book, some of which are of the ``Oh yeah, I forgot about that!'' variety.

Another point not yet made by other reviewers is the sheer joy that shines throughout the pages. It's clear that Bjarne Stroustrup is still jazzed about programming after all this time and considers it fun. This book happened to arrive when I was perplexed and frustrated with a problem (in an application written in another language). Reading this book helped to ignite my fire and made me remember just why I became a programmer in the first place.

There are a few things we purists may not like such as casting the return value from ``malloc()'' and using ``exit 2'' but those few nits are outweighed (pun intended) by the overall quality of this outstanding book.

What can I say? This book is by far the best choice for a "introduction to programming" college class or for self study for anyone serious about learning programming. It offers depth, clearness, vision, wisdom and raw technical skill far beyond the reach of any of its competitors..
What really amazes me is that Stroustrup has managed to write a book that's really, essentially about learning what programming is and how to do it best, using C++ just as a useful tool avoiding the trap of cherishing and exalting his "creature" bringing it to center stage and instead letting it do its quiet work in the background.
Seeing someone with caliber, history, skills and reputation of Stroustrup, who could just go on being revered writing highbrow terse articles, taking the time and exercising the patience necessary to write a beginner book is really a testimonial to the value of this guy.
As an added value, his approach contributes to fight off from the very beginning the confusion that exists in many aspiring ( and unfortunately even is some experts..) programmers about knowing a programming language or knowing the art and science of programming. I find it quite ironical that it should be the job of the creator of a language to underline so effectively the difference between a "language lawyer" and a good programmer.
It is true that the text has many typos and imperfections, as the long errata shows, but being realistic, how many long, clear, detailed, deep technical text don't have mistakes? Even here the author deserves some credit for being so strict and efficient on error correction. Some more proofreading would have surely helped anyhow, that s' a fact, but this issue is largely insignificant compared to the overall quality of the text.
There are only two things that I would have loved to see done in a different way. First, I agree with the idea that introducing polymorphism with the classic toy examples reduces the appreciation for its power and usefulness at first, but I think this fault is inevitably and gradually eliminated later on when the students end up applying the concept to more realistic and complex problems. Presenting it while also teaching computer graphics application concepts might end up making polymorphism seem more complex and obscure than what it actually is, unless the student has already been extensively exposed to the graphics techniques that are being used. I do believe that a clear, immediate, simple even if a bit primitive grasp on a concept is key to fully internalizing it.
I also think that using an established and powerful graphics library like OpenGL would have made the computer graphics section much more fascinating and useful.
What else to say, do yourself a favor and read this book. It has something to tell you, even if you are an expert programmer.
And.. ah yes, thanks Bjarne.

Well, since other reviewers have done a great job of explaining exactly why this book is great, I will just add a "me too".

I am a professional C++ programmer, but have always enjoyed Bjarne's writings. He always gives you something new and for an experienced programmer it is interesting to get insight into his style and methods.

Another point is that this is the only C++ tutorial I know of that supports both Windows and Unix/Linux, so it would be a great introduction to multi platform programming.

I also got so if someone asks be on a good book to learn C++ I have one that I have read and can recommend.

Even though I rated this book as a 5-star product, there are questions that I have about it. First of all, even though I understand the author is not trying to teach C++, it's still unclear why he decided to create his own header file (std_lib_facilities.h) in order to teach programming for beginners. This is how a beginner thinks: he thinks that every programming language has built-in tools that he could use in order to write a simple program. Then he starts reading a C++ book and finds out that he needs to add an iostream header file to his first simple program. He finds out that the iostream file is not a part of the C++ language, yet he knows that the file needs to be added to his early programs. Then he starts reading the book I am reviewing now and finds out that a beginner needs to add a header file called std_lib_facilities.h to his first program. Even though the std_lib_facilities.h file contains the info about iostream and other files, he wonders who's teaching a real C++ and who's teaching a fake C++. Is it Stroustrup who's teaching a real C++ or is it other people who wrote C++ books for beginners that are teaching a real C++? Yes, I understand that Stroustrup is only teaching programming in this book, but how is a beginner supposed to know that the tool he's using for programming is real or fake?
I am running Gentoo Linux and don't have Windows installed, so I am a bit confused on how to compile and link his C++ file that requires the FLTK library. He says in his book that we should read a specific documentation to find out how to do it, but I think a beginner wouldn't be able to understand anything from such a documentation. That's why I believe he should have explained in his book to linux users how to compile and link his files with FLTK.
But the book is a 5-star product nonetheless!