Static 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;

We may want to group these characters, to form a party. This is where arrays can help us. Arrays are objects designed to store a collection of other objects.

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.

Note: this lesson introduces static arrays, which have a fixed size that must be known at compile time. For most cases, a dynamic array is more useful, as it can grow and shrink as needed at run time. We covered dynamic arrays in our beginner course:

Dynamic Arrays using std::vector

Explore the fundamentals of dynamic arrays with an introduction to std::vector

Creating a std::array

There are hundreds of implementations of arrays in C++ that we can use, and we can even create our own once we learn more advanced topics.

The standard library’s implementation of static arrays is called std::array

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;

The number of objects an array contains - 5 in the previous example - is sometimes referred to as its size or its length.

We can initialize the values at the same time:

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

When we initialize the values at the same time we declare the array, we can optionally remove the type and size. The compiler can infer this based on the initial values we provide.

As such, the following code is equivalent to the previous:

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

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

Setting the Size of a std::array

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 the following 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;

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:

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

1invalid template argument for 'std::array', expected compile-time constant expression

Element Access using the [] Operator

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, indexing is zero-based. That means we start counting from 0. Therefore, 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]};

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}

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

1First
2Second
3Third

We also have the front() and back() methods, as an alternative way to access the first and last elements respectively:

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 << "Front: " << MyArray.front();  
10
11  // Log out the element at index [size - 1]
12  cout << "\nBack: " << MyArray.back();  
13}

1Front: First
2Back: Third

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}

1First

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.

Specifically, it will throw a std::out_of_range exception:

1#include <array>
2#include <iostream>
3
4int main() {
5  using std::array;
6  array MyArray{"First", "Second", "Third"};
7
8  try {
9    MyArray.at(3);
10  } catch (std::out_of_range& e) {
11    std::cout << e.what();
12  }
13}

1invalid array<T, N> subscript

Exceptions: throw, try and catch

This lesson provides an introduction to exceptions, detailing the use of throw, try, and catch.

However, in most cases, we should not use at(). The additional check performed by at() has a performance cost, and it 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.

1#include <array>
2#include <iostream>
3
4int main() {
5  using std::array;
6  array MyArray{"First", "Second", "Third"};
7
8  MyArray[3];
9}

1array subscript out of range
2example.exe (process 52600) exited with code 3.

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}

Iteration using a for Loop

A common task we have when working with arrays is to loop over every element in them, 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 (size_t i{0}; i < 3; ++i) { // see below 
8    std::cout << MyArray[i] << ", ";
9  }
10}

11, 2, 3,

Rather than having the array’s size of 3 included in our loop header, we can make our code a little smarter and more resilient to code changes.

Using the size() Method

The previous example uses i < 3 to determine when our loop should end, as we know our array has a size of 3.

However, if we later update our code to change the size of our array, we would need to find and update everywhere we were assuming the size to be 3, or we would have a bug.

Additionally, we don’t always know the array size - for example, we might be writing a template function that can be instantiated with arrays of different sizes.

We can make our code a little smarter - std::array has a size() method that, predictably, returns the size of the array:

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

1Size: 3

We can update our loop to use this method:

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

11, 2, 3,

Iteration using a Range-Based For Loop

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, 2, 3,

We cover ranges and range-based for loops later in the chapter.

Updating Objects in Arrays

Once we’ve accessed an object in an array - for example, using the [] or at() method - we can use it as normal.

For example, we can apply operators to it, or send it to a function:

1#include <array>
2#include <iostream>
3
4void Double(int& x) { x *= 2; }
5
6int main() {
7  std::array MyArray{1, 2, 3};
8
9  MyArray.front()++;
10  MyArray[1] += 2;
11  Double(MyArray.back());
12
13  for (int i : MyArray) {
14    std::cout << i << ", ";
15  }
16}

12, 4, 6,

We can replace an object at an index entirely using the assignment operator, =:

1#include <array>
2#include <iostream>
3
4void Set(int& x, int y) { x = 300; }
5
6int main() {
7  std::array MyArray{1, 2, 3};
8
9  MyArray.front() = 100;
10  MyArray[1] = 200;
11  Set(MyArray.back(), 300);
12
13  for (int i : MyArray) {
14    std::cout << i << ", ";
15  }
16}

1100, 200, 300,

Storing More Complex Types

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}

Where the objects stored in our array have member functions, we can access them in the usual way:

1#include <array>
2#include <iostream>
3
4class Character {
5public:
6  void SetHealth(int Health) {
7    mHealth = Health;
8  }
9  int GetHealth() { return mHealth; }
10
11private:
12  int mHealth{100};
13};
14
15int main() {
16  std::array<Character, 5> Party;
17  Party[0] = Character{};
18
19  std::cout << "Health: "
20    << Party[0].GetHealth();
21
22  Party[0].SetHealth(200);
23  std::cout << "\nHealth: "
24    << Party[0].GetHealth();
25}

1Health: 100
2Health: 200

Multidimensional Arrays

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]};

Later in the course, we cover dedicated types to represent multi-dimensional arrays, but nesting arrays in this way is still commonly used.

Type Aliases

Often, C++ types can become very complex. This can make our code hard to read or frustrating to write if we constantly need to repeat a huge type name.

We can use a using statement to create a simpler alias for our types. Here, we alias our complex nested array type to the much simpler name of Grid:

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  }};

We covered type aliases in more detail earlier in the course:

The using Keyword

This lesson introduces the using keyword in C++, focusing on namespaces, enums, and type aliasing

Array Pointers and References

Like any other object, we can 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;

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}

Summary

In this lesson, we explored the use of std::array in C++, covering its fundamental properties and usage. We've gained a solid understanding of how to effectively utilize std::array, including:

• std::array provides a safe, fixed-size array alternative to dynamic arrays such as std::vector.
• We learned how to declare, initialize, and access elements in std::array using various methods, including subscript notation and at() for bounds-checked access.
• The lesson covered the importance of std::size_t for indexing and the use of size() method to make code more adaptable and less error-prone.
• We discussed iterating over std::array elements using traditional for loops and range-based for loops.
• The versatility of std::array was highlighted through examples showing it can store complex types, including multidimensional arrays.

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

View Course