Tuesday, November 20, 2012

C Pointers Explained, Really

While I was in college, a friend of mine complained that he was confused while programming in C, struggling to learn the syntax for pointers.

He gave the example of something like: *x=**p++ being ugly and unreadable, with too many operations layered on each other, making it hard to tell what was happening.  He said he had done a bit of programming with assembly language, but he wasn't accustomed to the nuances of C.

I wrote the following explanation on our student message board, and I got a lot of good feedback.  Some people said that they had been programming in C for years, but not until they read my post did they finally understand pointers.  So here it is, unearthed from my backups and slightly edited.  I hope it helps someone again...

Message 1956 (8 left): Thu Jan 25 1990  2:44am
From: Bill! (easterb@ucscb)
Subject: Okay

Well, if you know assembly, you have a head start
on many of the cis freshpersons here.  You at least know
about memory maps:  RAM is a long long array of bytes.
It helped me to learn about pointers if I kept this in mind.
For some reason, books and instructors talking about
pointers want to overlook this.

When I have some code:

int n;
int *p;

There is a place in my memory that looks like this:

Address:   :
  0x5100|     |   n is an integer, one machine word big
  0x5104|     |   p is a pointer, also one word big
  0x5108|     |   other unused memory

Let's give these variables some values.
I set n to be the number 151.

        n = 151;

I set the pointer p to point to the integer n.

        p = &n;

That says, "the value of the variable p is assigned the
address of the variable n".

Address:     :     Value at that address:
  0x5100  | 151|  n
  0x5104  |5100|  p
  0x5108  |   ?|

Now I want to print out the value of n, by two ways.

        printf("n is %d.\n", n);
        printf("n is %d.\n", *p);

The * operator says, "give me the object at the following address."
The object's type is the type that the pointer was declared as.
So, since we declared "int *p", the object pointed at will be
_assumed_ by C to be an int.  In this case, we were careful to
make this coincide with what we were pointing at.

Now I want to print out the memory address of n.

        printf("n is located at $%x.\n", &n);
        printf("n is located at $%x.\n", p);

The & operator says, "tell me the address where the following object
starts."  In this case, it is hex 5100 (I put a '$' before it, to
conform to the Assembly notation I am used to).
Notice the _value_ of p is an address.

Hm.  Does p have an address?  Sure.  It is a variable, and all
variables have their own address.  The address of p is hex 5104.

        printf("p is located at $%x.\n", &p);

Here we are taking the address of a pointer variable, 
using the & operator.

char name[] = "Bill";
char *p;
int *q;

Now we have an array to play with.  Here's how memory looks now:

 0x5100 |'B'|  "name" is an address constant that has value hex 5100
 0x5101 |'i'|  char: 1 byte
 0x5102 |'l'|  char: 1 byte
 0x5103 |'l'|  char: 1 byte
 0x5104 |\0 |  char: 1 byte
 0x5105 |   |  p is a pointer: 1 word
 0x5109 |   |  q is a pointer: 1 word

        p = name;

We set p to the value of name.  Now p has value hex 5100 too.
We can use the * dereferencing operator on p, and get the
character 'B' as a result.

Now what happens if I do this:


The pointer p is incremented.  What value does it have now?
Hex 5101.  Pretty simple.

Now let's try something irresponsible:

        q = name;

But q is a pointer to int!  If we dereference q, it will take
the word (typically 4 bytes) beginning at address "name" (which
is hex 5100) and try to convert it to an int.  'B', 'i', 'l', 'l'
converted to an int will be some large number, dependant on the
bit-ordering algorithm on your machine's architecture.  On ucscb,
it becomes 1114205292.  (to see how, line up the binary representation
of the ascii values for those 4 characters, and then run the 32 bits
together, and convert that resultant binary number as an integer.)

What we have just seen here is a key issue of pointers that I
mentioned earlier:  C assumes that what they are pointing at
is an object of the type that the pointer was designed to point at.
It is up to the programmer to make sure this happens correctly.


