Explaining pointers to a Javascript developer

pointers

Solution

Here's an attempt at a self-contained answer from first principles.

Pointers are part of a type system that permit the implementation of reference semantics. Here's how. We suppose that our language has a type system, by which every variable is of a certain type. C is a good example, but many languages work like this. So we can have a bunch of variables:

int a = 10;
int b = 25;

Further, we assume that function arguments are always copied from the caller scope into the function scope. (This is also true for many real languages, though the details can quickly become subtle when the type system gets 'hidden' from the user (e.g. such as in Java)). So let's have a function:

void foo(int x, int y);

When calling `foo(a, b)`, the variables `a` and `b` are copied into local variables `x` and `y` corresponding to the formal parameters, and those copies are visible within the function scope. Whatever the function does with `x` and `y` has no effect on the variables `a` and `b` at the call site. The entire function call is opaque to the caller.

Now let's move on to pointers. A language with pointers contains, for every object type `T`, a related type `T *`, which is the type "pointer to `T`". Values of type `T *` are produced by taking the address of an existing object of type `T`. So a language that has pointers also needs to have a way to produce pointers, which is "taking the address of something". The purpose of a pointer is to store the address of an object.

But that's only one half of the picture. The other half is what to do with the address of an object. The main reason for caring about the address of an object is to be able to refer to the object whose address is being stored. This object is obtained by a second operation, suitably called dereferencing, which when applied to a pointer produces the object which is being "pointed to". Importantly, we do not a copy of the object, but we get the actual object.

In C, the address-of operator is spelled `&`, and the dereference operator is spelled `*`.

int * p = &a;    // p stores the address of 'a'

*p = 12;         // now a == 12

The first operand of the final assignment, `*p`, is the object `a` itself. Both `a` and `*p` are the same object.

Now why is this useful? Because we can pass pointers to functions to allow functions to change things outside the function's own scope. Pointers allow for indirection, and thus for referencing. You can tell the function about "something else". Here's the standard example:

void swap(int * p, int * q)
{
    int tmp = *p;
    *p = *q;
    *q = tmp;
}

We can tell the function `swap` about our variables `a` and `b` by giving it the addresses of those variables:

swap(&a, &b);

In this way, we are using pointers to implement reference semantics for the function `swap`. The function gets to refer to variables elsewhere and can modify them.

The fundamental mechanism of reference semantics can thus be summarized thus:

The caller takes the address of the object to be refered to:

 T a;
 mangle_me(&a);

The callee takes a pointer parameter and dereferneces the pointer to access the refered value.

 void mangle_me(T * p)
 {
     // use *p
 }

Reference semantics are important for may aspects of programming, and many programming languages supply them in some way or another. For example, C++ adds native reference support to the language, largely removing the needs for pointers. Go uses explicit pointers, but offers some notational "convenience" by sometimes automagically dereferencing a pointer. Java and Python "hide" pointer-ness inside their type system, e.g. the type of a variable is in some sense a pointer to the type of the object. In some languages, some types like ints are naked value types, and others (like lists and dictionaries) are "hidden-pointer-included" reference types. Your milage may vary.

Problem

Original source

Related problems

• Common Uses For Pointers?