Customer Reviews

C Primer Plus (5th Edition)

5 star:		(30)
4 star:		(6)
3 star:		(1)
2 star:		(0)
1 star:		(0)

 

 

I looked very hard to find the best possible book for learning C. It would be nice if you could absorb new programming languages through osmosis, but it doesn't work that way. Some people will tell you to buy the K&R book, but that's pretty old! This book covers the C99 standard, which is the latest. I've read my share of awful programming books and can tell the difference.

C Primer Plus, 5th edition provides clear and detailed explanations of all concepts covered, as well as review questions and programming excercises at the end of each chapter. As any serious programmer knows, you can't learn just by reading. You have to DO the excercises. I regard the excercises a book has to offer as just as important as the material covered. The excercises in the Big Blue Book are varied and just challenging enough to really get you to remember what you read in each chapter. If you follow through with this book you WILL have a solid foundation in the C programming language.

In the fall of 2004, I used the fourth edition of "C Primer Plus" as the text for my class in introductory programming in C. Although I was not part of the decision to use it, I found it to be more than satisfactory. The explanations are detailed and the order of the coverage is appropriate, although like almost everyone else, I altered the order of presentation a bit. It covers what we commonly refer to as "plain vanilla C"; in other words programs run from a command line interface. The coverage is complete, everything that one would cover in any beginning course in C is present. The exercises and programming examples are generally well done, and the answers to the review questions are included.
In looking through the fifth edition, I found very little that was different from the fourth edition. The order of the material and the explanations are almost identical. Therefore, my evaluation of the book is a bit different. I give it poor marks as a new edition, as I did not see anything that justified publishing a new edition. However, since the fourth edition worked so well, this one is also a good choice for learning C. Therefore, my rating of this book is simultaneously an A for content and an F in terms of being justified.

Excellent book that withstood the test of the time. Incidentally it has also sentimental value for me because many years ago, when I started my journey into progamming and had my first programming course in C itself, this book came to the rescue.

The course textbook was a different one, which after the first couple of introductury chapters became vague. Especially on pointers it lost me.

Then... I got this book. It started to read like an obsessive page turner. Once I reached the chapter on pointers I was amazed more-the topic in fact was extremly simple. I got very curious of the guys background. When I looked up that he was a physicist by upbringing, the great quality of the book made sence right away.


In one word, this book is THE BOOK as a first book in C, especially for new programmers.

After that ancient times, I red many C books of different complexity and scope, but this book still remains among few of my favorits for its lucid and extremly understandable coverage.

As you can guess, the book has a sentimental value for me.

In fact, if you have older version, especially last two, then there is no compelling reason to upgrade to this version.

Have you finished the book?
Now you are ready to enjoy the succinct C Programming Language, by Brian W. Kernighan, the author of C

This review is a rewrite of a previous review which I have deleted since on further reflection I have decided that it was too critical and did not represent the book fairly.

Basically, I had given the book a low rating based on my belief that it is not suitable for beginners. While I still hold this view to some respect, I now feel that I placed too much emphasis on this criticism when I decided to give the book only two stars.

Let's get that aspect out of the way first. My only real criticism of this book is that, as others have mentioned, the first 100 pages or so are a little long winded and potentially confusing for the beginner. The issue here is that Prata goes into, in my opinion, far too much detail when describing the printf() and scanf() functions along with their various conversion specifiers, modifiers and flags. As a total newcomer to C I felt like I was reading a reference manual at first. If you've never been exposed to C before - i.e. either you're a complete programming beginner or you've only ever programmed in simpler, higher level languages like BASIC or Python - then it can be quite overwhelming since the user is exposed to more layers of detail and complexity, with a much higher potential for bugs and errors. Unfortunately, Prata bombards the student with far more detail than is necessary at this stage.

For example, is there any real need to cover so many conversion specifiers and modifiers, when surely it would be more prudent to explain two or three and then refer the student to an appendix for the rest? The same can be said with his treatment of data types - the book in my opinion dwells too much on types and their various possible sizes on various systems. As if that weren't enough, we're also exposed to another potential wave of confusion as Prata sees fit to bring different C standards into the equation. For example, consider the following passage on page 156 (still relatively early in the book):

"When appearing in an expression, char and short, both signed and unsigned, are automatically converted to int or, if necessary, to unsigned int. (If short is the same size as int, unsigned short is larger than int; in that case, unsigned short is converted to unsigned int.) Under K&R C, but not under current C, float is automatically converted to double. Because they are conversions to larger types, they are called promotions."

