Optional Values, std::optional and Monadic Operations

When creating classes, a common situation we’ll run into is the concept of an optional field.

For example, if we’re creating a Character class, our character may, or may not, belong to a guild:

1#include <iostream>
2
3class Character {
4public:
5  std::string Name;
6  std::string Guild;
7};
8
9int main(){
10  Character Bob{"Bob", "The Fellowship"};
11  std::cout << "Bob's Guild: "
12    << Bob.Guild;
13
14  Character Anna{"Anna"};
15  std::cout << "\nAnna's Guild: "
16    << Anna.Guild;
17}
18

1Bob's Guild: The Fellowship
2Anna's Guild:
3

In this example, our optional field is a simple string, but potentially any data type can be optional.

We’d like a generic, reusable way of handling such situations, and also making it explicit when a piece of data is optional.

The standard library provides a container that can help us here

std::optional

The std::optional container is available by including the optional header and can be created like any other object. We pass a template parameter to denote what type of data it will contain:

1#include <optional>
2
3std::optional<std::string> Name;
4

When declaring our std::optional container, we can provide an initial value:

1#include <optional>
2
3using namespace std::string_literals;
4std::optional<std::string> Name {"Bob"s};
5

When providing an initial value, we can remove the template parameter. This asks the compiler to infer the correct type, using class template argument deduction (CTAD):

1#include <optional>
2
3using namespace std::string_literals;
4std::optional Name {"Bob"s};
5

has_value() and value()

We can check if a std::optional container contains a value using the has_value() method, and we can access its value using the value() method:

1#include <iostream>
2#include <optional>
3
4class Character {
5public:
6  std::string Name;
7  std::optional<std::string> Guild;
8};
9
10int main(){
11  Character Bob{"Bob", "The Fellowship"};
12  if (Bob.Guild.has_value()) {
13    std::cout << "Bob's Guild: "
14      << Bob.Guild.value();
15  }
16}
17

1Bob's Guild: The Fellowship
2

As a syntactic shortcut, we can cast a std::optional to a boolean value, which will have the same return value as the has_value() method. This removes the need to call has_value() in most situations:

1#include <iostream>
2#include <optional>
3
4class Character {
5public:
6  std::string Name;
7  std::optional<std::string> Guild;
8};
9
10int main(){
11  Character Anna{"Anna"};
12  if (!Anna.Guild) {
13    std::cout << "Anna has no guild";
14  }
15}
16

1Anna has no guild
2

Special attention should be paid here when dealing with optional booleans, as this behavior can be a source of bugs. A std::optional will return the boolean value of true if it contains a value, even if that value is falsy. To access the underlying boolean value, we need to remember to use the value() method:

1#include <iostream>
2#include <optional>
3
4int main(){
5  std::optional MyBool{false};
6  if (MyBool) {
7    std::cout << "MyBool has a value...";
8  }
9
10  if (!MyBool.value()) {
11    std::cout << "but its value is falsy";
12  }
13}
14

1MyBool has a value...but its value is false
2

value_or()

The value_or() method will return the value contained in the optional. But, if the optional doesn’t have a value, it will return what we passed as an argument to value_or():

1#include <iostream>
2#include <optional>
3
4class Character {
5public:
6  std::string Name;
7  std::optional<std::string> Guild;
8};
9
10int main(){
11  Character Anna{"Anna"};
12  std::cout << "Anna's Guild: "
13    << Anna.Guild.value_or("[None]");
14}
15

1Anna's Guild: [None]
2

Updating Optional Values using = or emplace()

In some ways, we can treat the std::optional wrapper as invisible, and write code in the same way we would if it were a regular variable of the underlying type.

The assignment (=) operator is an example of this - we can update the value contained in a std::optional container using the = operator:

1#include <iostream>
2#include <optional>
3
4int main(){
5  using namespace std::string_literals;
6
7  std::optional Name{"Bob"s};
8  std::cout << "Name: " << Name.value();
9
10  Name = "Anna"s;
11  std::cout << "\nName: " << Name.value();
12}
13

1Name: Bob
2Name: Anna
3

For non-trivial types, constructing them outside of the container, and then moving them in using the = operator has a performance cost. Instead, we can construct them in place, using the emplace() function in the same way we’ve seen with other containers.

Any arguments we pass to this function are forwarded to the constructor for the underlying type our std::optional is using:

1#include <iostream>
2#include <optional>
3
4class Character {
5public:
6  Character(std::string Name, std::string Guild)
7    : Name{Name}, Guild{Guild}{}
8
9  std::string Name;
10  std::optional<std::string> Guild;
11};
12
13int main(){
14  using namespace std::string_literals;
15
16  std::optional<Character> Player;
17  Player.emplace("Bob"s, "The Fellowship"s);
18
19  std::cout << "Name: " << Player.value().Name;
20}
21

