Intro to C Pointers and Dynamic Memory

Memory is the oxygen of a C program. Doing anything constructive in C involves using memory. As we saw last time, memory for stack variables is cleaned up automatically. More advanced C programing requires using dynamic memory allocation, which you have to manage yourself.

Dynamic memory allocation allows you to get blocks of memory of any size (within reason), and control them using pointers. Pointers have a reputation for being hard to deal with, but the basic mechanisms are simple. The only mental adjustment is the idea of dealing with something that refers to something else.


Warning! This is intended as a quick, rough introduction to a deep topic. The goal is to just take the edge off of C a bit, not explain every aspect of memory management. Before you go out and write sensitive code (particularly security or server software), you must take the time to understand the deeper ramifications of memory management. You've been warned.


Pointer Syntax

It's obvious a pointer points to something, but what? A pointer refers to a location in memory. In other words, it refers to a piece of data. Here's a basic pointer example:

#include <stdio.h>

main ()
{
  // declare an int variable and an int pointer variable
  int  number;
  int* pointer;

  // set a value for 'number'
  number = 5;

  // now link 'pointer' to 'number' by putting the 'addressof'
  // operator (&) in front of the number variable
  pointer = &number;

  // print values of number and pointer
  // note the %p marker is used for pointer and &number
  printf( "value of number:  %i\n", number );
  printf( "value of &number: %p\n", &number );
  printf( "value of pointer: %p\n", pointer );
  
  // print value of pointer's target (number) using
  // the asterisk (*) operator
  printf( "value of pointer's _target_: %i\n", *pointer );
}

This gives you something similar to this:

value of number:  5
value of &number: 0xbffffc5c
value of pointer: 0xbffffc5c
value of pointer's _target_: 5

Notice how the pointer simply stores the address (location) of the original variable. That's why the second and third lines of output have the same value. It may seem like this code doesn't have much practical use, but we're just trying to get the basic syntax straight first.

The key thing here is that just like a normal variable, the pointer variable has a value. With a normal variable, the literal value (such as "5") is the interesting data. With a pointer, the interesting data is what's at the memory address that it refers to (0xbffffc5c in this case). You can get the value of the target variable using the asterisk:

printf( "value of pointer's target: %i\n", *pointer );

This is called dereferencing. The star does all the necessary low-level calculations to fetch the data so you don't have to do the math yourself.

Hexidecimal Notation

