Fixed size arrays using std::array

Inevitably, we will want to store a group of data that has the same type. For example, let's imagine we have 5 characters.

1class Character {};
2Character Frodo;
3Character Gandalf;
4Character Gimli;
5Character Legolas;
6Character Aragorn;
7

We may want to group these characters together, to form a party. This is where arrays come in

Under the hood, arrays are a contiguous block of memory, big enough to store all our objects. Therefore, to create an array, we need to know the type of objects it will contain, and how many of them we need to store.

Creating a std::array

The standard library has an implementation of arrays that we can use, to familiarise ourselves with the concept. Remember, it is the concept that is important - not the particular implementation within the standard library.

There are hundreds of implementations of arrays in C++ that we can use, or we can even create our own once we learn more advanced topics. We're using the version in the standard library here just because it is easy to include in our project, and is a good introduction to the key concepts.

To use std::array, we need to #include <array>. We can then declare an array by giving it a name and specifying the type and quantity of things it will contain. The following example shows how we can declare an array that stores 5 integers:

1#include <array>
2
3std::array<int, 5> MyArray;
4

We can initialize the values at the same time:

1#include <array>
2
3std::array<int, 5> MyArray { 1, 2, 3, 4, 5 };
4

When we initialize the values at the same time we declare the array, we can optionally remove the type and size. This lets the compiler infer it.

To do this, the compiler is using Class Template Argument Deduction (CTAD), which we covered in our earlier lessons on templates:

1#include <array>
2
3std::array MyArray { 1, 2, 3, 4, 5 };
4

Resizing std::array Objects

A key thing to note about std::array is that the array has a static size. This means the size of the array must be known at compile time, and the size can not change through the lifecycle of our program.

We can use an expression to set the size of our array, but the result of that expression must be known at compile time. Something like this would work, because the compiler can figure out what integer is returned by the expression:

1#include <array>
2
3constexpr int GetSize() {
4  return 2 + 3;
5}
6
7std::array<int, GetSize()> MyArray;
8

However, if the compiler cannot determine what the result of the expression is, it will throw an error. This means we cannot set or change the size of a std::array at run time:

1std::array<int, GetUserInput()> MyArray;
2

In the beginner course, we introduced std::vector, which is an array that can dynamically resize itself at runtime

C++ Arrays using std::vector

An introduction to how we can store collections of objects into a single container, using the std::vector class

Accessing Items in std::array Containers

We can access the members of our array using the MyArray[x] notation, where x is the index of the element we want to access. The index of an element within an array is just its position.

However, we start counting from 0. This means the first element of the array is at index 0, the second element is at index 1, and so on.

For example, to access the elements of our array, we would do this:

1#include <array>
2
3std::array MyArray{1, 2, 3, 4, 5};
4
5int FirstElement{MyArray[0]};
6int SecondElement{MyArray[1]};
7int LastElement{MyArray[4]};
8

Note that because we start counting from 0, this also means the last element of an array is at an index of 1 less than its size. For an array of size 5, the last element is at index 4.

As with all values, the index can be derived from any expression that results in an integer:

1#include <array>
2#include <iostream>
3
4int CalculateIndex(){ return 1 + 1; }
5
6int main(){
7  using std::cout, std::array;
8  array MyArray{"First", "Second", "Third"};
9
10  // Log out the element at index 0
11  cout << MyArray[3 - 3] << "\n";
12
13  // Log out the element at index 1
14  int Index{1};
15  cout << MyArray[Index] << "\n";
16
17  // Log out the element at index 2
18  cout << MyArray[CalculateIndex()] << "\n";
19}
20

This code logs out elements at indices 1, 2, and 3 in order:

1First
2Second
3Third
4

Element Access using the at() method

There is an alternative to the [] operator - elements can be accessed by passing their index to the at() method:

1#include <array>
2#include <iostream>
3
4int main(){
5  using std::cout, std::array;
6  array MyArray{"First", "Second", "Third"};
7
8  // Log out the element at index 0
9  cout << MyArray.at(0); 
10}
11

1First
2

The main difference between [] and at() is that the [] method does not perform bounds-checking on the index we pass.

For example, if our MyArray only has a size of 5, and we try to access MyArray[10], our program’s behavior will become unpredictable, often resulting in a crash.

The at() method checks if the index we provide as an argument is appropriate for the size of the array. If the argument passed to at() is out of range, an exception will be thrown. We cover exceptions in detail later in this course.