At a stage in which the beginner is not likely to feel very confident about the bigger picture, statements like this are liable to either confuse, bore or a mixture of both. I found that it disrupted the learning flow somewhat. At times during the first 150 pages of this book, I found my attention wandering as I worried which of the information I should be retaining and which was just extrenuous detail that I would pick up again later. It was a while before I felt like I was making any progress, put it that way.

OK, so that's the negative out of the way. It's a little hairy for the beginner to begin with. But having now gotten all the way to the end of the book, I feel like heaping praise on what is a very well structured and thorough introduction to C.

One of the main things I like about this book is that it doesn't treat the reader like a teenager. One of the most irritating things about some of today's modern programming texts is that they go out of their way to "liven up" the learning process, as if they're so worried that students are going to find the practice of programming boring that they feel like they have to inject goofy pictures, cheesy jokes and crossword puzzles into the proceedings (see the Head First series for a perfect example). Not so with Prata's "C Primer Plus." Programming is a very logical, but complicated process and in truth that's what attracts a certain kind of mind to it. If a dry, logical approach to the subject doesn't attract you then to be honest programming isn't really for you. When you get down to the practical nuts and bolts of programming there are no cartoon gorillas or wordsearch puzzles or goofy analogies to liven things up. I can see the attraction to this style of learning for someone who isn't interested in programming at all but who is forced to learn it for a course, but if you're really enthusiastic about coding then a treatment like Prata's "C Primer Plus" is going to feel just right.

He doesn't repeat himself to excess (like other programming authors I could name) and he builds on previously learned knowledge at a pace which is just right. Each chapter ends with a very well worded summary to stimulate recall, as well as some excellent review questions and programming exercises.

The programming exercises are what really make this book in my opinion. They're graded just right and contain a mix of short exercises in which for example you're prompted to write a function that does some simple task to demonstrate some concept or other - and much larger exercises on which you can find yourself working most of the evening if your'e not careful. It's virtually impossible to breeze through the exercises in minutes, which means that if you stick to your guns and complete them, you really will feel confident and familiar with the concepts you've learned in that chapter. If you don't complete the exercises, you're not going to make it through this book, put it that way. I found them extremely useful and very satisfying to complete - for instance, in one exercise Prata has you writing a simple airplane booking program with two levels of menus, using structures which are then writen to disk in a binary file. It's upon completion of exercises like these that you really feel like you're a C programmer and it's impossible not to feel very pleased with yourself.

The subject of pointers can be a make-or-break issue for the C student and on reflection Prata explains them very well indeed. Initially I was confused and a little frustrated, but I think that was because I'd found the book very easy up until that point that my brain took a little while to change to the required gear to understand them. But once I'd gotten over my initial confusion I found the subject very interesting and understandable. Again, the end of chapter exercises are a superb way to absorb and intergrate this topic.

After a surprisingly understandable chapter on bit-fiddling and an admittedly dreary chapter on the preprocessor and the standard library, the book really takes it up a notch in the final chapter on advanced data representation and it was at this point I really started to feel things come together, albeit with some mental effort. The concepts of linked lists and binary trees can feel complicated to the beginner since it's a step up from the theoretical treatment of syntax and structure to a more applied subject. And while I found the subject of binary trees very heavy going at times, it was great to finally get through it and to feel like I understood it.

After completing this book all the way to the end I really feel like I know enough about the basics of C to tackle some more involved programming texts and indeed I've just started "Practical Algorithms for Programmers" by Binstock and Rex, for which the last chapter of Prata's primer has really prepared me. It really feels as if I've worked out in a mental gymnasium.

If you have done absolutely no programming before whatsoever then I'm not sure I'd recommend this book. In fact I'm not even sure I'd recommend C - maybe it would be better to play around with something like Python for a while in order to learn the basic concepts. This book is no "C for Dummies" and it does require a lot of time and effort to get through. But the results are worth it. This is probably the best (and most thorough) introduction to the C programming language on the market and it's worthy of a place on anyone's shelf.

Great book, and it assumes pretty much no programming knowledge; starts with the basics (variables, types, numering and so on) and moves, gradually and methodically, into the thornier aspects of the language. Takes its time, too -- perhaps to a fault; if you're a programmer with some experience (as I am), you might find it a little too slow, but then again, C's a rather unforgiving language, and Prata knows this well enough to spend ample amounts of time explaining the details and subtleties of the language's behavior that sometimes take years to learn on one's own. Lots and lots of problems and exercises, too, and highly readable at that. Highly recommend.

