👀 Views: 427 💬 Answers: 1 📅 Created: 2025-08-26

c++20 coroutines custom-allocator C++

I'm not sure how to approach I'm currently working with an scenario when trying to integrate C++20 coroutines with a custom memory allocator in a complex data structure... I have a coroutine that is supposed to yield a `std::vector<int>` that uses a custom allocator derived from `std::allocator`. However, when I attempt to run the coroutine, it leads to an unexpected `std::bad_alloc` behavior. Here's a simplified version of what I have: ```cpp #include <iostream> #include <vector> #include <coroutine> template <typename T> struct CustomAllocator { using value_type = T; CustomAllocator() = default; template <typename U> CustomAllocator(const CustomAllocator<U>&) {} T* allocate(std::size_t n) { std::cout << "Allocating " << n << " items" << std::endl; return static_cast<T*>(::operator new(n * sizeof(T))); } void deallocate(T* p, std::size_t) noexcept { std::cout << "Deallocating" << std::endl; ::operator delete(p); } }; struct MyCoroutine { struct promise_type { auto get_return_object() { return std::coroutine_handle<promise_type>::from_promise(*this); } auto initial_suspend() { return std::suspend_always(); } auto final_suspend() noexcept { return std::suspend_always(); } void unhandled_exception() { std::terminate(); } void return_void() {} }; using handle_type = std::coroutine_handle<promise_type>; handle_type coro; MyCoroutine(handle_type h) : coro(h) {} ~MyCoroutine() { coro.destroy(); } void resume() { coro.resume(); } }; MyCoroutine myCoroutine() { std::vector<int, CustomAllocator<int>> v; v.push_back(1); co_return; } int main() { MyCoroutine coro = myCoroutine(); coro.resume(); return 0; } ``` When I run this code, I get the following behavior: ``` std::bad_alloc: Failed to allocate memory ``` I've tried checking if my custom allocator is properly managing memory, and I've even reduced the complexity by using the default allocator, which works fine. I suspect there may be an scenario with how the coroutine interacts with the allocation. Could it be that coroutines require special handling when memory is allocated in this manner? Any insights or workarounds would be greatly appreciated! I've been using C++ for about a year now. Has anyone dealt with something similar? Is there a better approach?