C++ Arrays using std::vector

Inevitably, we will want to store a group of related objects. That might be a collection of characters in a party; a collection of buttons on a UI, or just a simple collection of numbers.

Programmers have invented a huge range of options for storing collections - these containers are typically called data structures. Here, we’ll introduce the most common choice - the dynamic array.

Lets imagine we have these 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.

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.

Creating an Array using std::vector

The standard library has an implementation of dynamic arrays that we can use. Confusingly, the C++ standard library calls dynamic arrays “vectors”. This has little in common with the vectors we’ve been working with in earlier lessons. It’s just an unfortunate name.

It’s also generally not the name used for these collections, even among C++ developers. Typically, we call them “dynamic arrays”, “resizable arrays”, or simply “arrays”.

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

1#include <vector>
2
3std::vector<int> MyVector;
4

We can initialize the values at the same time:

1std::vector<int> MyVector { 1, 2, 3, 4, 5 };
2

When we are initializing the values at the same time we declare the vector, we can optionally remove the type. This lets the compiler infer it.

To do this, the compiler is using Class Template Argument Deduction (CTAD), which we’ll cover more in the intermediate course:

1std::vector MyVector { 1, 2, 3, 4, 5 };
2

Accessing Items in Arrays

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

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

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

1std::vector MyVector { 1, 2, 3, 4, 5 };
2
3int FirstElement { MyVector[0] };
4int SecondElement { MyVector[1] };
5int LastElement { MyVector[4] };
6

Note that because we start counting from 0, this also means the last element of a vector is at an index of 1 less than its size. For a vector 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:

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

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

1First
2Second
3Third
4

Adding Items to Arrays

Once our vector is created, we’ll often want to add more items to it. Typically, we want to add items to the end of arrays. Adding items to the end of arrays has performance benefits over adding them to the start. We’ll cover the performance characteristics of containers in more detail in the intermediate chapter.

For now, what we need to know is that vectors have two methods for adding items to their end: push_back and emplace_back

push_back

If an object has already been constructed, and we want to add it to the back of our vector, we can use push_back:

1class Character {
2public:
3  std::string Name;
4}
5
6int main() {
7  Character Legolas { "Legolas" };
8  std::vector<Character> MyVector;
9  MyVector.push_back(Legolas);
10}
11

emplace_back

If the object we want to add does not already exist, we can construct it right inside of the vector, using emplace_back.

The arguments we call emplace_back with will be passed to the constructor of the object type the vector stores:

1class Character {
2public:
3  std::string Name;
4}
5
6int main() {
7  std::vector<Character> MyVector;
8  MyVector.emplace_back("Legolas");
9}
10

Constructing an object in place has performance benefits over creating the object and then moving or copying it into the vector. So, where possible, prefer emplace_back over push_back.

Storing Complex Types in Arrays

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

1class Character {};
2
3// A party of characters
4std::vector<Character>;
5
6// A party of character pointers
7std::vector<Character*>;
8
9// A party of const character references
10std::vector<const Character&>;
11

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

1std::vector<std::vector<int>> MyGrid {{
2  { 1, 2, 3 },
3  { 4, 5, 6 },
4  { 7, 8, 9 }
5}};
6
7int TopLeft { MyGrid[0][0] }; // 1
8int BottomRight { MyGrid[2][2] }; // 9
9

1using Grid = std::vector<std::vector<int>>;
2
3Grid MyGrid {{
4  { 1, 2, 3 },
5  { 4, 5, 6 },
6  { 7, 8, 9 }
7}};
8

We can also have pointers to arrays:

1// Pointer to an array
2std::vector<std::vector<int>>* MyGridPointer;
3
4// Pointer to an array with a using statement
5using Grid = std::vector<std::vector<int>>;
6Grid* AliasedPointer;
7

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

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

Looping over Arrays using 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:

1std::vector MyVector { 1, 2, 3 };
2
3for (int i { 0 }; i < 3; ++i) {
4  std::cout << MyVector[i];
5}
6

Line 3, highlighted above, uses the i < 3 conditional, as we know our array has a size of 3. However, often, we won’t know what size the vector we’re dealing with is.

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

1std::vector MyVector { 1, 2, 3 };
2std::cout << MyVector.size(); // 3
3

We can update our loop to use this method:

1std::vector MyVector { 1, 2, 3 };
2
3for (int i { 0 }; i < MyVector.size(); ++i) {
4  std::cout << MyVector[i];
5}
6

Using the std::size_t type

There is an issue with using int values as the index of vectors: the size of vectors 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 vector, as well as other objects.

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

1std::vector MyVector { 1, 2, 3 };
2
3for (std::size_t i { 0 }; i < 3; ++i) {
4  std::cout << MyVector[i];
5}
6

Iterating over Arrays 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 vector.

For those scenarios, we can just use this syntax:

1std::vector MyVector { 1, 2, 3 };
2
3for (int Number : MyVector) {
4  std::cout << Number;
5}
6

This is known as a range-based for loop. There are some things to note:

Firstly, by convention, C++ programmers tend to use auto when working with these types of loops:

1std::vector MyVector { 1, 2, 3 };
2
3for (auto Number : MyVector) {
4  std::cout << Number;
5}
6

Secondly, they use pass-by-value. This means each item in the collection is copied into the body of the loop. This is almost never what we want, so we can pass by reference instead:

1std::vector MyVector { 1, 2, 3 };
2
3for (auto& Number : MyVector) {
4  std::cout << Number;
5}
6

Finally, just like when we’re passing-by-reference into a function, if the function isn’t going to modify that reference, we should mark it as const:

1std::vector MyVector { 1, 2, 3 };
2
3for (const auto& Number : MyVector) {
4  std::cout << Number;
5}
6