如何解决C++20 协程捕获与引用奇怪的崩溃与`unique_ptr`
这是在 main 中使用第 (2) 行版本（并且第 (1) 行被注释）时崩溃的代码。很奇怪，这段代码用一个简单的替换实现（第 (1) 行）来编译罚款，它模仿了第 (2) 行的行为。当然，如果是未定义的行为，就没法很好的解释了，但是我不明白为什么会崩溃。基本上，它是 C++ 中的生成器实现协程，通过引用捕获进行测试。它始终有效，除非与 unique_ptr 一起使用（原始指针有效）。只是，为什么？
#include <iostream>
#include <coroutine>
#include <cassert>
#include <optional>
#include <memory>
using std::cout;
using std::endl;
template<typename T>
class generator
{
public:
struct promise_type
{
std::optional<T> t_;
promise_type() = default;
~promise_type() = default;
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void unhandled_exception() {}
generator get_return_object() { return {std::coroutine_handle<promise_type>::from_promise(*this)}; }
std::suspend_always yield_value(T t) { t_ = t; return {}; }
void return_void() {}
};
private:
std::coroutine_handle<promise_type> h_;
generator(std::coroutine_handle<promise_type> h) : h_(h) {}
public:
generator() = default;
// ------ Prevent copies
generator(const generator&) = delete;
generator& operator=(const generator&) = delete;
// ------ Allow moves
generator(generator&& other) noexcept
: h_(move(other.h_)) // move may be unnecessary,coroutine_handle acts like a lightweight pointer
{
other.h_ = {}; // Unlink handle in moved generator
// move() does not guarantee to destroy original value
}
generator& operator=(generator&& other) noexcept
{
h_ = move(other.h_);
other.h_ = {};
return *this;
}
~generator()
{
if(h_)
{
h_.destroy();
h_ = {};
}
}
bool is_resumable() const
{
return h_ && !h_.done();
}
bool operator()()
{
return resume();
}
bool resume()
{
assert(is_resumable());
h_();
return !h_.done();
}
[[nodiscard]] const T& get() const
{
return h_.promise().t_.value();
}
[[nodiscard]] T& get() // Allow movable
{
return h_.promise().t_.value();
}
};
struct F
{
/*F(const std::function<generator<int>()>& del)
{
handle = del();
}*/
template<typename T>
F(T del)
{
handle = del();
}
~F() { cout << "dtor" << endl; }
generator<int> handle;
};
template<typename T>
struct UniquePtr
{
UniquePtr(T* t) : t_(t) {}
UniquePtr(UniquePtr&&) = delete;
UniquePtr(const UniquePtr&) = delete;
UniquePtr& operator=(UniquePtr&&) = delete;
UniquePtr& operator=(const UniquePtr&) = delete;
~UniquePtr() { delete t_; }
T* operator->() const { return t_;}
private:
T* t_;
};
int main()
{
int x = 10;
auto a = [&]() -> generator<int> {
x = 20;
co_yield x;
};
//UniquePtr<F> ptr(new F(a)); // (1)
std::unique_ptr<F> ptr(new F(a)); // (2)
generator<int>& gen = ptr->handle;
gen();
cout << gen.get() << "/" << x << endl;
return 0;
}
编辑。 :
它也崩溃了 Godbolt（错误 139），这里是链接：https://godbolt.org/z/cWYY8PKx4。也许这是一个 gcc 实现问题，围绕 std::unique_ptr 优化？我无法在 Godbolt 上的其他编译器上进行测试，clang 上不支持协程。
解决方法
虽然还不清楚为什么会发生这种情况，但似乎 std::suspend_always initial_suspend() { return {}; } 在与 lambda 结合使用并结合对作用域唯一性指针的优化时也会在错误的情况下错误地执行参数捕获范围。
稍微修改的变体：
struct F
{
template<typename T>
F(T del)
{
auto y = 0;
cout << "&y = " << &y << endl;
handle = del();
}
~F() { cout << "dtor" << endl; }
generator<int> handle;
};
int main()
{
int x = 10;
cout << "&x = " << &x << endl;
auto a = [&]() -> generator<int> {
cout << "[&x] = " << &x << endl;
co_yield x;
};
auto ptr = std::make_unique<F>(a);
generator<int>& gen = ptr->handle;
gen();
a()();
return 0;
}
输出：
&x = 0x7fff46a718cc
&y = 0x7fff46a71834
[&x] = 0x7fff46a71840
[&x] = 0x7fff46a718cc
dtor
F() 的构造函数的堆栈帧内的第二个和第三个输出点。不过，这仅适用于 &y，最后一个执行正确。
在使用 std::suspend_never initial_suspend() { return {}; } 或转换为显式 std::function 时，它的行为也确实正确，表明捕获机制中存在错误。
根据优化级别，捕获的范围是 this 的 F 或 F() 的构造函数的堆栈帧。
我没有跟踪您的所有代码，但首先让我想到的是您正在创建一个通过引用使用局部变量的 lambda (a)。我相信这可能意味着 x 在某些控制路径中不在范围内之前不会被使用。将 x 作为参数传递比通过引用传递要简洁得多。
如果我误解了 lambda 的一些语法，我可能会离题。
,我想我知道它崩溃的原因了。 没有细节，我会试着一步一步地解释发生了什么。
让我们专注于这一部分：
int x = 10;
auto a = [&]() -> generator<int> {
x = 20;
co_yield x;
};
我们可能已经习惯了这些 lambda 表达式，但有时我们会忘记基础知识和真正发生的事情，我们可能会被愚弄。首先，用显式的最终等价物替换 lambda 语法糖。
int x = 10;
struct A {
int &x;
A(int& x) : x(x) {}
generator<int> operator()() {
x = 20;
co_yield x;
}
}
A a(x);
然后，事情变得更加清晰。现在，专注于这一部分。
template<typename T>
F(T del)
{
handle = del();
}
模板解析后，这将有效地执行以下代码：
F(A del)
{
handle = del();
}
调用 del()，我们创建了一个新的协程，但正如后面解释的，协程引用结构 A 的变量。当我们离开 F() 的作用域时，del 被销毁。
现在，当我们这样做时：
A a(x);
F f(a);
f.handle();
这本质上与将 f.handle(); 替换为：
del.x = 20;
这段代码很短，但需要解释一下，因为这里不存在变量del，这是为了语义说明。让我们解释一下：我们将值 x 分配给 del 的成员引用 20。目前，这只是明显的翻译。但什么是 del ？它指的是在 F 的构造函数中创建的变量。在 C++ 中，this 隐式用于查找变量，我们在使用 lambdas 时通常会滥用它，例如 x = 20; co_yield x;（否则，lambdas 将不太有用），而这里只是 del .但是由于我们在 f 的构造函数之外，因此 del 不再存在。
是的，但是由于变量是通过引用捕获的，我们在这里应该没问题，不是吗？
实际上没有，因为是的，x 是通过引用捕获的，并且此引用存在。在 C++ 中，引用可以转换为指针，甚至什么都没有。在这种情况下，由于我们将引用存储在类成员中，因此引用可能会被编译为原始指针。它指向一个在我们需要时实际存在的值。所以有什么问题 ？ 指向的值存在，但指针实际上已不存在。这与通常的运行时错误相反，而且是一个令人困惑的错误，因为指示对象不在原因中。它实际上并没有明确显示，但这里的 del 类型在语义上是对 del 构造函数中的 F 参数的引用，该参数不再存在。因此，错误似乎很明显。
我不是专家，所以我不知道它是否正确，但是通过我使用的测试和替代方案，我很确定这就是幕后发生的事情。我用 MSVC 尝试了相关代码，但它也崩溃了。它不是编译器错误。它有时工作而不是与某些 std::unique_ptr 一起工作的事实可能属于未定义行为的情况，这只是高层次上的坏运气。在某些情况下，一个很好的替代方案是堆分配的 lambda，不幸的是，这可能是有充分理由的，不存在。
在这种情况下，参数 del 需要是 const 引用。我不了解 unique_ptr 实现的细节，但它可能有一些特殊的东西
template<typename T>
F(const T& del)
{
handle = del();
}
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
