Customer Reviews

Accelerated C++: Practical Programming by Example

5 star:		(71)
4 star:		(13)
3 star:		(4)
2 star:		(5)
1 star:		(1)

 

 

This is a nice change for the better! Instead of introducing the basics and then going on to class design, inheritance, and polymorphism, Andrew and Barbara delay things such as class design until the latter part of the book and instead launch straight into use of the STL, illustrated with practical examples of how to use STL containers and algorithms to solve programming problems.

As far as I am concerned, this is definitely a change for the better. Most programming projects I see heavily abuse inheritance to do things that would have better been done with templates and, as a rule, most C++ projects continue to ignore the STL, even though it is probably the most fundamental contribution to C++ programmer productivity in years. Following this book, readers are encouraged to use STL from the word go, which is as it should be.

The language and flow of the book are excellent, and the presentation is very lucid. What really shines through is that both authors are experts on the topic and really know what they are talking about. The explanations of language features are complete, correct, and precise. There is none of the muddled exposition that I find in so many other C++ books. The teaching experience that Andrew and Barbara have gained over the years is truly reflected in the prose. The book anticipates many questions and typically answers them just at the right time, namely, when the question is just about to pop into the reader's head.

Information density of the book is high. A lot of information is packed into few words, so the reader has to concentrate on what is being said, and skipping paragraphs is not something that I would recommend. The concentration, however, is well repaid by the large amount of solid knowledge that is imparted: I believe that no other C++ book manages to convey as much information per page as this one.

To me, the target audience are people who have done some programming in other languages and do not know C++. (I would not recommend the book for people who have never programmed before, unless they are very determined readers.) More seasoned C++ programmers also will get good value. And, if you are an experienced C++ programmer, but haven't much used the standard library up to now, there is still plenty of meat to be found: there are enough gems of advice in the book for it appeal to people who have considerable C++ experience.

This is an excellent effort from two experts in the field. I recommend it!

I'll start by saying that I probably would not have understood this book as well as I have, if I had not already been teaching myself C++ through other forums (primers and online). The thing that most of these other forums have in common is that they start with the basics and build up slowly to the more abstract concepts. The problems come during the switchovers (char* to string, procedural programming to object oriented, pointers to iterators, linked lists to containers, etc). In almost all cases you learn the more basic, and paradoxically more difficult concepts first. Then you have to 'unlearn what you have learned' in order to use the more advanced concepts.

So what's different about this book? It teaches a mix of syntax and 'advanced' concepts right from the beginning. You learn the basics of loops and choice statements while using the Standard Library. You also use them in specific examples that have real world uses (the grading program in the first few chapters for example). The Standard Library is _easy_ compared to arrays, char*, rolling your own linked list, using pointers, etc. Since it takes far less time to learn, you can be writing useful programs very quickly. _Then_ the authors go on to describe some of the more 'basic' concepts, usually in terms of how they implement some of the ideas behind the Standard Library. Since you have that understanding already, things like pointers become easier not only to learn, but to understand how they can be used.

I have one complaint about the book, and that's with the grading program, specifically how it appears in Chapter 4. As written, it's very confusing to actually enter data to get it to run correctly. A minor complaint though, considering how many times I thought to myself 'Aha! This is what I could use to solve this problem I've been having.' Or 'Aha! So this is what those other books were trying to say.'

In a nutshell, it's a refreshing look at C++ and if not able to stand on its own, is a must have supplement for anyone learning or using the language. At the very least, it's made me question the seeming SOP of giving the Standard Library one or two chapters and calling fundamentally harder concepts 'basic' and the concepts that make programming in C++ easier being considered 'advanced'.

I have nothing to say about this book, except, among hundreds of C++ "intro-level" books available, this book is simply "the best". Why?

The answer is easy: Because it teachs C++ the way C++ should be taught.

Why re-invent the wheel if there are a lot of wheels available for you to use? Why learn to do things in "the hard way" if there is a lot easier ways to do?

C++ should be taught from its C-inherited no-more. In C, we used to do something in "the hard way". For example, just to use string efficiently, one would need to understand pointer properly, since C-string is pointer to char (char*). Just to dynamically store some instances of the object (to store the objects "as needed"), one would need to know how to manipulate pointers, which always lead to problems and confusion, to imprement the dynamic container.

And that's what almost all other C++ books try to teach you "first". And they will teach you what should be taught ealier "later". You, by that way, it takes longer to be productive, or even to be an able programmer.

Then, how C++ should be taught?

Bjarne Stroustrup, the father of C++, said clearly in one of his paper, named "Learning Standard C++ as a new Language", (available in his homepage) something like "Learning a programming language should support the learning of effective programming techniques. My favourite approach is to start teaching the basic language (variables, declaration, loop, etc...), together with a good library". And this is exactly the approach taught by this book.

