LETTERS

Revisiting Variably Dimensioned Arrays in C

Many scientific and engineering programmers are changing from Fortran to C or C++ for technical and numerical applications. As with Fortran, C/C++ enable separate development of general-purpose routines, and libraries for holding them, that can be linked later with a variety of programs.

However, a serious weakness of C/C++ is the inability of either language to handle arrays with two or more dimensions as arguments to a function--if the array sizes are to be specified at run time.

With single-dimensioned arrays, there is no problem. In C or C++, the array dimension can be omitted in the function (for example, float a[];). With arrays of two or more dimensions, all sizes except the first must be known at compile time, as these sizes are used by the compiler in generating the machine instructions to access the array elements.

This has been a major cause for the slowness of scientists, mathematicians, and engineers to accept C or C++ as a viable language for their work, despite the availability of better data and program structuring features and recursion.

In his article, "Variably Dimensioned Arrays in C" (DDJ, August 1993), John Ross discussed a number of methods for overcoming this weakness of C or C++. The most useful and transparent method for the user of the function or library is to use pointer variables instead of arrays. The person using the library would write a program calling such a function by passing the address of the array and its dimensions as arguments. The person writing the function itself would use the pointer variable and increment it as needed to process the desired array elements.

This approach is most suitable if the array can be processed sequentially. It has the disadvantage for the function writer that the use of pointers and the need for sequential processing of the array can make the function itself difficult to understand and write.

However, the approach can be extended and simplified by using the preprocessor. It is possible to define a macro for performing an array-address calculation. Then elements of an array can be referred to with a convenient notation, and the function becomes much more readable.

To calculate the address of an element of the array, we need to add to the base address (for instance, the address of the start of the array), the number of elements in the rows before the current one, and the position of the desired element in its row. If a is the start address of the array, m the number of rows, and n the number of columns, the address of the i,j element will be a+i*n+j.

A suitable macro might be #define A(I,J) (*(a+(I)*n+(J))), where we are using the uppercase A to refer to elements of the array passed through the pointer argument a. Macros use a notation different from array references, one that will be familiar to Fortran programmers for the arguments. We can refer to an element of the array as A(1,3), for example.

This is not as fast as directly incrementing pointer variables, as John demonstrated, but makes the program easier to read--and will be applicable to a wider range of applications.

For example, an algorithm for matrix multiplication (Example 1) and its implementation in C (Example 2) show a direct correspondence of the lines, made possible by the use of simple macros for array references. Such a function can be called from a C program where the arrays are declared normally (Example 3).

You have to be careful if you try to mix such C functions with Fortran programs, because the two languages use different storage orders for the elements. Fortran holds the elements of an array column-wise, whereas C and C++ hold the elements row-wise. This, in effect, is a reversal of the order of the dimensions.

T. Graham Freeman

Australian Defense Force Academy

Example 1: Simplest algorithm for array multiplication.

for i = 1 to m
  for j = 1 to p
    C(i,j) = 0
    for k = 1 to n
      C(i,j) = C(i,j)+A(i,k)*B(k,j);

Example 2: C/C++ function using macros to simplify array references.

void matmul(int m, int n, int p,
   float *a, float *b, float *c)
   /* "a" is m rows by n cols,
      "b" is n rows by p cols, and
      "c" is m rows by p cols */ {
#define A(I,J) (*(a+(I)*n+(J)))
#define B(I,J) (*(b+(I)*p+(J)))
#define C(I,J) (*(c+(I)*p+(J)))
  int i, j, k;
  for (i=0; i<m; ++i)  {
    for (j=0; j<p; ++j)  {
      C(i,j) = 0;
      for (k=0; k<n; ++k)  {
        C(i,j) += A(i,k)*B(k,j);
     }
   }
 }
#undef A
#undef B
#undef C
}

Example 3: Main program to call the function in Example 2.

void matmul(int m, int n, int p,
    float *a, float *b, float *c);

main()
  {
    float aa[6][4],
    bb[4][7],
    cc[6][7];
    /* read numbers into aa and bb */
    matmul(6,4,7,aa,bb,cc);
    /* matmul(6,4,7,

      (float*)aa,(float*)bb,(float*)cc);


       will press the warning messages */
    /* print cc */
  }