**Course Title:** Modern C++ Programming: Mastering C++ with Best Practices and Advanced Techniques **Section Title:** Error Handling and Exceptions **Topic:** Modern alternatives: `std::optional`, `std::variant`, and `std::expected` in C++17/20. ### Overview In traditional C++ programming, handling errors and exceptions is often a cumbersome and error-prone process. However, with the introduction of C++17 and C++20, several modern alternatives have been introduced to simplify and improve error handling. In this topic, we will explore three essential classes: `std::optional`, `std::variant`, and `std::expected`, and how they can be used to write more efficient and safer code. ### What are `std::optional`, `std::variant`, and `std::expected`? * `std::optional` (available since C++17) represents a value that may or may not be present. It can be used to avoid pointer null checks and handle cases where a function may not return a valid value. * `std::variant` (available since C++17) represents a type-safe union that can hold a value of different types. * `std::expected` (not yet part of the standard, but part of the C++23 proposal, but can be found in the [Hdr22 headers](https://github.com/ThePhD/Hdr22)): represents a result that may contain either a value or an error. ### Why do we need these modern alternatives? Traditional C++ programming uses raw pointers, `NULL`, or special values (like `INT_MIN`) to indicate the absence of a valid value or an error. However, these approaches are error-prone, hard to read, and can lead to undefined behavior. The modern alternatives introduced in C++17 and C++20 offer a safer, more expressive, and more efficient way to handle errors and represent optional or variant values. ### Using `std::optional` Here's an example of using `std::optional` to represent a value that may or may not be present: ```cpp #include <optional> #include <string> std::optional<std::string> getUserInput() { std::string input; // simulate user input if (/* input is valid */) { return input; } else { return std::nullopt; } } int main() { auto userInput = getUserInput(); if (userInput.has_value()) { std::cout << "User input: " << userInput.value() << std::endl; } else { std::cout << "No user input provided." << std::endl; } return 0; } ``` In this example, `getUserInput()` returns an `std::optional<std::string>` that may contain a valid `std::string` value or be empty (`std::nullopt`). The caller can check if a valid value is present using `has_value()` and retrieve the value using `value()`. ### Using `std::variant` Here's an example of using `std::variant` to represent a type-safe union: ```cpp #include <variant> #include <string> #include <complex> std::variant<std::string, std::complex<double>> calculateResult() { // simulate calculation if (/* result is complex */) { return std::complex<double>(3.0, 4.0); } else { return std::string("not complex"); } } int main() { auto result = calculateResult(); if (std::holds_alternative<std::complex<double>>(result)) { std::cout << "Result is complex: " << std::get<std::complex<double>>(result) << std::endl; } else { std::cout << "Result is not complex: " << std::get<std::string>(result) << std::endl; } return 0; } ``` In this example, `calculateResult()` returns an `std::variant<std::string, std::complex<double>>` that can hold either a `std::string` or a `std::complex<double>` value. The caller can use `holds_alternative()` to check the type of the value and `std::get<>` to retrieve it. ### Using `std::expected` (C++23 proposal) Here's an example of using `std::expected` to represent a result that may contain either a value or an error: ```cpp // std::expected requires C++23 or later // or you can include a third party headers #include <Hdr22/hdr/optional<> #include <Hdr22/hdr/monadic<> // assume ErrorType is a custom error type std::expected<std::string, ErrorType> performOperation() { // simulate operation if (/* operation succeeds */) { return std::string("success"); } else { return ErrorType("operation failed"); } } int main() { auto result = performOperation(); if (result) { std::cout << "Result is valid: " << *result << std::endl; } else { std::cout << "Result is error: " << result.error() << std::endl; } return 0; } ``` In this example, `performOperation()` returns an `std::expected<std::string, ErrorType>` that may contain either a valid `std::string` value or an `ErrorType` value. The caller can use the boolean operator `if (result)` to check if the result is valid and `*` to retrieve the value or `.error()` to retrieve the error. ### Takeaways and Conclusion * `std::optional`, `std::variant`, and `std::expected` (once available) offer modern alternatives to traditional error handling and value representation in C++. * These classes simplify and improve error handling by providing a safer and more expressive way to represent optional or variant values. * By using these classes, you can write more efficient and effective C++ code. We recommend you to read [C++ Documentation](https://en.cppreference.com) For latest updates. You can also check [Modern C++ Essentials](https://github.com/AnthonyCalandra/modern-cpp-essentials) We appreciate your time and value the comments and feedback on our content, and provide opportunity for any reader to ask for further help if needed either on the topic or any other one.