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.<\/p>\n
He gave the example of something like: *x=**p++<\/tt> being ugly and unreadable, with too many operations layered on each other, making it hard to tell what was happening. \u00a0He said he had done a bit of programming with assembly language, but he wasn’t accustomed to the nuances of C.<\/p>\n
I wrote the following explanation on our student message board, and I got a lot of good feedback. \u00a0Some people said that they had been programming in C for years, but not until they read my post did they finally understand pointers. \u00a0So here it is, unearthed from my backups and slightly edited. \u00a0I hope it helps someone again…<\/p>\n
Message 1956 (8 left): Thu Jan 25 1990 2:44am
\nFrom: Bill! (easterb@ucscb)
\nSubject: Okay<\/p>\n
Well, if you know assembly, you have a head start\u00a0on many of the CS freshpersons here. You at least know\u00a0about memory maps: RAM is a long long array of bytes.\u00a0It helped me to learn about pointers if I kept this in mind.\u00a0For some reason, books and instructors talking about\u00a0pointers want to overlook this.<\/p>\n
When I have some code:<\/p>\n
main()\n{\n int n;\n int *p;<\/pre>\nThere is a place in my memory that looks like this:<\/p>\n
:\nAddress: :\n |-----|\n0x5100 | | n is an integer, one machine word big\n |-----|\n0x5104 | | p is a pointer, also one word big\n |-----|\n0x5108 | | other unused memory\n |-----|\n :\n :<\/pre>\nLet’s give these variables some values.\u00a0I set n to be the number 151.<\/p>\n
n = 151;<\/pre>\nI set the pointer p to point to the integer n.<\/p>\n
p = &n;<\/pre>\nThat says, “the value of the variable p is assigned the\u00a0address of the variable n”.<\/p>\n
:\nAddress: : Value at that address:\n |----|\n0x5100 | 151| n\n |----|\n0x5104 |5100| p\n |----|\n0x5108 | ? |\n |----|\n :\n :<\/pre>\nNow I want to print out the value of n, by two ways.<\/p>\n
printf(\"n is %d.n\", n);\nprintf(\"n is %d.n\", *p);<\/pre>\nThe * operator says, “give me the object at the following address.”\u00a0The object’s type is the type that the pointer was declared as.\u00a0So, since we declared “int *p”, the object pointed at will be\u00a0_assumed_ by C to be an int. In this case, we were careful to\u00a0make this coincide with what we were pointing at.<\/p>\n
Now I want to print out the memory address of n.<\/p>\n
printf(\"n is located at $%x.n\", &n);\nprintf(\"n is located at $%x.n\", p);<\/pre>\nThe & operator says, “tell me the address where the following object\u00a0starts.” In this case, it is hex 5100 (I put a ‘$’\u00a0before it, to\u00a0conform to the Assembly notation I am used to).\u00a0Notice the _value_ of p is an address.<\/p>\n
Hm. Does p have an address? Sure. It is a variable, and all\u00a0variables have their own address. The address of p is hex 5104.<\/p>\n
printf(\"p is located at $%x.n\", &p);<\/pre>\nHere we are taking the address of a pointer variable,\u00a0using the & operator.<\/p>\n
main()\n{\nchar name[] = \"Bill\";\nchar *p;\nint *q;<\/pre>\nNow we have an array to play with. Here’s how memory looks now:<\/p>\n
|---|\n0x5100 |'B'| \"name\" is an address constant that has value hex 5100\n |---|\n0x5101 |'i'| char: 1 byte\n |---|\n0x5102 |'l'| char: 1 byte\n |---|\n0x5103 |'l'| char: 1 byte\n |---|\n0x5104 | | char: 1 byte\n |---|\n0x5105 | | p is a pointer: 1 word\n |---|\n0x5109 | | q is a pointer: 1 word\n |---|<\/pre>\np = name;<\/pre>\nWe set p to the value of name. Now p has value hex 5100 too.\u00a0We can use the * dereferencing operator on p, and get the\u00a0character ‘B’ as a result.<\/p>\n
Now what happens if I do this:<\/p>\n
++p;<\/pre>\nThe pointer p is incremented. What value does it have now?\u00a0Hex 5101. Pretty simple.<\/p>\n
Now let’s try something irresponsible:<\/p>\n
q = name;<\/pre>\nBut q is a pointer to int! If we dereference q, it will take\u00a0the word (typically 4 bytes) beginning at address “name” (which\u00a0is hex 5100) and try to convert it to an int. ‘B’, ‘i’, ‘l’, ‘l’\u00a0converted to an int will be some large number, dependant on the\u00a0bit-ordering algorithm on your machine’s architecture. On ucscb,\u00a0it becomes 1114205292. (to see how, line up the binary representation\u00a0of the ascii values for those 4 characters, and then run the 32 bits\u00a0together, and convert that resultant binary number as an integer.)<\/p>\n
What we have just seen here is a key issue of pointers that I\u00a0mentioned earlier: C assumes that what they are pointing at\u00a0is an object of the type that the pointer was designed to point at.\u00a0It is up to the programmer to make sure this happens correctly.<\/p>\n
++q;<\/pre>\nThe int pointer is incremented. What value does it have now?\u00a0Hex 5104. Huh?!? The answer is simple if you accept the above\u00a0paragraph. It gets incremented by the size of the object it\u00a0_thinks_ it is pointing at. It’s an int pointer, so incrementing\u00a0it makes it advance a number of bytes equal to the size of an int.<\/p>\n
Now print the dereferenced value of q (i.e. the value of the object\u00a0q is pointing to). Well, it’s pointing at a null byte, and then\u00a0the first 3 bytes of the char *p. Now we’re all messed up.\u00a0Nice going. Try to convert _that_ to an integer representation.\u00a0Well actually, C will do it happily. But it’ll be another weird\u00a0number.<\/p>\n
main()\n{\n int n;\n\n n = 151;\n f(n);\n}\n\nf(x)\nint x;\n{\n printf(\"%d.n\", x);\n}<\/pre>\nHere is a simple program that passes an int “by value”.\u00a0That is, it copies the value of n into the new variable x!<\/p>\n
|---|\n0x5100 |151| n is an integer\n |---|\n0x5104 |151| x is another integer\n |---|<\/pre>\nWhen we mention x, we are using the value at location 5104,\u00a0and we can change it, read it, whatever, and it won’t affect n,\u00a0the int at location 5100.<\/p>\n
But what if we want to have f() modify the value and then\u00a0have that new value be available in main()? C does this by\u00a0passing the variable “by reference”.<\/p>\n
main()\n{\nint n;\n\n n = 151;\n f(&n);\n}\n\nf(x)\nint *x;\n{\n printf(\"%d.n\", *x);\n *x = 451;\n}<\/pre>\nPass the _address_ of n, and declare x as a _pointer_ to int.\u00a0Actually, this is still passing by value, but the value being\u00a0passed is the address, not the number.<\/p>\n
|----|\n0x5100 | 151| n is an integer\n |----|\n0x5104 |5100| x is a pointer to int\n |----|<\/pre>\nNow if f() when we make use of *x, we are referring to the\u00a0value at location 5100. This is the location of n.\u00a0After the assignment “*x = 451;”, this is what we have:<\/p>\n
|----|\n0x5100 | 451| n is an integer\n |----|\n0x5104 |5100| x is a pointer to int\n |----|<\/pre>\nx still points to location 5100, but we have changed the value\u00a0of the object at that location.<\/p>\n
Well, those are the basics.\u00a0You mentioned things like “*x=**p++” being ugly and unreadable.\u00a0Well, yeah, but here is a diagram that may help:<\/p>\n
|----| here is a word in memory with initial value 0. \n0x5100 | 0 | no variable name<\/pre>\n |----|\n0x5104 | 12 | here is a value, a word in memory. no variable name.\n |----|\n0x5108 |5104| Here is an int pointer, pointing at the previous word.\n |----|\n0x511c |5108| here is p, a pointer to int pointer.\n |----|\n0x5120 |5100| here is x, a pointer. guess where it's pointing.\n |----|<\/pre>\nFirst let’s see what p and x were declared as:<\/p>\n
int *x; \/* pointer to int *\/\nint **p; \/* pointer to pointer.<\/pre>\nThe subordinate pointer is a pointer to int.*\/<\/p>\n
You should know now what “*x” means. It means, “the value of location 5100.”<\/p>\n
And you know what “*p” means, “the value of location 5108”.\u00a0Now that value is another address! Okay, let’s dereference that\u00a0address: “**p” and we find (by the declaration) an int.<\/p>\n
Now “*x = **p” looks like, “this int at 5100 gets the value of\u00a0that int at 5104.”<\/p>\n
And what does “**p++” mean? Well, ++ binds tighter than *, so this\u00a0is equivalent to: *( *( p++ ) )<\/p>\n
Or, “pointer to pointer to int, and by the way, after we’re done,\u00a0p has been incremented. But we looked where it was pointing\u00a0before it got incremented, so we don’t care. Let the next statement\u00a0worry about it.”<\/p>\n
\nThis content is copyright 2012 by Bill Karwin. \u00a0I’ll share it under the terms of the Creative Commons License, Attribution-NonCommercial-ShareAlike 3.0 Unported.<\/span><\/p>\n