Defining Arrays

The definition of an array determines its name, the type of its elements, and the number of elements in the array. An array definition without any explicit initialization has the following syntax:

type name[ number_of_elements ];

The number of elements, between square brackets ([]), must be an integer expression whose value is greater than zero. Here is an example:

char buffer[4*512];

This line defines an array with the name buffer, which consists of 2,048 elements of type char.

You can determine the size of the memory block that an array occupies using the sizeof operator. The array’s size in memory is always equal to the size of one element times the number of elements in the array. Thus, for the array buffer in our example, the expression sizeof(buffer) yields the value of 2048 * sizeof(char); in other words, the array buffer occupies 2,048 bytes of memory because sizeof(char) always equals one.

In an array definition, you can specify the number of elements as a constant expression or, under certain conditions, as an expression involving variables. The resulting array is accordingly called a fixed-length or a variable-length array.

int a[10];            // a has external linkage.
static int b[10];     // b has static storage duration and file scope.

void func()
{
  static int c[10];   // c has static storage duration and block scope.
  int d[10];          // d has automatic storage duration.
  /* ... */
}

void func( int n )
{
  int vla[2*n];            // OK: storage duration is automatic.
  static int e[n];         // Illegal: a variable length array cannot
                           //          have static storage duration.
  struct S { int f[n]; };  // Illegal: f is not an ordinary identifier.
  /* ... */
}

Accessing Array Elements

The subscript operator, [], provides an easy way to address the individual elements of an array by index. If myArray is the name of an array and i is an integer, then the expression myArray[i] designates the array element with the index i. Array elements are indexed beginning with 0. Thus, if len is the number of elements in an array, the last element of the array has the index len-1 (see “Memory Addressing Operators”).

The following code fragment defines the array myArray and assigns a value to each element.

#define A_SIZE 4
long myArray[A_SIZE];
for ( int i = 0;  i < A_SIZE;  ++i )
  myArray[i] = 2 * i;

The diagram in Figure 8-1 illustrates the result of this assignment loop.

Figure 8-1. Values assigned to elements by index

An array index can be any integer expression desired. The subscript operator, [], does not bring any range checking with it; C gives priority to execution speed in this regard. It is up to you, the programmer, to ensure that an index does not exceed the range of permissible values. The following incorrect example assigns a value to a memory location outside the array:

long myArray[4];
myArray[4] = 8;         // Error: subscript must not exceed 3.

Such “off-by-one” errors can easily cause a program to crash (or, worse still, can cause silent data corruption), and are not always as easy to recognize as they are in this simple example.

Another way to address array elements, as an alternative to the subscript operator, is to use pointer arithmetic. After all, the name of an array is implicitly converted into a pointer to the first array element in all expressions except sizeof operations. For example, the expression myArray+i yields a pointer to the element with the index i, and the expression *(myArray+i) is equivalent to myArray[i] (see “Pointer arithmetic”).

The following loop statement uses a pointer instead of an index to step through the array myArray, and doubles the value of each element:

for ( long *p = myArray; p < myArray + A_SIZE; ++p )
  *p *= 2;

Initializing Arrays

If you do not explicitly initialize an array variable, the usual rules apply: if the array has automatic storage duration, then its elements have undefined values. Otherwise, all elements are initialized by default to the value 0. (If the elements are pointers, they are initialized to NULL.) For more details, see “Initialization”.

int a[4] = { 1, 2, 4, 8 };

a[0] = 1,  a[1] = 2,  a[2] = 4,  a[3] = 8

int a[4] = { 1, 2 };
int a[]  = { 1, 2, 0, 0 };
int a[]  = { 1, 2, 0, 0, };
int a[4] = { 1, 2, 0, 0, 5 };

typedef struct { unsigned long pin;
                 char name[64];
                 /* ... */
               } Person;
Person team[6] = { { 1000, "Mary"}, { 2000, "Harry"} };

[constant_expression]

#define A_SIZE 20
int a[A_SIZE] = { 1, 2, [A_SIZE/2] = 1, 2 };

int a[] = { [1000] = -1 };

Strings

