Array data types

Arrays can be declared with any data type. To the computer, we are just declaring \(n\) amount of some variable, and it takes care of putting all the n variables back-to-back in memory.

First index is 0

Most programming languages (but not all) have 0 as the first index for arrays of items. (In the Lua programming language, we start at 1!)

Size must be known at compile-time

Traditional C-style arrays must have its size be defined during its declaration and the array cannot be resized during the program's execution. Because the array size can't change, and because we may need to know the size of the array throughout the program, we will generally use a named constant to store the size of the array.

const int MAX_STUDENTS = 100;
string students[MAX_STUDENTS];

Array size (const) vs. item count (variable)

Because an array's size cannot be changed after its declaration, it often becomes necessary to overshoot the amount of spaces we need in the array so that we always have enough room for our data. Perhaps a school's classrooms range from 20 to 70 seats, so we would want to declare the array of the biggest size so that we don't run out of space. Because of this, not all spaces in the array may be taken up at any given time.

C++ doesn't have a function to directly get the amount of elements in an array, so generally when declaring an array we need to also have an associated variable to track how many items we've stored in the array.

Example: Declaring an array, storing a value for the element at index 0, adding 1 to the item count

const int MAX_STUDENTS = 100;   // total array size
int studentCount = 0;           // how many elements
string students[MAX_STUDENTS];  // array declaration

students[0] = "Rai";            // setting up first student
studentCount++;                 // adding 1 to student count

In C++, we declare an array similarly to how we declare a variable, except that we need to specify an array size during declaration:

Example: Declaring an array of strings of size 100

// An array of size 100
string students[100];

Or, if we already have data to put into it, we can initialize it with an initializer list. Then the array will be sized at however many items you give it.

Example: Declaring an array of strings, initializing the data with an initializer list

// An array of size 4
string students[] = {"Rai", "Anuj", "Rebekah", "Rose"};

Valid indices

As stated earlier, if an array is of size \(n\), then its valid indices are 0 to n-1. In most computer languages, arrays and lists start at index 0 and go up from there, meaning to count for items we have "0, 1, 2, 3".

Accessing array elements via index

After we've declared an array, we can treat its elements like normal variables, storing data within it and accessing that data. Each one can be accessed via its index (position in the array) and the subscript operator: [].

In math, you might be used to these subscripts:

\[ a_n = a_{n-1} + 2 \]

But with C++, subscripts look like this:

So, declaring an array and accessing its values can look like this:

Example: Declaring an array and storing values for each element, displaying the value of the element at index 0

string courses[4];
courses[0] = "CS 134";
courses[1] = "CS 200";
courses[2] = "CS 210";
courses[3] = "ASL 120";

cout << "First course: " << courses[0] << endl;

Or, with modern C++ (from 2011 and later) you can initialize an array with an initializer list, {}

Example: Using an initializer list to initialize an array's elements

string courses[4] = {
  "CS 134",
  "CS 200",
  "CS 210",
  "ASL 120"
};

cout << "First course: " << courses[0] << endl;

string cats[4];

Let's say we have our student array and a maximum amount of 22 seats:

const int TOTAL_SEATS = 22;
string students[TOTAL_SEATS];

One design consideration to think about here is that, if we iterate from i = 0 to TOTAL_SEATS, we're going to iterate over seats that have students AND seats that are empty. What if we were writing a program and JUST wanted to display a list of students enrolled in the course, and not waste paper space or screen space drawing blank links for empty seats?

In this case we usually need to keep a variable to track how many items we're actually storing in the array. For example:

int studentCount;

so the TOTAL_SEATS would be the size of the array, but the studentCount might be less than or equal to that number. Every time we added a student we would add +1 to the studentCount. That way, we could use studentCount in our for loop to display just active students, none of the empty seats.

… The TOTAL_SEATS remain the same, even as the studentCount grows from more students taking up space in available seats…

Since the array index is always an integer, we could use a variable to determine which item in an array to modify - such as asking the user which item they want to edit.

Example: Asking the user to enter an index and displaying the element at that index

cout << "Edit which item? (0-9): ";
cin >> itemIndex;
cout << "Enter price for item: ";
cin >> prices[ itemIndex ];

Using for loops is the most common way to iterate over all the data in an array, setting data or accessing data. Have an array of size n? We want to iterate from i = 0 to \(n-1\), going up by 1 each time.

We can iterate over all the items in an array and have the user enter information for each element by using a loop. Since the first index is 0, we sometimes just add +1 to the index for the user's benefit, since people generally aren't used to lists starting at 0.

const int TOTAL_ITEMS = 10;
float prices[TOTAL_ITEMS];

for ( int i = 0; i < TOTAL_ITEMS; i++ )
{
  cout << "Enter price for item " << (i+1) << ": ";
  cin >> prices[i];
}

We can display all the elements of an array by using a loop as well, though we usually don't want to show all elements of the array - usually just the items we know we're storing data in. Recall that we usually will have an extra integer variable to count how many items have actually been stored in the array, which is different from the total array size.

const int MAX_STUDENTS = 100;
int studentCount = 0;
string students[MAX_STUDENTS];

// (...Let's say 20 students were added here...)

// Iterate from index 0 to 19, since we have stored
// 20 students so far.
for ( int i = 0; i < studentCount; i++ )
{
  cout << "Student " << (i+1)
    << " is " << students[i] << endl;
}