I, personally, agree with the previous reviewer that with the approach used in this book, pointer and array are easier to understand than learning from the traditional approach.

Learning C++ from its standard library aspect can make you a productive programmer in much much shorter time than learning from the traditional approach, which begin with C-subset, and many programming techniques that you have to "unlearn" as you progress on.

In case that you're wondering how much you will learn from a book of this size. All I can tell you is, more than you can ever imagine. However, you will have to concentrate on what it's saying. And then, after you finish this book, you will have no (or almost no) problem when moving on to the more difficult (say, more advanced) books like those by Stroustrup, Lippman, Musser & Saini, Austern, Josuttis ... etc (all are my personal favourites).

The wheels had been invented. So why not just use them?

In short, this book is nothing more than the BEST book on introductory C++ ever written, period.

Andrew Koenig and Barbara Moo have written a terrific introductory book on C++ here. They teach you C++ by presenting programming problems to be solved, and introducing the exact language features you need to solve them, one right after the other. Very early on you find yourself using the power and simplicity of the STL to write some pretty cool programs. The programming examples are very interesting, and this book has the clearest exposition of the workings of pointers and arrays that I've ever seen. (In fact, they introduced iterators earlier in the book when using the STL, and I think introducing them in this order makes their discussion of pointers a lot easier to understand than it would be otherwise.) They eventually cover all the features of the language that a person realistically needs to accomplish just about anything, the discussion of each feature always motivated by an actual need for it to solve a problem at hand. I'm glad I've got this one on my shelf!

