6950

30
+114  Q:

## What are the barriers to understanding pointers and what can be done to overcome them?

Why are pointers such a leading factor of confusion for many new, and even old, college level students in C or C++? Are there any tools or thought processes that helped you understand how pointers work at the variable, function, and beyond level?

What are some good practice things that can be done to bring somebody to the level of, "Ah-hah, I got it," without getting them bogged down in the overall concept? Basically, drill like scenarios.

+6  A:

Why are pointers such a leading factor of confusion for many new, and even old, college level students in the C/C++ language?

The concept of a placeholder for a value - variables - maps onto something we're taught in school - algebra. There isn't an existing parallel you can draw without understanding how memory is physically laid out within a computer, and no one thinks about this kind of thing until they're dealing with low level things - at the C/C++/byte communications level.

Are there any tools or thought processes that helped you understand how pointers work at the variable, function, and beyond level?

Addresses boxes. I remember when I was learning to program BASIC into microcomputers, there were these pretty books with games in them, and sometimes you had to poke values into particular addresses. They had a picture of a bunch of boxes, incrementally labelled with 0, 1, 2... and it was explained that only one small thing (a byte) could fit in these boxes, and there were a lot of them - some computers had as many as 65535! They were next to each other, and they all had an address.

What are some good practice things that can be done to bring somebody to the level of, "Ah-hah, I got it," without getting them bogged down in the overall concept? Basically, drill like scenarios.

For a drill? Make a struct:

``````struct {
char a;
char b;
char c;
char d;
} mystruct;
mystruct.a = 'r';
mystruct.b = 's';
mystruct.c = 't';
mystruct.d = 'u';

char* my_pointer;
my_pointer = &mystruct.b;
cout << 'Start: my_pointer = ' << *my_pointer << endl;
my_pointer++;
cout << 'After: my_pointer = ' << *my_pointer << endl;
my_pointer = &mystruct.a;
cout << 'Then: my_pointer = ' << *my_pointer << endl;
my_pointer = my_pointer + 3;
cout << 'End: my_pointer = ' << *my_pointer << endl;
``````

Same example as above, except in C:

``````// Same example as above, except in C:
struct {
char a;
char b;
char c;
char d;
} mystruct;

mystruct.a = 'r';
mystruct.b = 's';
mystruct.c = 't';
mystruct.d = 'u';

char* my_pointer;
my_pointer = &mystruct.b;

printf("Start: my_pointer = %c\n", *my_pointer);
my_pointer++;
printf("After: my_pointer = %c\n", *my_pointer);
my_pointer = &mystruct.a;
printf("Then: my_pointer = %c\n", *my_pointer);
my_pointer = my_pointer + 3;
printf("End: my_pointer = %c\n", *my_pointer);
``````

Perhaps that explains some of the basics through example?

+6  A:

I don't think pointers as a concept are particularly tricky - most students' mental models map to something like this and some quick box sketches can help.

The difficulty, at least that which I've experienced in the past and seen others deal with, is that the management of pointers in C/C++ can be unncessarily convoluted.

A:

I don't see what is so confusing about pointers. They point to a location in memory, that is it stores the memory address. In C/C++ you can specify the type the pointer points to. For example:

``int* my_int_pointer;``

Says that my_int_pointer contains the address to a location that contains an int.

The problem with pointers is that they point to a location in memory, so it is easy to trail off into some location you should not be in. As proof look at the numerous security holes in C/C++ applications from buffer overflow (incrementing the pointer past the allocated boundary).

+21  A:

The reason pointers seem to confuse so many people is that they mostly come with little or no background in computer architecture. Since many don't seem to have an idea of how computers (the machine) is actually implemented - working in C/C++ seems alien.

A drill is to ask them to implement a simple bytecode based virtual machine (in any language they chose, python works great for this) with an instruction set focussed on pointer operations (load, store, direct/indirect addressing). Then ask them to write simple programs for that instruction set.

Anything requiring slightly more than simple addition is going to involve pointers and they are sure to get it.

I agree. For example, I learned to program in assembly before C and knowing how registers work, learning pointers was easy. In fact, there wasn't much learning, it all came very natural.
Take a basic CPU, say something that runs lawnmowers or dish washers and implement it. Or a very very basic subset of ARM or MIPS. Both of those have a very simple ISA.
+1  A:

