Understanding and Using C Pointers and over 2 million other books are available for Amazon Kindle . Learn more
FREE Delivery in the UK.
Only 6 left in stock (more on the way).
Dispatched from and sold by Amazon.
Gift-wrap available.
Trade in your item
Get a £3.22
Gift Card.
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See all 2 images

Understanding and Using C Pointers Paperback – 18 May 2013

See all 2 formats and editions Hide other formats and editions
Amazon Price New from Used from
Kindle Edition
"Please retry"
"Please retry"
£12.85 £12.21

Trade In Promotion

Frequently Bought Together

Understanding and Using C Pointers + Mastering Algorithms with C + Expert C Programming
Price For All Three: £74.56

Buy the selected items together

Trade In this Item for up to £3.22
Trade in Understanding and Using C Pointers for an Amazon Gift Card of up to £3.22, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Learn more

Product details

More About the Authors

Discover books, learn about writers, and more.

Product Description

Book Description

Core techniques for memory management

About the Author

Richard Reese has worked in the industry and academics for the past 29 years. For 10 years he provided software development support at Lockheed and at one point developed a C based network application. He was a contract instructor providing software training to industry for 5 years. Richard is currently an Associate Professor at Tarleton State University in Stephenville Texas.

What Other Items Do Customers Buy After Viewing This Item?

Customer Reviews

There are no customer reviews yet on Amazon.co.uk.
5 star
4 star
3 star
2 star
1 star

Most Helpful Customer Reviews on Amazon.com (beta)

Amazon.com: 25 reviews
36 of 41 people found the following review helpful
Useful but flawed 31 July 2013
By Surajit A. Bose - Published on Amazon.com
Format: Paperback Verified Purchase
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.
8 of 8 people found the following review helpful
Great Pointer Resource 18 May 2013
By IADev - Published on Amazon.com
Format: Paperback
This book is ideal for the programmer who has only had a casual introduction to pointers. One example is that type size_t is explained and not just shown. Some of the tutorials I have seen use types like this in pointer discussions without giving the full explanation of what is going on. In my opinion, those looking to really understand programming are going to spend some time looking at memory models-and this work was a gentle introduction that was approachable on topics that included dynamic memory allocations. While it wasn't in depth, I also appreciated seeing a mention of the RAII technique and an approach in C. Some new programmers should also find the discussion about function pointers as eye-opening. The section titled "Using Pointers to Support Data Structures" was also full of good introduction material to seeing how pointers could be used to implement common data structures. New users to pointers will also likely be glad to see this book addresses good things as well as bad things to look out for in using pointers as well as examples of the why.

Overall conclusion: Would be a great resource for those looking to dig further into C and trying to master pointers.

Disclaimer: I got a copy of this book for review as part of O'Reilly blogger program.
2 of 2 people found the following review helpful
Good Book on Pointers 4 Nov. 2013
By Andy - Published on Amazon.com
Format: Paperback
There have been many books written about the C Programming language. But this one is different. Why? Because this book focuses on pointers to convey a deeper understanding on C. It covers important memory management technology involving the stack and the heap along with the use of pointers in this context. It helps you to understand pointers and shows you how they work and how they should be managed.

Reese assumes that the reader has a minimal understanding of C.
The audience are developers that are learning C or experienced C or C++ programmers. For C# or Java developers this book should help to better understand C and get an insight into how object-oriented languages deal with the stack and the heap.

IMHO the reader need a bit more than a minimal understanding of C. The book shows only code snippets (which will make it more difficult for novice programmers). So the reader need to know how to write a complete program in C and how to compile it.
Further the reader need some understanding of common data structures like linked lists. If you are a C# or Java developer and don't have any C background this book won't be of much use for you.

The Book uses a lot of references to later chapters (forward references), which makes it sometimes difficult to read.

What I really liked on this book is the representation of the memory (as small boxes) along with the source code. It visually shows the reader what is happening in memory.

This book really helped me to get a better understanding of Pointers and memory management.
9 of 12 people found the following review helpful
Fantastic, Must Have for the C programmer 14 May 2013
By Amit Saha - Published on Amazon.com
Format: Kindle Edition
I received a review copy of the book as part of the blogger review program.


As the title implies, in the book "Understanding and Using C Pointers", the author discusses pointers in C. It discusses various aspects of pointers and their application in dynamic memory allocation (and implementing linked lists, dynamic arrays, etc.), their usage in the form of function pointers, structure pointers and various other related concepts. The treatment of the topics have a nice flow. The author gently begins by introducing the concepts of a stack and a heap in the context of the runtime memory layout of a executing program and then proceeds to discuss memory allocation, before discussing the topics mentioned earlier. The book's contents describe an area of C which can be scary and confusing sometimes, but need not necessarily be so - which is what the book aims to demonstrate.


The book is absolutely fantastic and if you have anything to do with C or simply wanted to read an entire book on pointers, this is it. You will learn a number of new things, and suddenly a number of pointer mysteries will be demystified.


A must have for your collection if you would love to learn more about pointers in C or simply understand them better.
2 of 2 people found the following review helpful
Understanding & Using C Pointers 2 Jun. 2013
By Mat - Published on Amazon.com
Format: Kindle Edition
Pointers and memory management are probably the two most intimidating factors about C. Where was this book when I was in college?

Understanding and Using C Pointers is probably the best book i've read on pointers and memory management. The author does an excellent job explaining the subject matter and providing clear, concise examples along with the text.

Another reason I picked this book up is it's content to secure coding--which serves to purposes: one to ensure the code I write is secure, an two, to help me find code in my environment that isn't.

If you're still intimidated by pointers and managing memory, you need this book.
Were these reviews helpful? Let us know

Look for similar items by category