After having read this book I very much regret coming to C++ from a self-taught Pascal and C background - it could have been so much easier. Many introductory texts on C++ assume a background in one of the procedural languages and consequently start teaching the C subset of C++ first. This is, according to the authors' experience, counterproductive to understanding 'proper' C++ and programming true to it's paradigms and design. Thus they follow the radically new approach of discussing whatever (sometimes advanced) facilities C++ offers to solve a particular problem instead of going from one isolated language feature to the next. This leads to the somewhat unorthodox chapter sequence, which teaches the design of user types (classes) after introducing template functions (a feature many seasoned C++ programmers still don't know how to use effectively) or even stranger: the explanation of pointers and arrays (chapter 10) in terms of the standard library iterators and containers, which have been introduced as early as chapter 3. What I particularly liked are the useful and real world examples, although the book does cover the omni-present 'hello world' program, it otherwise fully delivers on it's promise of teaching 'practical programming by example' (subtitle). Due to this approach and the well constructed exercises at the end of each chapter the book gets the student writing non-trivial, useful programs taking full advantage of advanced C++ library features almost from day one. The authors also lead by example and show proper commenting and programming for flexibility techniques even in the smallest code fragments. This is in refreshing contrast to many an author's crime of showing the 'quick and easy' way first and the 'proper' way later.
If you read The Design and Evolution of C++ you'll soon notice the repeated mentioning of Koenig and Moo as two of the key players in the development of the language. Their in-depth knowledge and experience really shows in this work. Although the book is mainly aimed at beginners, veteran C++ programmers can still profit from it, even if only by loosing some more bad old C habits.

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

I picked up a copy of "Accelerated C++" to see what the fuss was about, and I'll add my voice to those who have praised this book. It is the first book I've seen to introduce C++ coding in a high-level manner along with some notion of invariants, and reminded me in some ways of the text which taught me Modula-2 a decade ago (Sale's "Modula-2: Disciple and Design", as if it matters). I think/hope that this book will help to improve the average quality of [C++] programming.

If you've been put off learning C++ because you think that it's just a low-level language, this book might be your reason to try again: it shows how to use C++ in a high-level style, and more importantly it reminds us how to _think_ in a high-level style and translate that directly to code.

-- James Dennett <jdennett@acm.org>

I'll add my voice to the those praising Andrew Koenig and Barbara Moo for their terrific introductory book on C++. But, after you read this book, you must immediately read Herb Sutter's "Exceptional C++". Why? Because "Accelerated C++" teaches you the basics of using try, catch, and throw, without teaching you the disciplines you need to write exception safe code. If you actually tried to use "Accelerated C++"'s culminating example of a smart pointer in a real program, you'd be creating a bug farm. "Exceptional C++" brings you the missing lessons. However, you can 't read the Sutter book unless you understand the material in "Accelerated C++".

It comes as no surprise that the text book co-authored by Andrew Koenig, a leading authority on C++, is one of the best. This book teaches C++ "in the right order" -- it follows the basic philosophy that new programmers should be "re-use consumers" before they become "re-use producers". In other words, it has new programmers leveraging the standard library to great effect from the beginning, rather than having them struggle to design classes. The result is a book that is full of C++ code examples that really look like modern C++ (making use of the STL, namespaces, and exceptions) from the beginning. (for example, string is introduced I think in chapter 1.

The coverage of the STL is just right -- they focus on the more important classes (map,list,vector), and leave the rest for a more complete reference (see Josuttis: the standard C++ library, a tutorial and a reference)

When the book finally does discuss class design (about half way through), it is done right, and the class designs are better thought out than those in many other text books (and indeed, reflect the fact that the authors are familiar with designing high quality class libraries, such as those in the C++ language) Not only do the authors emphasise good practice (keeping mindful of class invariants), when they give examples of custom classes, they do it right, with absolutely no conceptual bloopers, something which is extremely rare in C++ texts (this is the first book I've seen that doesn't make big bloopers when computing random integers for example)

While polymorphism is left until quite late in the book, it's covered quite nicely, and there's a chapter on the handle/body idiom and reference counts.

Overall, this is a very strong beginners text, and is highly recommended. The quality of the example code is unusually high, and the early emphasis on the standard library is a welcome change from more traditional books.

The only thing that this book is lacking is examples. It seems a little terse. This is not necessarily a problem, but it means the beginner will need to supllement the book with further examples (another book, or a professors lecture notes) Not a big problem given the modest pricetag. On the other hand, experienced C programmers wanting to learn C++ will love this title because it skips over the stuff they "already know" and goes straight into "real" C++.

Readers of this review should be easily able to discern if their expertise enables them to discard any warnings given here, or if they are in the class of potential users of this book who require the type of warning provided. With that proviso,let us continue.

I have perused a few books of C++ instruction (i.e., examined them carefully) and I must say this one is among the most user-friendly of them; it has enabled me to dip into the previous ones I had tried earlier and understand what those other texts were trying to say. Those other texts got me so confused that I sometimes wondered if I could remember my name, for they were not so well organized and seemed to leave out important pedagogical steps.

This book has enabled me to avoid most such frustrations, and I now have the firm belief that the primary obstacle to learning this programming language is not an intellectual one--it is nowhere near as tough intellectually as your average advanced mathematics or physics text--the obstacle is overcoming frustration. Even this excellent text will provide the diligent reader with plenty of frustration.

For example, at the relatively naive level of this reviewer, the programming example in chapter 4 required me to flip back and forth to find the code for several functions and header files. After finally getting a successful compilation I ran the program and saw a blank board.
I had no idea what was going on. I was confused and even managed to convince myself that the code on page 70: while (read(cin, record)), etc., meant that the program was trying to read a text file named "record" which I needed to create in accordance with the statement on page 61, where the authors say:

"Such a file might look like

Smith 93 91 47 90 92 73 100 87
Carpenter 75 90 87 92 93 60 0 98 "

The text leads one to believe that a file is the input to this program.

After some floundering around I finally got it through my thick skull (so far as C++ is concerned, anyway) that the program on page 70 required CONSOLE input and I needed to type in the example on page 61, with ENTER at the end of each line and the appropriate end-of-file indication at the end. This made the program run and I saw the correct output. An understanding of basic file input/output would allow a reader to generate such a file, but at my level of knowledge this was not yet possible.


Pedagogically it would have been very useful for beginners on my level to have had all the files listed in final form in one place, and a more detailed statement of instructions for what the actual program input is. Unfortunately, my experience is that most C++ books are inappropriate for self-study because of the kinds of inadequacies presented here. Despite these criticisms, in my opinion--by comparison with what I have seen--this book is worth 5 stars.

I recently acquired Prata's C++ Primer Plus and it is a thorough but lengthy text, but one which gives instruction on iterators and other useful concepts much later than in the text at hand. Prata, the text under review, and the manual provided with one's C++ software, should give the beginner all that is needed for acquisition of basic C++ knowledge via self-study, in my opinion.

With the help of Koenig and Moo I am beginning to see the sheer elegance of the C++ programming language--a new experience for me; I never thought I would think of a programming language in this way. There is intellectual beauty in this book!

Therefore I recommend this text heartily. Just remember that your primary obstacle to learning C++ is frustration, not lack of smarts on your part. Also, if I may be so forward as to offer a bit of advice to the novice, learning a programming language is an "experimental science." If you're not sure of something, you have to write small programs and learn what the code is doing via example and make minor variations to solidify your understanding. For example, it seems that initialization of dynamically allocated vectors isn't spelled out in an obvious way in C++ texts, from what I can tell.
std::vector<double> w;
followed by, say, w[0] = x;
doesn't work but
w.push_back(x);
does -- I had to experiment to find this out. If there is another way, I haven't discovered it yet at my level of development.

Without this fine text--despite the frustrations mentioned above -- I would never have been able to achieve a successful entry into C++. Thank you Koenig and Moo!