I think that the main reason that people have trouble with it is because it's generally not taught in an interesting and engaging manner. I'd like to see a lecturer get 10 volunteers from the crowd and give them a 1 meter ruler each, get them to stand around in a certain configuration and use the rulers to point at each other. Then show pointer arithmetic by moving people around (and where they point their rulers). It'd be a simple but effective (and above all memorable) way of showing the concepts without getting too bogged down in the mechanics.

Once you get to C and C++ it seems to get harder for some people. I'm not sure if this is because they are finally putting theory that they don't properly grasp into practice or because pointer manipulation is inherantly harder in those languages. I can't remember my own transition that well but I knew pointers in Pascal and then moved to C and got totally lost.

+234  A:

Pointers is a concept that for many can be confusing at first, in particular when it comes to copying pointer values around and still referencing the same memory block.

I've found that the best analogy is to consider the pointer as a piece of paper with a house address on it, and the memory block it references as the actual house. All sorts of operations can thus be easily explained.

I've added some Delphi code down below, and some comments where appropriate. I chose Delphi since my other main programming language, C#, does not exhibit things like memory leaks in the same way.

If you only wish to learn the high-level concept of pointers, then you should ignore the parts labelled "Memory layout" in the explanation below. They are intended to give examples of what memory could look like after operations, but they are more low-level in nature. However, in order to accurately explain how buffer overruns really work, it was important that I added these diagrams.

Disclaimer: For all intents and purposes, this explanation and the example memory layouts are vastly simplified. There's more overhead and a lot more details you would need to know if you need to deal with memory on a low-level basis. However, for the intents of explaining memory and pointers, it is accurate enough.

Let's assume the THouse class used below looks like this:

``````type
THouse = class
private
FName : array[0..9] of Char;
public
constructor Create(name: PChar);
end;
``````

When you initialize the house object, the name given to the constructor is copied into the private field FName. There is a reason it is defined as a fixed-size array.

In memory, there will be some overhead associated with the house allocation, I'll illustrate this below like this:

```---[ttttNNNNNNNNNN]---
^   ^
|   |
|   +- the FName array
|
```

The "tttt" area is overhead, there will typically be more of this for various types of runtimes and languages, like 8 or 12 bytes. It is imperative that whatever values are stored in this area never gets changed by anything other than the memory allocator or the core system routines, or you risk crashing the program.

Allocate memory

Get an entrepreneur to build your house, and give you the address to the house. In contrast to the real world, memory allocation cannot be told where to allocate, but will find a suitable spot with enough room, and report back the address to the allocated memory.

In other words, the entrepreneur will choose the spot.

``````THouse.Create('My house');
``````

Memory layout:

```---[ttttNNNNNNNNNN]---
1234My house
```

Keep a variable with the address

Write the address to your new house down on a piece of paper. This paper will serve as your reference to your house. Without this piece of paper, you're lost, and cannot find the house, unless you're already in it.

``````var
h: THouse;
begin
h := THouse.Create('My house');
...
``````

Memory layout:

```    h
v
---[ttttNNNNNNNNNN]---
1234My house
```

Copy pointer value

Just write the address on a new piece of paper. You now have two pieces of paper that will get you to the same house, not two separate houses. Any attempts to follow the address from one paper and rearrange the furniture at that house will make it seem that the other house has been modified in the same manner, unless you can explicitly detect that it's actually just one house.

Note This is usually the concept that I have the most problem explaining to people, two pointers does not mean two objects or memory blocks.

``````var
h1, h2: THouse;
begin
h1 := THouse.Create('My house');
h2 := h1; // copies the address, not the house
...
``````
```    h1
v
---[ttttNNNNNNNNNN]---
1234My house
^
h2
```

Freeing the memory

Demolish the house. You can then later on reuse the paper for a new address if you so wish, or clear it to forget the address to the house that no longer exists.

``````var
h: THouse;
begin
h := THouse.Create('My house');
...
h.Free;
h := nil;
``````

Here I first construct the house, and get hold of its address. Then I do something to the house (use it, the ... code, left as an exercise for the reader), and then I free it. Lastly I clear the address from my variable.

Memory layout:

```    h                        <--+
v                           +- before free
---[ttttNNNNNNNNNN]---          |
1234My house             <--+

h (now points nowhere)   <--+
+- after free
----------------------          | (note, memory might still
xx34My house             <--+  contain some data)
```

