Expressive C++ with std::optional and Structured Bindings

Part 1: Handling Optional Values with std::optional

A frequent challenge in programming is how to handle functions that might not be able to return a valid result. For instance, a function designed to find an element in a data structure might not find it. A function that parses a number from a string might be given invalid input. How should the function signal this failure?

A common but flawed approach is using "sentinel values"—special values like -1, nullptr, or an empty string to indicate an error. This approach has significant drawbacks.

As the article explains, sentinel values are often ambiguous and require the caller to remember and check for a specific magic value. C++17 provides a much more robust and expressive solution: std::optional.

A Type-Safe Wrapper for Optional Values

std::optional<T> is a template class that acts as a wrapper. An instance of std::optional<T> either contains a value of type T or it contains nothing. It explicitly models the possibility of an absent value in the type system itself.

Let's watch a short video that demonstrates its practical use.

As you saw, using std::optional makes the function's contract clear: it might not return a value, and the caller is forced by the type system to consider this possibility.

Working with std::optional

Once you have a std::optional object, you need to interact with it safely. There are several ways to check for and access the contained value.

To formalize this, here's a summary of the main operations:

• Checking for a value:
  • if (opt.has_value()) { ... }
  • if (opt) { ... } (More idiomatic; uses an explicit operator bool)
• Accessing the value:
  • *opt: Dereference operator. Fast, but results in undefined behavior if the optional is empty. Use only after you have checked that it contains a value.
  • opt.value(): Returns the value, but throws a std::bad_optional_access exception if the optional is empty. Safer than * if you aren't certain.
  • opt.value_or(default_value): Returns the contained value if one exists, otherwise returns default_value. This is both safe and convenient.

Finally, for a deeper dive into the semantics and a comparison with pointers, the learncpp.com article provides excellent detail.

Part 2: Deconstructing Data with Structured Bindings

Another common task is dealing with functions that return multiple values. In Python, you can do this very naturally with tuples: min_val, max_val = find_min_max(data). Before C++17, the equivalent in C++ was significantly more cumbersome, often involving std::pair or std::tuple and awkward access functions like std::get.

C++17 introduced structured bindings to solve this problem, providing a syntax that is just as clean as Python's.

The new syntax is a dramatic improvement in readability and conciseness.

Key Use Cases

Structured bindings are versatile and can be used in several common scenarios.

In essence, a structured binding declaration introduces new names that are bound to the elements or members of an object. This works for:

1. C-style arrays.
2. Tuple-like types that support std::get (e.g., std::tuple, std::pair, std::array).
3. Structs and classes with all public, non-static data members.

Where It Matters: Real Code from Deep Learning Frameworks

These features aren't just academic curiosities; they are used extensively in modern, high-performance codebases, including the deep learning frameworks you're interested in. Using them makes your own code more robust and easier to read.

Let's look at some examples from ONNX Runtime, a popular inference engine.

These examples demonstrate that modern C++ features for expressiveness are not at odds with performance; they are essential tools used by developers writing the fast, low-level code you aim to master.

Putting It All Together

Let's combine std::optional and structured bindings in a single, practical example. Imagine we want to write a function that finds the minimum and maximum values in a range of data. If the range is empty, there is no minimum or maximum. This is a perfect use case for std::optional. The function can return an optional pair.

#include <iostream>
#include <vector>
#include <optional>
#include <utility> // For std::pair
#include <span>
#include <algorithm> // For std::minmax_element

// A function to find the min and max element in a span.
// It returns an optional pair of iterators. If the span is empty,
// it returns an empty optional.
std::optional<std::pair<int, int>> find_min_max(std::span<const int> data) {
    if (data.empty()) {
        return std::nullopt; // or just return {};
    }

    // std::minmax_element is a standard algorithm that does this efficiently.
    // It returns a pair of iterators to the min and max elements.
    const auto [min_it, max_it] = std::minmax_element(data.begin(), data.end());

    // We dereference the iterators to get the actual values.
    return std::make_pair(*min_it, *max_it);
}

int main() {
    std::vector<int> numbers = {10, 5, 42, 17, -5, 100, 3};
    std::vector<int> empty_vec = {};

    // Use a C++17 "if-statement with initializer"
    if (auto result = find_min_max(numbers)) {
        // Here, result is a std::optional<std::pair<int, int>> that is NOT empty.
        
        // Use a structured binding to unpack the pair from the optional.
        // Note we have to dereference the optional with * first.
        auto [min_val, max_val] = *result;

        std::cout << "Numbers: Min = " << min_val << ", Max = " << max_val << std::endl;
    } else {
        std::cout << "Could not find min/max for non-empty vector (this shouldn't happen)." << std::endl;
    }

    if (auto result = find_min_max(empty_vec)) {
        auto [min_val, max_val] = *result;
        std::cout << "Empty: Min = " << min_val << ", Max = " << max_val << std::endl;
    } else {
        std::cout << "Could not find min/max for empty vector, as expected." << std::endl;
    }

    return 0;
}

This example combines multiple modern C++ idioms: std::span for a non-owning view of the data, std::optional to handle the failure case (empty input), an if-statement with an initializer to scope the result variable, and a structured binding to elegantly unpack the final values.

Conclusion

In this lesson, you've added two powerful C++17 features to your toolkit that significantly improve code clarity and robustness.

Key Takeaways:

• std::optional for optional values: Use std::optional<T> for functions that may fail to return a value. It's a type-safe, explicit alternative to ambiguous sentinel values.
• Structured Bindings for unpacking: Use auto [a, b] = ... to cleanly deconstruct tuple-like objects, pairs, and simple structs. This makes code more readable, especially when iterating over maps or handling functions with multiple return values.
• Modern C++ is expressive: These features are prime examples of how modern C++ enables you to write code that is not only efficient but also safe, clear, and expressive.

We have spent the last few lessons learning to write more correct and expressive code. However, even with the best intentions, bugs happen. In our next lesson, we will shift focus from writing code to verifying it. You will learn how to use powerful tools like AddressSanitizer and UndefinedBehaviorSanitizer to automatically detect subtle and dangerous memory errors and undefined behavior in your programs.