\n void foo(){\n std::cout << "Hello world";\n }\n\n int main() {\n foo(); \n }\n<\/pre><\/div>\n\n\nBut this is not a coroutine either, it will cause a compile error.<\/p>\n\n\n
\n void foo(){\n co_return "Hello world"; \/\/Neither with co_wait or co_yield\n }\n\n int main() {\n foo(); \n }\n<\/pre><\/div>\n\n\nEvery coroutine must have a return type that satisfies a number of requirements<\/p>\n\n\n\n
Elements of coroutines<\/h2>\n\n\n\n
Each coroutine is associated with the promise object, the coroutine handle and the coroutine state.<\/p>\n\n\n\n
Promise Object<\/h3>\n\n\n\n
This object is manipulated from inside the coroutine. The coroutine submits its result or exception through this object.
An example:<\/p>\n\n\n
\n struct return_object {\n struct promise_type {\n return_object get_return_object() { return {}; }\n std::suspend_never initial_suspend() { return {}; }\n std::suspend_never final_suspend() noexcept { return {}; }\n void unhandled_exception() {} \n void return_void(){}\n };\n };\n<\/pre><\/div>\n\n\nAll the functions inside promise_type are mandatory, let\u00b4s explain each one.<\/p>\n\n\n\n
\n- get_return_object() to obtain the object that is passed back to the caller.<\/li>\n\n\n\n
- std::suspend_never initial_suspend() the coroutine keeps running until the first suspending co_await. This is the model for \u201chot-start\u201d coroutines which execute synchronously during their construction and don\u2019t return an object until the first suspension inside the function body.<\/li>\n\n\n\n
- final_suspend after the coroutine function body has finished
When a coroutine reaches a suspension point the return object obtained earlier is returned to the caller\/resumer, after implicit conversion to the return type of the coroutine, if necessary.<\/li>\n\n\n\n - return_value or return_void to define what the coroutine returns.<\/li>\n\n\n\n
- if the coroutine ends with an uncaught exception, catches the exception and calls unhandled_exception() from within the catch-block
Coroutine Handle<\/h3>
The coroutine handle, manipulated from outside the coroutine. This is used to resume execution of the coroutine or to destroy the coroutine frame.
An example:<\/p><\/li>\n<\/ul>\n\n\n
\n #include <concepts>\n #include <coroutine>\n #include <exception>\n #include <iostream>\n\n \/\/definition of the return object and the promise type\n struct return_object {\n struct promise_type {\n return_object get_return_object() { return {}; }\n std::suspend_never initial_suspend() { return {}; }\n std::suspend_never final_suspend() noexcept { return {}; }\n void return_void() {}\n void unhandled_exception() {}\n };\n };\n\n \/\/this is a coroutine, the return type satisfies the requirements and inside is co_return operator.\n return_object foo()\n {\n co_return; \n \/* destroys all variables with automatic storage duration in reverse order they were created.\n Calls promise_type.final_suspend() and co_awaits the result *\/ \n }\n\n int main()\n {\n \/\/we create a handle of type coroutine_handle\n std::coroutine_handle<> handle; \n \/\/this coroutine do nothing\n foo();\n \/\/we can manipulate the hanlde from outside the coroutine\n handle.resume();\n handle.destroy();\n }\n\n<\/pre><\/div>\n\n\nThe hanlde is like a pointer to the coroutine state, so we can change the value of any parameter in that state and the handle will remain the same. To do that we will use co_await but first we need to understand the coroutine states.<\/p>\n\n\n\n
Coroutine state<\/h3>\n\n\n\n
The coroutine state is an internal heap-allocated object that contains:<\/p>\n\n\n\n
\n- the promise object<\/li>\n\n\n\n
- the parameters<\/li>\n\n\n\n
- the current suspension point<\/li>\n\n\n\n
- local variables whose lifetime spans the current suspension point
\nco_await<\/h2>\n
The unary operator co_await suspends a coroutine and returns control to the caller.<\/p>\n
Awaitable object<\/h3>\n
We must use the expression „co_await expr;“ where „expr“ is the awaitable object or awaiter. The awaiter has three methods:<\/p>\n<\/li>\n\n\n\n
- await_ready is an optimization, if it returns true, then co_await does not suspend the function. The header provides two pre-defined awaiters, std::suspend_always and std::suspend_never. As their names imply, suspend_always::await_ready always returns false, while suspend_never::await_ready always returns true.<\/li>\n\n\n\n
- await_suspend Store the coroutine handle every time await_suspend is called.<\/li>\n\n\n\n
- await_resume returns the value of the co_await expression.<\/li>\n<\/ul>\n\n\n\n
An example:<\/p>\n\n\n
\n \n \/\/definition of the return object and the promise type\n struct return_object {\n struct promise_type {\n return_object get_return_object() { return {}; }\n std::suspend_never initial_suspend() { return {}; }\n std::suspend_never final_suspend() noexcept { return {}; }\n void return_void() {}\n void unhandled_exception() {}\n };\n };\n\n struct awaiter {\n std::coroutine_handle<> *handle_;\n constexpr bool await_ready() const noexcept { return false; }\n void await_suspend(std::coroutine_handle<> handle) { *handle_ = handle; }\n constexpr void await_resume() const noexcept {}\n };\n\n \/\/Coroutine using co_await\n return_object foo(std::coroutine_handle<> *handle)\n {\n int fib1 = 0;\n int fib2 = 1;\n \/\/pass the handler to the await_suspend method\n awaiter wait{handle};\n for (int i = 0;; ++i) {\n co_await wait; \/\/suspends the coroutine and returns control to the caller.\n std::cout << fib1 << ", " << fib2 << ", ";\n fib1 = fib2 + fib1; \n fib2 = fib2 + fib1; \n } \n }\n\n int main()\n {\n \/\/we create a handle of type coroutine_handle\n std::coroutine_handle<> handle; \n \/\/pass the control of the handler to foo\n foo(&handle);\n std::cout << "Fibonacci: ";\n for (int i = 1; i < 11; ++i) {\n handle();\n }\n \/\/To avoid leaking memory, destroy coroutine state \n handle.destroy();\n }\n<\/pre><\/div>\n\n\nThis is the output:<\/p>\n\n\n
\n Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, \n 233, 377, 610, 987, 1597, 2584, 4181,\n<\/pre><\/div>\n\n\nYou can avoid to use the awaitable by creating the handle in the return_object and returning it to the caller using the get_return_object method from promise_type.
An example:<\/p>\n\n\n
\n \n\n struct return_object {\n struct promise_type {\n return_object get_return_object() {\n return {\n \/\/return the handle\n .handle_ = std::coroutine_handle::from_promise(*this)\n };\n }\n std::suspend_never initial_suspend() { return {}; }\n std::suspend_never final_suspend() noexcept { return {}; }\n void unhandled_exception() {}\n };\n \/\/create the handle\n std::coroutine_handle handle_;\n operator std::coroutine_handle() const { return handle_; }\n operator std::coroutine_handle<>() const { return handle_; }\n };\n\n return_object foo()\n {\n int fib1 = 0;\n int fib2 = 1;\n std::cout << "Fibonacci: ";\n for (int i = 0;; ++i) {\n co_await std::suspend_always{}; \n std::cout << fib1 << ", " << fib2 << ", ";\n fib1 = fib2 + fib1; \n fib2 = fib2 + fib1; \n } \n }\n\n int main()\n {\n \/\/we create a pointer to a handle\n std::coroutine_handle<> handle = foo(); \n for (int i = 1; i < 11; ++i) {\n handle();\n }\n handle.destroy(); \n }\n<\/pre><\/div>\n\n\nThis is the output:<\/p>\n\n\n
\n Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, \n 144, 233, 377, 610, 987, 1597, 2584, 4181,\n<\/pre><\/div>\n\n\nTransmit info<\/h3>\n\n\n\n
What we did till now is to pass the control from the caller to the coroutine but we can send just the info in the promise object to main by changing the handle.
An example:<\/p>\n\n\n
\n template\n struct awaiter {\n \/\/we will send the promise oject in place of the handle\n promise_object *promise_;\n bool await_ready() { return false; }\n bool await_suspend(std::coroutine_handle handle) {\n promise_ = &handle.promise();\n return false; \/\/to don\u00b4t suspend the coroutine \n \/\/till the promise is set in the coroutine. \n }\n promise *await_resume() { return promise_; }\n };\n\n struct return_object {\n struct promise_type {\n \/\/add something to send, the value is set in the coroutine\n std::string message;\n return_object get_return_object() {\n return {\n .handle_ = std::coroutine_handle::from_promise(*this)\n };\n }\n std::suspend_never initial_suspend() { return {}; }\n std::suspend_never final_suspend() noexcept { return {}; }\n void unhandled_exception() {}\n };\n std::coroutine_handle handle_;\n operator std::coroutine_handle() const { return handle_; }\n };\n\n \/\/Coroutine using co_await\n return_object foo()\n {\n auto pointer_promise = co_await awaiter{};\n int fib1 = 0;\n int fib2 = 1;\n std::cout << "Fibonacci: ";\n for (int i = 0;; ++i) {\n pointer_promise->message = std::to_string(fib1) + ", " \\\n + std::to_string(fib2) + ", ";\n co_await std::suspend_always{}; \n fib1 = fib2 + fib1; \n fib2 = fib2 + fib1; \n } \n }\n\n int main()\n {\n \/\/create a pointer to a handle\n std::coroutine_handle handle = foo();\n \/\/from this pointer handle only need the promise object\n return_object::promise_type &promise = handle.promise(); \n for (int i = 1; i < 11; ++i) {\n \/\/print the promise param that we set in the coroutine \n std::cout << promise.message;\n handle();\n }\n handle.destroy();\n }\n<\/pre><\/div>\n\n\nThis is the output:<\/p>\n\n\n
\n Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181,\n<\/pre><\/div>\n\n\nco_yield<\/h2>\n\n\n\n
Suspend execution returning a value, so using co_yeild, we can simplify the previous example by adding a yield_value method to the promise_type inside our return object.
An example:<\/p>\n\n\n
\n \n struct return_object {\n struct promise_type {\n std::string message;\n return_object get_return_object() {\n return {\n .handle_ = std::coroutine_handle::from_promise(*this)\n };\n }\n std::suspend_never initial_suspend() { return {}; }\n std::suspend_never final_suspend() noexcept { return {}; }\n void unhandled_exception() {}\n \/\/by addding this method we can modify the promise_object values to transmit\n std::suspend_always yield_value(auto value) {\n \/\/store in message the value passed by co_yield\n message = value;\n return {};\n }\n };\n std::coroutine_handle handle_;\n };\n\n \/\/Coroutine using co_yield\n return_object foo()\n {\n int fib1 = 0;\n int fib2 = 1;\n std::cout << "Fibonacci: ";\n for (int i = 0;; ++i) {\n auto value = std::to_string(fib1) + ", " + std::to_string(fib2) + ", ";\n fib1 = fib2 + fib1; \n fib2 = fib2 + fib1; \n co_yield value; \n } \n }\n\n int main()\n {\n auto handle = foo().handle_; \n auto &promise = handle.promise(); \n for (int i = 1; i < 11; ++i) {\n std::cout << promise.message;\n handle();\n }\n handle.destroy();\n } \n<\/pre><\/div>\n\n\nThis is the output:<\/p>\n\n\n
\n Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181,\n<\/pre><\/div>\n\n\nco_return<\/h2>\n\n\n\n
co_return signal the end of a coroutine, there are three ways for a coroutine to signal that it is complete:<\/p>\n\n\n\n
\n- \u201cco_return value;\u201d to return a final value.<\/li>\n\n\n\n
- \u201cco_return;\u201d to end the coroutine without a final value.<\/li>\n\n\n\n
- let execution fall off the end of the function.<\/li>\n<\/ul>\n\n\n\n
An example:<\/p>\n\n\n
\n \n\n struct return_object {\n struct promise_type {\n std::string message;\n return_object get_return_object() {\n return {\n .handle_ = std::coroutine_handle::from_promise(*this)\n };\n }\n std::suspend_never initial_suspend() { return {}; }\n std::suspend_always final_suspend() noexcept { return {}; }\n void unhandled_exception() {}\n std::suspend_always return_value(auto value) {\n \/\/the value passed with co_return is stored in message\n message = value;\n return {};\n }\n };\n std::coroutine_handle handle_;\n };\n\n \/\/Coroutine using co_return\n return_object foo()\n {\n int fib1 = 0;\n int fib2 = 1;\n std::string message = "";\n for (int i = 1; i<11; ++i) {\n auto value = std::to_string(fib1) + ", " + std::to_string(fib2) + ", ";\n fib1 = fib2 + fib1; \n fib2 = fib2 + fib1; \n message = message + value; \n }\n co_return message; \n }\n\n int main()\n {\n auto handle = foo().handle_; \n \/\/at this point coroutin is suspended at its final suspend point, \n std::cout << handle.done() << std::endl; \n auto &promise = handle.promise(); \n std::cout << "Fibonacci: ";\n std::cout << promise.message << std::endl; \n handle.destroy();\n }\n<\/pre><\/div>\n\n\nThis is the output:<\/p>\n\n\n
\n Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181,\n<\/pre><\/div>\n\n\nComparation<\/h1>\n\n\n\n
In a normal cpp function we need to store the numbers in an array and in each iteration pass the array and the index to a function. When the function returns the memory still being used.<\/p>\n\n\n
\n void foo(int index, int fibo[]){\n if (index == 0)\n fibo[index] = 0;\n else if (index == 1)\n fibo[index] = 1;\n else\n fibo[index] = fibo[index - 1] + fibo[index - 2];\n }\n\n int main() {\n int n = 20;\n int fibo[n];\n int index = 0;\n while (index < n) {\n foo(index, fibo); \n index++;\n }\n cout << "Fibonacci :";\n for (int i = 0; i < n; i++)\n cout << fibo[i] << " ";\n }\n<\/pre><\/div>\n\n\nThis is the output:<\/p>\n\n\n
\n Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, \n<\/pre><\/div>\n\n\nAs we so in the previous examples, with a coroutine we don\u00b4t need this number of variables and to send it each time. In case of the coroutines, when the task finish the memory is released.<\/p>\n\n\n\n
Example<\/h2>\n\n\n\n
In the next example we will code to produce a state machine with the next state diagram
![\"Diagrama](\"https:\/\/www.blauringlabs.com\/wp-content\/uploads\/168548172-f7707d87-1ce0-42d2-af53-876060ad5893.png\")
<\/p>\n\n\n\n
Code<\/h3>\n\n\n\n
Add some libraries<\/p>\n\n\n
\n #include <coroutine>\n #include <iostream>\n #include <stdlib.h>\n #include <math.h>\n<\/pre><\/div>\n\n\nDefine the states. As we don\u00b4t have any sensor we declare an extra state, standby, to have an infinite while loop and create a new simulated sensor values each time goes to start state.<\/p>\n\n\n
\n enum State { start, cooling, heating, charging, finish, standby};\n static const char *enum_str[] = { "Start", "Cooling", "Heating", "charging", "Finish", "StandBy" };\n<\/pre><\/div>\n\n\nCreate a struct message to the data that the coroutine should return to the caller<\/p>\n\n\n
\n struct message {\n double temperature;\n double batteryCharge;\n State state;\n };\n<\/pre><\/div>\n\n\nNext code is for the return_object type<\/p>\n\n\n
\n struct return_object {\n struct promise_type {\n message info;\n return_object get_return_object() {\n return {\n .handle_ = std::coroutine_handle::from_promise(*this)\n };\n }\n std::suspend_never initial_suspend() { return {}; }\n std::suspend_always final_suspend() noexcept { return {}; }\n void unhandled_exception() {}\n std::suspend_always yield_value(message value) {\n info = value;\n return {};\n }\n std::suspend_always return_value(message value) {\n info = value;\n return {};\n }\n };\n std::coroutine_handle handle_;\n };\n<\/pre><\/div>\n\n\nNow we create a coroutine to manage the cooling and heating states transitions.<\/p>\n\n\n
\n return_object acclimate(message info){\n if(info.batteryCharge>20){\n while(info.temperature > 20 and info.batteryCharge>20){ \n info.temperature = info.temperature - 0.1; \n \/*as we haven\u00b4t any real battery this code simulates a battery discharge while cooling*\/\n info.batteryCharge = info.batteryCharge - 0.8;\n info.state = cooling;\n co_yield info;\n }\n while(info.temperature < 18 and info.batteryCharge>20){\n info.temperature = info.temperature + 0.1; \n \/*as we haven\u00b4t any real battery this code simulates a battery discharge while heating*\/\n info.batteryCharge = info.batteryCharge - 0.8;\n info.state = heating;\n co_yield info;\n }\n if(info.temperature<=20 or info.temperature>=18){ \n info.state = charging;\n co_yield info;\n }\n }else{ \n info.state = charging;\n co_yield info;\n }\n }\n<\/pre><\/div>\n\n\nDefine a second coroutine to manage the battery charge.<\/p>\n\n\n
\n return_object charger(message info){ \n while(info.batteryCharge<94.9){\n info.batteryCharge = info.batteryCharge + 0.1;\n \/*as we haven\u00b4t any real sensor this code simulates a change of temperature while battery is charging*\/\n info.temperature = info.temperature + 0.01;\n }\n co_return info;\n }\n<\/pre><\/div>\n\n\nAs we haven\u00b4t any real sensor we need to simulate new temperature values and the same for the battery charge state. Once we got those values we manage the first state flow. For that we code te next<\/p>\n\n\n
\n void init_values(message *p_info){\n p_info->temperature = rand() % 55;\n p_info->batteryCharge = rand() % 100;\n if(p_info->temperature<18 and p_info->batteryCharge>20){\n p_info->state = heating;\n std::cout << "The actual temperature is " + std::to_string(p_info->temperature) + ". Heating at " + std::to_string(p_info->batteryCharge) + "% of battery." << std::endl; \n }else if(p_info->temperature>20 and p_info->batteryCharge>20){\n p_info->state = cooling; \n std::cout << "The actual temperature is " + std::to_string(p_info->temperature) + ". Cooling at " + std::to_string(p_info->batteryCharge) + "% of battery." << std::endl; \n }else{\n if(p_info->batteryCharge>20){\n p_info->state = finish;\n }else{ \n p_info->state = charging;\n }\n }\n }\n<\/pre><\/div>\n\n\nAt last, our main function where we call the coroutines and define the states funcionalities.<\/p>\n\n\n
\n int main(){ \n\n message info;\n info.state = start;\n message* p_info = nullptr;\n p_info = &info; \n\n std::coroutine_handle handle; \n return_object::promise_type* promise;\n std::coroutine_handle handle2; \n return_object::promise_type* promise2; \n\n while(info.state != 5){\n switch (info.state) {\n case start: \n std::cout << "Start a new sequence" << std::endl;\n init_values(p_info);\n handle = acclimate(info).handle_;\n promise = &handle.promise();\n break;\n case cooling: \n handle();\n info = promise->info;\n break;\n case heating: \n handle();\n info = promise->info;\n break;\n case finish: \n std::cout << "The actual temperature is " + std::to_string(info.temperature) + ". " + enum_str[info.state] + " at " + std::to_string(info.batteryCharge) + "% of battery." << std::endl; \n info.state = start; \n break;\n case charging:\n std::cout << "The actual temperature is " + std::to_string(info.temperature) + ". Start " + enum_str[info.state] + " at " + std::to_string(info.batteryCharge) + "% of battery." << std::endl; \n handle2 = charger(info).handle_; \n promise2 = &handle2.promise(); \n info = promise2->info;\n std::cout << "The actual temperature is " + std::to_string(info.temperature) + ". Finish " + enum_str[charging] + " at " + std::to_string(info.batteryCharge) + "% of battery." << std::endl; \n if(info.temperature<18){ \n handle = acclimate(info).handle_; \n promise = &handle.promise(); \n info = promise->info;\n info.state = heating;\n std::cout << "The actual temperature is " + std::to_string(info.temperature) + ". " + enum_str[info.state] + " at " + std::to_string(info.batteryCharge) + "% of battery." << std::endl; \n }else if(info.temperature>20){ \n handle = acclimate(info).handle_; \n promise = &handle.promise(); \n info.state = cooling; \n std::cout << "The actual temperature is " + std::to_string(info.temperature) + ". " + enum_str[info.state] + " at " + std::to_string(info.batteryCharge) + "% of battery." << std::endl; \n }else{\n info.state = finish;\n }\n break;\n }\n }\n } \n<\/pre><\/div>\n\n\nOutput:<\/p>\n\n\n
\n Start a new sequence\n The actual temperature is 28.00. Cooling at 86.00% of battery.\n The actual temperature is 20.00. Start charging at 22.00% of battery.\n The actual temperature is 27.30. Finish charging at 95.00% of battery.\n The actual temperature is 27.30. Cooling at 95.00% of battery.\n The actual temperature is 19.90. Start charging at 35.80% of battery.\n The actual temperature is 25.82. Finish charging at 95.00% of battery.\n The actual temperature is 25.82. Cooling at 95.00% of battery.\n The actual temperature is 19.92. Start charging at 47.80% of battery.\n The actual temperature is 24.64. Finish charging at 95.00% of battery.\n The actual temperature is 24.64. Cooling at 95.00% of battery.\n The actual temperature is 19.94. Start charging at 57.40% of battery.\n The actual temperature is 23.70. Finish charging at 95.00% of battery.\n The actual temperature is 23.70. Cooling at 95.00% of battery.\n The actual temperature is 19.90. Start charging at 64.60% of battery.\n The actual temperature is 22.94. Finish charging at 95.00% of battery.\n The actual temperature is 22.94. Cooling at 95.00% of battery.\n The actual temperature is 19.94. Start charging at 71.00% of battery.\n The actual temperature is 22.34. Finish charging at 95.00% of battery.\n The actual temperature is 22.34. Cooling at 95.00% of battery.\n The actual temperature is 19.94. Start charging at 75.80% of battery.\n The actual temperature is 21.86. Finish charging at 95.00% of battery.\n The actual temperature is 21.86. Cooling at 95.00% of battery.\n The actual temperature is 19.96. Start charging at 79.80% of battery.\n The actual temperature is 21.48. Finish charging at 95.00% of battery.\n The actual temperature is 21.48. Cooling at 95.00% of battery.\n The actual temperature is 19.98. Start charging at 83.00% of battery.\n The actual temperature is 21.18. Finish charging at 95.00% of battery.\n The actual temperature is 21.18. Cooling at 95.00% of battery.\n The actual temperature is 19.98. Start charging at 85.40% of battery.\n The actual temperature is 20.94. Finish charging at 95.00% of battery.\n The actual temperature is 20.94. Cooling at 95.00% of battery.\n The actual temperature is 19.94. Start charging at 87.00% of battery.\n The actual temperature is 20.74. Finish charging at 95.00% of battery.\n The actual temperature is 20.74. Cooling at 95.00% of battery.\n The actual temperature is 19.94. Start charging at 88.60% of battery.\n The actual temperature is 20.58. Finish charging at 95.00% of battery.\n The actual temperature is 20.58. Cooling at 95.00% of battery.\n The actual temperature is 19.98. Start charging at 90.20% of battery.\n The actual temperature is 20.46. Finish charging% of battery.\n The actual temperature is 20.46. Cooling at 95.00% of battery.\n The actual temperature is 19.96. Start charging at 91.00% of battery.\n The actual temperature is 20.36. Finish charging at 95.00% of battery.\n The actual temperature is 20.36. Cooling at 95.00% of battery.\n The actual temperature is 19.96. Start charging at 91.80% of battery.\n The actual temperature is 20.28. Finish charging at 95.00% of battery.\n The actual temperature is 20.28. Cooling at 95.00% of battery.\n The actual temperature is 19.98. Start charging at 92.60% of battery.\n The actual temperature is 20.22. Finish charging at 95.00% of battery.\n The actual temperature is 20.22. Cooling at 95.00% of battery.\n The actual temperature is 19.92. Start charging at 92.60% of battery.\n The actual temperature is 20.16. Finish charging at 95.00% of battery.\n The actual temperature is 20.16. Cooling at 95.00% of battery.\n The actual temperature is 19.96. Start charging at 93.40% of battery.\n The actual temperature is 20.12. Finish charging at 95.00% of battery.\n The actual temperature is 20.12. Cooling at 95.00% of battery.\n The actual temperature is 19.92. Start charging at 93.40% of battery.\n The actual temperature is 20.08. Finish charging at 95.00% of battery.\n The actual temperature is 20.08. Cooling at 95.00% of battery.\n The actual temperature is 19.98. Start charging at 94.20% of battery.\n The actual temperature is 20.06. Finish charging at 95.00% of battery.\n The actual temperature is 20.06. Cooling at 95.00% of battery.\n The actual temperature is 19.96. Start charging at 94.20% of battery.\n The actual temperature is 20.04. Finish charging at 95.00% of battery.\n The actual temperature is 20.04. Cooling at 95.00% of battery.\n The actual temperature is 19.94. Start charging at 94.20% of battery.\n The actual temperature is 20.02. Finish charging at 95.00% of battery.\n The actual temperature is 20.02. Cooling at 95.00% of battery.\n The actual temperature is 19.92. Cooling at 94.20% of battery.\n The actual temperature is 20.00. Finish charging at 95.00% of battery.\n The actual temperature is 20.00. Cooling at 95.00% of battery.\n The actual temperature is 19.90. Start charging at 94.20% of battery.\n The actual temperature is 19.98. Finish charging at 95.00% of battery.\n The actual temperature is 19.98. Finish at 95.00% of battery.\n<\/pre><\/div>\n\n\nCompiler<\/h2>\n\n\n\n
Use compiler explorer or gcc 11.2 or older. Use the next flags -std=c++20 and -fcoroutines<\/p>\n\n\n\n
Example<\/h2>\n\n\n\n
01- https:\/\/en.cppreference.com\/w\/cpp\/language\/coroutines<\/a><\/p>\n\n\n\n