Dangling pointers

You tell your entrepreneur to destroy the house, but you forget to erase the address from your piece of paper. When later on you look at the piece of paper, you've forgotten that the house is no longer there, and goes to visit it, with failed results (see also the part about an invalid reference below).

``````var
h: THouse;
begin
h := THouse.Create('My house');
...
h.Free;
... // forgot to clear h here
h.OpenFrontDoor; // will most likely fail
``````

Using `h` after the call to `.Free` might work, but that is just pure luck. Most likely it will fail, at a customers place, in the middle of a critical operation.

```    h                        <--+
v                           +- before free
---[ttttNNNNNNNNNN]---          |
1234My house             <--+

h                        <--+
v                           +- after free
----------------------          |
xx34My house             <--+
```

As you can see, h still points to the remnants of the data in memory, but since it might not be complete, using it as before might fail.

Memory leak

You lose the piece of paper and cannot find the house. The house is still standing somewhere though, and when you later on want to construct a new house, you cannot reuse that spot.

``````var
h: THouse;
begin
h := THouse.Create('My house');
h := THouse.Create('My house'); // uh-oh, what happened to our first house?
...
h.Free;
h := nil;
``````

Here we overwrote the contents of the `h` variable with the address of a new house, but the old one is still standing... somewhere. After this code, there is no way to reach that house, and it will be left standing. In other words, the allocated memory will stay allocated until the application closes, at which point the operating system will tear it down.

Memory layout after first allocation:

```    h
v
---[ttttNNNNNNNNNN]---
1234My house
```

Memory layout after second allocation:

```                       h
v
---[ttttNNNNNNNNNN]---[ttttNNNNNNNNNN]
1234My house       5678My house
```

A more common way to get this method is just to forget to free something, instead of overwriting it as above. In Delphi terms, this will occur with the following method:

``````procedure OpenTheFrontDoorOfANewHouse;
var
h: THouse;
begin
h := THouse.Create('My house');
h.OpenFrontDoor;
// uh-oh, no .Free here, where does the address go?
end;
``````

After this method has executed, there's no place in our variables that the address to the house exists, but the house is still out there.

Memory layout:

```    h                        <--+
v                           +- before losing pointer
---[ttttNNNNNNNNNN]---          |
1234My house             <--+

h (now points nowhere)   <--+
+- after losing pointer
---[ttttNNNNNNNNNN]---          |
1234My house             <--+
```

As you can see, the old data is left intact in memory, and will not be reused by the memory allocator. The allocator keeps track of which areas of memory has been used, and will not reuse them unless you free it.

Freeing the memory but keeping a (now invalid) reference

Demolish the house, erase one of the pieces of paper but you also have another piece of paper with the old address on it, when you go to the address, you won't find a house, but you might find something that resembles the ruins of one.

Perhaps you will even find a house, but it is not the house you were originally given the address to, and thus any attempts to use it as though it belongs to you might fail horribly.

Sometimes you might even find that a neighbouring address has a rather big house set up on it that occupies three address (Main Street 1-3), and your address goes to the middle of the house. Any attempts to treat that part of the large 3-address house as a single small house might also fail horribly.

``````var
h1, h2: THouse;
begin
h1 := THouse.Create('My house');
h2 := h1; // copies the address, not the house
...
h1.Free;
h1 := nil;
h2.OpenFrontDoor; // uh-oh, what happened to our house?
``````

Here the house was torn down, through the reference in `h1`, and while `h1` was cleared as well, `h2` still has the old, out-of-date, address. Access to the house that is no longer standing might or might not work.

This is a variation of the dangling pointer above. See its memory layout.

Buffer overrun

You move more stuff into the house than you can possibly fit, spilling into the neighbours house or yard. When the owner of that neighbouring house later on comes home, he'll find all sorts of things he'll consider his own.

This is the reason I chose a fixed-size array. To set the stage, assume that the second house we allocate will, for some reason, be placed before the first one in memory. In other words, the second house will have a lower address than the first one. Also, they're allocated right next to each other.

Thus, this code:

``````var
h1, h2: THouse;
begin
h1 := THouse.Create('My house');
h2 := THouse.Create('My other house somewhere');
^-----------------------^
longer than 10 characters
0123456789 <-- 10 characters
``````

