如何最好地在 if 语句中测试和展开 std::optional

Question

我有多个 return 一个 std::optional<T> 的功能。这是一个虚构类型的示例 MyType:

struct MyType {
    // ...
}

std::optional<MyType> calculateOptional() {
    // ... lengthy calculation

    if (success) {
        return MyType(/* etc */);
    }

    return std::nullopt;
}

让我们假设这些函数对运行来说成本很高，并且我想避免多次调用它们。

调用它们时我想立即测试可选值，如果它确实包含一个值，我想立即使用它并且永远不会再使用它。例如，在 Swift 中，我可以使用标准的 if-let 语句：

if let result = calculateOptional() {
    // Use result var
}

我想在 C++ 中复制这种测试和展开行为，同时在使用时尽可能保持代码干净。例如，明显的简单解决方案（至少对我而言）是：

if (auto result = calculateOptional()) {
    MyType result_unwrapped = *result;
    // Use result_unwrapped var
}

但是你必须在 if 内解包，或者在任何地方使用 *result，这与 Swift.

无关

到目前为止，我唯一真正接近 Swift 外观的解决方案是：

template<typename T> bool optionalTestUnwrap(std::optional<T> opt, T& value) {
    if (!opt.has_value()) { return false; }
    value = *opt;
    return true;
}

#define ifopt(var, opt) if (typename decltype((opt))::value_type (var); optionalTestUnwrap((opt), (var)))

ifopt (result, calculateOptional()) {
    // Use result var
}

...但我也不喜欢使用宏来替换普通的 if 语句。

Answer 1

您可以将可选项包装在自己的类型中，隐式转换为类型并显式转换为 bool。抱歉，到目前为止我还没有对此进行测试，但我认为它应该可以工作。

template<class T>
struct opt {
    std::optional<T> _optional; // public so it stays an aggregate, probably writing constructors is better

    explicit bool() const {
        return _optional.has_value();
    }

    T&() {
        return *_optional;
    }

    const T&() const {
         return *_optional;
    }

    T&&() && { // Let's be fancy
         return std::move(*optional);
    }
}

opt<int> blub(bool val) {
    return val ? opt<int>{0} : opt<int>{std::nullopt};
}

int main() {
    if(auto x = blub(val)) { // I hope this works as I think it does
        int y = x+1;
    }
}

Answer 2

就我个人而言，我会这样做：

if (auto result = calculateOptional()) {
    // use *result
}

第二个最好的方法是给可选的一个丑陋的名字并为它创建一个更好命名的别名：

if (auto resultOpt = calculateOptional()) {
    auto& result = *resultOpt;
    // use result
}

我觉得这样就够了。这是故意隐藏外部作用域名称的一个很好的用例（即同时命名 optional 和内部别名 result），但我认为我们不需要在这里发疯。即使使用 *result 也不是什么大问题——类型系统可能会发现所有误用。

如果我们真的想继续 Swift，您正在使用的宏需要默认构造 - 而这并不是必需的。我们可以做得更好一点（理想情况下 __opt 被一种选择唯一名称的机制所取代，例如与 __LINE__ 连接）：

#define if_let(name, expr)              \
    if (auto __opt = expr)              \
        if (auto& name = *__opt; false) {} else

如：

if_let(result, calculateOptional()) {
    // use result
} else {
    // we didn't get a result
}

这没有任何额外的开销或要求。但这有点荒谬，有其自身的问题，而且似乎不值得。但如果我们只是玩得开心，这行得通。

Answer 3

这可能是一种干净的方式，灵感来自此 post 中的所有其他答案：

template <typename T>
inline std::pair<bool, T> _unwrap(const std::optional<T> &val) {
    return { val.has_value(), *val };
}

#define unwrap(x, val) const auto &[_##x, x] = _unwrap(val); (_##x)

用法：

if (unwrap(result, calculateOptional())) {
  // result is now equivalent to *calculateOptional()
}

优点：

不要乱用 if 语句
它保持了一种类似方法的感觉
您仍然可以在 if 语句的右侧添加更多条件

缺点：

只读但可选的已经是

很高兴听到 issues/fixes 你们可能认为这个解决方案可能存在。

Answer 4

如果calculateOptional() returns一个std::pair<bool sucess, T result>或者可以合二为一，可以用下面的构造：

if (auto [s, result] = calculatePair(); s) {

} else {

}

或者你使用例外； (...) 捕获所有异常

try {
    auto result = calculate();

} catch (...) {

}

但你可以更具体

try {
    auto result = calculate();

} catch (nosuccess) {

}

Answer 5

另一个简单且可能更安全的方法：

#define unwrap(x, val, block) if (auto opt_##x = val) { auto &x = opt_##x; block }

用法：

unwrap(result, calculateOptional(), {
  // use result
});

如何最好地在 if 语句中测试和展开 std::optional

How best to test and unwrap std::optional in an if statement

c++

c++17

stdoptional