Customer Reviews

C Primer Plus (4th Edition)

5 star:		(21)
4 star:		(7)
3 star:		(0)
2 star:		(1)
1 star:		(0)

 

 

This book gives a fairly comprehensive overview of the most popular programming language ever employed. The C language still dominates the programming scene, even though at times it appears to be dying out. Compilers, embedded systems, scientific programming, and myriads of other applications use C extensively.

After a brief historical background and a discussion on how to compile programs in C, the author discusses the basic data types and character strings in C. The author emphasizes the lean nature of the C language, and gives an elementary discussion on debugging in C. A good discussion is given on integer and floating-point underflow and overflow and also the mechanics of argument passing via the stack.

The author then discusses the operators and control statements in C. He includes a discussion of Lvalues and Rvalues, and this is helpful since many books on C gloss over this. Good examples of the ability of C to do multiple assignment are given. Side effects, which are modifications of data objects, and sequence points, which are points in program execution at which side effects are evaluated before proceeding to the next step in the program, are briefly discussed. An understanding of side effects is crucial to programming effectively in C. Type conversion, forbidden in some other languages, can be done in C, and the author gives a fairly good discussion of type conversion and the cast operator. Nine examples are given that effectively illustrate the different uses of "for" loops. Unfortunately, the author includes a discussion of the "goto" statement, but does admonish against its use.

The author then moves into more about input and output and how to use buffered versus unbuffered input. Some of the discussion on how to create user interfaces is antiquated given the current state of graphical tools to do this.

C functions are defined and their use encouraged as building blocks. A program ideally should be written as a collection of function calls, and the author is sympathetic with this approach. The importance of function prototyping is discussed, along with a detailed discussion of recursion. The &operator is covered in the context of function calls the modify a value in the calling function without using a return value. This peculiarity of C is a sticking point to mathematicians when they attempt to program in C. The author explains fairly effectively the reasons for doing this in C, giving examples of what can happen when one adheres to a practice of never producing side effects in function calls.

The most difficult feature of C for newcomers is the existence of pointer variables. These are first discussed in the context of function calls and then in terms of the creation and initialization of arrays. Pointer arithmetic, an anathema to some programmers is given a fine treatment, along with how pointers are used to manipulate character strings and string functions.

The file communication capability of C is given a lengthy treatment in the book via standard I/O functions. The ability of C to support both global and local variables is discussed, with the important concepts of file, block, and function prototype given detailed treatment. The volatile, const, and restrict keywords are discussed also.

Data structures, the tour de force of C programming, is discussed in great detail by the author. He shows how to create nested structures, and most importantly how to define and use pointers to structures. This is one of the most powerful features of C, and is responsible for its continued use in performance-intensive applications.

Readers interested in the more "low-level" features of C will appreciate the discussion on bit fiddling. Indeed in embedded systems and cryptography an understanding of this is crucial for designing effective programs.

The important technique of conditional compilation, using the ifdef, else, endif, and ifndef directives are discussed with many helpful examples. Memory allocation, with malloc(), free(), and calloc() functions is given ample treatment. Anyone who has done any type of debugging of C applications will realize the importance of a complete understanding of this topic. Memory leaks and dangling pointers can cause great distress in applications written in C. The author should have spent more time here on dynamic memory allocation in C.

Some discussion is given on the more advanced data structures in C, such as linked lists, abstract data types, and binary trees.

I have an eight year-old copy, and when getting back into C programming after a long layoff (don't ever take a promotion to project leader if you can't keep coding), I pulled this one off my shelf (skipping K&R's book, Herb Schildt's book, and three others in my library).

It got me right back into the mindset quickly (I started with the pointers chapter, where all the action is), and helped me get the rust knocked off quick. The examples are well-explained, small and easy to test, and the progression of the book is logical and sane. Buy it and you can wait a year before needing another book on C.

This is a great book. It has clear explainations and examples and it moves forward fairly evenly. Unlike many beginner's books, this book is thorough and does not dwell on topics or redundant examples. This book is for any beginner or intermediate programmer that wishes to build a serious C programming foundation.

Stephen Prata's "C Primer Plus, 4th Ed" (CPP4E) is an excellent book. I took a close look at the competition and even started reading O'Reilly's "Practical C Programming" before realizing CPP4E was the book for me. I had no C programming background, but had the knowledge of C-64 BASIC, Pascal, and other languages shared by many kids born in the 1970s. If you're looking for a well-conceived introduction to C, Prata's book is for you.

CPP4E impresses the reader on many levels. First, Prata's writing is exceptionally clear. He doesn't require you to dissect that one "key sentence" which encapsulates all the author has to say on a single topic. Prata defines all of his terms, uses them in examples, and reintroduces them when later new ideas require background presented earlier.

Second, CPP4E is a "teach yourself" manual. If you read the text, type in the examples, answer the review questions, and try at least some of the programming exercises, you will learn something. I typed many of the examples in the book by hand and also made use of the code supplied on the publisher's Web site. CPP4E should be used in classes as an introductory C book.

Third, it's evident a lot of thought and work went into publishing CPP4E. The index is thorough and applicable. The arrangement of topics makes sense. The diagrams are easy to decipher. The errata available on the publisher's Web site is comprehensive. I did find a few minor issues and submitted those to SAMS, which they acknowledged.

My only concern is the author's differentiation between "serious code" and "more relaxed programming." He says on p. 410 "in serious programming, you should use fgets() rather than gets(), but this book takes a more relaxed approach." Unfortunately, this relaxed approach is the reason why computers are constantly compromised. By now programmers should realize that users deploy their code in the most hostile of environments, and intruders will blow away anything that's not bullet proof. While Prata does show readers how to take more secure approaches, I'd like to see a security theme consistently applied throughout the fifth edition.

