Handling optional values is crucial in C++ to prevent runtime errors and undefined behavior. Imagine you're looking for a specific item in a list. If it isn't found, how do you handle that? Traditionally, you might use pointers or sentinel values, but these can be error-prone. The std::optional class template in C++17 offers a cleaner, type-safe alternative.

The goal of this lesson is to help you understand and use std::optional to handle values that may or may not be present. We'll cover its creation, usage, and practical applications with real examples.

So, what is std::optional? Think of it as a container that may or may not hold a value. It’s useful when a function might not always return a meaningful value. For example, if you try to find an item in a list and it's not there, instead of returning a null pointer or a special sentinel value, you can return an std::optional.

Creating an std::optional value is simple:

In this code snippet:

• val is an std::optional initialized with the integer value 42.
• emptyVal is an empty std::optional of type int.

Accessing the value contained in an std::optional can be done safely by first checking if it contains a value using the .has_value() member function. If the std::optional does contain a value, the .value() member function can be used to access the contained value. Here's an example to illustrate these concepts:

Using .value() without checking .has_value() will throw an exception if the std::optional is empty. To avoid this, always check with .has_value() before accessing the value.

Alternatively, you can access the value with the * operator. Instead of val.value(), you can use *val.

To reset an std::optional to an empty state:

In this code snippet:

• val is an std::optional initialized with the integer value 42.
• The reset function is called on val, setting it to the empty state.
• The if statement checks if val is now empty and prints the corresponding message.

Returning an std::optional from a function is useful when a function might not always have a meaningful value to return. Let's walk through the findStringIndex function that returns an index of a target string in the provided vector of strings.

• It iterates over a vector of strings.
• If the target string is found, it returns an std::optional containing the string.
• If not found, it returns std::nullopt, representing an empty optional.

Here is how we utilize it:

In this code snippet:

• A vector of strings myStrings is created and populated with fruit names.
• The findStringIndex function is called with myStrings and the target string "banana".
• The if statement checks if result contains a value, printing the found string if so.
• If result is empty, it prints "String not found."

The value_or function can be used to provide a default value when the std::optional is empty. This simplifies code and reduces the need for manual checks.

In this code snippet:

• value_or returns the contained value if the std::optional is not empty. Otherwise, it returns the provided default value.
• value1 will contain 42 as val has a value.
• value2 will contain -1 as emptyVal is empty.

To sum up, you've learned about std::optional, a type-safe way to handle values that may or may not be present. We've covered:

• What std::optional is and its significance.
• How to create, return, and use optional.
• Error handling using optional.
• How to manage optional with has_value and value methods.
• Using the value_or function to simplify code.

Next, you'll put these concepts into practice. Get ready to solidify your understanding through hands-on exercises!