This book is a useful overview of what pointers are, how they work, and how they should be managed for security and effectiveness. It is great to have a recent book devoted entirely to pointers. Many books on C either scant the topic, or deal with woefully out of date C standards. Reese takes into account the current C11 standard, which alone makes it very welcome.
The book, however, has several flaws. A lot of the material deals with nonstandard libraries. For example, the section on pointers and threads mentions C11 support for threads, but then discusses the POSIX standard rather than going into any details about the C standard. I found this and other references to extensions outside the C standard annoying; a book about C should focus on portable code.
Also, the book is not well organized. Throughout the book there are "forward references" saying that the topic being mentioned will be discussed elsewhere later. This leads to a lot of back-and-forth flipping of pages. For example, pointer arithmetic is explained in Chapter 1, but is used only in Chapter 4; a particular data structure is minimally introduced on page 133, then actually used sixty pages later. The way information is presented and explained could have been more systematic.
The biggest flaw is that some of the code is nonstandard and frankly, quite ugly. For instance:
(1) a function on page 89 uses pointers to memory that has already been deallocated, which is undefined behavior. The same function has redundant variables "length" and "currentPosition" -- one of the two would have been sufficient to accomplish the task.
(2) Elsewhere, Reese defines a linked list header structure with pointers to the head node, the tail node, and the current node. This structure is used at several later points in the book, but the reason for including a pointer to the current node is never made clear; none of the code in the book ever uses it, and indeed, it's difficult to see why it would be useful.
(3) While Reese explains the difference between the value 0 and the NUL character, in several places his code elides the difference, using the former where the latter would be more strictly appropriate (e.g., page 131 has `while (*string != 0)` when `while (*string != '\0')` or preferably `while (*string)` would be better style.
(4) Throughout, the book provides examples of infinite loops with break statements instead of using good structured style and having the break condition be the loop conditional.
(5) Surprisingly for a book that mentions the C99 and C11 standards often, there are a lot of references to using Microsoft Visual C++ as a compiler. Microsoft does not, and by all accounts never will, support C standards past C89. It is a C++ compiler, not a current C compiler. It mandates practices that are not C like in their philosophy, and Reese's code succumbs. For instance, he explicitly casts the return values from malloc and realloc to pointers of the appropriate type, which is not considered good C style. Good C code should be written in compliance to the C standard, not in conformance with the requirements imposed by a compiler geared to a different language.
The chronically problematic sample code is a serious shortcoming, and would be quite misleading for relatively new programmers. But then, the book is more a review of programming techniques using pointers than an introduction to them. It is geared more towards intermediate or experienced programmers than towards novices. For someone who has enough experience to be able to refactor the code properly, the book is a very useful review.