{"id":5202,"date":"2017-02-27T17:04:26","date_gmt":"2017-02-27T17:04:26","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/coroutines\/"},"modified":"2023-06-26T12:21:06","modified_gmt":"2023-06-26T12:21:06","slug":"coroutines","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/coroutines\/","title":{"rendered":"Coroutines"},"content":{"rendered":"

Coroutines are functions that can suspend and resume their execution while keeping their state. The evolution in C++20 goes one step further.<\/p>\n

<\/p>\n

What I present in this post as a new idea in C++20 is quite old. Melvin Conway coins the term coroutines. He used it in his publication of compiler construction in 1963. Donald Knuth<\/a> called procedures a particular case of coroutines. Sometimes, it just takes a bit longer.<\/p>\n

Although I know coroutines from Python, it was quite challenging for me to understand the new concept in C++20. Hence, before I dive into the details, here is the first contact.<\/p>\n<\/p>\n

A first contact<\/h2>\n

With the new keywords co_await<\/span> and co_yield, <\/span>C++20 will extend the concept of a function.<\/p>\n

Thanks to  co_await expression<\/span><\/strong>, it is possible to suspend and resume the execution of the expression<\/span>. If you use co_await expression<\/span> in a function func<\/span>, the call  auto getResult = func()<\/span> has not to be blocked, if the function result is unavailable. Instead of resource-consuming blocking, you have resource-friendly waiting.<\/p>\n

co_yield expression<\/strong><\/span> enables it to write a generator function. The generator function returns on request each time a new value is. A generator function is a data stream from which you can pick values. The data stream can be infinite; therefore, we are at the center of lazy evaluation<\/a> with C++.<\/p>\n

A simple example<\/h3>\n

The program is as simple as possible. The function getNumbers<\/span> returns all integers from begin<\/span> to end<\/span> incremented by inc<\/span>. begin<\/span> has to be smaller than end<\/span>, and inc<\/span> has to be positive.<\/p>\n

\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31<\/pre>\n<\/td>\n
\n
\/\/ greedyGenerator.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <vector><\/span>\r\n\r\nstd::<\/span>vector<<\/span>int<\/span>><\/span> getNumbers(int<\/span> begin, int<\/span> end, int<\/span> inc=<\/span> 1<\/span>){\r\n  \r\n  std::<\/span>vector<<\/span>int<\/span>><\/span> numbers;\r\n  for<\/span> (int<\/span> i=<\/span> begin; i <<\/span> end; i +=<\/span> inc){\r\n    numbers.push_back(i);\r\n  }\r\n  \r\n  return<\/span> numbers;\r\n  \r\n}\r\n\r\nint<\/span> main(){\r\n\r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n  auto<\/span> numbers=<\/span> getNumbers(-<\/span>10<\/span>, 11<\/span>);\r\n  \r\n  for<\/span> (auto<\/span> n:<\/span> numbers) std::<\/span>cout <<<\/span> n <<<\/span> \" \"<\/span>;\r\n  \r\n  std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n\r\n  for<\/span> (auto<\/span> n:<\/span> getNumbers(0<\/span>,101<\/span>,5<\/span>)) std::<\/span>cout <<<\/span> n <<<\/span> \" \"<\/span>;\r\n\r\n  std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
Of course, I reinvented the wheel with getNumbers<\/span> because since C++11, that job can be done with  std::iota<\/span><\/a>.<\/p>\n
For completeness, here is the output.<\/p>\n
\"greedyGenerator\"<\/p>\n
Two observations about the program are essential. On the other hand, the vector numbers<\/span> in line 8 always get all values. That even holds if I’m only interested in the first five elements of a vector with 1000 elements. On the other hand, it’s quite easy to transform the function getNumbers<\/span> into a generator.<\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28<\/pre>\n<\/td>\n
\n
\/\/ lazyGenerator.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <vector><\/span>\r\n\r\ngenerator<<\/span>int<\/span>><\/span> generatorForNumbers(int<\/span> begin, int<\/span> inc=<\/span> 1<\/span>){\r\n  \r\n  for<\/span> (int<\/span> i=<\/span> begin;; i +=<\/span> inc){\r\n    co_yield i;\r\n  }\r\n  \r\n}\r\n\r\nint<\/span> main(){\r\n\r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n  auto<\/span> numbers=<\/span> generatorForNumbers(-<\/span>10<\/span>);\r\n  \r\n  for<\/span> (<\/span>int i= 1; i <= 20; ++i<\/span>) std::<\/span>cout <<<\/span> numbers <<<\/span> \" \"<\/span>;\r\n  \r\n  std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n\r\n  for<\/span> (auto<\/span> n:<\/span> generatorForNumbers(0<\/span>, 5<\/span>)) std::<\/span>cout <<<\/span> n <<<\/span> \" \"<\/span>;\r\n\r\n  std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
While the function getNumbers <\/span>in the file greedyGenerator.cpp<\/span> returns a std::vector<int><\/span>, the coroutine generatorForNumbers<\/span> in lazyGenerator.cpp<\/span> returns a generator. The generator numbers <\/span>in line 18 or generatorForNumbers(0, 5)<\/span> in line 24 return on request a new number. The range-based for-loop triggers the query. To be precise. The query of the coroutine returns the value i <\/span>via co_yield i<\/span> and immediately suspends its execution. If a new value is requested, the coroutine resumes its execution precisely at that place.<\/p>\n
The expression getForNumber(0, 5)<\/span> in line 24 may look slightly weird. This is a just-in-place usage of a generator.<\/p>\n
I want to stress one point explicitly. The coroutine generatorForNumbers<\/span> creates an infinite data stream because the for-loop in line 8 has no end condition. That is no problem if I only ask for a finite number of values, such as in line 20. That will not hold for line 24. There is no end condition.<\/p>\n
As promised. Here are the details of the coroutines. I will answer the following questions:<\/p>\n