The value of pointer is displayed in hexadecimal format (just like web colors). Don't be intimdated by the alien notation, it's still just a number. Hexidecimal numbers are expressed in base 16, meaning each digit has 16 different values. Decimal numbers (the ones we're used to) are expressed in base 10:

Decimal has 10 possible values for each digit:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
  
Hexidecimal has 16 possible values for each digit:                  
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f
                                                    
The 0x part is just a prefix to tell C that it's a hexidecimal number. The actual numeric value is bffffc5c. So now you can sleep tonight knowing what is meant by the term "base 16".

Pointers Making You See Stars?

Pointer syntax tends to confuse novice C programmers. The problem is that the asterisk (aka "star") is used for two distinct purposes: in a pointer declaration and when returning the value of the target.

Here's an example of each:

// declare a basic int variable  
int number = 18;

// use the asterisk to _declare_ a pointer
int * numberPointer;

// assign a value to the pointer
numberPointer  = &number;

// use the asterisk again, this time to _fetch_
// the value of the _target_ variable (number)

printf ("Value of target: %i", *numberPointer);

In an ideal world, a pointer declaration wouldn't contain an asterisk, but this is the syntax that we have in our universe.

Copy Versus Reference

Keep in mind the difference between a pointer which refers to a variable and a copy of a variable. Here's an example:

#include <stdio.h>

main ()
{
  float   myNumber;
  float   myNumberCopy;
  float * myNumberPointer;
  
  // first, set an initial value  
  myNumber = 1.618;
  
  // copy the value
  myNumberCopy = myNumber;
  
  // make a pointer to the value using the
  // ampersand, known as the "addressof" operator
  myNumberPointer = &myNumber;
  
  // change the original
  myNumber = 2.0;
  
  // now check the values.
  // be sure to use the star (*) to fetch the value
  // of myNumberPointer's target
  
  printf( "myNumber: %f\n", myNumber );
  printf( "myNumberCopy: %f\n", myNumberCopy );
  printf( "myNumberPointer: %f\n", *myNumberPointer );
}

Here's the output:

myNumber: 2.000000
myNumberCopy: 1.618000
myNumberPointer: 2.000000

The copy gets its own value, but the pointer stays linked to the original.

Malloc and Free Functions

The memory for basic variables such as ints, floats and simple arrays are handled automatically. Sometimes, though, you need to exercise more control. Dynamic memory management means that you can reserve a large block of memory, but you have to take reponsibility for freeing it later.

The malloc family of functions are used to deal with these blocks of memory. The most basic of these is malloc(), which takes a size as input and returns a pointer to the a new block of memory. The term "malloc" is short for "memory allocate". Here's a simple example:

// reserve 4 bytes of memory
void * memoryBlock = malloc ( 4 );

The "void *" type means that the memoryBlock will store a pointer to a block of memory with an undefined type. That is, we're not specifying what kind of data will go in there. When you're done with the block of memory, you have to release it using the free() function:

free ( memoryBlock );

If you don't do this, you'll have a memory leak on your hands (yuck!).

Making a Memory Block Useful

Allocating 4 byte memory block isn't all that interesting. What we really want to do is get a memory block that can hold a certain number of values. For example, if we want to hold 20 int values, we can do this:

void * memoryBlock = malloc ( sizeof(int) * 20 );

We use the sizeof() function to calculate the size of a particular type of variable. That number is then multiplied by the number of values we want to store (20).

We can also use a variation of the malloc function, called calloc. The calloc function takes two arguments, a value count and the base value size. It also clears the memory before returning a pointer, which is useful in avoiding unpredictable behavior and crashes in certain cases:

void * memoryBlock = calloc ( 20, sizeof(int) );

A memory block like this can effectively be used as a more flexible array. This approach is actually much more common in real-world C programs. It's also more predictable and flexible than a "variable size array" (mentioned in the previous tutorial).

But how do we get and set values in each slot? One common approach is to use the ++ and -- operators to move the pointer forward or back in the memory block. In order to do this, we should set the correct type for the returned memory block:

// create a "moveable" int pointer
int * memoryBlock = calloc ( 10, sizeof(int) );

This allow the ++ operator to move forward the exact size of an int variable each time, effectively moving forward one "slot" in our array-like memory block.

#include <stdio.h>
#include <stdlib.h> // for calloc and free
#include <time.h>   // for random seeding

main ()
{
  const int count = 10;
  int * memoryBlock = calloc ( count, sizeof(int) );
  
  if ( memoryBlock == NULL )
  {
    // we can't assume the memoryBlock pointer is valid.
    // if it's NULL, something's wrong and we just exit
    return 1;
  }

  // currentSlot will hold the current "slot" in the,
  // array allowing us to move forward without losing
  // track of the beginning. Yes, C arrays are primitive
  //
  // Note we don't have to do '&memoryBlock' because
  // we don't want a pointer to a pointer. All we
  // want is a _copy_ of the same memory address
    
  int * currentSlot = memoryBlock;


  // seed random number so we can generate values
  srand(time(NULL));
  
  int i;    
  for ( i = 0; i < count; i++ )
  {
    // use the star to set the value at the slot,
    // then advance the pointer to the next slot    
    *currentSlot = rand();
    currentSlot++;
  }

  // reset the pointer back to the beginning of the
  // memory block (slot 0)
  currentSlot = memoryBlock;

  for ( i = 0; i < count; i++ )
  {
    // use the star to get the value at this slot,
    // then advance the pointer
    printf("Value at slot %i: %i\n", i, *currentSlot);
    currentSlot++;
  }

  // we're all done with this memory block so we
  // can free it  
  free( memoryBlock );
}

This isn't the only correct way to do this sort of thing, just one approach. Also, keep in mind that since a memory block can be treated as an array, you're likely to see things like this in code:

char * myString;

Since a string is an array of individual characters, a memory block filled with individual characters can act as a string as well.

Arrays of Arrays

Multi-dimensional arrays are not unique to C, but deserve mention here. They basically come in two flavors. The major basic form:

int grid [10][10];

...and the more flexible form you're likely to see in the wild:

int ** numberGrid;

This may look a bit strange, but remember two points:

1. A memory block is represented as a pointer (void * memoryBlock)
2. A memory block can act as an array

So if this is an array:

int * numberArray;

... this can be an array of arrays:

int ** numberGrid;

Be careful, though, because this sort of declaration could also be treated as an array of pointers to specific ints, which is a subtle difference.

Array of Strings

Dealing with strings in C is really deserving of its own post so I'm not going to go into deep details here, but there's one convention that you should be aware of for general code reading:

char ** inputValues;

This sort of thing is usually an array of strings. Remember, a string is an array of individual characters, so a an array of strings is a two-dimension array of characters.

Final Example

Here's a short program that illustrates all of these points.

#include <stdio.h>
#include <stdlib.h>

int main ()
{
  // number of strings
  const int count = 5;
  
  // declare an array of strings
  char ** stringArray = calloc ( count, sizeof(char *) );
  printf("stringArray address: %p\n", stringArray);

  // if the memory we asked for isn't available, return
  if ( stringArray == NULL )
  {
    return 1;
  }
  
  // this is what we'll use to move through the
  // memory block
  char ** currentString = stringArray;
  int i;  

  printf("Initial currentString address: %p\n", currentString);
    
  // now we have to loop through the memory block and
  // allocate memory for a string at each "array" slot.
  //
  // note that the asprintf() function doesn't return
  // the string. Instead, it writes directly to the
  // slot in the memory block
  for ( i = 0; i < count; i++ )
  {
    asprintf ( currentString, "String %i", i );
    currentString++;
    printf("currentString address: %p\n", currentString);  
  }
  
  // reset memory block to the original address.  
  // In other words, go the beginning of the "array"
  currentString = stringArray;
  printf("currentString address after reset: %p\n", currentString);
  

  // display the string at this particular slot.
  // we have to use the star to de-reference
  for ( i = 0; i < count; i++ )
  {
    printf( "%s\n", *currentString );
    currentString++;
  }

  // reset
  currentString = stringArray;

  // loop through and free the memory for the
  // string at each slot
  for ( i = 0; i < count; i++ )
  {
    free ( *currentString );
    currentString++;
  }

  // now free the memory block itself
  free ( stringArray );
}

This should give some output like this:

stringArray address: 0x500120
Initial currentString address: 0x500120
currentString address: 0x500124
currentString address: 0x500128
currentString address: 0x50012c
currentString address: 0x500130
currentString address: 0x500134
currentString address after reset: 0x500120
String 0
String 1
String 2
String 3
String 4

Notice how each time we do currentString++, the address increases by four bytes:

500120 > 500120 > 500124...

This allows us to move through the memory block and treat it as an array. After the loop is complete, we have to "reset" currentString by reassigning its value to that of stringArray:

currentString = stringArray;

If we don't do this and attempt to keep moving through the array, we'll run off the end of the memory block and bad things will happen. This is how bugs are born! There are various tools to avoid these sorts of situations, but those are beyond the scope of this post.

Wrap Up

You should now have at least a basic grasp on how pointers and dynamic memory management work in C. Now go out and experiment on your own. Go on, get.

Comments Temporarily Disabled

I had to temporarily disable comments due to spam. I'll re-enable them soon.