在c++++协程中处理异常的关键在于利用try...catch块捕获异常、处理co_await表达式抛出的异常，并通过promise对象的unhandled_exception()方法管理未处理异常。1. 在协程体内直接使用try...catch捕获并处理异常；2. co_await表达式若引发异常，会传播至协程体，需在try...catch中捕获；3. 未处理的异常会调用promise的unhandled_exception()方法，默认终止程序，可自定义保存异常；4. 异常可在协程链中通过set_exception传递；5. 使用raii或智能指针避免异常导致资源泄漏。
在C++协程中处理异常，本质上就是在协程帧的生命周期内，确保即使发生错误，程序也能优雅地恢复或终止，避免崩溃。 这需要我们理解协程的挂起和恢复机制，并巧妙地利用try...catch块。
协程帧中的异常捕获与传播，主要依赖于co_await操作符和promise对象。 当协程体内部抛出异常时，这个异常需要能够被“传递”到调用者或者协程的promise对象，以便进行处理。
处理协程中的异常，需要关注几个关键点：一是协程体内的异常捕获，二是co_await表达式中的异常处理，三是promise对象的异常处理机制。
立即学习“C++免费学习笔记（深入）”；
如何在协程体内捕获异常？
最直接的方式，就是在协程函数体内使用try...catch块。 这和普通的C++函数异常处理没有本质区别，但需要注意的是，协程可能会挂起，因此异常发生的位置和处理的位置可能不在同一个函数调用栈上。
例如：
#include#include struct MyCoroutine { struct promise_type { int result; MyCoroutine get_return_object() { return {std::coroutine_handle ::from_promise(*this)}; } std::suspend_never initial_suspend() { return {}; } std::suspend_never final_suspend() noexcept { return {}; } void unhandled_exception() { std::terminate(); } void return_value(int value) { result = value; } }; std::coroutine_handle handle; }; MyCoroutine my_coroutine() { try { // 模拟可能抛出异常的操作 throw std::runtime_error("Something went wrong!"); co_return 42; // 如果没有异常，返回42 } catch (const std::exception& e) { std::cerr << "Caught exception in coroutine: " << e.what() << std::endl; co_return -1; // 发生异常时，返回-1 } } int main() { MyCoroutine coro = my_coroutine(); std::cout << "Result: " << coro.handle.promise().result << std::endl; coro.handle.destroy(); return 0; }
在这个例子中，如果throw std::runtime_error被执行，那么异常会被catch块捕获，并打印错误信息。 协程最终会co_return -1，将-1作为结果返回。
co_await 表达式如何处理异常？
当co_await一个可能抛出异常的awaitable对象时，异常的处理会稍微复杂一些。 如果awaitable对象的await_resume()方法抛出异常，那么这个异常会被传播到协程中，就像co_await表达式直接抛出异常一样。
#include#include #include struct ExceptionAwaitable { bool await_ready() { return false; } void await_suspend(std::coroutine_handle<> h) { h.resume(); } int await_resume() { throw std::runtime_error("Exception from await_resume!"); } }; struct MyCoroutine2 { struct promise_type { int result; MyCoroutine2 get_return_object() { return {std::coroutine_handle ::from_promise(*this)}; } std::suspend_never initial_suspend() { return {}; } std::suspend_never final_suspend() noexcept { return {}; } void unhandled_exception() { std::terminate(); } void return_value(int value) { result = value; } }; std::coroutine_handle handle; }; MyCoroutine2 my_coroutine2() { try { int value = co_await ExceptionAwaitable{}; std::cout << "Value after co_await: " << value << std::endl; // 不会被执行 co_return 42; } catch (const std::exception& e) { std::cerr << "Caught exception after co_await: " << e.what() << std::endl; co_return -1; } } int main() { MyCoroutine2 coro = my_coroutine2(); std::cout << "Result: " << coro.handle.promise().result << std::endl; coro.handle.destroy(); return 0; }
在这个例子中，ExceptionAwaitable的await_resume()方法会抛出一个异常。 这个异常会被my_coroutine2函数中的try...catch块捕获。
Promise对象的unhandled_exception()方法有什么作用？
如果协程体内的异常没有被捕获，那么会调用promise对象的unhandled_exception()方法。 默认情况下，这个方法会调用std::terminate()，导致程序终止。 我们可以自定义这个方法，来实现更灵活的异常处理。
例如，我们可以记录错误信息，或者尝试恢复协程的状态。
#include#include #include struct MyCoroutine3 { struct promise_type { int result; std::exception_ptr exception; MyCoroutine3 get_return_object() { return {std::coroutine_handle ::from_promise(*this)}; } std::suspend_never initial_suspend() { return {}; } std::suspend_never final_suspend() noexcept { return {}; } void unhandled_exception() { exception = std::current_exception(); // 保存异常 } void return_value(int value) { result = value; } }; std::coroutine_handle handle; }; MyCoroutine3 my_coroutine3() { throw std::runtime_error("Unhandled exception in coroutine!"); co_return 42; // 不会被执行 } int main() { MyCoroutine3 coro = my_coroutine3(); if (coro.handle.promise().exception) { try { std::rethrow_exception(coro.handle.promise().exception); } catch (const std::exception& e) { std::cerr << "Caught unhandled exception in main: " << e.what() << std::endl; } } else { std::cout << "Result: " << coro.handle.promise().result << std::endl; } coro.handle.destroy(); return 0; }
在这个例子中，my_coroutine3函数会抛出一个未处理的异常。 这个异常会被promise对象的unhandled_exception()方法捕获，并保存到exception成员中。 在main函数中，我们可以检查exception成员是否为空，如果不为空，则重新抛出异常并进行处理。
如何在co_await链中传递异常？
在复杂的协程调用链中，异常需要在不同的协程之间传递。 这可以通过promise对象的return_void()和set_exception()方法来实现。
当一个协程需要将异常传递给它的调用者时，它可以调用promise对象的set_exception()方法。 这个方法会将异常保存到promise对象中，并在协程恢复时重新抛出。
#include#include #include struct NestedCoroutine { struct promise_type { NestedCoroutine get_return_object() { return {std::coroutine_handle ::from_promise(*this)}; } std::suspend_never initial_suspend() { return {}; } std::suspend_never final_suspend() noexcept { return {}; } void unhandled_exception() { std::terminate(); } void return_void() {} // 协程不返回值时使用 void set_exception(std::exception_ptr e) { exception = e; } std::exception_ptr exception; }; std::coroutine_handle handle; }; NestedCoroutine nested_coroutine() { throw std::runtime_error("Exception from nested coroutine!"); co_return; // 不会被执行 } struct MyCoroutine4 { struct promise_type { int result; MyCoroutine4 get_return_object() { return {std::coroutine_handle ::from_promise(*this)}; } std::suspend_never initial_suspend() { return {}; } std::suspend_never final_suspend() noexcept { return {}; } void unhandled_exception() { std::terminate(); } void return_value(int value) { result = value; } }; std::coroutine_handle handle; }; MyCoroutine4 my_coroutine4() { try { co_await nested_coroutine(); co_return 42; // 不会被执行 } catch (const std::exception& e) { std::cerr << "Caught exception in my_coroutine4: " << e.what() << std::endl; co_return -1; } } int main() { MyCoroutine4 coro = my_coroutine4(); std::cout << "Result: " << coro.handle.promise().result << std::endl; coro.handle.destroy(); return 0; }
在这个例子中，nested_coroutine函数会抛出一个异常。 这个异常会被传递到my_coroutine4函数中，并被try...catch块捕获。
如何避免异常导致的资源泄漏？
在使用协程时，需要特别注意资源管理。 如果在协程挂起时发生异常，那么可能会导致资源泄漏。 为了避免这种情况，可以使用RAII（Resource Acquisition Is Initialization）技术，或者使用智能指针来管理资源。
另外，也可以在promise对象的final_suspend()方法中释放资源。 这个方法会在协程结束时被调用，无论协程是正常结束还是因为异常而结束。
