Pointer

A pointer is a variable that stores both a memory address and the type of data that resides at that memory location.

  • Obtaining the value stored at that location is known as dereferencing the pointer
    • anal: The index within a textbook has page numbers which reference pages in the book. Dereferencing the pointer would be done by flipping to that page and reading the text.
    • the type of the pointer tells the compiler what operations can be performed through that pointer
  • a pointer is a very thin abstraction built on top of a language's own addressing capabilities
  • Each unit of memory in a system is assigned a unique address (memory location).
    • A pointer is an object that stores this address.
      • This is similar in concept to how we dont store images in a database, we just store its url location
    • Conceptually, the fact that memory is just stored in blocks makes memory itself a very large array.
    • arrays work a bit differently in that the variable points to the address (location) of the first character in the array
  • pointers are used partly because they are sometimes the only way to express a computation, and partly because they usually lead to more compact and efficient code than can be obtained in other ways
    • They are especially efficient when used in repetitive operations
  • pointers are used for constructing references, which in turn are fundamental to constructing nearly all data structures
  • using a pointer to retrieve the value that is stored at the relevant memory location is called dereferencing the pointer
  • anal:if storage were a reference book, then the page number in the index would be the pointer, and flipping to that page and reading the text would be dereferencing that pointer.
  • the format of a pointer is dependent on the underlying computer architecture (since pointer's pertain to physical memory locations)
  • Pointers and arrays are closely related
    • Any operation that can be achieved by array subscripting can also be done with pointers
    • consider that when we declare an array x of length 10, we are reserving 10 contiguous memory cells. We can create a pointer that points to the first element with ptr = &x[0];. Now, we can copy the contents of that first element to y with y = *ptr;.
      • Since elements in an array are contiguous, by defintion ptr+1 points to the second element in the array, and *(ptr+1) refers to the contents of x[1]
    • ex. a char occupies a single byte, a short occupies 2 contiguous bytes, a long occupies 4 contiguous bytes, and so on.
      • Naturally, this means that contiguous groups of memory cells can be manipulated
  • A pointer is a group of cells (often two or four) that can hold an address

Example

Imagine we executed the following code:

int a = 5;
int *ptr = NULL;

assuming that a is stored at 0x8130 and ptr at 0x8134, our memory would look like: | Address | Value | |---------|------------| | 0x8130 | 0x00000005 | | 0x8134 | 0x00000000 |

now this code is run:

ptr = &a;

And our memory looks like this: | Address | Value | |---------|------------| | 0x8130 | 0x00000005 | | 0x8134 | 0x00008130 |

now we can dereference ptr:

*ptr = 8;

And our computer takes the contents of ptr (0x00008130), locates the address, and assigns 8 to that location, yielding this memory: | Address | Value | |---------|------------| | 0x8130 | 0x00000008 | | 0x8134 | 0x00008130 |


Backlinks