Pointer Arithmetic

Introduction

It's perhaps too harsh a judgement of C, but certainly one of the reasons the language was invented was to write operating systems. Writing such code requires the ability to access addresses in memory in an efficient manner. This is why pointers are such an important part of the C language. They're also a big reason programmers have bugs.

If you're going to master C, you need to understand pointer arithmetic, and in particular, the relationship between arrays and pointers.

Arbitrary Pointer Casting

Here's an example.

    // Casting 32 bit int, 0x0000ffff, to a pointer
    char * ptr  = reinterpret_cast<char *>( 0x0000ffff ) ;
    char * ptr2 = reinterpret_cast<char *>( 0x0000ffff ) ;

Unfortunately, this is not good for safe programs. In a safe programming language (say, Java), the goal is to access objects from pointers only when there's an object there. Furthermore, you want to call the correct operations based on the object's type.

Arbitrary pointer casting allows you to access any memory location and do anything you want at that location, regardless of whether you can access that memory location or whether the data is valid at that memory location.

Arrays and Pointer Arithmetic

Consider the following declaration.

    int arr[ 10 ] ; 

OK, now what do you think of arr[ i ]? What is that? (Assume i is some int). You might say, it's the i^th element of the array. That's correct too. What type does arr[i] have?

It's an int! (Beginning programming students often think arr[ i ] is not the same as an int, because it uses brackets. It takes a while to convince them they have the same type as a plain int variable).

Do you know, however, that arr[ i ] is defined using pointer arithmetic?

In particular:

    arr[ i ] == * ( arr + i )

A pointer is an address in memory. arr contains an address in memory---the address where arr[ 0 ] is located.

What is arr + i? If arr is a pointer to arr[ 0 ] then arr + i is a pointer to arr[ i ].

Perhaps this is easier shown in a diagram.

Now that you see the diagram, something may strange. Why is arr + 1 at address 1004 and not 1001?

That's pointer arithmetic in action. arr + 1 points to one element past arr. arr + 3 is points to 3 elements past arr. Thus, arr + i points to i elements past arr.

The idea is to have arr + i point to i elements after arr regardless of what type of element the array holds.

The Type's the Thing

Here's a diagram of that.

Why is there a difference? What's the differnce between arr before and now?

The difference is in the type. Before, arr had (roughly) type int * and now arr has type short *.

In C, a pointer is not only an address, it tells you what (in principle) the data type at that address is. Thus, int * is a pointer to an int. Not only does it tell you the data type, but you can also determine the data type's size.

You can find out the data type's size with the sizeof() operator.

    sizeof( int ) ==> 4
    sizeof( short ) ==> 4

Here's the formula for computing the address of ptr + i where ptr has type T *. then the formula for the address is:

   addr( ptr + i ) = addr( ptr ) + [ sizeof( T ) * i ]

T can be a pointer

   int * arr[ 10 ] ;
   int ** ptr = arr ;

   addr( ptr + i ) = addr( ptr ) + [ sizeof( int * ) * i ]
                   = addr( ptr ) + [ 4 * i ]

Static arrays are constant

   int arr[ 10 ] ;

You can't do the following:

   int arr[ 10 ] ;

   arr = arr + 1 ; // NO! Can't reassign to arr--it's constant

   int arr[ 10 ] ;
   int * ptr ;

   ptr = arr + 1 ; // This is OK. ptr is a variable.

Parameter Passing an Array

   void foo( int arr[ 10 ], int size ) {
     // code here
   }

   void foo( int * arr, int size ) {
     // code here
   }

Why doesn't this cause problems? After all, won't we pass arr as an argument? Isn't arr a constant?

Yes, it is. However, we pass a copy of the address to arr the parameter. Thus, the copy can be manipulated while the original pointer address that was passed during the function call is unchanged.

Subtraction

    int arr[ 10 ] ;
    int * p1, * p2 ;

    p1 = arr + 3 ; // p1 == & arr[ 3 ] 
    p2 = p1 - 2 ; // p1 == & arr[ 1 ] 

