std::expected Class Template
The std::expected is a class template in C++ that serves as a mechanism for managing functions that may return either a valid result or an error. It is a wrapper that is particularly useful in scenarios where exceptions might not be the preferred error-handling approach.
Syntax
The std::expected is used as the value return by the function as shown below:
std::expected<T, E> function_name {
// statements
}
where,
- T: This parameter represents the type of the expected (valid) value that the function may return when it succeeds.
- E: This parameter represents the type of error condition that the function may return when it fails.
When a function returns an instance of std::expected, the caller can easily check whether the result is valid (contains a value of type T) or represents an error (contains an error of type E). This approach provides a clear and structured way to handle errors in a functional, non-exception-based manner.
std::expected Member Functions
Following are some commonly used Member functions of the std::expected class:
|
S.No. |
Function |
Description |
|---|---|---|
|
1 |
value() | It allows you to retrieve the stored value of type T. |
|
2 |
error() | This one facilitates access to the stored error of type E. |
|
3 |
has_value(): | This member function is used to inquire whether the std::expected contains a value or not. It returns true if the std::expected holds a value and false if it holds an error. |
|
4 |
error_code() | When applicable, this member function is employed to convert the stored error into an error code. |
C++23 – Header
C++23, the next major version of the C++ programming language, brings several exciting features and enhancements. One of the significant additions in C++23 is the <expected> header, which aims to improve error handling and make code more robust and readable. In this article, we will explore the feature of <expected> header, its purpose, and how it simplifies error handling in C++.
Problem with Error Handling
Error handling in C++ has historically been a complex and error-prone task. C++ has exceptions and error codes, but choosing the right approach and implementing error handling consistently across a codebase can be challenging. Additionally, exceptions can introduce performance overhead in certain scenarios.