The int pointer is incremented.  What value does it have now?
Hex 5104.  Huh?!?  The answer is simple if you accept the above
paragraph.  It gets incremented by the size of the object it
_thinks_ it is pointing at.  It's an int pointer, so incrementing
it makes it advance a number of bytes equal to the size of an int.

Now print the dereferenced value of q (i.e. the value of the object
q is pointing to).  Well, it's pointing at a null byte, and then
the first 3 bytes of the char *p.  Now we're all messed up.
Nice going.  Try to convert _that_ to an integer representation.
Well actually, C will do it happily.  But it'll be another weird 

int n;

        n = 151;

int x;
        printf("%d.\n", x);

Here is a simple program that passes an int "by value".
That is, it copies the value of n into the new variable x!

 0x5100 |151|  n is an integer
 0x5104 |151|  x is another integer

When we mention x, we are using the value at location 5104,
and we can change it, read it, whatever, and it won't affect n,
the int at location 5100.

But what if we want to have f() modify the value and then
have that new value be available in main()?  C does this by
passing the variable "by reference".

int n;

        n = 151;

int *x;
        printf("%d.\n", *x);
        *x = 451;

Pass the _address_ of n, and declare x as a _pointer_ to int.
Actually, this is still passing by value, but the value being
passed is the address, not the number.

 0x5100 | 151|  n is an integer
 0x5104 |5100|  x is a pointer to int

Now if f() when we make use of *x, we are referring to the
value at location 5100.  This is the location of n.
After the assignment "*x = 451;", this is what we have:

 0x5100 | 451|  n is an integer
 0x5104 |5100|  x is a pointer to int

x still points to location 5100, but we have changed the value
of the object at that location.

Well, those are the basics.
You mentioned things like "*x=**p++" being ugly and unreadable.
Well, yeah, but here is a diagram that may help:

        |----|  here is a word in memory with initial value 0. 
 0x5100 |   0|  no variable name
 0x5104 |  12|  here is a value, a word in memory.  no variable name.
 0x5108 |5104|  Here is an int pointer, pointing at the previous word.
 0x511c |5108|  here is p, a pointer to int pointer.
 0x5120 |5100|  here is x, a pointer.  guess where it's pointing.

First let's see what p and x were declared as:
int *x;    /* pointer to int */
int **p;   /* pointer to pointer.  
              The subordinate pointer is a pointer to int.*/

You should know now what "*x" means.  It means, "the value of location 5100."
And you know what "*p" means, "the value of location 5108".
Now that value is another address!  Okay, let's dereference that
address: "**p" and we find (by the declaration) an int.

Now "*x = **p" looks like, "this int at 5100 gets the value of
that int at 5104."

And what does "**p++" mean?  Well, ++ binds tighter than *, so this
is equivalent to:  *( *( p++ ) )
Or, "pointer to pointer to int, and by the way, after we're done,
p has been incremented.  But we looked where it was pointing
before it got incremented, so we don't care.  Let the next statement
worry about it."

This content is copyright 2012 by Bill Karwin.  I'll share it under the terms of the Creative Commons License, Attribution-NonCommercial-ShareAlike 3.0 Unported.


Bushinji said...

Great post!
I finally got it, thanks a bunch! :)

Marin Todinov said...

Dear Programming Guru,

You are an absolute legend, ive been programming for 4 years and i have a masters in computer science, your explanation of pointers has helped me increase my efficiency in recursive functions and made a map in my breain of how these basic fundamental structers.

Not only is your explanation clear, but it is exellant, Thank you So much for your sharing of this fundamental knowledge, i will repay the favour some day and teach someone else like you have me, its the least i can do.

Thank you again,

Marin Todinov said...
This comment has been removed by the author.
quantumdude said...

