导致此代码“分割故障”的原因是coroutine调用`promist_type :: return_value(）`

我认为对这个问题缺乏兴趣主要是因为Coroutines是如此新(甚至在这一点上甚至在技术上都不是标准化(。这是一个有趣的话题。我不得不做一些挖掘，但是我发现CPPCON 2016的这次演讲非常有用，以及Coroutine标准的草稿。

直接陷入问题：我认为您(在进行一些研究之前我也是我也很困惑，对应该如何编写Coroutines，这不幸的是，这需要对C 语言如何实现它们有很多了解在引擎盖下。例如，必须通过手柄来控制Coroutines(包括恢复(，但是您不会在任何地方存储手柄。

此外，您可能不应该使用std::future或std::async(并且仅使用std::launch::async使用std::async的FYI几乎没有用(。这些类型很难独自使用，并且不利于在C 20中编写Coroutines。例如，在我的测试中，我发现segfault是由 std::future实例在访问点没有有效的情况下引起的。

这是您提供的固定代码(删除了不必要的详细信息(。它对所有重要的内容都有评论，可以说在哪里以及为什么会发生什么。我选择将所有内容直接嵌套在awaitable内，以更清洁且易于阅读，但也可以通过coroutine_traits进行。

注意：我用最新标准草稿和/await编译标志在VisualStudio 2017中编写/测试了这一点。

#include <iostream>
#include <utility>
#include <experimental/coroutine>
template<typename T>
class awaitable
{
public: // -- promise type -- //
    // declare the promise type and alias the handle type
    struct promise_type;
    typedef std::experimental::coroutine_handle<promise_type> handle;
    struct promise_type
    {
        T ret_val; // storage location for the return value
        // we need to provide a way to convert a promise into the awaitable object (via the handle)
        awaitable get_return_object() { return awaitable { handle::from_promise(*this) }; }
        // we won't suspend upon starting - we want to start immediately
        auto initial_suspend() { return std::experimental::suspend_never{}; }
        // we need to buffer the return value, so we need to suspend at the end of the coroutine.
        // if we didn't do this the coroutine object could be destroyed and we'd access undefined memory.
        auto final_suspend() { return std::experimental::suspend_always{}; }
        // this is called when the coroutine body uses co_return expr
        // where expr is not cv-qualified void (otherwise return_void() is used).
        // the current coroutine standard draft dictates this MUST return void.
        template<typename U>
        void return_value(U &&v) { ret_val = std::forward<U>(v); }
        // this is called if an exception is thrown in the coroutine.
        // immediately after this, the final suspend is performed (so the coroutine will be done() after this).
        void unhandled_exception()
        {
            // we can either terminate() (i.e. we do not allow/expect exeptions)
            // or we could store and rethrow the exception later (i.e. std::exception_ptr).
            // i'll use the terminate() option since that's what you used.
            std::terminate();
        }
    };
public: // -- non-coroutine support -- //
    // we provide a method to get the value - note that this method is not a coroutine.
    // if we didn't provide this, we couldn't use it in e.g. main() because main() cannot be a coroutine.
    T get()
    {
        while (!co.done()) co.resume(); // resume the coroutine until it's done (at final suspend)
        return co.promise().ret_val;    // then get its value (via copy to allow calling get() multiple times)
    }
public: // -- coroutine support -- //
    bool await_ready() { return co.done(); } // are we already done?
    T    await_resume() { return get(); }    // when await is resumed, we need to block and get the value
    // no special suspend logic - defaults are good.
    // this takes generic coroutine_handle<> rather than handle to be generic.
    // coroutine_handle<> is the same as coroutine_handle<void>.
    // it can kind of be though of like a void* to a coroutine of any type.
    // i.e. we can suspend this coroutine to co_await a coroutine of any type.
    void await_suspend(std::experimental::coroutine_handle<>) {}
public: // -- data -- //
    // we need to store a handle for the coroutine
    handle co = nullptr;
public: // -- ctor / dtor / asgn -- //
    // we can make an awaitable type from a (coroutine) handle
    explicit awaitable(handle h) : co(h) {}
    // in dtor, we need to destroy the coroutine if it's still valid
    ~awaitable() { if (co) co.destroy(); }
    // we can also make an empty awaitable
    awaitable() = default;
    // we can't copy an awaitable
    awaitable(const awaitable&) = delete;
    awaitable &operator=(const awaitable&) = delete;
    // but we can move from one
    awaitable(awaitable &&other) : co(std::exchange(other.co, nullptr)) {}
    awaitable &operator=(awaitable &&other) { co = std::exchange(other.co, nullptr); return *this; }
};
awaitable<int> async_add(int a, int b) { co_return a + b; }
awaitable<int> async_fib(int n)
{
    if (n <= 2) co_return 1;
    int a = 1, b = 1;
    for (int i = 0; i < n - 2; ++i)
    {
        int c = co_await async_add(a, b); // we're a coroutine, so we can co_await the result of async_add
        a = b;
        b = c;
    }
    co_return b;
}
int main()
{
    // we're NOT a coroutine, so we can't suspend and do other things - use .get() rather than co_await
    std::cerr << async_fib(8).get() << 'n';
    return 0;
}