A string is a continuous sequence of characters terminated by '\0', the null character. The length of a string is considered to be the number of characters excluding the terminating null character. There is no string type in C, and consequently there are no operators that accept strings as operands.

Instead, strings are stored in arrays whose elements have the type char or a wide-character type—that is, one of the types wchar_t, char16_t, or char32_t. Strings of wide characters are also called wide strings. The C standard library provides numerous functions to perform basic operations on strings such as comparing, copying, and concatenating them. In addition to the traditional string functions, C11 has also introduced “secure” versions, which ensure that string operations do not exceed the bounds of an array (see “String Processing”).

You can initialize arrays of any character type using string literals. For example, the following two array definitions are equivalent:

char str1[30] = "Let's go";      // String length: 8; array length: 30.

char str1[30] = { 'L', 'e', 't', '\'', 's',' ', 'g', 'o', '\0' };

An array holding a string must always be at least one element longer than the string length to accommodate the terminating null character. The array str1 can store strings up to a maximum length of 29. It would be a mistake to define the array with a length of 8 rather than 30 because then it wouldn’t contain the terminating null character.

If you define a character array without an explicit length and initialize it with a string literal, the array created is one element longer than the string length. Here is an example:

char str2[] = " to London!";  // String length: 11 (note leading space);
                              // array length: 12.

The following statement uses the standard function strcat() to append the string in str2 to the string in str1 (the array str1 must be large enough to hold all the characters in the concatenated string):

#include <string.h>

char str1[30] = "Let's go";
char str2[ ] = " to London!";

/* ... */

strcat( str1, str2 );
puts( str1 );

The output printed by the puts() call is the new content of the array str1:

Let's go to London!

The names str1 and str2 are pointers to the first character of the string stored in each array. Such a pointer is called a pointer to a string, or a string pointer for short. String manipulation functions such as strcat() and puts() receive the beginning addresses of strings as their arguments. Such functions generally process a string character by character until they reach the terminator, '\0'. The function in Example 8-1 is one possible implementation of the standard function strcat(). It uses pointers to step through the strings referenced by its arguments.

// The function strcat() appends a copy of the second string
// to the end of the first string.
// Arguments:    Pointers to the two strings.
// Return value: A pointer to the first string, now
//               concatenated with the second string.

char *strcat( char * restrict s1, const char * restrict s2 )
{
  char *rtnPtr = s1;
  while ( *s1 != '\0' )                // Find the end of string s1.
    ++s1;
  while (( *s1++ = *s2++ ) != '\0' )   // The first character from s2
    ;                                  // replaces the terminator of s1.
  return rtnPtr;
}

The char array beginning at the address s1 must be at least as long as the sum of the two strings’ lengths, plus one for the terminating null character. To test for this condition before calling strcat(), you might use the standard function strlen(), which returns the length of the string referenced by its argument:

if ( sizeof(str1) >= ( strlen( str1 ) + strlen( str2 ) + 1 ) )
  strcat( str1, str2 );

A wide-string literal is identified by one of the prefixes L, u, or U (see “String Literals”). Accordingly, the initialization of a wchar_t array looks like this:

#include <stddef.h>                // Definition of the type wchar_t
/* ... */
wchar_t dinner[] = L"chop suey";   // String length: 10;
                                   // array length: 11;
                                   // array size: 11 * sizeof(wchar_t)

Multidimensional Arrays

A multidimensional array in C is merely an array whose elements are themselves arrays. The elements of an n-dimensional array are (n-1)-dimensional arrays. For example, each element of a two-dimensional array is a one-dimensional array. The elements of a one-dimensional array, of course, do not have an array type.

A multidimensional array declaration has a pair of brackets for each dimension:

char screen[10][40][80];      // A three-dimensional array

The array screen consists of the 10 elements screen[0] to screen[9]. Each of these elements is a two-dimensional array consisting in turn of 40 one-dimensional arrays of 80 characters each. All in all, the array screen contains 32,000 elements of the type char.

To access a char element in the three-dimensional array screen, you must specify three indices. For example, the following statement writes the character Z in the last char element of the array:

screen[9][39][79] = 'Z';

float mat[3][5];