You can also use a range-based for loop in versions of C++ from 2011 or later:

for ( auto & student : students )
{
  cout << student << endl;
}

Sets all elements of this string array to an empty string and resets the elementCount to 0 afterwards.

Example: Iterating over an array and setting each element's value to 0

void Clear( string arr[], int & elementCount )
{
  for ( int i = 0; i < elementCount; i++ )
  {
    arr[i] = "";
  }
  elementCount = 0;
}

Often in our programs we will only set up one item at a time (perhaps when selected from a menu). This means we need to get the data for the array and figure out where in the array it will go.

void AddItem( string arr[], int & elementCount )
{
  cout << "Enter new element: ";
  cin >> arr[ elementCount ];
  elementCount++;
}

For an array, elementCount starts at 0 when the array is empty. This also happens to be the index where we will insert our first element - at 0.

Once we add our first element, our elementCount will be 1, and the next index to insert data at will also be 1.

Then, elementCount will be 2, and the next index to insert at will be 2.

Because of this, the elementCount variable both tells us how many items have been stored in the array and what is the next index to store new information at.

string names[5];

for ( int i = 0; i < ARRAY_SIZE; i++ )
{
    employeeWage[i] += 5.12;
}

Let's say we're writing a simple restaurant program where we need a list of dishes and their prices together. Later on, we will write our own data type using structs and classes to keep these items together. But for now, we would implement this relationship by keeping track of two separate arrays with the data we need.

This is an option, design-wise, however usually it's better to store the two arrays within a structure or class instead of making parallel arrays.

Example: Using 3 parallel arrays to store a dish's name, price, and if its vegetarian

const int MAX_DISHES = 20;
int dishCount = 0;

// Information about a dish
string  dishNames[MAX_DISHES];
float   dishPrices[MAX_DISHES];
bool    dishVegetarian[MAX_DISHES];

// ... Let's say we created some dishes here...

// Display the menu
cout << "What would you like to order?" << endl;
for ( int i = 0; i < dishCount; i++ )
{
  cout << "Dish #" << i << ":" << endl;
  cout << "* Name:   " << dishNames[i] << endl;
  cout << "* Price: $" << dishPrices[i] << endl;

  if ( dishVegetarian[i] ) {
    cout << "* Is vegetarian" << endl;
  }

  cout << endl;
}

// Get the index of dish they want
int whichDish;
cout << "Selection: ";
cin >> whichDish;

To display the contents of a 2D array, it can be useful to have two for loops, one nested in the other. The outer for loop will only increment once the inner one finishes its cycle. I usually put the rows as the outer loop and the columns as the inner-loop.

for ( int row = 0; row < ROWS; row++ )
{
    cout << "Row: " << row << endl;
    for ( int col = 0; col < COLUMNS; col++ )
    {
        cout << "\t Col: " << col
             << ": " << arr[row][col]
             << endl;
    }
}

string spreadsheet[32][32]; // rows and columns
int vertices[4][4][4];    // x, y, z

Let's say we wanted to turn a day planner into a program. Perhaps we originally stored the day plan like this:

We can convert this into a 2D array of strings (the "task"), with one dimension being for "day of the week" and the other dimension being for "hour of the day"…

int DAYS_OF_WEEK = 7;
int HOURS_IN_DAY = 24;
string todo[ DAYS_OF_WEEK ][ HOURS_IN_DAY ];

We could ask the user what day they want to set a task for, and if they type "Sunday" that could translate to 0, and "Saturday" could translate to 6 (or however you want to organize your week)…

We could ask them next for what hour the task is at, and that can map to the second index: "0" for midnight, "8" for 8 am, "13" for 1 pm, and so on to 23.

With this information, we can get the user's todo task and store it at the appropriate indices:

int day, hour;

cout << "Enter the day:" << endl;
cout << "0. Sunday    \n"
     << "1. Monday    \n"
     << "2. Tuesday   \n"
     << "3. Wednesday \n"
     << "4. Thursday  \n"
     << "5. Friday    \n"
     << "6. Saturday  \n";

cout << "Day: ";
cin >> day;

cout << "Enter the hour (0 to 23): ";
cin >> hour;

cout << "Enter your task: ";
cin >> todo[ day ][ hour ];

With the user's week planned out, you could then display it back to the user by using a nested for loop: One loop for the day, one loop for the hour.

cout << "YOUR SCHEDULE" << endl;

for ( int day = 0; day < DAYS_OF_WEEK; day++ )
{
  for ( int hour = 0; hour < HOURS_IN_DAY; hour++ )
  {
    cout << day << ", "
         << hour << ": "
         << todo[ day ][ hour ] << endl;
  }
}

Though you'd probably want to do some extra formatting; such as determining that if the day is 0, then write "Sunday" instead of the number "0".

const int ROWS = 10;
const int COLUMNS = 3;
string spreadsheet[ROWS][COLUMNS];

const int ROWS = 3;
const int COLUMNS = 4;
string pixelColors[ROWS][COLUMNS];

Row: 0
   Col: 0: #00ffff
   Col: 1: #ff00ff
   Col: 2: #000000
   Col: 3: #00ff00
Row: 1
   Col: 0: #000000
   Col: 1: #00ffff
   Col: 2: #ff0000
   Col: 3: #0000ff
Row: 2
   Col: 0: #000000
   Col: 1: #ffff00
   Col: 2: #ff0000
   Col: 3: #00ff00