I can't get an optional with (cond) ? value : nullopt ... what should I write instead?
Suppose I'm implementing the function returning an std::optional<T>. In that function, I compute some condition, and then want to return either a value, or a nullopt. I can do it like so:
std::optional<T> foo()
{
auto cond = compute_condition();
if (cond) return compute_value();
return std::nullopt;
}
and this works fine. But - I want a one-liner. I would have liked to be able to write:
std::optional<T> foo()
{
return (compute_condition()) ? compute_value() : std::nullopt;
}
but this fails to compile (GodBolt.org):
error: operands to '?:' have different types 'T' and 'const std::nullopt_t'
is there something in the standard I can use?
Note: This question is related, but less general.
Answer
I don't think there's anything in the standard catering to your use-case. Here is a flawed, less efficient, but mostly decent-looking, and non-idiomatic, solution:
Use following utility function template:
template <typename T>
std::optional<T> value_if(bool cond, T&& value)
{
if (cond) return value;
return std::nullopt;
}
and then write:
std::optional<T> foo()
{
return value_if<int>(compute_condition(), compute_value());
}
... but - this has the drawback of always computing the value, even if the condition does not hold.
Q: Why are you specifying T in the invocation of value_if()?
A: That's because the result of compute_value() may need to undergo implicit conversion to fit the optional's type. If I just let T be deduced, I might get the wrong optional.