I doubt it can be done portably, but are there any solutions out there? I think it could be done by creating an alternate stack and reseting SP,BP, and IP on function entry, and having yield save IP and restore SP+BP. Destructors and exception safety seem tricky but solvable.
Has it been done? Is it impossible?
Does this point you in the right direction? It seems like an elegant solution that has lasted the test of time.....it's 9 years old!
[update] I'm actually making successful use of it myself. Curiousity got the better of me, so I looked into this solution, and found it was a good fit for a problem I've been working on for some time!
You might be better off with an iterator than a coroutine if possible. That way you can keep calling next() to get the next value, but you can keep your state as member variables instead of local variables.
It might make things more maintainable. Another c++ developer might not immediately understand the coroutine whereas they might be more familiar with an iterator.
I dont think there are many full-blown, clean implementations in C++. One try that I like is protothread library.
Yes it can be done with out a problem. All you need is a little asm to move the call stack to a newly allocated stack on the heap.
I would look at the experimental Boost.Coroutine library.
The one thing that you should watch out for is a stackoverflow. On most operating systems overflowing the stack will cause a SEGFAULT because virtual memory page is not mapped. However if you allocate the stack on the heap you don't get any guarantee. Just keep that in mind
You should always consider using threads instead; especially in modern hardware. If you have work that can be logically separated in Co-routines, using threads means the work might actually be done concurrently, by separate execution units (processor cores).
But, maybe you do want to use coroutines, perhaps because you have an well tested algorithm that has already been written and tested that way, or because you are porting code written that way.
If you work within Windows, you should take a look at fibers. Fibers will give you a coroutine-like framework with support from the OS.
I am not familiar with other OS's to recommend alternatives there.
On POSIX, you can use makecontext()/swapcontext() routines to portably switch execution contexts. On Windows, you can use the fiber API. Otherwise, all you need is a bit of glue assembly code that switches the machine context. I have implemented coroutines both with ASM (for AMD64) and with swapcontext(); neither is very hard.
WvCont is a part of WvStreams that implements so-called semi-coroutines. These are a little easier to handle than full-on coroutines: you call into it, and it yields back to the person who called it.
It's implemented using the more flexible WvTask, which supports full-on coroutines; you can find it in the same library.
Works on win32 and Linux, at least, and probably any other Unix system.