Is there a less verbose idiom for unpacking an optional in C++?

Question

In the project I am currently working on I find myself writing a lot of code that looks like the following, where, get_optional_foo is returning an std::optional:

//...
auto maybe_foo = get_optional_foo(quux, ...)
if (!maybe_foo.has_value())
    return {};
auto foo = maybe_foo.value()
//...
// continue on, doing things with foo...

I want to bail out of the function if I get a null option; otherwise, I want to assign a non-optional variable to the value. I've started using the convention of naming the optional with a maybe_ prefix but am wondering if there is some way of doing this such that I don't need to use a temporary for the optional at all? This variable is only ever going to be used to check for a null option and dereference if there is a value.

Why not just treat it as a pointer? `auto foo = get_optional_foo(quux, ...) if (!foo) return {}; ... foo->some_member;` — NathanOliver, Nov 11 '20 at 14:38
Yep. It's made to emulate a pointer except no dynamic allocation. You can also dereference it. — NathanOliver, Nov 11 '20 at 14:40
I didnt know this. Write it up as an answer and I'll accept it. — jwezorek, Nov 11 '20 at 14:42
If you have a lot of them, add .value() after the call and catch std::bad_optional_access — JVApen, Nov 11 '20 at 19:04

score 3 · Accepted Answer · edited Nov 11 '20 at 14:49

3

You don't need an intermediate object. std::optional supports a pointer interface to access it so you can just use it like:

//...
auto foo = get_optional_foo(quux, ...)
if (!foo)
    return {};
//...
foo->some_member;
(*foo).some_member;

edited Nov 11 '20 at 14:49

cigien

57,834
11
73
112

answered Nov 11 '20 at 14:44

NathanOliver

171,901
28
288
402

Kostas · Answer 2 · 2020-11-11T14:49:16.533

1

Shortest I can think of:

auto maybe_foo = get_optional_foo(quux, ...)
if (!maybe_foo) return {};

auto &foo = *maybe_foo; // alternatively, use `*maybe_foo` below

If you have multiple optionals in the function and it's very unlikely they'll be empty you can wrap the whole thing with a try - catch.

try {
  auto &foo = get_optional_foo(quux, ...).value();
  auto &bar = get_optional_bar(...).value();
  ...
} catch (std::bad_optional_access &e) {
  return {};
}

edited Nov 11 '20 at 14:49

answered Nov 11 '20 at 14:43

Kostas

4,061
1
14
32

If you want shorter, you can write `return maybe_foo ? *maybe_foo : {}`. – ypnos Nov 11 '20 at 14:45
If we wanted to return, then we could just use `return maybe_foo.value_or({});` though. – Kostas Nov 11 '20 at 14:46
@ypnos Clang complains about this: `error: initializer list cannot be used on the right hand side of operator ':'`. – HolyBlackCat Nov 11 '20 at 14:53
@Kostas That would make an unnecessary default constructor call if the condition is false. – HolyBlackCat Nov 11 '20 at 14:54
@HolyBlackCat For `value_or({})`? I'm sure any decent compiler is happy to optimize this with copy elision. – Kostas Nov 11 '20 at 14:56
1

What I'm saying is, if the optional already stores a value, `{}` will still default-construct a new object, even if it's not needed. If the default constructor body is not visible, the compiler has to assume it could have side effects, and has to call it. – HolyBlackCat Nov 11 '20 at 15:05

score 1 · Answer 3 · answered Nov 11 '20 at 14:48

1

Slightly different than what you are asking, but consider:

  if (auto foo = get_optional_foo(1)) {
    // ...
    return foo->x;
  } else {
    return {};
  }

This places the main body of the function in an if() block, which may be more readable.

answered Nov 11 '20 at 14:48

Matt

20,108
1
57
70

Is there a less verbose idiom for unpacking an optional in C++?

3 Answers3