Modern C++ in Advent of Code: Day2

It is day two of Advent of Code. Today we will be working with a struct and have a look at the spaceship operator.

As always, please try to solve the problem before looking at the solution. For all articles in this series, check out this list.

Day2: Part1

We are given instructions in text form. The format is line-based with a single command on each line, with each command formed from a direction and a numerical value.

forward 10
down 2
up 1

Parsing text is one of the areas where the C++ standard library doesn’t particularly excel. The high-level facilities are not very efficient, and low-level facilities are not particularly easy to use. I will be sticking with the high-level facilities but will call out where the code is particularly inefficient.

We will need a way to track the position as we parse the input. The easiest way is to create a simple struct with two fields: depth that is adjusted using up and down commands and distance that is affected using the forward command.

We can simplify the problem for us and deal with each line in isolation. Since each command translates into a position delta, we can parse a line and return a Position. The outside code can then add the delta to the running position.

As in Day 1, we will start by writing tests for this line parsing function:

Note that this code now requires that Position is comparable because of EXEPECT_EQ. We can fix that quickly by adding a default spaceship operator to our struct. The default implementation provides a lexicographic comparator, but we only need == and !=.

Now its time to implement the line parsing:

We first find the space delimiting the command from the number (line 2), then convert the number to an integer (line 3), and return a different position delta based on the command.

If we did care about performance, we would be working with a std::string_view. Unfortunately, the standard library doesn’t currently offer facilities to convert std::string_view to a number (directly), and we would have to write a wrapper around std::from_chars .

With that said, while we are forcing copies of std::string , all the commands we are parsing should comfortably fit within small string optimization. Thus even with copies, we shouldn’t be causing memory allocations and the cost should be equivalent to using std::string_view.

To parse the entire input, we now go line by line and call our line parsing code. But first, the test code:

One thing we are still missing is a way to add the position deltas together. We can add the operator+= to our Position struct, so we don’t have to deal with the additions manually.

With a line parser and Position supporting operator += the complete parsing code is quite streamlined:

We go line-by-line until we reach the end of the file, apply our line parser on each line and add the result to the running total.

Day2: Part2

The second part of the problem introduces an interesting twist. Instead of up and down representing a direct movement, they change the direction, with forward then applying this direction.

So far, our code was stateless, and each line was interpreted in isolation. The introduction of direction changes the meaning of forward. Therefore, we must keep track of direction by changing our line parsing code to be stateful. But let’s start by adjusting our Position struct.

Moving the raw operations to member functions will make our parsing code a bit cleaner to read.

This test also decides on the interface of how we provide the state to the line parser. We have other options, and for example, this parsing code could also be a member function of our position struct: pos.parse(line).

With all this preparation, our line parser is very similar to the version from part1:

And putting all this together also in a very similar fashion:

We still call the line parser on each line as before. However, this time, we pass in the state that is kept across all the invocations.

Lastly, since I didn’t show it in Part1, let’s look at our main function, which is very similar to Day1.

Links and technical notes

The repository with daily solutions is available at: https://github.com/HappyCerberus/moderncpp-aoc-2021.

For articles about the other days in Advent of Code, check out this list.

And please don’t forget to try Advent of Code for yourself.

Thank you for reading

Thank you for reading this article. Did you enjoy it?

I also publish videos on YouTube. Do you have questions? Hit me up on Twitter or LinkedIn.