Memory layout after first allocation:

```                        h1
v
-----------------------[ttttNNNNNNNNNN]
5678My house
```

Memory layout after second allocation:

```    h2                  h1
v                   v
---[ttttNNNNNNNNNN]----[ttttNNNNNNNNNN]
1234My other house somewhereouse
^---+--^
|
+- overwritten
```

The part that will most often cause crash is when you overwrite important parts of the data you stored that really should not be randomly changed. For instance it might not be a problem that parts of the name of the h1-house was changed, in terms of crashing the program, but overwriting the overhead of the object will most likely crash when you try to use the broken object, as will overwriting links that is stored to other objects in the object.

When you follow an address on a piece of paper, you get to a house, and at that house there is another piece of paper with a new address on it, for the next house in the chain, and so on.

``````var
h1, h2: THouse;
begin
h1 := THouse.Create('Home');
h2 := THouse.Create('Cabin');
h1.NextHouse := h2;
``````

Here we create a link from our home house to our cabin. We can follow the chain until a house has no `NextHouse` reference, which means it's the last one. To visit all our houses, we could use the following code:

``````var
h1, h2: THouse;
h: THouse;
begin
h1 := THouse.Create('Home');
h2 := THouse.Create('Cabin');
h1.NextHouse := h2;
...
h := h1;
while h <> nil do
begin
h.LockAllDoors;
h.CloseAllWindows;
h := h.NextHouse;
end;
``````

Memory layout (added NextHouse as a link in the object, noted with the four LLLL's in the below diagram):

```    h1                      h2
v                       v
---[ttttNNNNNNNNNNLLLL]----[ttttNNNNNNNNNNLLLL]
1234Home       +        5678Cabin      +
|        ^              |
```

In basic terms, what is a memory address?

A memory address is in basic terms just a number. If you think of memory as a big array of bytes, the very first byte has the address 0, the next one the address 1 and so on upwards. This is simplified, but good enough.

So this memory layout:

```    h1                 h2
v                  v
---[ttttNNNNNNNNNN]---[ttttNNNNNNNNNN]
1234My house       5678My house
```

• h1 = 4
• h2 = 23

Which means that our linked list above might actuall look like this:

```    h1 (=4)                 h2 (=28)
v                       v
---[ttttNNNNNNNNNNLLLL]----[ttttNNNNNNNNNNLLLL]
1234Home      0028      5678Cabin     0000
|        ^              |
```

It is typical to store an address that "points nowhere" as a zero-address.

In basic terms, what is a pointer?

A pointer is just a variable holding a memory address. You can typically ask the programming language to give you its number, but most programming languages and runtimes tries to hide the fact that there is a number beneath, just because the number itself does not really hold any meaning to you. It is best to think of a pointer as a black box, ie. you don't really know or care about how it is actually implemented, just as long as it works.

Fantastic explanation. I already had a basic understanding on pointers, but this really brings it home. Thanks!
The buffer overrun is hilarious. "Neighbor comes home, cracks his skull open slipping on your junk, and sues you into oblivion."
This is a nice explanation of the concept, sure. The concept is NOT the thing that I find confusing about pointers though, so this whole essay was a bit wasted.
On you, perhaps yes, on the 87 people that has voted it up, perhaps not.
But just to have asked, what do *you* find confusing about pointers?
Under "Freeing the memory", wouldn't you only "erase the address from your paper" after *also* setting your pointer to null? Otherwise, you're still pointing to memory location of deallocated memory (dangling pointer)
No, the contents of the paper is the pointer value, so when you erase it, you set it to null, but I didn't go into that level of detail in this post.
wish I can upvote it twice !
I've revisited this post several times since you wrote the answer. Your clarification with code is excellent, and I appreciate you revisiting it to add/refine more thoughts. Bravo Lasse!
+1 very nice. I used for a long time the similar analogy to explain messaging, services and queues (service name => the address on envelope, queue => the mailbox in front of house etc) so the address on paper/house resonated a chord with me :)
+1 excellent explanation, always a great idea to map programming concepts to real life situations, makes it easier to understand.
Very nice answer. Just one comment for "Allocate memory". Some alloc methods such as VirtualAlloc on Win32 does allow you to specify the address of the allocation, but its not the common case to do so.
+1 Great job on this analogy
These are really good analogies. Many thanks for posting.
This is a wonderful explanation. It is a shame that so many college and university professors are incapable of explaining things clearly. Must be the autism. There are no complicated concepts, just bad explanations.
Added diagrams of how memory *could* look after allocation, freeing, etc. with proper explanations. This also allowed me to illustrate the effects of buffer overruns and to give a proper (simplified) explanation of what a pointer really is at the end. Also fixed some typos. This also brought the answer into wiki-mode, which is just as well, at this point it isn't meant to be a rep-farm.
@Lasse +1 I wish I could upvote more. This is the best/most-detailed answer I have seen on SO so far. It turns out that I know more about pointers than I thought I did because they act the same as references in C# (except C# does garbage collection and the compiler won't let you overflow fixed-size arrays).
@Lasse Two things: First, are the pointers stored on the stack and therefore disposed when they fall out of scope and; Two, would it be worth it to add an example of cloning in your answer. I'm not sure how it's done in C but it's a pretty common question that a lot of primarily C# developers (including me) struggle to grasp when they start learning the intricacies of references.
Cloning is a difficult subject, and I am loath to change this answer into also covering references in a managed garbage-collected environment. Perhaps it would be best served with a separate answer or even question? I'm open to suggestions however (also, anyone with enough rep is free to edit the answer as well.)
@Lasse Please forgive my ignorance of C. I meant it in a C context not a C# GCed environment. How would you 'clone' an object in C (IE, create a new object copy of the data)? Ex. H2 = H1 where H2 is a completely new object with contents identical to H1, not just a reference pointing to H1.
If h1 and h2 are pointers, `memcpy( h2, h1, sizeof(struct house) )` http://opengroup.org/onlinepubs/007908799/xsh/memcpy.html
+3  A:

