{"id":8139,"date":"2023-08-28T06:49:55","date_gmt":"2023-08-28T06:49:55","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=8139"},"modified":"2023-08-28T07:10:01","modified_gmt":"2023-08-28T07:10:01","slug":"c23-a-new-way-of-error-handling-with-stdexpected","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c23-a-new-way-of-error-handling-with-stdexpected\/","title":{"rendered":"C++23: A New Way of Error Handling with std::expected"},"content":{"rendered":"\n

C++23 extends the interface of std::optional<\/code> and gets the new data type std::expected<\/code> for error handling.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

Before I dive into the extended monadic interface of std::optional<\/code> in C++23, I want to introduce this C++17 type.<\/p>\n\n\n\n

std::optional<\/code><\/h2>\n\n\n\n

std::optional<\/code> is quite comfortable for calculations such as database queries that may have a result. This vocabulary type requires the header <optional<\/code>>. <\/p>\n\n\n\n

The various constructors and the convenience function std::make_optional<\/code> let you define an optional object opt <\/code>with or without a value. opt.emplace<\/code> will construct the contained value in-place and opt.reset<\/code> will destroy the container value. You can explicitly ask a std::optional<\/code> container if it has a value, or you can check it in a logical expression. opt.value<\/code> returns the value, and opt.value_or<\/code> returns the value or a default value. If opt <\/code>has no contained value, the call opt.value<\/code> will throw a std::bad_optional_access<\/code> exception.<\/p>\n\n\n\n

Here is a short example using std::optional<\/code>.<\/p>\n\n\n\n

\/\/ optional.cpp<\/span>\n\n#include <optional><\/span>\n#include <iostream><\/span>\n#include <vector><\/span>\n\nstd::<\/span>optional<<\/span>int<\/span>><\/span> getFirst(const<\/span> std::<\/span>vector<<\/span>int<\/span>>&<\/span> vec){\n  if<\/span> ( !<\/span>vec.empty() ) return<\/span> std::<\/span>optional<<\/span>int<\/span>><\/span>(vec[0<\/span>]);\n  else<\/span> return<\/span> std::<\/span>optional<<\/span>int<\/span>><\/span>();\n}\n\nint<\/span> main() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n    std::<\/span>vector<<\/span>int<\/span>><\/span> myVec{1<\/span>, 2<\/span>, 3<\/span>};\n    std::<\/span>vector<<\/span>int<\/span>><\/span> myEmptyVec;\n    \n    auto<\/span> myInt=<\/span> getFirst(myVec);\n    \n    if<\/span> (myInt){\n        std::<\/span>cout <<<\/span> "*myInt: "<\/span>  <<<\/span> *<\/span>myInt <<<\/span> '\\n'<\/span>;\n        std::<\/span>cout <<<\/span> "myInt.value(): "<\/span> <<<\/span> myInt.value() <<<\/span> '\\n'<\/span>;\n        std::<\/span>cout <<<\/span> "myInt.value_or(2017):"<\/span> <<<\/span> myInt.value_or(2017<\/span>) <<<\/span> '\\n'<\/span>;\n    }\n    \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n    auto<\/span> myEmptyInt=<\/span> getFirst(myEmptyVec);\n    \n    if<\/span> (!<\/span>myEmptyInt){\n        std::<\/span>cout <<<\/span> "myEmptyInt.value_or(2017):"<\/span> <<<\/span> myEmptyInt.value_or(2017<\/span>) <<<\/span> '\\n'<\/span>;\n    }\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre><\/div>\n\n\n\n
I use std::optional <\/code>in the function getFirst<\/code>. getFirst<\/code> returns the first element if it exists. You get a std::optional<\/code> object if not. The main function has two vectors. Both invoke getFirst <\/code>and return a std::optional <\/code>object. In the case of myInt<\/code>, the object has a value; in the case of myEmptyInt<\/code>, the object has no value. The program displays the value of myInt <\/code>and myEmptyInt<\/code>. myInt.value_or(2017)<\/code> returns the value, but myEmptyInt.value_or(2017) <\/code>returns the default value. <\/p>\n\n\n\n
Here is the output of the program.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
The Monadic Extension of std::optional<\/code><\/h2>\n\n\n\n
In C++23, std::optional<\/code> is extended with monadic operations opt.and_then<\/code>, opt.transform<\/code>, and opt.or_else. <\/code><\/p>\n\n\n\n
    \n
  • opt.and_then<\/code> returns the result of the given function call if it exists or an empty std::optional<\/code>.<\/li>\n\n\n\n
  • opt.transform<\/code> returns a std::optional<\/code> containing its transformed value or an empty std::optional<\/code>. <\/li>\n\n\n\n
  • opt.or_else<\/code> returns the std::optional<\/code> if it contains a value or the result of the given function otherwise.<\/li>\n<\/ul>\n\n\n\n
    These monadic operations enable the composition of operations on std::optional<\/code>:<\/p>\n\n\n\n
    \/\/ optionalMonadic.cpp<\/span>\n\n#include <iostream><\/span>\n#include <optional><\/span>\n#include <vector><\/span>\n#include <string><\/span>\n\nstd::<\/span>optional<<\/span>int<\/span>><\/span> getInt(std::<\/span>string arg) {\n    try {\n        return<\/span> {std::<\/span>stoi(arg)};\n    }\n    catch<\/span> (...) {\n        return<\/span> { };\n    }\n}\n\n \nint<\/span> main() {\n \n    std::<\/span>cout <<<\/span> '\\n'<\/span>; \n\n    std::<\/span>vector<<\/span>std::<\/span>optional<<\/span>std::<\/span>string>><\/span> strings =<\/span> {"66"<\/span>, "foo"<\/span>, "-5"<\/span>};\n\n    for<\/span> (auto<\/span> s:<\/span> strings) {\n        auto<\/span> res =<\/span> s.and_then(getInt)\n                  .transform( [](int<\/span> n) { return<\/span> n +<\/span> 100<\/span>;})\n                  .transform( [](int<\/span> n) { return<\/span> std::<\/span>to_string(n); })\n                  .or_else([] { return<\/span> std::<\/span>optional{std::<\/span>string("Error"<\/span>) }; });\n        std::<\/span>cout <<<\/span> *<\/span>res <<<\/span> ' '<\/span>;\n    }\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre><\/div>\n\n\n\n
    The range-based for-loop iterates through the std::vector<std::optional<std::string>><\/code>. First, the function getInt <\/code>converts each element to an integer, adds 100, converts it back to a string, and finally displays it. If the initial conversion to int <\/code>fails, the string Error <\/code>is returned and displayed.<\/p>\n\n\n\n
    \"\"<\/figure>\n\n\n\n
    std::expected<\/code> already supports the monadic interface.<\/p>\n\n\n\n
    std::expected<\/code><\/h2>\n\n\n\n
    std::expected<T, E><\/code> provides a way to store either of two values. An instance of std::expected <\/code>always holds a value: either the expected value of type T<\/code>, or the unexpected value of type E<\/code>. This vocabulary type requires the header <expected<\/code>>. Thanks to std::expected<\/code>, you can implement functions that either return a value or an error. The stored value is allocated directly within the storage occupied by the expected object. No dynamic memory allocation takes place.<\/p>\n\n\n\n
    std::expected<\/code> has a similar interface, such as std::optional<\/code>. In contrast to std::optional<\/code>, std::exptected<\/code> can return an error message.<\/p>\n\n\n\n
    The various constructors let you define an expected object exp <\/code>with an expected value. exp.emplace<\/code> will construct the contained value in-place. You can explicitly ask a std::expected<\/code> container if it has a value, or you can check it in a logical expression. exp.value<\/code> returns the expected value, and exp.value_or<\/code> returns the expected value or a default value. If exp <\/code>has an unexpected value, the call exp.value<\/code> will throw a std::bad_expected_access<\/code> exception.<\/p>\n\n\n\n
    std::unexpected<\/code> represents the unexpected value stored in std::expected<\/code>.<\/p>\n\n\n\n
    \/\/ expected.cpp<\/span>\n\n#include <iostream><\/span>\n#include <expected><\/span>\n#include <vector><\/span>\n#include <string><\/span>\n\nstd::<\/span>expected<<\/span>int<\/span>, std::<\/span>string><\/span> getInt(std::<\/span>string arg) {\n    try {\n        return<\/span> std::<\/span>stoi(arg);\n    }\n    catch<\/span> (...) {\n        return<\/span> std::<\/span>unexpected{std::<\/span>string(arg +<\/span> ": Error"<\/span>)};\n    }\n}\n\n \nint<\/span> main() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>vector<<\/span>std::<\/span>string><\/span> strings =<\/span> {"66"<\/span>, "foo"<\/span>, "-5"<\/span>};\n\n    for<\/span> (auto<\/span> s:<\/span> strings) {                                 \/\/ (1)<\/span>\n        auto<\/span> res =<\/span> getInt(s);\n        if<\/span> (res) {\n            std::<\/span>cout <<<\/span> res.value() <<<\/span> ' '<\/span>;                \/\/ (3)<\/span>\n        }\n        else<\/span> {\n            std::<\/span>cout <<<\/span> res.error() <<<\/span> ' '<\/span>;                \/\/ (4)<\/span>\n        }\n    }\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    for<\/span> (auto<\/span> s:<\/span> strings) {                                 \/\/ (2)<\/span>\n        auto<\/span> res =<\/span> getInt(s);\n        std::<\/span>cout <<<\/span> res.value_or(2023<\/span>) <<<\/span> ' '<\/span>;             \/\/ (5)<\/span>\n    }\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre><\/div>\n\n\n\n
    The function getInt <\/code>converts each string to an integer and returns a std::expected<int, std::string><\/code>. int <\/code>represents the expected, and std::string <\/code>the unexpected value. The two range-based for-loops (lines 1 and 2) iterate through the std::vector<std::string><\/code>. In the first range-based for-loop (line 1), the expected (line 3) or the unexpected value (line 4) is displayed. In the second range-based for-loop (line 2), the expected or the default value 2023 (line 5) is displayed.<\/p>\n\n\n\n
    \"\"<\/figure>\n\n\n\n
    std::expected<\/code> supports monadic operations for convenient function composition: exp.and_then<\/code>, exp.transform, exp.or_else<\/code>, and exp.transform_error<\/code>. <\/p>\n\n\n\n
      \n
    • exp.and_then<\/code> returns the result of the given function call if it exists or an empty std::expected<\/code>. <\/li>\n\n\n\n
    • exp.transform<\/code> returns a std::expected<\/code> containing its transformed value or an empty std::exptec<\/code>ted.<\/li>\n\n\n\n
    • exp.or_else<\/code> returns the std::expecte<\/code>d if it contains a value or the result of the given function otherwise. \u00a0<\/li>\n\n\n\n
    • exp.transform_error<\/code> returns the std::expected<\/code> if it contains an expected value. Otherwise, it returns a std::expected<\/code> that contains a transformed unexpected value.<\/li>\n<\/ul>\n\n\n\n
      The following program is based on the previous program optionalMonadic.cpp<\/code>. Essentially, the type std::optional<\/code> is replaced with std::expected<\/code>.<\/p>\n\n\n\n
      \/\/ expectedMonadic.cpp<\/span>\n\n#include <iostream><\/span>\n#include <expected><\/span>\n#include <vector><\/span>\n#include <string><\/span>\n\n\nstd::<\/span>expected<<\/span>int<\/span>, std::<\/span>string><\/span> getInt(std::<\/span>string arg) {\n    try {\n        return<\/span> std::<\/span>stoi(arg);\n    }\n    catch<\/span> (...) {\n        return<\/span> std::<\/span>unexpected{std::<\/span>string(arg +<\/span> ": Error"<\/span>)};\n    }\n}\n \nint<\/span> main() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>vector<<\/span>std::<\/span>string><\/span> strings =<\/span> {"66"<\/span>, "foo"<\/span>, "-5"<\/span>};\n\n    for<\/span> (auto<\/span> s:<\/span> strings) {\n        auto<\/span> res =<\/span> getInt(s)\n                   .transform( [](int<\/span> n) { return<\/span> n +<\/span> 100<\/span>; })\n                   .transform( [](int<\/span> n) { return<\/span> std::<\/span>to_string(n); });\n        std::<\/span>cout <<<\/span> *<\/span>res <<<\/span> ' '<\/span>;        \n    }   \n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;                                  \n                                        \n}\n<\/pre><\/div>\n\n\n\n
      The range-based for-loop iterates through the std::vector<std::string><\/code>. First, the function getInt <\/code>converts each string to an integer, adds 100<\/code>, converts it back to a string, and finally displays it. If the initial conversion to int <\/code>fails, the string arg + \": Error\"<\/code> is returned and displayed.    <\/p>\n\n\n\n
      \"\"<\/figure>\n\n\n\n
      What’s Next? <\/h2>\n\n\n\n
      The four associative containers std::flat_map<\/code>, std::flat_multimap<\/code>, std::flat_set<\/code>, and std::flat_multiset<\/code> in C++23 are a drop-in replacement for the ordered associative containers std::map<\/code>, std::multimap<\/code>, std::set<\/code>, and std::multiset<\/code>. We have them for one reason in C++23: performance. <\/p>\n","protected":false},"excerpt":{"rendered":"
      C++23 extends the interface of std::optional and gets the new data type std::expected for error handling. Before I dive into the extended monadic interface of std::optional in C++23, I want to introduce this C++17 type. std::optional std::optional is quite comfortable for calculations such as database queries that may have a result. This vocabulary type requires […]<\/p>\n","protected":false},"author":21,"featured_media":8141,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[378],"tags":[478],"class_list":["post-8139","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-23","tag-error-handling"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/8139","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=8139"}],"version-history":[{"count":24,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/8139\/revisions"}],"predecessor-version":[{"id":8170,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/8139\/revisions\/8170"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/8141"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=8139"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=8139"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=8139"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}