从汇编的眼光看C++(之递归函数与模板类)

 递归,相信有过基本C语言经验的朋友都明白,就是函数自己调用自己。所以,本质上说,它和普通的函数调用没有什么区别。今天之所以会把模板类和递归联系在一起,是因为我们可以用递归的方法实现模板的递归。闲话不多说,我们先从一个统计函数开始说起。

[cpp]  view plain copy
  1. int process(int m)  
  2. {  
  3.     int index = 0;  
  4.     int count = 0;  
  5.     assert(m >= 0);  
  6.   
  7.     for (; index <=m; index++){  
  8.         count += index;  
  9.     }  
  10.   
  11.     return count;  
  12. }  
    上面的代码不太难。大家可以看一下,其实就是一个和计算函数,它计算从0~m递增的总和是多少。那么这样的一段代码,用递归应该怎么写呢?大家可以自己试一下。下面的代码是我自己的一个方案,供大家参考。

[cpp]  view plain copy
  1. int process(int m)  
  2. {  
  3.     assert(m >= 0);  
  4.   
  5.     if(m == 0)  
  6.         return 0;  
  7.     else  
  8.         return process(m -1) + m;  
  9. }  
    我们看到,递归的目的就是把大的计算拆分到小的计算,最后再进行计算合并。比如说,我们计算process(5),那就需要计算process(4);process(4)又需要计算process(3);process(3)又需要计算process(2);process(2)有需要计算process(1);process(1)计算有需要process(0);process(0)就可以得到结果了,数值为0,那么进而可以得到process(1),以此类推,最后可以得到结果process(5)的数值。这就是递归处理的全过程。

    那么,这和模板类有什么关系,我们可以看看下面这个范例:

[cpp]  view plain copy
  1. template<int m>  
  2. class calculate  
  3. {  
  4. public:  
  5.     static int process()  
  6.     {  
  7.         return calculate<m-1>::process() + m;  
  8.     }  
  9. };  
  10.   
  11. template<>  
  12. class calculate<0>  
  13. {  
  14. public:  
  15.     static int process()  
  16.     {  
  17.         return 0;  
  18.     }  
  19. };  
    上面这段代码非常有意思。我们发现模板的数据类型不再是int、double或者是自己定义的数据类型,而是一个一个具体的数字。但是每一种数字也代表了一种类型,所以说,calculate<5>和calculate<4>就是两种不同的类。除此之外,我们还是用到了静态处理函数。但是这里的静态函数有点特别,我们发现静态函数process需要调用另外一个类的静态函数,也就是calculate<m-1>的静态函数才能获得结果。所以为了获得结果,我们需要创建很多的类和很多的静态函数。那么,类什么时候结束呢?我们看到了calculate下面还有一个类,那就是calculate的特化模板,也就是说那m=0的时候,并不再继续向下处理了,计算开始回归。那么这个类怎么应用呢,我们来一起看一看:

[cpp]  view plain copy
  1. 258:      int value = calculate<5>::process();  
  2. 004013D8   call        @ILT+45(calculate<5>::process) (00401032)  
  3. 004013DD   mov         dword ptr [ebp-4],eax  
  4. 259:      return;  
  5. 260:  }  
    上面就是调用引申的汇编的代码。汇编和一般的函数调用无异,我们可以跟进去看看:

[cpp]  view plain copy
  1. 242:          return calculate<m-1>::process() + m;  
  2. 00401F68   call        @ILT+40(calculate<4>::process) (0040102d)  
  3. 00401F6D   add         eax,5  
  4. 243:      }  
    上面的代码省略了中间的跳转。我们发现代码继续调用了calculate<4>的静态处理函数。这种调用当然会一直持续下去。那什么时候结束呢?对。就是前面说过的calculate<1>的静态函数,就是前面说的特化函数,我们可以一起看看:

[cpp]  view plain copy
  1. 250:      static int process()  
  2. 251:      {  
  3. 00402090   push        ebp  
  4. 00402091   mov         ebp,esp  
  5. 00402093   sub         esp,40h  
  6. 00402096   push        ebx  
  7. 00402097   push        esi  
  8. 00402098   push        edi  
  9. 00402099   lea         edi,[ebp-40h]  
  10. 0040209C   mov         ecx,10h  
  11. 004020A1   mov         eax,0CCCCCCCCh  
  12. 004020A6   rep stos    dword ptr [edi]  
  13. 252:          return 0;  
  14. 004020A8   xor         eax,eax  
  15. 253:      }  
  16. 004020AA   pop         edi  
  17. 004020AB   pop         esi  
  18. 004020AC   pop         ebx  
  19. 004020AD   mov         esp,ebp  
  20. 004020AF   pop         ebp  
  21. 004020B0   ret  
    看的出来,这里才是真正的递归出口,到了这里之后,函数开始折返,这也就意外着我们的计算即将结束。所有的流程和递归非常相似。所以递归函数和模板递归的区别就是一点:递归函数是在代码执行的时候完成的,模板递归是在编译的时候完成的。

思考题:

    自己编写一个阶乘的函数?尝试一下是否可以转变成递归函数?是否可以用模板类递归得到呢?

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值