A tutorial with a good set of diagrams helps greatly with the understanding of pointers.

Such as this one: Pointers in C and C++ Tutorial

Joel Spolsky makes some good points about understanding pointers in his Guerrilla Guide to Interviewing article, excerpt:

"For some reason most people seem to be born without the part of the brain that understands pointers. This is an aptitude thing, not a skill thing – it requires a complex form of doubly-indirected thinking that some people just can't do."

A:

@Lassevk: Buddy, I had my "ah-ha moment" years ago, but only now I got a really really really good, simple and amazing metaphorical example! All other examples I've ever seen were crappy (even those created by me, a guy considered by friends as a great teacher).

I'll surely save this one for future reference! Thank you, man.

+51  A:

In my first Comp Sci class, we did the following exercise. Granted, this was a lecture hall with roughly 200 students in it...

Professor writes on the board: "int john;"

John stands up

Professor writes: "int *sally = &john;"

Sally stands up, points at john

Professor: "int *bill = sally;"

Bill stands up, points at John

Professor: "*bill = sam;"

John sits down. Sam stands up. Bill & Sally both point to Sam.

I think you get the idea. I think we spent about an hour doing this, until we went over the basics of pointer assignment.

good exercise ... too bad you got it wrong ! sally is still pointing at john after your sequence.
I don't think I got it wrong. My intention was to change the value of the pointed-to variable from John to Sam. It's a little harder to represent with people, because it looks like you're changing the value of both pointers.
This would be good example if Sam went and sat in John's seat.
You are still wrong!: at the end bill is a separate variable pointing at sam, while sally, another variable, is unchanged and still pointing at john. Hoo boy! Who was your professor again?
slahmais: no, you're wrong. Neither of the pointers were changed. john was replaced with sam, and the pointers, unchanged, now point at sam, who is now at the address that john was once in. Wow, pointers are easy, what kind of doofus would find this crap confusing?
But the reason it's confusing though is that it's not like john got up from his seat and then sam sat down, as we might imagine. It's more like sam came over and stuck his hand into john and cloned the sam programming into john's body, like hugo weaving in matrix reloaded.
More like Sam takes John's seat, and John floats around the room until he bumps into something critical and causes a segfault.
Why would John float, he's an int!
A:

I have read a few tutorials on pointers, but by far the best one I have read is this one: http://computer.howstuffworks.com/c20.htm. It is part of the "How C Programming Works" article. Worth spending 15 mins reading.