However, in most cases, we should not use at(). This is because the additional check performed by at() has a performance cost, and it really shouldn't be necessary.

This is because, when we build our program in “debug” mode, most compilers will perform bounds checking on the [] operator anyway. We will get an alert if our index is out of range.

This means we’ll be able to see any out-of-range issues during the development of our program and then, when we build in release mode, those checks are removed. As such, using [] typically gets almost all of the benefits of at(), with none of the performance overhead once we release our software.

Using the std::size_t type

There is an issue with using int values as the index of arrays: the size of arrays can be larger than the maximum value storable in an int.

To deal with this problem, we have the std::size_t data type. size_t is guaranteed to be large enough to match the largest possible size of the array and other objects.

Because of this, it is the recommended way of storing array indices:

1std::size_t SomeIndex;
2
3std::size_t CalculateIndex(){
4  // ...
5}
6

Storing More Complex Types in std::array Containers

Our above example uses arrays with simple integers, but we can store any type in our array.

1#include <utility>
2#include <array>
3
4class Character {};
5
6int main(){
7  // A party of 5 characters
8  std::array<Character, 5> A;
9
10  // A party of 5 character pointers
11  std::array<Character*, 5> B;
12
13  // A party of 5 const character pointers
14  std::array<const Character*, 5> C;
15
16  // A collection of 5 pairs
17  std::array<std::pair<int, bool>, 5> D;
18}
19

Arrays can also store other arrays. This creates "multidimensional arrays". For example, a 3x3 grid could be represented as an array of 3 rows, each row being an array of 3 items

1#include <array>
2
3std::array<std::array<int, 3>, 3> MyGrid{
4  {
5    {1, 2, 3},
6    {4, 5, 6},
7    {7, 8, 9}
8  }};
9
10int TopLeft{MyGrid[0][0]};
11int BottomRight{MyGrid[2][2]};
12

1#include <array>
2
3using Grid = std::array<std::array<int, 3>, 3>;
4
5Grid MyGrid{
6  {
7    {1, 2, 3},
8    {4, 5, 6},
9    {7, 8, 9}
10  }};
11

We can also have pointers to arrays:

1#include <array>
2
3// Pointer to an array
4std::array<std::array<int, 3>, 3>* MyGridPtr;
5
6// Pointer to an array with a using statement
7using Grid = std::array<std::array<int, 3>, 3>;
8Grid* AliasedPointer;
9

We can also have references to arrays, with or without const:

1#include <iostream>
2#include <array>
3
4using Grid = std::array<std::array<int, 3>, 3>;
5
6void SetTopLeft(Grid& GridToChange, int Value){
7  GridToChange[0][0] = Value;
8}
9
10void LogTopLeft(const Grid& GridToLog){
11  std::cout << GridToLog[0][0];
12}
13

Iterating over a std::array with a for Loop

A common task we have when working with arrays is to loop over every element in them, in order to do something to each object.

We could do this with a for loop:

1#include <iostream>
2#include <array>
3
4int main(){
5  std::array MyArray{1, 2, 3};
6
7  for (std::size_t i{0}; i < 3; i++) {
8    std::cout << MyArray[i];
9  }
10}
11

1123
2

Line 3, highlighted above, uses the i < 3 conditional, as we know our array has a size of 3. However, if we add or remove an integer from our array on line 1, we would need to remember to also change line 3, as the size will no longer be 3.

And we don’t always know the array size anyway - for example, we might be writing a function that receives an array of potentially any size.

We can make our code a little smarter - std::array has a size() method that, predictably, returns the size of the array. The following code will log out 3:

1#include <iostream>
2#include <array>
3
4int main(){
5  std::array MyArray{1, 2, 3};
6  std::cout << MyArray.size();
7}
8

13
2

We can update our loop to use this method:

1#include <iostream>
2#include <array>
3
4int main(){
5  using std::size_t;
6  std::array MyArray{1, 2, 3};
7
8  for (size_t i{0}; i < MyArray.size(); i++) {
9    std::cout << MyArray[i];
10  }
11}
12

1123
2

Often, we usually don’t need to work with indices at all - we just want to iterate over everything in the array.

We can do that using a range-based for loop, which looks like this:

1#include <iostream>
2#include <array>
3
4int main(){
5  std::array MyArray{1, 2, 3};
6
7  for (int& Number : MyArray) {
8    std::cout << Number;
9  }
10}
11

1123
2

We cover range-based for loops in more detail later in the course.