Pointers

STOP! If you have not gone over Section 1: Simple C or do not completely understand what is going on, do not proceed. The following will make absolutely no sense if you have not read Section 1. Go back and re-read pages that are troubling you and practice before proceeding! If you are comfortable with the material discussed thus far, lets begin our journey into pointers...

Pointers :: Definition

• Pointers provide an indirect method of accessing variables. The reason why some people have difficulty understanding the concept of a pointer is that they are usually introduced without some sort of analogy or easily understood example.
• For our simple to understand example, let's think about a typical textbook. It will usually have a table of contents, some chapters, and an index. Suppose we have a Chemistry textbook and would like to find more information on the noble gases. What one would typically do instead of flipping through the entire text, is to consult the index in the back. The index would direct us to the page(s) on which we can read more on noble gases. Conceptually, this is how pointers work!
• A pointer is simply a reference containing a memory address. In our example, the noble gas entry in the index would list page numbers for more information. This is analogous to a pointer reference containing the memory address of where the real data is actually stored!
• You may be wondering, what is the point of this (no pun intended)? Why don't I just make all variables without the use of pointers? It's because sometimes you can't. What if you needed an array of ints, but didn't know the size of the array before hand? What if you needed a string, but it grew dynamically as the program ran? What if you need variables that are persistent through function use without declaring them global (remember the swap function)? They are all solved through the use of pointers. Pointers are also essential in creating larger custom data structures, such as linked lists.
• So now that you understand how pointers work, let's define them a little better.
  • A pointer when declared is just a reference. DECLARING A POINTER DOES NOT CREATE ANY SPACE FOR THE POINTER TO POINT TO. We will tackle this dynamic memory allocation issue later.
  • As stated prior, a pointer is a reference to an area of memory. This is known as a memory address. A pointer may point to dynamically allocated memory or a variable declared within a block.
  • Since a pointer contains memory addresses, the size of a pointer typically corresponds to the word size of your computer. You can think of a "word" as how much data your computer can access at once. Typical machines today are 32- or 64-bit machines. 8-bits per byte equates to 4- or 8-byte pointer sizes. More on this later.

Pointers :: Declaration and Syntax

• Pointers are declared by using the * in front of the variable identifier. For example:

    int *ip;
    float *fp = NULL;
  

  This delcares a pointer, ip, to an integer. Let's say we want ip to point to an integer. The second line delares a pointer to a float, but initializes the pointer to point to the NULL pointer. The NULL pointer points to a place in memory that cannot be accessed. NULL is useful when checking for error conditions and many functions return NULL if they fail.

    int x = 5;
    int *ip;
  
    ip = &x;
  

  We first encountered the & operator first in the I/O section. The & operator is to specify the address-of x. Thus, the pointer, ip is pointing to x by assigning the address of x. This is important. You must understand this concept.
• This brings up the question, if pointers contain addresses, then how do I get the actual value of what the pointer is pointing to? This is solved through the * operator. The * dereferences the pointer to the value. So,

    printf("%d %d\n", x, *ip);
  

  would print 5 5 to the screen.
• There is a critical difference between a dereference and a pointer declaration:

    int x = 0, y = 5, *ip = &y;
  
    x = *ip;
  

  The statement int *ip = &y; is different than x = *ip;. The first statement does not dereference, the * signifies to create a pointer to an int. The second statement uses a dereference.
• Remember the swap function? We can now simulate call by reference using pointers. Here is a modified version of the swap function using pointers:

    void swap(int *x, int *y) {
      int tmp;
  
      tmp = *x;
      *x = *y;
      *y = tmp;
    }
  
    int main() {
      int a = 2, b = 3;
  
      swap(&a, &b);
      return EXIT_SUCCESS;
    }
  

  This snip of swapping code works. When you call swap, you must give the address-of a and b, because swap is expecting a pointer.
• Why does this work? It's because you are giving the address-of the variables. This memory does not "go away" or get "popped off" after the function swap ends. The changes within swap change the values located in those memory addresses.

Pointers :: Pointers and const Type Qualifier

• The const type qualifier can make things a little confusing when it is used with pointer declarations.
• The below example is from Weiss pg. 132:

    const int * const ip;  /* The pointer *ip is const and what it points at is const */
          int * const ip;  /* The pointer *ip is const              */
    const int *       ip;  /* What *ip is pointing at is const      */
          int *       ip;  /* Nothing is const                      */
  

  As you can see, you must be careful when specifying the const qualifier when using pointers.

Pointers :: void Pointers

• void pointers can be assigned to any pointer value. It sometimes necessary to store/copy/move pointers without regard to the type it references.
• You cannot dereference a void pointer.
• Functions such as malloc, free, and scanf utilize void pointers.

Pointers :: Pointers to Functions

• Earlier, we said that you can pass functions as parameters into functions. This was essentially a reference, or pointer, passed into the function.
• There is an alternative way to declare and pass in functions as parameters into functions. It is discussed in detail in Weiss, pgs. 135-136.

Pointers :: Pointer Arithmetic

• C is one of the few languages that allows pointer arithmetic. In other words, you actually move the pointer reference by an arithmetic operation. For example:

    int x = 5, *ip = &x;
  
    ip++;
  

  On a typical 32-bit machine, *ip would be pointing to 5 after initialization. But ip++; increments the pointer 32-bits or 4-bytes. So whatever was in the next 4-bytes, *ip would be pointing at it.
• Pointer arithmetic is very useful when dealing with arrays, because arrays and pointers share a special relationship in C. More on this when we get to arrays!

Pointers Review

• Pointers are an indirect reference to something else. They are primarily used to reference items that might dynamically change size at run time.
• Pointers have special operators, & and *. The & operator gives the address-of a pointer. The * dereferences the pointer (when not used in a pointer declaration statement).
• You must be careful when using const type qualifier. You have to also be cautious about the void pointer.
• C allows pointer arithmetic, which gives the programmer the freedom to move the pointer using simple arithmetic. This is very powerful, yet can lead to disaster if not used properly.

© 1999-2008 Alfred Park (fred AT randu.org)