This is a fantastic book, and I strongly recommend it. It walks you through the basic concepts and doesn't assume that you already know how to program. I picked up the 2nd Edition of this book over 10 years ago and taught myself how to program with it. At the time, I knew nothing about computer languages, but this book goes slow enough and explains the basic concepts so that I was able to learn. I have read a lot of programming books since that time, but I can say that this book was the most enjoyable and clearest that I have used. A lot of books try to teach you everything at once (GUI programming, object oriented programming, etc). I recommend learning C first with this book. Once you have the basics down, then go on to learning OOP and the GUI. Don't try to do it all at once.

I'm a freshman in college right now, and this book was required for my Intro to C class. Additionally, this is the first programming language (other than html, lol) I have ever studied.

This book might scare you a little bit when you first pick it up; it's almost a thousand pages dedicated soley to learning a language that was first formally described in 1972. This language is old, and in some ways it shows. When you start studying an aspect of C such as pointers, you might wonder why something so low-level as memory addresses ever need to be understood. Thankfully, this book takes, in their own words, a "spiral" approach to learning the language. This book does not thoroughly go through each single aspect of C, one at a time. It does not thoroughly cover every method of input, then everything about arrays, then all about pointers, etc. Rather, the authors start by introducing you to a single, simple program and go on to describe what makes that program work. They might then cover a little bit about how to get input from the user, then move on for a chapter or two, and then return to input in more detail later.

In general, the author will progress through the book by giving you a sample program, then explaining how and why it works. Wash, rinse, and repeat. This simple formula means that all of the practical methods introduced in the book are reinforced by useful and interesting theory.

In this way, the authors have taken a massive and potentially overwhelming subject and turned it into something that you can play with. The authors start by giving you a basic toolset, and keep on giving you more tools at just the right time to keep you going. By the time you get to the tenth chapter (not to mention the twentieth), you'll have enough of an understanding of how C works to look at a complex program written by any professional programmer, and at least understand what the author of that program is trying to do. You may not understand all of the tools and methods that other programmer used, but at least you will not feel completely lost looking at someone else's code.

All of the written examples in the book were tested on multiple machines with several (eleven?) different compilers, just to make sure that the programs given work as intended. I have found only two typographical errors in all my reading of the book, and both of those were noted on the publishers' website. This book is soundly fact-checked.

What else to say? As a student who plans to make the most of their education (only one shot at it, haha), I couldn't be happier.

C Primer Plus is an oddly written book. It treats its readers as absolute, or extremely novice programmers, yet if you try to read through the book from cover to cover, you could easily be overwhelmed over the amount of content. I wouldn't recommend the book ALONE as a sole source for a newcomer to C, there are better books that make the learning experience less overwhelming.

With that said, I still highly recommend keeping this book on your shelf as a reference point and/or to use as a different view into a concept. It doesn't cover all of C and the standard libraries, but it covers the most important points and functions. The explanations tend to be more detailed and better than free resources such as sites like [...].

My main gripe, as with most programming books, are with the code examples. The author sacrifices readability of the code (nesting function calls within an already lengthy scanf() statement, for example) for shorter code length. I'm sure this was done for logistic reasons, but I fear many newcomers will copycat the style of coding, a bad habit that'll be hard to break in the future. However, the code examples are very clear and concise.

Over the years, as I've flirted with the idea of really sitting down to learn C, I've looked at a variety of intro-to-C type books; I've even bought a couple - only to set them aside to collect dust. This book (C Primer Plus, 5th ed.) is, frankly, one of the best intro books I've seen. I've read the first 13 chapters thus far and have been very pleased with the content. Topics are presented logically, explained well, and include numerous sample programs in the text body to reinforce newly introduced ideas. If you take the time to walk through the sample programs, look at the review questions, and work on the end-chapter programming exercises, you'll be in good shape. This book is worth every bit of the purchase price; it will stay in my personal library for years to come and I will highly recommend it to friends and colleagues looking to learn core C programming skills.

Note: I do have basic programming skills in other languages, but I think this book would be fine for any "true" novice as long as they gave themselves time and diligently worked through the exercises.

I am a beginner in C and this book helped me a lot to understand basic (and less basic...) C stuffs.
With funny examples, humor, it is a book to have if you want to evolve in programming languages.