Arrays: Data Structures

• Data Structures enable sophisticated data manipulation and organization.

Arrays

• Arrays store multiple values using a single name.
• An array is a series of variables of the same data type placed in consecutive memory locations as a block.
• Subscripts, or index values, are used to differentiate between the different array values.
• The data stored should be of the same kind, making it easier to read and use.
• The programmer must tell the computer how many memory locations to reserve for an array.
• This number cannot be changed while the program runs.
• To change the reserved memory, the source code must be edited, re-compiled, and executed again.
• Each individual value of an array is called an element.
• Each Element is given a number (index) corresponding to its location in memory.
  • An array element's index gives its location information relative to the first member.
  • The actual memory address is stored with the array's name.
• An array element is written using two parts of information: the array name and the index number.

One-Dimensional Arrays

• The simplest array is the one-dimensional array, which can be visualized as a column of memory locations.
• The index, a number inside square brackets, acts as a reference.
• It can be a constant, variable, or expression.
• A one-dimensional array is declared using: data_type array_name[array_size];
• The number of elements in an array can not change while the program is executing.
• Example array named numbers: int Numbers[5]; that can store five values of type integer (int).
• Individual elements of an array are accessed using the array's name with an index enclosed in square brackets [].
• Each element in an array is numbered by its index (offset/subscript), which gives its relative position to the first element.
• The smallest index is called the lower bound will always be 0 in C/C++.
• The highest index is called the upper bound.
• When declaring an array, the number in the square brackets [] is the size, but when accessing an element, it denotes the element's index.

Size of an Array

• The number of elements in the array is called its range (size).
• The upper bound (highest index) is one less than the range (size).
• Equation for range: range = upper bound + 1
• Example: int a[100]; specifies an array of 100 integers with a lower bound of 0, a range of 100, and an upper bound of 99.

Declaring and Initialising an Array

• The array num is declared to hold 5 integer values: int num[5];.
• num[0]=58; initializes the first array element with an integer value of 58.
• The index for this first element is 0; also considered the lower bound.
• num[1]=9; initializes the second array element with an integer value of 9.
• (index is 1) array element with an integer value of 9.
• num[2]=8; initializes the third array element with an integer value of 8.
• num[3]=5; initializes the fourth array element with an integer value of 5.
• num[4]=7; this represents the initialization of the fifth (and final) array element with an integer value of 7.
• The index for this last element is 4; also considered the higher bound.
• An array i is declared to hold five float values: float i[5];.
• Code example: i[]={ 58.2,9.12,8.77,100.001,7.19 }; initializes all array elements with float values 58.2, 9.12, 8.77, 100.001, and 7.19 respectively: the index starts at [0].
• The program doesn't need a specified number when initializing the array during the declaration: float i[]={ 58.2, 9.12, 8.77, 100.001, 7.19 };
• The compiler will count the actual number of elements and create an array to store them all.

Visualizing Arrays

• int i[]={ 58, 9, 8, 100, 7 };
• In memory, given four bytes per integer, this array occupies 20 bytes in total.

Behavior with Insufficient Initializer Values:

• When the number of initialiser values are less than the number of array elements, the remaining elements are initialised to zero (0).
• Example: double rate[3]={ 0.075, 0.81 };
• The rate array will hold: 0.075 , 0.81, and the last element 0.0 by default.
• When an array such as: int x[8]={3}; is declared, the variable values are:
• 3, 0, 0, 0, 0, 0, 0, 0

Practice exercises:

• Declaring an integer array named c with five elements requires the code int c[5];.
• Assigning value 12 to the first element of array c translates to c[0] = 12;.
• Adding the first 3 elements of array c and storing the result in the 4th array element: c[3] = c[0] + c[1] + c[2];.
• Dividing the 4th element of array c by 7 and assigning the result to the last element of array c: c[4] = c[3] / 7;.

Iterating Arrays

• Accessing each element of an array can be done through a loop.
• It’s important to either know or be able to determine the size of the array, as that will be the condition to end the loop.

Finding the Size of an Array

• To find the size of an array (number of elements), use the sizeof operator, which gives the size of the operand in Bytes.
• Code example to determine and display the size of the array:

// Find the number of elements in array
#include <iostream>
using namespace std;

int main() {
    int myArray[] = {5, 2, -98765, 8, 56, 78, 1, 4445, 23, 1209837, -9999, -834, 429, -674, -388, -689, -654, 267, 301, 581, -387, -82, -402, -485, -649, 961, -911, -275, -41, 683, -846, 909, 284, 644, -618, 717, -862, -670, 594, -497, 729, -447, 497, -861, 389};

    cout << "myArray is " << sizeof(myArray) << " Bytes" << endl;
    cout << "First element of myArray is " << sizeof(myArray[0]) << " Bytes" << endl;

    int arraySize = sizeof(myArray) / sizeof(myArray[0]);
    cout << "myArray has " << arraySize << " elements" << endl;

Two-Dimensional Arrays

• A two-dimensional array is a block of memory locations associated with a single variable name, designated by row and column numbers.
• The row number is always specified first, and then the column number.
• The total number of elements in a two-dimensional array is calculated by multiplying the row size (first dimension) by the column size (second dimension). The calculated value should be an integer data type.
• The row and column numbers can be constants, variables, or expressions: data_type array_name [row_size] [column_size];
• The number of elements in a two-dimensional array can NOT change while the program is executing.
• data_type array_name [row_size] [column_size];
• Total Number of Elements = row_size * column_size
• Example: int numbers[5][3];
• A two-dimensional array can store 15 integer values.
• It has 15 memory locations where you can store an integer.
• Each element can be called using a row and column index (similar to a table).
• Iterating through a two-dimensional array is performed using nested loops.
• The outer loop is for the rows and the inner loop is for the columns.

What happens in Memory…

• double rate[3][3]={ {0.075, 0.81}, {4.6} }; the remaining elements get initialized to Zero (0).