INFO: Dynamic Memory Allocation for Two-Dimensional Arrays

• Microsoft C for MS-DOS, versions 6.0, 6.0a, 6.0ax
• Microsoft C for OS/2, versions 6.0, 6.0a
• Microsoft C/C++ for MS-DOS, version 7.0
• Microsoft Visual C++ for Windows, versions 1.0, 1.5
• Microsoft Visual C++ 32-bit Edition, versions 1.0, 2.0, 2.1, 4.0, 4.1, 5.0

SUMMARY

The C language does not internally support dynamic memory allocation for two-dimensional arrays. Creating such a structure requires some programming to set it up; however, once created the elements can be referred to by the familiar double bracket ([][]) notation. There is memory overhead involved in creating the structure. This technique is platform-independent working in the MS-DOS, Windows, Windows NT, and OS/2 operating systems.

MORE INFORMATION

For the compiler to generate code for two-dimensional array element dereferencing, the number of columns of the array must be known at compile time. Therefore, it is possible to dynamically allocate a two-dimensional array if pointer declaration includes the "width" of the array. Below is a code fragment that illustrates this:

    char (*array)[columns];

    array = (char (*)[columns]) malloc(sizeof(char) * rows * columns);
    if (array == NULL)
    {
        printf("Not enough memory!\n");
        return;
    }

These are the steps for dynamically allocating a two-dimensional array:

1. Declare a double dereferenced pointer of a desired type.

2. Allocate the number of rows times the size of a pointer and assign the first dereference to the beginning of this allocation.

3. Loop through the rows and allocate the number of columns times the size of the element.

   Array of                    Arrays of
   Pointers                    Elements

   ------     -------------------------                      -------
   |    | -->|   |   |   |   |   |   |     . . . . . . .       |   |
   ------     -------------------------                      -------
   |    | -->|   |   |   |   |   |   |     . . . . . . .       |   |
   ------     -------------------------                      -------
   |    | -->|   |   |   |   |   |   |     . . . . . . .       |   |
   ------     -------------------------                      -------
   |    | -->|   |   |   |   |   |   |     . . . . . . .       |   |
   ------     -------------------------                      -------
         .
         .
         .
         .
         .    -------------------------                      -------
   |    | -->|   |   |   |   |   |   |     . . . . . . .       |   |
   ------     -------------------------                      -------
   |    | -->|   |   |   |   |   |   |     . . . . . . .       |   |
   ------     -------------------------                      -------

Unlike a statically declared two-dimensional array, the rows are not contiguous with one another. But because this is an array of arrays it is possible to have a total structure larger than 64K without using huge pointers. If either the number of rows or the size of the rows is greater than 64K, then huge pointers are necessary.

Sample Code

/* Semi-pseudo code for a two-dimensional array of char's
 * Note that this sample uses the far heap and uses far pointers.
 * For 32-Bit Windows applications on Windows NT or Win32S or for
 * OS/2, use malloc() and remove the _far keywords.
 */

    char _far * _far * array;
    unsigned int i;
    unsigned int rows, columns;  /* let's keep it within 64k */

    /*  Set the rows and columns to desired dimensions. */
    rows    = 8;
    columns = 12;

    array = (char _far * _far *) _fmalloc(sizeof(char _far *) * rows);
    if (array == NULL)
    {
        printf("Not enough memory\n");
        return;
    }
    for (i = 0; i < rows; i++)
    {
        array[i] = (char _far *) _fmalloc(sizeof(char) * columns);
        if (array[i] == NULL)
        {
            printf("Not enough memory\n");
            /* handle error, _free() the previously allocated rows */
            return;
        }
    }

    /* to use the array: array[row][column] */
    array[0][1] = 'x';

    /* etc.   */

/* To Free the memory used by the array

 */
    for (i = 0; i< rows; i++)
        _ffree(array[i]);
    _ffree(array);