nice link, didnt think to check that site. Great explanations.
+3  A:

The complexities of pointers go beyond what we can easily teach. Having students point to each other and using pieces of paper with house addresses are both great learning tools. They do a great job of introducing the basic concepts. Indeed, learning the basic concepts is vital to successfully using pointers. However, in production code, it's common to get into much more complex scenarios than these simple demonstrations can encapsulate.

I've been involved with systems where we had structures pointing to other structures pointing to other structures. Some of those structures also contained embedded structures (rather than pointers to additional structures). This is where pointers get really confusing. If you've got multiple levels of indirection, and you start ending up with code like this:

``````widget->wazzle.fizzle = fazzle.foozle->wazzle;
``````

it can get confusing really quickly (imagine a lot more lines, and potentially more levels). Throw in arrays of pointers, and node to node pointers (trees, linked lists) and it gets worse still. I've seen some really good developers get lost once they started working on such systems, even developers who understood the basics really well.

Complex structures of pointers don't necessarily indicate poor coding, either (though they can). Composition is a vital piece of good object-oriented programming, and in languages with raw pointers, it will inevitably lead to multi-layered indirection. Further, systems often need to use third-party libraries with structures which don't match each other in style or technique. In situations like that, complexity is naturally going to arise (though certainly, we should fight it as much as possible).

I think the best thing colleges can do to help students learn pointers is to to use good demonstrations, combined with projects that require pointer use. One difficult project will do more for pointer understanding than a thousand demonstrations. Demonstrations can get you a shallow understanding, but to deeply grasp pointers, you have to really use them.

+1  A:

I don't think that pointers themselves are confusing. Most people can understand the concept. Now how many pointers can you think about or how many levels of indirection are you comfortable with. It doesn't take too many to put people over the edge. The fact that they can be changed accidently by bugs in your program can also make them very difficult to debug when things go wrong in your code.

+5  A:

I found Ted Jensen's "Tutorial on Pointers and Arrays in C" an excellent resource for learning about pointers. It is divided into 10 lessons, beginning with an explanation of what pointers are (and what they're for) and finishing with function pointers. http://home.netcom.com/~tjensen/ptr/cpoint.htm

Moving on from there, Beej's Guide to Network Programming teaches the Unix sockets API, from which you can begin to do really fun things. http://beej.us/guide/bgnet/

I second Ted Jensen's tutorial. It breaks down pointers to a level of detail, that's not overly-detailed, no book I've read does. Extremely helpful! :)
A:

I wrote this post, and a followup (linked in the post) about exactly that:

http://svec.wordpress.com/2007/12/28/understanding-c-pointers-part-0/

A:

I like the house address analogy, but I've always thought of the address being to the mailbox itself. This way you can visualize the concept of dereferencing the pointer (opening the mailbox).

For instance following a linked list: 1) start with your paper with the address 2) Go to the address on the paper 3) Open the mailbox to find a new piece of paper with the next address on it

In a linear linked list, the last mailbox has nothing in it (end of the list). In a circular linked list, the last mailbox has the address of the first mailbox in it.

Note that step 3 is where the dereference occurs and where you'll crash or go wrong when the address is invalid. Assuming you could walk up to the mailbox of an invalid address, imagine that there's a black hole or something in there that turns the world inside out :)

+26  A:

What? Nobody has linked to Binky yet? That's how I learned pointers.

I think the visualization, drawing boxes and arrows to other boxes, can really help understanding.
+9  A:

An analogy I've found helpful for explaining pointers is hyperlinks. Most people can understand that a link on a web page 'points' to another page on the internet, and if you can copy & paste that hyperlink then they will both point to the same original web page. If you go and edit that original page, then follow either of those links (pointers) you'll get that that new updated page.

I really like this. It's not hard to see that writing out a hyperlink twice does not make two websites appear (just like `int *a = b` does not make two copies of `*b`).
This is actually very intuitive and something everyone should be able to relate to. Although there are a lot of scenarios where this analogy falls apart. Great for a quick introduction though. +1
+1  A:

Just to confuse things a bit more, sometimes you have to work with handles instead of pointers. Handles are pointers to pointers, so that the back end can move things in memory to defragment the heap. If the pointer changes in mid-routine, the results are unpredictable, so you first have to lock the handle to make sure nothing goes anywhere.

