Accelerated C++: Practical Programming by Example (C++ In-Depth Series)

The authors are widely considered to be among the world's foremost authorities on C++. What is perhaps even more important for the purposes of this review is that the authors are not only knowledgeable, but are also great teachers: they have used the material in this book for their professional-education course at Stanford University, and their pedagogic skills show on every page. It comes as no surprise, then, that "Accelerated C++" is consistently recommended to programmers who wish to learn C++. The Good: This book does not talk down to the reader. It assumes that you are intelligent and implicitly expects you to have previously come into contact with either procedural or object-oriented programming. Many different topics are covered in a short space (around 300 pages in total), but the text is highly readable owing to the authors's relaxed tone, as well as their many cross-references and their detailed explanations of the examples (after all, the book's subtitle is "practical programming by example"). Equally important, the authors have provided on their website the source code for all the examples in the book (and more), packaged for different platforms. As should be obvious, modifying, compiling, and running the code in parallel to reading the text is integral to understanding the concepts being introduced. In contradistinction to many other popular volumes, this book teaches real C++, not "C with classes". To illustrate this point, let me note that pointers and arrays are only introduced in Chapter 10 (of 16). "Accelerated C++" jumps right in and describes a variety of topics that are of use to professional C++ programmers, such as standard library algorithms, templates, allocators, dynamic binding, and more. The Bad: Some readers may find the student-grading and character-pictures examples a little boring (though what simple example isn't somewhat boring?). Also, the difficulty level of the exercises is not consistent (e.g. some have already been worked out in the provided source code). This book isn't really great as a reference: new concepts are introduced when they are needed for the purposes of the examples. This means that the chapters cannot really be read out of order. Futhermore, certain things like bitsets, switches, enums, and multiple inheritance are either relegated to the Appendices or are not mentioned at all. In a similar vein, object-oriented programming is not thoroughly discussed (as can be expected from such a short book): e.g., inheritance is introduced in chapter 13 (of 16). Finally, this book was published in 2000 and quite a bit has changed in the meantime. Most notably, we are now expecting a new standard to come out (still known as C++0x). Unfortunately, this book doesn't talk about TR1 (a specification for functionality being added to C++'s standard library) or boost (a collection of libraries offering TR1 implementations and much more), or threading in C++. A new edition of "Accelerated C++" apparently is in the works. Lest the reader feel that I am being too negative, I note that it is impossible for one book to please everyone and cover everything, while being always up-to-date and still remaining short. In a nutshell, this book is great at what it intends to be: a fast-paced, authoritative, and pedagogically sound introduction to (1998/2003) standard C++ . This book definitely deserves 5 stars. ---------------- My two cents on recommended follow-ups: * C++ Primer, 4th edition, by Stanley B. Lippman, Josee Lajoie, Barbara E. Moo A great second book which can be used to solidify and expand your understanding. The "C++ Primer" is over 800 pages long, but it is so well written that it can either be read cover-to-cover or used as a reference (see also my review of it on amazon). * Effective C++, 3rd edition, by Scott Meyers This assumes you have already come across all of the material contained in "Accelerated C++" and in the "C++ Primer". It offers solid advice on numerous aspects of effective C++ development. Meyers also describes a few design patterns as well as more modern topics like TR1. Alexandros Gezerlis

I read a number of reviews before settling on a C++ book. A review in a programming journal led me to this book, and it didn't disappoint. The authors take a particular approach to teaching C++ which doesn't teach object-oriented programming or C++ concepts (such as the STL) as an afterthought, but as the primary way of using the language. Many C++ books assume some familiarity with C, and reintroduce the concept before showing how it differs from C++. This book skips straight to the 'C++ way' of doing things, to great effect. I had done a little PERL, a little Python, and a little C before diving into this book, but I was far from an experienced programmer. That said, I had no problem getting through this book, especially the first 65% of it. The depth and complexity of topics within this book increases rapidly after the first half. After showing basic OOP aspects of C++ and how to solve basic programming problems in C++, they start to have you implement STL classes to understand how to implement classes that can handle all types of operations appropriate to that class. The only complaint I have about this book is a strength and a weakness. As the chapters progress, the main example problem they have you work with (a program to keep track of and calculate students grades) continues to evolve and increase in complexity and features, which is great. The problem is, they often ask you to add a feature or reimplement a feature, assuming that you've either got it right there in front of you, and/or remember precisely how it was implemented. If you don't work through this book in some consecutive period of time (which I didn't - I took some breaks and/or used various machines to do different parts, and as such didn't have all my code nicely organized in one place) then it can take a considerable amount of effort to reimplement and/or rediscover the particular code they're asking you to modify. This is a reasonable expectation. It's just that if you don't have the same machine with a nice, organized copy of your code as you progressed, or if you've not been looking at the material for some time, it takes a good deal of effort to catch back up with where they want you to be in order to get on with the exercise they're asking you to do. All in all, I learned the most programming I've learned from any book by focusing on the problems and features highlighted in this book. The explanations are all excellent and clear, and teach you not only the basic C++ language, object-oriented programming, and STL features such as copy() and find() that are standard ways of doing common actions in C++.

I had taken a c++ class years prior though had never had to program with vigor using c++ in my work tasks. That changed and I needed a book to walk me through what was important in coming up to speed with learning, modifying and developing a very large c++ simulation. This book is perfect for this. This book walks one through a regimen that begins with material relevant in most programs; rather than "basic" not so relevant material. The length is not so large as to scare away; some similar books are so long that it would take a year to seriously plow through them. The book will get you up and going in using library functions and developing your own functions before it even touches class structure or inheritance which is addressed in the second half and is done is such a way that many of the advanced concepts are understood based upon the practical work covered in the first half of the book. The only critical remarks I have is that the book gives many very useful examples that really need to be followed and programmed by the reader and yet there is no output to these examples given to compare answers to. I also found that the generation of the input streams to many of the examples needed slight modifications depending upon the platform / compiler being used. Other than these two things, the book is a great buy.

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

This book was provided to me as a great way to learn C++ by example. I would have to disagree, at least as applied to my learning style. The book is structured such that you have to have completed and remember every example in every chapter before it to understand any of the examples in subsequent chapters. You might not look at the book for a couple weeks and then come back to it and be totally lost because you don't remember the example from chapter 3. I would say it's a decent book for those who are proficient in C++ but simply want to exercise their fundamentals by example, but is certainly not the best book for beginners. So, what is good about the book? It's short. If you look at most books on C++, they are very big, because C++ is very big. But again, this kind of ties into this book's problems. Each chapter is not stand-alone, which is a pain. I also like the emphasis on including namespaces in the code rather than simply putting in "using <namespace>" at the top of the code like many books. I give it 3 stars rather than 1 or 2, because the code presentation and examples are pretty decent. I give it 3 stars rather than 4, or 5, because it's difficult to use as a reference and nearly impossible to understand in later chapters without having memorized the previous chapter's examples. I think I get what they were going for, they wanted to expose you to the most common/important features of C++ while forcing you to exercise the skills by building pieces of the program as you go. This program would take shape over the course of the book and build upon specific code you had written in previous chapters. The problem is, if you don't do exactly that, you will be forever lost when trying to follow this book, making this more like a work-book than a textbook or reference book. For a beginning book on C++, I'd probably recommend C++ Primer by Lippman and Lajoie. It provides stand-alone, clear, and numerous examples on many topics in C++. You won't get a series of related problems to work on like you will in "Accelerated C++", but you will be able understand what you read without having to constantly look back at previous chapters.

C++ (and its many variants) is probably one of the most popular and widely used programming languages in the world. Its adaptability, flexibility, and scope of what it can perform on many different platforms is extremely impressive when I consider everywhere that I've seen elements or structures of the language. As I child I compiled programs and made rather simple executables on my Commodore 64 and my 486 - both close to top-of-the-line machines at the time. I learned BASIC fairly well, yet as I went to high school and beyond I let my interest in programming slide. Diversionary actions revealed, however, that I could never get away from my interest in programming - I made various games and programs on my TI-82 back in the '90's, but high school "coolness" took over and sports became the new thing. As I finished high school and went to college to study literature, I put my interest in programming to the side while all my friends went off to the left coast and everywhere in between going to school and/or taking technical jobs of various sorts in the tech boom at the time. So as a 33 year old liberal arts major and career technical sales rep with a strong interest in PC building, PC architecture, electronics, and microcontrollers, I decided it was time to get back to basics and learn what I've always wanted to learn - computer programming in its purest form. Fascinatingly this book wastes absolutely no time getting you into understanding C++ mode, and simple terms and things most programmers take for granted take quickly as you're working through the book. It's not long after you're programming "hello world" you're learning how to manipulate much more complex commands and KNOWING and UNDERSTANDING the why's and how's of what's going on. For a practical, hands-on, beginners' book, look no further. Read the author's intro and you'll understand exactly why a blank slate (when it comes to programming C++) of a mind is better suited to this learning method than someone who already has experience in C or C++. In short they start teaching functional commands and filling in the blanks on basics as needed. Certainly this shouldn't be your only C++ book, but if you're just getting started it's one heck of a first step! One last piece of advice - make sure you get a decent C++ programmer and compiler with all the standard libraries. Just google around and visit various forums - there are excellent resources online with all of this information. I don't want to promote one over the other, but if you're using windows you'll still want to start with a blank screen / non-GUI version so you get the hang of the language before you move on to programming in Windows. That's just my opinion - but you can certainly use a Windows C++ distro from the largest software brand in the world if you so choose!

While the concept of this book is nice, the execution is poor, and the result is an abject failure. This text is called "Accelerated C++," but I think "Retarded C++" would be a more appropriate name. This is because it may take you a very long time to learn C++ using this book. I bought it because 300 pages seemed more manageable than some of the other 900 or 1300 page introductions, but the writing is so bad that it ends up taking more than thrice as long to work through each page than if you'd chosen a standard text. Here are some major flaws with the book: 1. The exercises are often unclear. You're left wondering what they're really asking you to do. 2. As other reviewers have noted, there is way too much discussion. Programming languages, just like spoken languages, can only be learned from experience and practice. The word-to-code ratio is way off, and having to trudge through all of that text really slows the pace down without contributing that much. 3. The authors introduce concepts through example...and I mean by ONE example. They take one example and develop it throughout the text. There's nothing wrong with this, but it does get a little stale, and it would be refreshing to see alternate examples. 4. Learning by example can be a great way to approach a new topic such as programming. However, this approach works well only if you either have several examples so you see how a new syntax, data structure, or whatever is used in practice or by supplementing a single example with a clear formal explanation or definition. This book does neither. 5. The authors refer to subsequent chapters way too often. They mention something in a superficial way and then say that they'll talk about it more later. This is even more irritating when they have exercises that (implicitly) require material in later chapters. 6. Complicated examples and concepts get introduced immediately. While it may at first seem like this is accelerating the learning process, it is (once again) actually slowing it down. Most writers would introduce an idea and give a few simple or canonical examples. Later on, they circle back around and talk about special cases or more sophisticated versions of what you've learned. There's a reason why piano students learn scales before Chopin and why calculus students learn single-variable calculus before multivariable calculus: because it works. 7. Overall, it's just poorly written. Explanations are long and opaque. I am no stranger to reading technical texts and am usually able to absorb new material quickly even if it's in an unfamiliar area. Working through this book has been slow and painful. I hate to be cruel about it, but the authors ought to have put more thought into pedagogy or at least been more critical and revised the end product to address some of these fatal flaws.

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.