Base Address of Array

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're 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.

An array is a homogenous data structure, which implies that we may store

comparable types of data on the same array. When we talk about an array, we always
assume that each element takes up an identical amount of memory space. Every
array is determined using the base address for the array. Essentially, the base address
aids in determining the addresses of all array items.

Imagine an array A having n items. Every component of the array has a size of y bytes.
Again, if the array count begins at 0 (as in the C language), the last member of the
array is expressed as A[n-1].

Now, returning to the storage address of a single element, suppose it is in the array's
x location.
A[x} equals the array's initial address multiplied by the number of members
preceding x. Size of each element.

If we have an array A with 50 members, the starting address is 10764H (H stands for
hexadecimal), the size of every component is 2 bits, and if we want to get A[21], we
should assume that the array count starts at 0. So to achieve A[21], we need the
array number to be 22 . since we began to count from 0 rather than 1.

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

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.

Address of a[1][2] = base address + 6*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, as the name implies. 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.

Address of a[1][2] = base address + 7*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-

dimensional 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).

Solution: 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.

The array can also be sent as a pointer, much as an array of one dimension in a
function would be.

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