http://arjay.bc.ca/Modula-2/Text/Ch15/Ch15.8.html#15.8.5 talks about it a bit more coherently than me. :-)

+2  A:

I think that what makes pointers tricky to learn is that until pointers you're comfortable with the idea that "at this memory location is a set of bits that represent an int, a double, a character, whatever".

When you first see a pointer, you don't really get what's at that memory location. "What do you mean, it holds an address?"

I don't agree with the notion that "you either get them or you don't".

They become easier to understand when you start finding real uses for them (like not passing large structures into functions).

A:

Post office box number.

It's a piece of information that allows you to access something else.

(And if you do arithmetic on post office box numbers, you may have a problem, because the letter goes in the wrong box. And if somebody moves to another state -- with no forwarding address -- then you have a dangling pointer. On the other hand -- if the post office forwards the mail, then you have a pointer to a pointer.)

+1  A:

The problem with pointers is not the concept. It's the execution and language involved. Additional confusion results when teachers assume that it's the CONCEPT of pointers that's difficult, and not the jargon, or the convoluted mess C and C++ makes of the concept. So vast amounts of effort are poored into explaining the concept (like in the accepted answer for this question) and it's pretty much just wasted on someone like me, because I already understand all of that. It's just explaining the wrong part of the problem.

To give you an idea of where I'm coming from, I'm someone who understands pointers perfectly well, and I can use them competently in assembler language. Because in assembler language they are not referred to as pointers. They are referred to as addresses. When it comes to programming and using pointers in C, I make a lot of mistakes and get really confused. I still have not sorted this out. Let me give you an example.

When an api says:

``````int doIt(char *buffer )
//*buffer is a pointer to the buffer
``````

what does it want?

it could want:

a number representing an address to a buffer

(To give it that, do I say `doIt(mybuffer)`, or `doIt(*myBuffer)`?)

(is that `doIt(&mybuffer)` or `doIt(mybuffer)` or `doIt(*mybuffer)`?)

