The base address refers to the position of the array's first element in memory. The memory address for any component indicates the specific position in memory where the component is stored.

If you are asking about an array's memory address, remember that the memory address and base address are the same. However, if you are looking for the memory value of an element in an array, we can compute it using the base address.

A[21]= 10764+(22*2) =10764+44 = 10808H

If we know the stored location of a specific element, we may jump straight to that position, which is extremely useful when using pointer variables.

An array comprises a collection of arrays. This means that every element of the two-dimensional array is likewise an array, resulting in a matrix-like structure known as an array with two dimensions in C++.

It's a multidimensional array. Two-dimensional arrays are denoted by the array name[n][m], where n is the total number of rows and m is the number of columns.

## Finding the address of any component in an Array

Understanding the method of computing an absolute location for every component of an array with two dimensions requires knowledge of how a two-dimensional in-nature array is kept in memory.

Although a two-dimensional array in C++ appears to be significantly different from a one-dimensional array, its memory storage is fairly similar. The two-dimensional layout of a 2-D array is provided for the convenience of the user in the form of a matrix. These arrays of two dimensions are kept in memory the same way as one-dimensional arrays are.

To store an array with two dimensions in recall, we must first map the items into a 1-dimensional array, which is then stored contiguously in memory for ease of access.

This mapping and subsequent storage of memory can be accomplished by two techniques:

• Row Main Order
• Column Main Order

### Row Main Order

As the name implies, rows are sorted sequentially in memory. This implies that all of the elements from the initial row are kept in memory first, then all of the elements from the subsequent row, and further along.

As a result, we get a one-dimensional array derived from an array of two dimensions with consecutive rows. The address for each component of array_name[i][j], where i signifies the row number and j specifies the column number (0-based index) for that element, if there is an order will be:

The address of arr[i][j] equals the base address plus the number of items spanning arr[i][j] and arr[0][0] in rows in major order. * The size of a single component in an array.

Because the items are organized in row-major order, and the total number of components spanning arr[i][j] and the initial component of the array are going to be equal to the number of rows preceding the row where this element sits * the number of items in one row + the index of the component in its row.

This is just (i * m + j) for the component arr[i][j], where m equals the total number of columns within the array.

Consequently, the absolute location of any component in row-major order becomes:

• Address of arr[i][j] = Base address + (i * m + j) * the dimension of one array element.
• If we want to determine the absolute memory location of an[1][2] in row-major order.
• In this situation, i=1, j=2, and m=4. Applying anything to the formula yields,
• The numerical address of a[1][2] equals the base address plus (1*4 + 2)*size.
• Component a[1][2] appears after 6 items when it is turned into an array with one dimension utilizing row-major ordering.

### Column Main Order

Columns are sorted sequentially in memory. This indicates that all the items of the initial column are saved in recall, then every component of the subsequent column, and continuing.

As a result, we may create an array with one dimension from an array with two dimensions by storing columns consecutively. The address for every element array_name[i][j], when i signifies the row number and j specifies the column number (0-based index) for that element, in such an order will be:

• Address many arr[i][j] = base address plus (number of items spanning arr[i][j] to arr[0][0] in column-major order). * The size of a single component in an array
• As the elements are arranged in column-major peace, the number of elements among arr[i][j] and the initial component of the set will be equivalent to the "a number for columns before that column in which this component resides * several components in one column + the row number of an element" (because this will be the number of elements kept in this column before this component in column-major order).
• This is just (j * n + i) every component arr[i][j] when n is the total amount of columns in the array.
• Consequently, the absolute location of any component in row-major order becomes:
• Address for arr[i][j] = Base location + (j*n + i) * the dimension of one member in the array
• If we need to get the absolute memory location of a[1][2] using column-major order.
• In this situation, i=1, j=2, and n=3. Applying anything to the formula yields,
• Address of a[1][2] = Base address + (2 * 3 + 1)*size.
• Component a[1][2] appears after 7 items when it is turned into an array with one dimension using column-major ordering.

## Calculating the address for any element in the 1-D Array:

The one-dimensional array is a form of linear array. Accessing its elements requires a single subscript, which might be a row or column index.

`Address of A[I] = B + W * (I-LB)`
• I = Subset of the element whose address is to be discovered.
• B is the base address, W is the storage capacity of a single element in an array (in bytes), and LB is the lower limit or bound of the subscript (if not supplied, assume zero).

Example

Determine the address space of A[1700] if the base address of A[1300 ………… 1900] is 1020 and every component is 2 bytes in memory.

Solution

Given:

• Base address: B = 1040
• The lower limit or lower bound of the subscript LB is 1500
• A single element can be stored in an array. W = 2 Bytes.
• A subset of elements whose addresses must be discovered. I = 1900
• The formula employed is Address of A[I] = B + W * (I - LB).
`Address of A[1700] = 1040 + 2 * (1900 - 1500) = 1040 + 2 * (400) = 1040 + 800.Address of A[1900] = 1840.`

## Conclusion

• An array with two dimensions is an array of arrays with each element being an array, resulting in a matrix-like structure.
• A two-dimensional array's base address serves as a starting point for calculating the addresses of all array items.
• To store an array with two dimensions in memory, we must first map its elements to a limited array. Then they are contiguously stored in memory for convenient access.

There are two methods for converting the fundamental address of an array with two dimensions into a one-dimensional array for storage:

• Row Main Order: Rows are memorized in a continuous sequence.
• Column Main Order: Columns are sequentially sorted in memory.

We may alternatively supply the data set as an array that specifies the row and column sizes.