Overall, I strongly recommend CPP4E to anyone interested in an introduction to C. If you're looking for network programming, however, you won't find it here. Keep an eye on future reviews of mine for my picks on a socket programming guide. Keep in mind when reading this review that I'm a beginning C programmer. I'm not in a position to judge the author's style. However, I doubt many experienced programmers would read this entire book!

C Primer Plus by Stephen Prata is a well-paced book to learning C. It has examples of the concepts in every section, and he doesn't gloss over important topics that are key to further your learning such as pointers. I would like to give this book 5 stars, but it suffers from quite a few errors. Not just errors in the descriptions, but errors in explaining code and errors in the examples. They aren't critical errors, and makes for a little bit of fun finding the errors.

An example of errors in 4th edition:

While explaining two-dimensional arrays, here a a glaring error:
---
#define COLS 4
int sum2d(int ar[][COLS], int rows)
{
<code>
}

You can use it with any of the following function calls:

tot = sum2(array1, 5); // sum of a 5x4 array
tot = sum2(array2, 100); // sum of a 100x4 array
tot = sum2(array3, 2); // sum of a 5 x 2 array
---

The last example function call is incorrect, and he goes on in the next chapter explaining how the sum2d function would required to be changed to support more rows. There are 3-5 errors per chapter like this.

Solid 'B-'.

Wow! What an awesome book! First, let me tell you that I had tried many a time to learn C before, but until I read this book it wasn't "sinking in" (important things like pointers, the fact that functions copied their parameters and that's why scanf() uses the address, etc). Of course, the bits and pieces that I did pick up probably helped quite a bit (in fact, I'm sure they did).

This book basically teaches you the majority of C's syntax, only the most important library functions, and finally, a little bit about coding style (sprinkled throughout the text). It also does a VERY GOOD job of explaining binary, hex and octal numbers and binary operations like and, or, and xor (among others). Oh, and when I say syntax, I mean syntax; I'm not referring to library functions, which are so numerous that one should use either an online or hard-copy manual for them (although, as I say, the most important ones are, of course, covered). Make sure to look somewhere else for information on realloc(), and strdup() comes in handy if you're using the GCC compiler.

The only thing I might say is a tad lacking in this text is something that most introductory texts ("primers") don't talk all that much about. The very last chapter tries to explain linked lists, queues, and binary search trees. They do a good job of explaining them and of how ADTs work, etc., but I am still thinking I can get a better explanation. They did do a pretty good job for squeezing it into one chapter, though.But don't let that slight problem steer you away from this book! If you want to learn C, START WITH THIS BOOK!!

I just ordered another book called "Mastering Algorithms in C" (by Kyle Loudon) that I'm hoping will be a good "next step". It covers not only linked lists, queues, and binary search trees, but several other algorithms that are commonly used and seem to be handy. Before teaching you these algorithms, however, pointers, recursion and "algorithm basics" are covered. From reading the user reviews I've decided that's probably the way to go, but don't take my word for it; all I'm saying is that after this book, it's probably a good idea to find a book on algorithms as your "next step".

Happy reading! :-)

If you are familiar with programming basic concepts then you will have no problem in getting started in C with the help of this book. Author has done great job explaining C concepts with excellent examples. However this book does not cover data structure and algorithms in too much details. I would like to recommend "Introduction to Algorithms" by Thomas H.Cormen to learn Algorithms.

I am a Freshman in High School and I received this book a few weeks ago. To tell you the truth I haven't finished the book; I'm about half-way through but I just had to right a review on it.

The book shows a lot of good examples as it takes you through the different sections. Often times the book stops to tell about the concepts and throws in a diagram or example to make sure your still paying attention. The book often asks: How do you think this works? or what do you think function x does in this list of code? what's going on in this diagram/code? Sometimes these little questions help me to sit back and visualize the code instead of continuosly reading and trying to absorb a gob of information.

There are review questions and programming exercises at the end of each chapter. This definatly gives you the vibe of a classroom book; which it basically is. But, this book is very easily self-taught and there is no need for a teacher to teach you it, though a formal education is always the best way to go.

This book is definatly easy to understand. It is for the new users of C and experienced users alike. Don't be afraid to jump into this book if you don't know a scratch about C; after all, I did it!

It's been an excellent book so far and I would recommend it to others.

I am relatively new to the subject (Having purchased K & R's programming c, second edition prior to this--no success) and I have to admit, after only three days I'm already into chapter five and have a vast understanding of the language. What I like, personally, is that they go about explaining the code in a no-non-sense way, being that they relate the practice code to something you can remember (i.e. explaining code using everyday words, such as using days of the week for enum). The only problem I have with the book is that they like to repeat information over and over...I suppose it is a good teaching trick but after a while this becomes rather tiresome. Overall...I'd give it 4 stars.

This book is a great way to learn C. It doesn't baby the reader (I'd recommend having just a bit of programming background before reading it), it's easy to read, and it's very comprehensive. Once you're done with this book, you're just about ready to get into API programming. The book is organized very well, in that that Prata will gloss over a fact, giving you just enough knoweledge so as not to overwhelm you. Then, he'll return to the information later on, covering it in much deeper detail. This is a much better way to learn, since you have a varied skill set early on, instead of simply learning large amounts of information one topic at a time. It's also much easier to build on what you've learned since it's had the time to ferment in your mind. The book also has the best library reference out of any tutorial style book I've seen. The only problem is the repeated use of flawed functions, such as gets, scanf, strcpy and the like. He points out the flaws, but then completely ignores his own warnings! Of course, reading a more advanced book will cover in depth the flaws of these functions and discourage their use, but bad habits learned early on are hard to break. Overall, though, a great book! If I could, I'd give it a 4.5, but since I can't, I'll be generous and give it a 5. Also check out his C++ Primer Plus.