7.12. Two-Dimensional And Higher Arrays

As suggested by the most recent version of the multtab demonstration and the illustrations appearing in Visualizing Arrays, we can easily create a multi-dimensional array as an automatic or local variable if we know the size of each dimension at compile time. However, if we want to specify the size of the array at runtime, we can only easily create a one-dimensional array: double* scores = new double[size];. It's difficult for us and the compiler to create a multi-dimensional array whose dimension sizes are determined at runtime as the seemingly natural way of doing so, double* scores = new double[nrows][ncols];, doesn't work.

To help us better understand the problems of creating and using multi-dimensional arrays, let's explore how the compiler maps a two-dimensional array to the linear address space of main memory. Said another way, to locate an element in a two-dimensional array, the compiler must convert two address variables, row, and column, into the single address value used to locate the element in main memory. Once we understand how the compiler does the mapping or conversion, we can use our understanding to develop two ways to create multi-dimensional arrays.

row-major Ordering

An illustration in chapter 4 suggests that we can view a computer's main memory as an array of bytes. In this view, each byte of main memory corresponds to one array element, and the address of each byte is analogous to the index location of the corresponding element. This arrangement suggests that when we create and use a one-dimensional array in a program, it's quite easy for the compiler to convert or map the location of an array element to a memory address. Although it takes multiple bytes of memory to store most C++ data types (see part (b) of the illustration), this fact does not significantly increase the complexity of the mapping operation. Recalling that the name of an array is the address of the array, the compiler generates the mapping operation array + i * sizeof(T), where T is some unspecified data type, array is the name of an array, and i is a valid index into the array. (This expression is similar to, but not the same as, the code a programmer writes to solve the sample problem. Test your understanding: Review Arithmetic with multi-byte data and try to write the correct C++ code. The answer is at the end of the page)

Historically, two similar techniques were used to map multi-dimensional arrays into linear memory: row-major and column-major order. (However, the only well-known computer maker using column-major ordering long ago converted to row-major.) The row-major order maps the elements of a two-dimensional array to a one-dimensional array by rows: reading left-to-right, top-to-bottom, the first row, then the second row, etc. Alternatively, column-major order maps the elements by columns: reading top-to-to-bottom, left-to-right, the first column, then the second column, etc.

	array[i][j] = array[2][1] = RM[i * ncols + j] = RM[2 * 3 + 1] = RM[7]
	(b)
	array + sizeof(T) * (i * ncols + j);
	(c)
	array[i * ncols + j] ≡ array + (i * ncols + j)
(a)	(d)

#include <iostream>
using namespace std;

void print(char array[][3], int i, int j)			// (a)
{
	cout << array[i][j] << endl;
}

void print(char array[][2], int i, int j)			// (b)
{
	cout << array[i][j] << endl;
}

void print(char* array, int i, int j, int ncols)		// (c)
{
	cout << array[i * ncols + j] << endl;
}

int main()
{
	char	a1[4][3] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L' };
	char	a2[3][2] = { 'u', 'v', 'w', 'x', 'y', 'z' };

	print(a1, 2, 1);					// calls (a)
	print(a2, 1, 0);					// calls (b)
	print((char *)a1, 2, 1, 3);				// calls (c)
	print((char *)a2, 1, 0, 2);				// calls (c)

	return 0;
}

Although understanding how a program stores and accesses a two-dimensional array in memory explains why functions require the second and subsequent dimension sizes, it doesn't help programmers create two-dimensional arrays whose sizes are determined at runtime. After all, the program in the previous example still specifies the array sizes with compile-time constants: a1[4][3] and a2[3][2]. But understanding how row major-ordering works does suggest how we can synthesize a two-dimensional array from a one-dimensional array.

Creating Two-Dimensional Arrays with row-major Ordering

Now that we have an idea of how row-major ordering works - how it converts two indexes into one index - we can use it to create a one-dimensional array that behaves like a two-dimensional array. The "trick" is a simple expression that consistently combines the row and column to produce the same, unique single array index value. For clarity, the following example evaluates the expression in an inline function.

#include <iostream>
#include <iomanip>
using namespace std;


inline int index(int row, int col, int ncols) { return row * ncols + col; }	// (a)

int main()
{
	int	nrows;
	int	ncols;

	cout << "Number of rows: ";
	cin >> nrows;
	cout << "Number of columns: ";
	cin >> ncols;

	int*	table = new int[nrows * ncols];					// (b)

	for (int row = 1; row <= nrows; row++)
		for (int col = 1; col <= ncols; col++)
			table[index(row - 1, col - 1, ncols)] = row * col;	// (c)


	for (int row = 0; row < nrows; row++)
	{
		for (int col = 0; col < ncols; col++)
			cout << setw(4) << table[index(row, col, ncols)];	// (c)
		cout << endl;
	}

	return 0;
}

Although creating a simulated two-dimensional array is easy, and we don't need to destroy it later (because the program makes it on the stack), using the array is a little awkward and unnatural. Whenever we want to access an array element, we must translate the row×column address into a single array index using the row-major ordering. Another two-dimensional technique is available.

Creating Two-Dimensional Arrays As An Array Of Arrays

Java takes a different approach to creating multi-dimensional arrays: it creates an array of arrays. Specifically, creating a two-dimensional array creates a one-dimensional array whose elements are arrays. We can do the same in C++. This technique reverses the advantages and disadvantages of the row-major solution. It takes more effort to create the array, and we must destroy it later, but using the array is less awkward because it only uses the array indexing operator.

#include <iostream> #include <iomanip> using namespace std; int main() { int nrows; int ncols; cout << "Number of rows: "; cin >> nrows; cout << "Number of columns: "; cin >> ncols; int** table = new int* [nrows]; // (i) for (int i = 0; i < nrows; i++) // (ii) table[i] = new int[ncols]; for (int row = 1; row <= nrows; row++) for (int col = 1; col <= ncols; col++) table[row-1][col-1] = row * col; // (iii) for (int row = 0; row < nrows; row++) { for (int col = 0; col < ncols; col++) cout << setw(4) << table[row][col]; // (iii) cout << endl; } for (int i = 0; i < nrows; i++) // (iv) delete[] table[i]; delete[] table; return 0; }

(a)

(b)

array + i