As it turns out, we can even point way past the end of the array.

    int arr[ 10 ] ;
    int * p1, * p2 ;

    p1 = arr + 100 ; // p1 == & arr[ 100 ] 
    p2 = arr - 100 ; // p1 == & arr[ -100 ] 

Passing the Array Size

If you try to compute the array's size using sizeof, you just get 4.

    // Compiler translates arr's type to int * 
    void foo ( int arr[], int size ) {
       // Prints 4 
       cout << sizeof( arr ) ;

       int arr2[ 10 ] ;

       // Prints 40 
       cout << sizeof( arr2 ) ;
    }

Two dimensional Arrays

    int arr[ 10 ][ 12 ] ;

    int * arr[ 10 ] ;

The type is rather complicated, and is due to the fact that arr[ 0 ] = & arr[ 0 ][ 0 ], arr[ 1 ] = & arr[ 1 ][ 0 ], and in general, arr[ i ] = & arr[ i ][ 0 ].

Pointer arithmetic says that arr + i gives you & arr[ i ], yet this skips an entire row of 12 elements, i.e., skips 48 bytes times i. Thus, if arr is address 1000_ten, then arr + 2 is address 1096_ten.

If the array's type were truly int **, pointer arithmetic would say the address is 1008_ten, so that doesn't work.

So, what's the lesson?

A two-dimensional array is not the same as an array of pointers to 1D arrays

    int (*ptr)[ 10 ] ;

If you have a conventional two dimensional array, and you want to compute the address for arr[ row ][ col ] and you have ROWS rows (where ROWS is some constant) and COLS columns, then the formula for the address in memory is:

   addr( & arr[ row ][ col ] ) = addr( arr ) + [ sizeof( int ) * COLS * row ]
                                             + [ sizeof( int ) * col ]

When you have a 2D array as a parameter to a function, there's no need to specify the number of rows. You just need to specify the number of columns. The reason is the formula above. The compiler can compute the address of an element in a 2D array just knowing the number of columns.

Thus, the following is valid in C, i.e. it compiles:

   void sumArr( int arr[][ COLS ], int numRows, int numCols ) {
   }

   void sumArr( int arr[ ROWS ][ COLS ], int numRows, int numCols ) {
   }

The following, however, is NOT valid in C:

   void sumArr( int arr[][], int numRows, int numCols ) {
   }

However, it's OK to write:

   void sumArr( int **arr, int numRows, int numCols ) {
   }

Pointer Subtraction

For example:

    int arr[ 10 ] ;
    int * p1 = arr + 2 ;
    int * p2 = arr + 5 ;

    cout << ( p2 - p1 ) ; // Prints 3 
    cout << ( p1 - p3 ) ; // Prints -3 

    ( p2 - p1 ) == ( addr( p2 ) - addr( p1 ) ) / sizeof( T )

p2 and p1 need not point to valid elements in an array. The formula above still works even when p2 and p1 contain invalid addresses (because they contain some address).

Pointer subtraction isn't used very much, but can be handy to determine the distances between two array elements (i.e., the difference in the array indexes). You may not know exactly which element you're pointing to using pointer subtraction, but you can tell relative distances.

Dereferencing causes problems

However, dereferencing pointers to invalid memory causes problems. Thus, *( arr - 1000 ) core dumps because you are trying to access the address.

Here's an analogy. You can write down anyone's address on a piece of paper, however, you can't just go inside the person's house at that address (which is like dereferencing). Thus, computing addresses is fine, dereferencing it may cause problems if the address is not a valid address in memory.

Nasty Types in C

Fortunately, our goal is simply to understand pointer arithmetic which is adding integers to pointers and subtracting pointers. This allows us to get a view of how C computes addresses.

Summary

Part of the reason we study this is the importance of pointers in C and the importance of C to systems programming, which falls under "low-level" programming.

Credits