今天长见识了

先是读《Programming in Lua》第9章讲 coroutine,然后去google coroutine,找到 Simon Tatham写的 一篇 coroutine in c,讲怎么在C语言中实现 coroutine,文中 先ugly地基于栈实现了一个:

java 代码
 
  1. int function(void) {  
  2. static int i, state = 0;  
  3. switch (state) {  
  4. case 0goto LABEL0;  
  5. case 1goto LABEL1;  
  6. }  
  7. LABEL0: /* start of function */  
  8. for (i = 0; i < 10; i++) {  
  9. state = 1/* so we will come back to LABEL1 */  
  10. return i;  
  11. LABEL1:; /* resume control straight after the return */  
  12. }  
  13. }  

这个方法简单,但是相当丑陋,你必须手工维护这些标签。然后提到了Duff's Device技巧:
cpp 代码
 
  1. switch (count % 8) {  
  2. case 0: do { *to = *from++;  
  3. case 7: *to = *from++;  
  4. case 6: *to = *from++;  
  5. case 5: *to = *from++;  
  6. case 4: *to = *from++;  
  7. case 3: *to = *from++;  
  8. case 2: *to = *from++;  
  9. case 1: *to = *from++;  
  10. while ((count -= 8) > 0);  
  11. }  

这段代码能编译通过吗?能的,不信你试试,这是一段用于拷贝数组的代码,我们一般拷贝数组是这样做的:
cpp 代码
 
  1. send(to, from, count)  
  2. register short *to, *from;  
  3. register count;  
  4. {  
  5. do  
  6. *to = *from++;  
  7. while(--count>0);  
  8. }  

如果循环的中的操作足够快,那么其实大部分时间都是浪费在判断循环条件上面的,而通过Duff's Device通过switch语句将要进行的连续循环操作的次数进行了预判(根据擦case语句的位置)然后依次执行,而不必每次都去进 行测试条件,从而加速循环。这个技巧怎么应用于实现更优雅的 coroutine呢?看代码
cpp 代码
 
  1. int function(void) {  
  2. static int i, state = 0;  
  3. switch (state) {  
  4. case 0: /* start of function */  
  5. for (i = 0; i < 10; i++) {  
  6. state = 1; /* so we will come back to "case 1" */  
  7. return i;  
  8. case 1:; /* resume control straight after the return */  
  9. }  
  10. }  
  11. }  

更好的方式是使用宏:
cpp 代码
 
  1. #define crBegin static int state=0; switch(state) { case 0:  
  2. #define crReturn(i,x) do { state=i; return x; case i:; } while (0)  
  3. #define crFinish }  
  4. int function(void) {  
  5. static int i;  
  6. crBegin;  
  7. for (i = 0; i < 10; i++)  
  8. crReturn(1, i);  
  9. crFinish;  
  10. }  

你可能感兴趣的:(C++,c,Google,C#,lua)