1Name: Bob
2

Destroying Optional Values using reset()

We can remove the value within a std::optional using the reset() method:

1#include <iostream>
2#include <optional>
3
4int main(){
5  using namespace std::string_literals;
6
7  std::optional Name{"Bob"s};
8  std::cout << "Name: " << Name.value();
9
10  Name.reset();
11  std::cout << "\nName: "
12    << Name.value_or("[None]");
13}
14

1Name: Bob
2Name: [None]
3

Comparing Optional Values

Comparison operators are another scenario where the wrapping std::optional can become invisible. We can compare values with values contained in std::optional containers using comparison operators like == and < in the usual way.

This generally means we can use == and != without any additional syntax:

1#include <iostream>
2#include <optional>
3
4int main(){
5  std::optional Optional{5};
6  if (Optional == 5) {
7    std::cout << "That's a five";
8  }
9}
10

1That's a five
2

An “empty” std::optional will always be not equal to any other object of the underlying type.

1#include <iostream>
2#include <optional>
3
4enum class Faction {
5  Human,
6  Elf,
7};
8
9class Character {
10public:
11  std::optional<Faction> Faction;
12};
13
14int main(){
15  Character Player;
16
17  if (Player.Faction != Faction::Human) {
18    std::cout << "Not Human";
19  }
20}
21

1Not Human
2

Less usefully, an empty std::optional will always be less than other values.

But in general, this type of comparison operation involving an empty std::optional container is very uncommon, and often a bug.

1#include <iostream>
2#include <optional>
3
4class Character {
5public:
6  std::optional<int> Health;
7};
8
9int main(){
10  Character Player;
11
12  if (Player.Health <= 0) {
13    std::cout << "Not Alive";
14  }
15}
16

1Not Alive
2

std::nullopt

When we want to return an empty std::optional, the std::nullopt token is the typical approach we use:

1#include <iostream>
2#include <optional>
3
4std::optional<int> GetInt(){
5  return std::nullopt;
6}
7
8int main(){
9  if (!GetInt().has_value()) {
10    std::cout << "That's a null";
11  }
12}
13

1That's a null
2

A more complex example is below:

1#include <iostream>
2#include <optional>
3
4class Character {
5public:
6  bool hasGuild{false};
7  std::string GuildName;
8};
9
10std::optional<std::string> GetGuildName(
11  const Character& Character){
12  if (Character.hasGuild) {
13    return Character.GuildName;
14  }
15  return std::nullopt;
16}
17
18int main(){
19  Character Player;
20
21  std::cout << "Guild: "
22    << GetGuildName(Player).value_or("[None]");
23}
24

1Guild: [None]
2

Monadic Operations (C++23)

As of C++23, the std::optional container supports three monadic operations: or_else(), and_then() and transform().

These methods all accept another function as an argument. This may not be something we’ve seen before, but we will cover it in more detail later in the course.

Additionally, all of the methods return a std::optional. This allows them to be chained together, as we’ll demonstrate later.

The behavior of these methods is easier to explain by example, so if these descriptions don’t make sense, scroll ahead to the following code snippet that shows them all being used.

• **or_else()** - if the std::optional contains a value, return the std::optional. Otherwise, invoke the provided function, and return what it returns. This should also be a std::optional.
• **and_then()** - if the std::optional is empty, return it. If the std::optional contains a value, invoke the provided function, passing the value as an argument. Then return the std::optional
• **transform()** - if the std::optional is empty, return it. If the std::optional contains a value, invoke the provided function. The function will receive the current value as an argument and will return a new value. The transform() function will then return a std::optional containing that new value.

These methods were added to support what is known as a functional programming style, which looks a bit different from what we may be used to. We cover topics related to this in a little more detail in our dedicated chapter on functions, which is coming up later.

For now, an example that uses all these methods, and the programming style they are designed to support, is highlighted below:

1#include <iostream>
2#include <optional>
3
4using OptInt = std::optional<int>;
5
6// For use with or_else()
7OptInt GetDefaultValue(){ return OptInt{1}; }
8
9// For use with transform()
10int Increment(int x){ return ++x; }
11int Double(int x){ return x * 2; }
12
13// For use with and_then()
14OptInt Log(OptInt x){
15  std::cout << "Value: " << x.value() << '\n';
16  return x;
17}
18
19int main(){
20  OptInt x;
21
22  x.or_else(GetDefaultValue)
23   .transform(Increment)
24   .and_then(Log)
25   .transform(Double)
26   .and_then(Log);
27}
28

1Value: 2
2Value: 4
3