You should use "%p" for printing pointers, not "%x", because this can cause problems where the size of an unsigned integer is less than the size of a pointer (i.e. 64-bit Intel PCs). Also, for complete portable, the pointers will need to be cast to void pointers (but this usually isn't a problem and can be ignored).

Gogus said...

Great explanation. I would add only a few words about pure arrays (passing arrays as function arguments).


i.love.it said...

i think you are wrong when u said:
"the first 3 bytes of the char *p"

p is a character type and only has 1 byte?

would q actually overlap its own bytes coming after p?

Bill Karwin said...

Hi i.love.it,

p is not a character, p is a pointer.

A pointer must be large enough to hold an address of memory. At the time I wrote this article, pointers were 4 bytes. Look at the addresses, p is stored in the 4 bytes starting at 0x5105, and q is stored in the 4 bytes starting at 0x5109.

So incrementing q did cause it to point to a space of 4 bytes starting at 0x5104, which includes the null at the end of the string, and part of the pointer p.

danmux said...

Great explanation. I would only add something about the variable names themselves don't actually exist when the program runs, that they are just handy readable tokens for the human, and the compiler maintains a symbol table to convert them to addresses. This has been a common source of confusion in my experience.

Chase S said...

Really, no one teaches it like this?

I figured this out many years ago, and have tried explaining it to many of my fellow students, perhaps I will just link them here from now on.

Good work!

Bill Karwin said...

@danmux, thanks, that's a good point. I originally wrote that post for someone who said he was already familiar with assembly programming, so I figured that point about identifiers not being real in the compiled code was understood.

@Chase S, thanks! You may even copy and distribute this post if you wish, under the license terms I mention at the end.

Gathogo said...

Very very well explained!!

Anthony Cesaro said...

First of all, thanks for the clear and concise explanation! I've been finding a lot of different attempts to better explain the concept and use of pointers and they all provide a good alternative to the way they are described in an academic context.

In your final diagram that explains how *x=**p++ works, shouldn't the last two addresses be 0x510c and 0x5110 instead of 0x511c and 0x5120? I guess it doesn't matter if those are just arbitrary addresses, but to be consistent with the addresses above it I would think you would just add 4 bytes to them since they are pointers (4 bytes at the time of you writing this article as mentioned).

I'm still learning this stuff on the side, as I am not a full-time programmer by trade (Unix systems engineer), but I'm trying to beef up my understanding of such lower level concepts to improve my troubleshooting and debugging abilities. Let me know if what I suggested as a correction isn't correct. :)

Bill Karwin said...

@Anthony Cesaro:

Yes, you're right, that's a mistake on my part. If the addresses were contiguous, the next one 4 bytes after 0x5108 would be 0x510c. Good catch.

But in practice, variables might not be allocated contiguously. They might be, but it's a detail handled by the operating system, and it might be implemented differently on another system. So you shouldn't assume variables are contiguous.

Chattrawit S. said...

OMG! Finally I found well-explained one. Thank you so much!

Rishikesh Fanse said...

nice one dude

akmal niazi khan said...

This blog awesome and i learn a lot about programming from here.The best thing about this blog is that you doing from beginning to experts level.

Love from

Priyansh Ramnani said...

Thanks a lot sir! :)
I had a great difficulty understanding pointers
This made my concept crystal clear!!

Prateek Pandey said...

Wow great one.

I found http://thecguru.com/pointer-basics-c/ helpful too.

Bill Karwin said...

Thanks for the link Prateek, that looks like a good article. It has nice illustrations too. My article suffers from the fact that I originally wrote it a long time ago in a text-only online community.

Prateek Pandey said...

Yes, Bill it is.

Consider mentioning it in your article

Michael Fulton said...

Thanks for this excellent read. I'm going to let the Qt API introduce me to cpp (which I know isn't "real" cpp). C and cpp remind me of Node JavaScript in the sense that it will let you shoot yourself in the foot if you don't make good choices. Pointers are something I haven't dealt with before and this made it crystal clear. Fwiw I appreciated original formatting. :)