(maybe that's `doIt(&mybuffer)`. or is it `doIt(&&mybuffer)` ? or even `doIt(&&&mybuffer)`)

and so on, and the language involved doesn't make it as clear because it involves the words "pointer" and "reference" that don't hold as much meaning and clarity to me as "x holds the address to y" and "this function requires an address to y". The answer additionally depends on just what the heck "mybuffer" is to begin with, and what doIt intends to do with it. The language doesn't support the levels of nesting that are encountered in practice. Like when I have to hand a "pointer" in to a function that creates a new buffer, and it modifies the pointer to point at the new location of the buffer. Does it really want the pointer, or a pointer to the pointer, so it knows where to go to modify the contents of the pointer. Most of the time I just have to guess what is meant by "pointer" and most of the time I'm wrong, regardless of how much experience I get at guessing.

"Pointer" is just too overloaded. Is a pointer an address to a value? or is it a variable that holds an address to a value. When a function wants a pointer, does it want the address that the pointer variable holds, or does it want the address to the pointer variable? I'm confused.

+1  A:

I think it might actually be a syntax issue. The C/C++ syntax for pointers seems inconsistent and more complex than it needs to be.

Ironically, the thing that actually helped me to understand pointers was encountering the concept of an iterator in the c++ Standard Template Library. It's ironic because I can only assume that iterators were conceived as a generalization of the pointer.

Sometimes you just can't see the forest until you learn to ignore the trees.

The problem is mostly in the C declaration syntax. But pointer use would sure be easier if `(*p)` would have been `(p->)`, and thus we'd have `p->->x` instead of the ambiguous `*p->x`
A:

Not a bad way to grasp it, via iterators.. but keep looking you'll see Alexandrescu start complaining about them.

Many ex-C++ devs (that never understood that iterators are a modern pointer before dumping the language) jump to C# and still believe they have decent iterators.

Hmm, the problem is that all that iterators are is in complete odds at what the runtime platforms (Java/CLR) are trying to achieve: new, simple, everyone-is-a-dev usage. Which can be good, but they said it once in the purple book and they said it even before and before C:

Indirection.

A very powerful concept but never so if you do it all the way.. Iterators are useful as they help with abstraction of algorithms, another example. And compile-time is the place for an algorithm, very simple. You know code + data, or in that other language C#:

IEnumerable + LINQ + Massive Framework = 300MB runtime penalty indirection of lousy, dragging apps via heaps of instances of reference types..

"Le Pointer is cheap."

What does this have to do with anything?
+1  A:

The reason it's so hard to understand is not because it's a difficult concept but because the syntax is inconsistent.

``````   int *mypointer;
``````

You are first learned that the leftmost part of a variable creation defines the type of the variable. Pointer declaration does not work like this in C and C++. Instead they say that the variable is pointing on the type to the left. In this case: `*`mypointer is pointing on an int.

I didn't fully grasp pointers until i tried using them in C# (with unsafe), they work in exact same way but with logical and consistent syntax. The pointer is a type itself. Here mypointer is a pointer to an int.

``````  int* mypointer;
``````

Don't even get me started on function pointers...

Actually, both of your fragments are valid C. It is a matter of a lot of years of C style that the first one is more common. The second is quite a bit more common in C++, for instance.
+1  A:

I could work with pointers when I only knew C++. I kind of knew what to do in some cases and what not to do from trial/error. But the thing that gave me complete understanding is assembly language. If you do some serious instruction level debugging with an assembly language program you've written, you should be able to understand a lot of things.

+1  A:

The confusion comes from the multiple abstraction layers mixed together in the "pointer" concept. Programmers don't get confused by ordinary references in Java/Python, but pointers are different in that they expose characteristics of the underlying memory-architecture.

It is a good principle to cleanly separate layers of abstraction, and pointers do not do that.

Interesting thing is, that C pointers actually don't expose any charasteristic of the underlying memory architecture. The only differences between Java references and C pointers are that you can have complex types involving pointers (eg. int*** or char* (*)(void**)), there is pointer arithmetic for arrays and pointers to struct members, the presence of the void*, and array/pointer duality. Other than that, they work just the same.
Good point. It's the pointer arithmetic and the possibility of buffer overflows -- breaking out of the abstraction by breaking out of the currently relevant memory area -- that does it.
A:

I learned machine code (6502 to be exact) before C so pointers were totally obvious.
I would suggest that teaching some machine code first would make a lot of the concepts in C more obvious.

A:

Since there are lot of good answers above, I'm not going add anything more than a small pointer. This was a technique told to me by one of my friends at college who happens to be a good programmer.

Whenever you see an '&' substitute the term 'address of' and '*' substitute 'address of'. This should easily get rid of most of the trivial doubts.

+2  A:

The reason I had a hard time understanding pointers, at first, is that many explanations include a lot of crap about passing by reference. All this does it confuse the issue. When you use a pointer parameter, you're still passing by value; but the value happens to be an address rather than, say, an int.

Someone else has already linked to this tutorial, but I can highlight the moment when I began to understand pointers:

A Tutorial on Pointers and Arrays in C: Chapter 3 - Pointers and Strings

``````int puts(const char *s);
``````

For the moment, ignore the `const`. The parameter passed to `puts()` is a pointer, that is the value of a pointer (since all parameters in C are passed by value), and the value of a pointer is the address to which it points, or, simply, an address. Thus when we write `puts(strA);` as we have seen, we are passing the address of strA[0].

The moment I read these words, the clouds parted and a beam of sunlight enveloped me with pointer understanding.

Even if you're a VB .NET or C# developer (as I am) and never use unsafe code, it's still worth understanding how pointers work, or you won't understand how object references work. Then you'll have the common-but-mistaken notion that passing an object reference to a method copies the object.

+2  A:

I think the main barrier to understanding pointers is bad teachers.

Almost everyone are taught lies about pointers: That they are nothing more than memory addresses, or that they allow you to point to arbitrary locations.

And of course that they are difficult to understand, dangerous and semi-magical.

None of which is true. Pointers are actually fairly simple concepts, as long as you stick to what the C++ language has to say about them and don't imbue them with attributes that "usually" turn out to work in practice, but nevertheless aren't guaranteed by the language, and so aren't part of the actual concept of a pointer.

I tried to write up an explanation of this a few months ago in this blog post -- hopefully it'll help someone.

(Note, before anyone gets pedantic on me, yes, the C++ standard does say that pointers represent memory addresses. But it does not say that "pointers are memory addresses, and nothing but memory addresses and may be used or thought of interchangeably with memory addresses". The distinction is important)