C++20 协程捕获与引用奇怪的崩溃与 `unique_ptr`

Question

这是一个代码，当在 main 中使用第 (2) 行版本（并且第 (1) 行被注释）时会崩溃。奇怪的是，此代码使用模仿第 (2) 行行为的简单替换实现（第 (1) 行）来编译罚款。当然如果是undefined behavior，就没法很好的解释了，但是我不明白为什么会崩溃。基本上，它是 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），这是 link：https://godbolt.org/z/cWYY8PKx4。也许是 gcc 实现问题，围绕 std::unique_ptr 优化？我无法在 Godbolt 上测试其他编译器，clang 上不支持协程。

Answer 1

我并没有完全按照您的代码进行操作，但我首先想到的是您正在创建一个通过引用使用局部变量的 lambda (a)。我相信这可能意味着 x 直到它不在某些控制路径的范围内才被使用。将 x 作为参数传递比通过引用传递要简洁得多。

如果我误解了 lambda 的某些语法，我可能会偏离方向。

Answer 2

参数del在这种情况下需要是常量引用。我不了解 unique_ptr 实施的细节，但它可能有一些特殊的东西

template<typename T>
F(const T& del)
{
    handle = del();
}

Answer 3

虽然还不清楚为什么会发生这种情况，但似乎 std::suspend_always initial_suspend() { return {}; } 与 lambda 结合使用并结合作用域 unique-ptrs 的优化时也会错误地执行在错误的范围内捕获参数。

稍作修改的变体：

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 时也能正确运行，表明捕获机制中存在错误。

根据优化级别，捕获的范围是 F 的 this 或 F() 的构造函数的堆栈帧。

Answer 4

我想我知道它崩溃的原因了。没有细节，我将尝试逐步解释它会发生什么。

让我们重点关注这部分：

    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，这是为了语义说明。让我们解释一下：我们将值 20 分配给 del 的成员引用 x。目前，这只是显而易见的翻译。但是 del 是什么？它指的是在F的构造函数中创建的变量。在 C++ 中，this 隐式地用于查找变量，我们通常在像 x = 20; co_yield x; 这样使用 lambda 时滥用它（否则，lambda 的用处不大），这里只是 del .但是由于我们在 f 的构造函数之外，del 不再存在。

是的，但是由于变量是通过引用捕获的，我们在这里应该没问题，不是吗？

其实没有，因为是的，x是引用捕获的，这个引用是存在的。在 C++ 中，引用可以转换为指针，甚至什么也没有。在这种情况下，由于我们在 class 成员中存储了一个引用，因此该引用可能会被编译成一个原始指针。并且它指向一个在我们需要的时候实际存在的值。所以有什么问题？ 指向的值存在，但指针实际上已经不存在了。这与通常的运行时错误相反，并且是一个令人困惑的错误，因为指针不在原因中。它实际上并没有显式显示，但是 del 的类型在语义上是对 F 的构造函数中的 del 参数的引用，它不再存在。因此，错误显得很明显。

我不是专家，所以我不知道它是否正确，但是通过我使用的测试和替代方案，我很确定这就是幕后发生的事情。我用 MSVC 尝试了相关代码，但它也崩溃了。它不是编译器错误。事实上，它有时会起作用而不是某些 std::unique_ptr 可能属于未定义行为的情况，这只是高层次的运气不好。在某些情况下，堆分配的 lambda 是一个很好的替代方案，不幸的是，可能出于充分的原因，它不存在。

C++20 协程捕获与引用奇怪的崩溃与 `unique_ptr`

C++20 coroutine capture with reference weird crash with `unique_ptr`

c++

gcc

c++20

c++-coroutine