for ( int row = 0;  row < 3;  ++row )
  for ( int col = 0;  col < 5;  ++col )
    mat[row][col] = row + (float)col/10;

extern float mat[ ][5];      // External declaration

int a3d[2][2][3] = { { { 1, 0, 0 }, { 4, 0, 0 } },
                     { { 7, 8, 0 }, { 0, 0, 0 } } };

int a3d[ ][2][3] = { { { 1 }, { 4 } },  { { 7, 8 } } };

int a3d[2][2][3] = {  { 1, 0, 0, 4 }, { 7, 8 } };
int a3d[2][2][3] = { 1, 0, 0, 4, 0, 0, 7, 8 };

int a3d[2][2][3] = { 1, [0][1][0]=4, [1][0][0]=7, 8 };

int a3d[2][2][3] = { {1}, [0][1]={4}, [1][0]={7, 8} };

Arrays as Arguments of Functions

When the name of an array appears as a function argument, the compiler implicitly converts it into a pointer to the array’s first element. Accordingly, the corresponding parameter of the function is always a pointer to the same object type as the type of the array elements.

You can declare the parameter either in array form or in pointer form: type name[ ] or type *name. The strcat() function defined in Example 8-1 illustrates the pointer notation. For more details and examples, see “Arrays as Function Parameters”. Here, however, we’ll take a closer look at the case of multidimensional arrays.

When you pass a multidimensional array as a function argument, the function receives a pointer to an array type. Because this array type is the type of the elements of the outermost array dimension, it must be a complete type. For this reason, you must specify all dimensions of the array elements in the corresponding function parameter declaration.

For example, the type of a matrix parameter is a pointer to a “row” array, and the length of the rows (i.e., the number of “columns”) must be included in the declaration. More specifically, if NCOLS is the number of columns, then the parameter for a matrix of float elements can be declared as follows:

#define NCOLS 10                           // The number of columns.
/* ... */
void somefunction( float (*pMat)[NCOLS] ); // A pointer to a row array.

This declaration is equivalent to the following:

void somefunction( float pMat[ ][NCOLS] );

The parentheses in the parameter declaration float (*pMat)[NCOLS] are necessary in order to declare a pointer to an array of float. Without them, float *pMat[NCOLS] would declare the identifier pMat as an array whose elements have the type float*, or pointer to float. See “Complex Declarators”.

In C99, parameter declarations can contain variable-length arrays. Thus, in a declaration of a pointer to a matrix, the number of columns need not be constant but can be another parameter of the function. For example, you can declare a function as follows:

void someVLAfunction( int ncols, float pMat[][ncols] );

Example 7-5 shows a function that uses a variable-length matrix as a parameter.

If you use multidimensional arrays in your programs, it is a good idea to define a type name for the (n-1)-dimensional elements of an n-dimensional array. Such typedef names can make your programs more readable and your arrays easier to handle. For example, the following typedef statement defines a type for the row arrays of a matrix of float elements (see also “typedef Declarations”):

typedef float ROW_t[NCOLS];   // A type for the "row" arrays.

Example 8-2 illustrates the use of an array type name such as ROW_t. The function printRow() provides formatted output of a row array. The function printMatrix() prints all the rows in the matrix.

// Print one "row" array.
void printRow( const ROW_t pRow )
{
  for ( int c = 0; c < NCOLS; ++c )
    printf( "%6.2f", pRow[c] );
  putchar( '\n' );
}

// Print the whole matrix.
void printMatrix( const ROW_t *pMat, int nRows )
{
  for ( int r = 0; r < nRows; ++r )
    printRow( pMat[r] );              // Print each row.
}

The parameters pRow and pMat are declared as pointers to const arrays because the functions do not modify the matrix. Because the number of rows is variable, it is passed to the function printMatrix() as a second argument.

The following code fragment defines and initializes an array of rows with type ROW_t, and then calls the function printMatrix():

ROW_t mat[] = { { 0.0F, 0.1F },
                { 1.0F, 1.1F, 1.2F },
                { 2.0F, 2.1F, 2.2F, 2.3F } };
int nRows = sizeof(mat) / sizeof(ROW_t);
printMatrix( mat, nRows );