存储在 class 中的闭包中通过引用捕获的临时对象的生命周期

Question

考虑以下代码片段：

struct foo { };

template <typename F>
struct impl : F
{
    impl(F&& f) : F{std::move(f)} { }
    auto get() { return (*this)(); }
};

template <typename X>
auto returner(X&& x)
{
    return impl{[&x]{ return x; }};
//               ^~
}

int main()
{
    auto x = returner(foo{}).get();
}

live example on wandbox.org

是否保证 foo{} 在 returner(foo{}).get() 表达式的整个持续时间内都处于活动状态？
或者 foo{} 仅在 returner(foo{}) 期间有效，因此在调用 impl::get() 时导致 未定义的行为 ?

标准在[class.temporary]中说：

Temporary objects are destroyed as the last step in evaluating the full-expression that (lexically) contains the point where they were created.

在[intro.execution]

A full-expression is

an unevaluated operand,

a constant-expression,

an init-declarator or a mem-initializer, including the constituent expressions of the initializer,

an invocation of a destructor generated at the end of the lifetime of an object other than a temporary object ([class.temporary]), or

an expression that is not a subexpression of another expression and that is not otherwise part of a full-expression.

我不确定与 foo{} 相关的 完整表达式 是 returner(foo{}) 还是 returner(foo{}).get().

Answer 1

这里的重要部分是：

A full-expression is [...] an expression that is not a subexpression of another expression and that is not otherwise part of a full-expression.

所以在returner(foo{}).get()中，returner(foo{})是表达式returner(foo{}).get()的一个子表达式，所以它不是一个完整的表达式。因此：

Is it guaranteed that foo{} will be alive for the entire duration of the returner(foo{}).get() expression?

是的。

存储在 class 中的闭包中通过引用捕获的临时对象的生命周期

Lifetime of a temporary captured by reference in a closure stored in a class

c++

lifetime

language-lawyer

temporary-objects

c++17