C＆＃x2B;＆＃x2B;的寿命是多少方法指针表达式？

Question

我有一个通用函数，可以调用它的可可。与std :: Invoke的呼叫的道德等同，除了它是Coroutine的一部分：

// Wait for some condition to be true, then invoke f with the supplied
// arguments. The caller must ensure that all references remain valid
// until the returned task is done.
template <typename F, typename Args...>
Task<void> WaitForConditionAndInvoke(F&& f, Args&&... args) {
  co_await SomeCondition();
  std::invoke(f, std::forward<Args>(args)...);
}

由于要求输入参数保持有效，因此通过WaitforCondition and Incoke 诸如lambda之类的临时性（除非返回的任务是直接co_await作为单个表达式的一部分）。即使使用Unary +将具有绑定状态的lambda转换为函数指针的lambda也是如此：功能指针本身是暂时的，Asan似乎在被销毁后正确地抱怨使用它。

我的问题是使用会员函数指针是否合法：

struct Object {
  void SomeMethod();
};

// Some global object; we're not worried about the object's lifetime.
Object object;

Task<void> WaitForConditionAndInvokeOnGlobalObject() {
  return WaitForConditionAndInvoke(&Object::SomeMethod, &object);
}

这似乎可以正常工作，但是我不清楚指针的寿命'object :: somemethod评估IS。这是否可以保证是恒定的表达，即不是暂时的？标准的哪一部分涵盖了这一点？

Answer 1

waitforcondition和Invoke coroutine将是危险的，除非每个参数在内，包括函数f是指拥有寿命足够长的对象。例如，waitforconditionandInvoke（std :: abs，1）具有未定义的行为，因为该对象构成了用int> int prvalue expression 1 。尽管恒定的表达值可以帮助编译器以使用死对象的已知值“工作”的方式来实现编译器，但在此处没有差异。

为了解决此问题，您可以使您的函数将每个RVALUE参数移动到本地对象中：

// All rvalue arguments are moved from.
// The caller must make sure all lvalue arguments remain valid until
// the returned task is done.
template <typename F, typename Args...>
Task<void> WaitForConditionAndInvoke(F&& f, Args&&... args) {
  // local_f could be declared an lvalue reference or object,
  // but not an rvalue reference:
  F local_f(std::forward<F>(f));
  // Similarly, the template arguments to tuple are lvalue references
  // or object types.
  std::tuple<Args...> local_args(std::forward<Args>(args)...);
  co_await SomeCondition();
  std::apply(std::forward<F>(local_f), std::move(local_args));
}

或更安全，以std :: bind执行操作，然后移动/复制所有内容。调用代码可以指定使用std :: ref或std :: cref的函数或函数参数作为参考而无需移动或复制。实际上，该实施仅是：

// All arguments are moved or copied from.
// A std::reference_wrapper can be used to skip the move/copy of
// the referenced object.
template <typename F, typename Args...>
Task<void> WaitForConditionAndInvoke(F&& f, Args&&... args) {
  auto bound_f = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
  co_await SomeCondition();
  bound_f();
}

Answer 2

正如评论者所说，这里不存在终身问题。 &Object::SomeMethod 是一个常量表达式，就像 42 或 &WaitForConditionAndInvokeOnGlobalObject 一样。

您可能会因为将类型命名为 struct Object 而感到困惑，因此表达式 &Object::SomeMethod 看起来看起来就像涉及一个对象...但事实并非如此； Object 是类型的名称。该表达式中不涉及任何对象；它是一个简单的编译时常量，就像 offsetof(Object, SomeDataMember) 或 sizeof(Object) 一样。

不涉及对象=不涉及生命周期问题。

编辑（从而完全改变我的答案）：啊，aschepler 是对的，你关心的是 F&& 所引用的事物的生命周期。 f 其中

template <typename F, typename Args...>
Task<void> WaitForConditionAndInvoke(F&& f, Args&&... args) {
  co_await SomeCondition();
  std::invoke(f, std::forward<Args>(args)...);
}

是值为 &Object::SomeMethod 的临时对象，它当然在其完整表达式的末尾处终止，即在 < 末尾的分号处终止代码>返回WaitForConditionAndInvoke(&Object::SomeMethod, &object);。一旦您点击该分号，所有临时变量都会超出范围，并且对它们的任何引用（例如，在协程框架中捕获的 f ）肯定会悬空。