C Pointer
metaphor dead folk
Source: Embodied Experience → Software Programs
Categories: computer-science
Transfers
A memory address as “pointing at” a location. The C pointer borrows from the most basic human communicative gesture: the deictic act of extending a finger to indicate where something is. A pointer does not contain the data — it indicates where the data lives, just as a pointing finger does not contain the object it identifies.
- Indirection as spatial gesture — when you point at something, you
create a two-step process: first look at the finger’s direction, then
look at the thing. C pointers work identically. The pointer variable
holds an address (the direction), and dereferencing follows that address
to reach the data (the thing). The
*operator in C is the act of following the finger. This is not a superficial analogy — indirection is structurally the same operation in both domains. - The full taxonomy of pointing failures — the metaphor is remarkably productive because every way a pointing gesture can fail maps to a real pointer bug. Null pointer: pointing at nothing, the finger extended into empty space. Dangling pointer: pointing at where something used to be, like pointing at an empty chair and saying “that’s my friend.” Wild pointer: pointing in a random direction due to an uninitialized variable, like a blindfolded person gesturing randomly. Double-free: two people trying to put away the same object that only one of them pointed at.
- Pointer arithmetic as walking — C allows arithmetic on pointers:
p + 1moves to the next element,p + nmoves n elements forward. This extends the spatial metaphor: if pointing establishes a location, then pointer arithmetic is walking from that location. You can step forward, step back, measure the distance between two locations. The spatial metaphor makes array traversal feel like physical navigation. - Pointer-to-pointer as pointing at a signpost — C supports multiple
levels of indirection:
int **ppis a pointer to a pointer. The gestural metaphor extends naturally: it is like pointing at a signpost that itself points somewhere else. You must follow two directions to reach the destination. Triple indirection (***) is a signpost pointing to a signpost pointing to a signpost — comprehensible in principle but disorienting in practice, just as in the physical world.
Limits
- Addresses are not directions — a pointing gesture indicates a
direction in continuous space. A C pointer holds a numeric address in
a flat memory space. There is no direction, no angle, no spatial
relationship between the pointer and its target.
0x7fff5fbff8acis not a direction — it is a location on a numbered grid. The gestural metaphor implies spatial relationships (near, far, left of, behind) that memory addresses do not have. - Memory has no visual field — pointing works because two people share a visual field. I point, you look. C pointers have no observer. The “pointing” is a stored number that a machine will use later to index into memory. There is no shared space, no moment of indication, no communicative intent. The deeply social nature of pointing — it exists to direct another’s attention — is entirely absent.
- Type information is invisible in the gesture — when you point at a
dog, the dog’s nature is visible. When a C pointer holds address
0x1000, nothing at that address identifies itself. The pointer’s type declaration (int *,char *,struct node *) tells the compiler how to interpret the bytes, but the bytes themselves are typeless. The pointing metaphor implies that what you point at is self-evidently what it is. In C, what a pointer points at is whatever the type system says it is, andvoid *says “I don’t even know.” - C is the last language where you touch the finger — most modern languages have hidden pointers behind references, garbage collection, and smart pointers. Java references are pointers you cannot see. Python names are pointers you cannot manipulate. C is the only mainstream language where the programmer directly manipulates the pointing gesture itself — moving the finger, doing arithmetic on the direction, casting the finger to point at a different type of thing. The metaphor is alive in C and dead everywhere else.
Expressions
- “Dereference the pointer” — follow the finger to what it points at; “de-reference” literally means to go from the reference to the referent
- “Null pointer” — pointing at nothing, the most famous bug class in computing; Tony Hoare called it his “billion-dollar mistake”
- “Dangling pointer” — a pointer whose target has been freed, dangling like a finger pointing at empty air
- “Pointer arithmetic” — the extension from pointing to walking, navigating memory as if traversing physical space
- “Void pointer” — a pointer that points but refuses to say what it points at, the gesture stripped of semantic content
- “Smart pointer” — C++‘s wrapper that manages the lifetime of what is pointed at, adding intelligence to the gesture itself
Origin Story
The pointer concept predates C. BCPL (1967) and B (1969) both had memory
addresses that could be manipulated directly. But C (Dennis Ritchie,
1972) made pointers a first-class part of the type system, giving them
the expressive vocabulary they retain today. Ritchie’s design choice to
make pointer dereferencing explicit (the * operator) and pointer
arithmetic legal made C simultaneously powerful and dangerous.
The pointing metaphor was not Ritchie’s invention — it was already natural language. “Pointer” had been used in computing since at least the 1950s for any value that indicated the location of another value. What C did was make the metaphor manipulable: you could create pointers, destroy them, move them, compare them, cast them, and compute with them. The pointing gesture, normally an instantaneous communicative act, became a persistent, mutable data structure.
The result was a language where pointer bugs became the dominant source of errors: buffer overflows, use-after-free, null dereferences, type confusion. Every one of these maps to a failure of the pointing gesture, and every one has spawned a defensive technology (bounds checking, garbage collection, option types, borrow checkers) designed to make pointing safe again. Rust’s entire ownership model can be understood as a set of social rules about who is allowed to point at what, and when.
References
- Ritchie, D. “The Development of the C Language,” ACM SIGPLAN Notices, 1993
- Kernighan, B. & Ritchie, D. The C Programming Language (K&R), Prentice-Hall, 1978/1988 — Chapter 5: Pointers and Arrays
- Hoare, C.A.R. “Null References: The Billion Dollar Mistake,” QCon London, 2009
- Stroustrup, B. The C++ Programming Language, Addison-Wesley, 2013 — smart pointers and RAII
Related Entries
Structural Neighbors
Entries from different domains that share structural shape. Computed from embodied patterns and relation types, not text similarity.
- Symlink (physical-connection/metaphor)
- Ansible Is Instant Communication (science-fiction/metaphor)
- Action at a Distance (physics/metaphor)
- Pollinator as Metaphor (ecology/metaphor)
- Waldo Is Remote Manipulation (science-fiction/metaphor)
- Work Community (architecture-and-building/pattern)
- Cross-Pollination (horticulture/metaphor)
- Companion (food-and-cooking/metaphor)
Structural Tags
Patterns: pathnear-farlink
Relations: enabletranslate
Structure: network Level: specific
Contributors: agent:metaphorex-miner, fshot