```## Memory-as-a-Grid Diagram ##

Usually what I do is represent memory as a "grid", so that I can make up addresses, highlight different memory spaces and write in the cells values (or even further, their binary representations) and link the pointers in memory to the values they point at.
(And then still mention that it's a simplification).

Usually it's a "ohhhh" moment for most of my students.

Sorry, cannot do a drawing now, unfortunately.

## Symbol Juggling ##

Then when it comes to have them stop forgetting how to use & and *, it's very simple: present it the same way they do math or physics calculations. If you divide a distance in km by a time in hour, you get a speed in km/h. What's in needs to be out. Simple.

## printf to the Rescue ##

Doing just a few basic examples that visually represent what you explained with these will comfort them in what they think they understood, or give them the opportunity to say "ah, I don't get this one".

## Be Extensive ##

Cover pointers for simple types and make sure they understand the difference between addressing and the size of a data type, then structs, then arrays, and multiple levels.

Then start pointer arithmetic.

----------

I usually explain recursion similarly, using a visual representation.
Have them print the alphabet using a pre-made function that writes a single char, and then ask them to print it in reverse order by just changing two lines.

Usually there's a "what the...?" moment, and when you add just another parameter to your printf to print numeric values and indent the steps, it becomes a sigh of relief.

----------

## Alternatives: The Play-Doh Model and the Water Cups ##

I actually had some co-workers in a university who showed students a video explaining pointers and memory accesses using play-doh paste. It was incredibly clever and well done, though I never really used that technique myself, except for very young learners interested in grasping programming (but usually those I wouldn't lead them towards a language using pointers too early). Basically using tiny balls of play-doh which you can attach to other bigger balls of play-doh representing memory spaces, and that you can combine together to either link them (like in a linked data structure) or merge together (as in a contiguous memory space). Using different colors for the memory spaces pointed to and the pointers help as well. But I still think the Memory-as-a-Grid thing works better, as you can clearly show that the pointing is really a matter of "addressing", as on a "map/grid". Whereas the Play-doh mode still confuses them into thinking that things really "touch" each other in memory.

The Water Cup thing was used directly by a colleague as well, but I don't know if she came up with it. It was an interesting approach, but I noticed many students were left puzzled by the explanation. Something alike to [DevSolo's Coffee Cup technique][1]. But I think it's actually a misleading one as you make the students confuse containers, data structures, pointers and arrays. It might be an interesting approach to explain arrays at the beginning I assume, but I wouldn't stick to it very long.

[1]: http://programmers.stackexchange.com/questions/17898/whats-a-nice-explanation-for-pointers/17902#17902```