A result type for C++

Posted June 01, 2026

Updated June 02, 2026

3 min read

I wrote my own version of the very useful ‘result type’ pattern for C++.

The goal of a result type is to provide one of two specific kinds of value as the result of an operation. One representing the typical, or expected outcome. And the other kind representing a secondary or unexpected outcome.

The primary use case is in error handling. If an operation has a more complex error state than a mere boolean flag, then this pattern works very well. A simple example would be a parser. The primary result would be the parsed data structure, while the error would be a detailed list of error messages.

This already exists in Rust through Result<T, E>, which integrates nicely with the overall design of that language.

C++23 also has std::expected, but it is relatively new and has extremely baroque syntax, as is tradition…

The following is my version of the concept, which is valid for C++20. It’s less than 50 lines of code. It’s reasonably efficient. It’s very readable and can be copied easily into an existing codebase.

 1template <typename Error>
 2struct failure { Error value; };
 3
 4template <typename Error>
 5failure(Error&&) -> failure<std::decay_t<Error>>;
 6
 7template <typename Value, typename Error>
 8class result
 9{
10public:
11    constexpr result(Value v) : m_data(std::in_place_index<0>, std::move(v)) {}
12    constexpr result(failure<Error> e) : m_data(std::in_place_index<1>, std::move(e.value)) {}
13
14    constexpr result& operator=(Value v) { m_data.template emplace<0>(std::move(v)); return *this; }
15    constexpr result& operator=(failure<Error> e) { m_data.template emplace<1>(std::move(e.value)); return *this; }
16
17    constexpr explicit operator bool() const noexcept
18    { return isValue(); }
19
20    constexpr Value& operator*() { return value(); }
21    constexpr Value* operator->() { return &value(); }
22
23    constexpr Value const& operator*() const { return value(); }
24    constexpr Value const* operator->() const { return &value(); }
25
26    constexpr bool isError() const noexcept { return m_data.index() == 1; }
27    constexpr bool isValue() const noexcept { return m_data.index() == 0; }
28
29    constexpr Value& value() { return std::get<0>(m_data); }
30    constexpr Error& error() { return std::get<1>(m_data); }
31
32    constexpr Value const& value() const { return std::get<0>(m_data); }
33    constexpr Error const& error() const { return std::get<1>(m_data); }
34
35    constexpr Value valueOr(Value def) const
36    { return isValue() ? std::get<0>(m_data) : std::move(def); }
37
38    constexpr Error errorOr(Error def) const
39    { return isError() ? std::get<1>(m_data) : std::move(def); }
40
41private:
42    std::variant<Value, Error> m_data;
43};

Here are a few specific design choices:

Error values must be wrapped by a failure struct. This allows for declarations like result<int,int> and makes instantiating the Error value more explicit, and thus more readable.
Follows STL conventions for accessing the Value value.
Leverages existing std::variant from STL for the sake of simplicity.

Overall it is quite ergonomic to use, as you can see here.

 1result<int, char const*> parse(string s)
 2{
 3    if (s == "a") return 1;
 4    if (s == "b") return 2;
 5    if (s == "c") return 3;
 6
 7    if (s.empty())
 8        return failure("s is empty");
 9    return failure("s is invalid");
10}
11
12int main(int argc, char** argv)
13{
14    if (auto r = parse(""))
15        cout << "res: " << *r << endl;
16    else
17        cout << "error: " << r.error() << endl;
18
19    if (auto r = parse("b"))
20        cout << "res: " << *r << endl;
21    else
22        cout << "error: " << r.error() << endl;
23
24    return 0;
25}

And that’s it, pretty simple. I mostly did this for fun, but I will be using it in my current project, and otherwise keep it as a new tool that I can use in the future.

Did you find this useful? Do you have any little C++ tricks of your own? If so, Let me know!

Send a message to mail@lzon.ca, or DM me on one of my social accounts on the homepage.

A result type for C++

Theme

Secrets