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

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

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

Creating std::optional Objects

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;

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

1#include <optional>
2#include <string>
3
4std::optional<std::string> Name{
5  std::string("Bob")};

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#include <string>
3
4std::optional Name{std::string("Bob")};

Retrieving Optional Values

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}

1Bob's Guild: The Fellowship

As a syntactic shortcut, we can implicitly convert 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}

1Anna has no guild

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}

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

The std::bad_optional_access Exception

If we're using exceptions, we can just call the value() method without necessarily being sure the std::optional currently contains a value. If it doesn't, a std::bad_optional_access exception will be thrown:

1#include <iostream>
2#include <optional>
3
4int main() {
5  std::optional<int> OptionalInt;
6
7  try {
8    OptionalInt.value();
9  } catch (std::bad_optional_access& e) {
10    std::cout << "Caught an exception: "
11      << e.what();
12  }
13}

1Caught an exception: Bad optional access

Exceptions: throw, try and catch

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

Exception Types

Gain a thorough understanding of exception types, including how to throw and catch both standard library and custom exceptions in your code

The * and -> Operators

The std::optional type has overloaded the -> and unary * operator to provide access to the underlying value.

1#include <iostream>
2#include <optional>
3
4int main() {
5  std::optional<int> OptionalInt{42};
6  std::cout << "Value: " << *OptionalInt;
7}

1Value: 42

The -> operator gives access to class members of the underlying type:

1#include <iostream>
2#include <optional>
3
4struct SomeType {
5  int Value;
6};
7
8int main() {
9  std::optional<SomeType> Optional{42};
10  std::cout << "Value: " << Optional->Value;
11}

1Value: 42

Unlike the value() method, these operators will not check if the std::optional contains a value. When we build our software with debug flags enabled, most compilers will include runtime checks to alert us if we use these operators on an empty std::optional.

With release configurations, these checks are removed to optimize performance, and any attempt to use these operators on an empty container will have undefined behaviour.

The value_or() Method

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}

1Anna's Guild: [None]

Updating Values

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, passing a value of the type the container is storing:

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

1Name: Bob
2Name: Anna

For non-trivial types, constructing them outside of the std::optional 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  std::optional<Character> Player;
15  Player.emplace("Bob", "The Fellowship");
16
17  std::cout << "Name: " << Player.value().Name;
18}

1Name: Bob

Resetting Optionals

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

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

1Name: Bob
2Name: [None]

Comparing Optionals

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}

1That's a five

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}

1Not Human

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.

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}

1Not Alive

Creating Empty Optionals

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}

1That's a null

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}

1Guild: [None]

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}

1Value: 2
2Value: 4

Summary

In this lesson, we introduced std::optional, which provides an explicit and type-safe way to work with values that may or may not be present. It helps avoid bugs and makes it clear when a value is optional. The key takeaways are:

• std::optional is a container that represents an optional value - it may or may not contain a value
• You can check if an optional contains a value using has_value() or by converting it to a bool
• Access the value in an optional using value(), operator*, operator->, or value_or()
• value() will throw a std::bad_optional_access exception if the optional is empty
• You can reset an optional to an empty state with reset()
• Optionals support comparison operators with the underlying type
• An empty optional can be created using std::nullopt
• C++23 adds monadic operations to optional: and_then(), or_else() and transform()

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