Static and Dynamic Memory

Static memory is what you have seen and used so far: variables (including pointer variables) and arrays of fixed size. You can work with these blocks of memory in your program code using their names as well as their addresses (see Chapter 9, “Working with Pointers”).

With static memory you define the maximum amount of space required for a variable when you write your program:

char a[1000]; // Fixed at runtime.

Whether needed or not, all of that memory will be reserved for that variable and there is no way to change the amount of static memory while the program runs.

Dynamic memory is different. It comes in blocks without names, just addresses. It is allocated when the program runs, in chunks from a large pool that the standard C library manages for you.

You use the standard library's malloc() function to request a block of a certain size—in bytes—from the available memory pool. The size is dynamic and can be determined when the program runs (Figure 10.1):

int memsize;
// memsize gets a value at runtime.
x = malloc(memsize);

Figure 10.1. A block of dynamic memory (represented in the bottom grid) does not have a name as variables and pointers do (the top grid). Referring to a dynamic memory block's address is the only way to access it.

[View full size image]

When you are done with the block, you return it to the pool using the free() function:

free(x);

Every call to malloc() must be balanced by a call to free(). A missing or double free() call is considered a bug (specifically, a missing free() statement creates a memory leak).

If enough memory is available to satisfy your request, the malloc() function returns the starting address of the newly allocated block. You usually store this address in a pointer variable for later use.

There is a small problem, though. Remember from the previous chapter that a pointer variable can only hold an address of the appropriate type, that is, a char pointer variable can only hold the address of a char, an int pointer variable can only hold the address of an integer, and so on. However, the blocks of memory whose starting addresses malloc() returns are just that: untyped blocks of memory of the requested size. The type of the data stored in them is usually determined later on in the program, after the malloc() call.

To accommodate addresses of such untyped blocks of memory, C provides a special type of pointer variable called a void pointer. You define such a pointer like so:

void *x;

A void pointer variable can store addresses of any type, including integers, chars, floats, etc. It can also store the addresses of the untyped blocks of memory that malloc() returns:

void *x;
x = malloc();

Finally, as an extra precaution, the pointer should be set to NULL after you have freed the associated memory:

void *x;
x = malloc (size);
free(x);
x = NULL;

By taking this final step, the program knows that x no longer refers to a block of memory. This is desired so that any uses of x (unless it is assigned another value beforehand) will fail rather than create hard-to-debug oddities.

Let's write our first dynamic memory example using malloc() and free(). The example is short but introduces the basic syntax that will be used again in all subsequent examples, so it is important for you to understand this process clearly.

To request and return dynamic memory

/* memory c - Script 10.1 */
#include <stdio.h>
#include <stdlib.h>

int main (void) {

void *x;

x = malloc(1000);

printf("Starting block address:
 %p.
", x);

free(x);
x = NULL;

    getchar();
    return 0;
 }

void *x;
x = NULL; /*x doesn't point anywhere.

x = malloc(1000);
if (x == NULL) {
    printf("Unable to allocate!
");
    // Handle the error.
}