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

转自：http://blog.csdn.net/feixiaoxing/article/details/6798532    

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

view
plain

int process(int m)  

{  

    int index = 0;  

    int count = 0;  

    assert(m >= 0);  

  

    for (; index <=m; index++){  

        count += index;  

    }  

  

    return count;  

}  

    上面的代码不太难。大家可以看一下，其实就是一个和计算函数，它计算从0~m递增的总和是多少。那么这样的一段代码，用递归应该怎么写呢？大家可以自己试一下。下面的代码是我自己的一个方案，供大家参考。

view
plain

int process(int m)  

{  

    assert(m >= 0);  

  

    if(m == 0)  

        return 0;  

    else  

        return process(m -1) + m;  

}  

    我们看到，递归的目的就是把大的计算拆分到小的计算，最后再进行计算合并。比如说，我们计算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）的数值。这就是递归处理的全过程。

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

view
plain

template<int m>  

class calculate  

{  

public:  

    static int process()  

    {  

        return calculate<m-1>::process() + m;  

    }  

};  

  

template<>  

class calculate<0>  

{  

public:  

    static int process()  

    {  

        return 0;  

    }  

};  

    上面这段代码非常有意思。我们发现模板的数据类型不再是int、double或者是自己定义的数据类型，而是一个一个具体的数字。但是每一种数字也代表了一种类型，所以说，calculate<5>和calculate<4>就是两种不同的类。除此之外，我们还是用到了静态处理函数。但是这里的静态函数有点特别，我们发现静态函数process需要调用另外一个类的静态函数，也就是calculate<m-1>的静态函数才能获得结果。所以为了获得结果，我们需要创建很多的类和很多的静态函数。那么，类什么时候结束呢？我们看到了calculate下面还有一个类，那就是calculate的特化模板，也就是说那m=0的时候，并不再继续向下处理了，计算开始回归。那么这个类怎么应用呢，我们来一起看一看：

view
plain

258:      int value = calculate<5>::process();  

004013D8   call        @ILT+45(calculate<5>::process) (00401032)  

004013DD   mov         dword ptr [ebp-4],eax  

259:      return;  

260:  }  

    上面就是调用引申的汇编的代码。汇编和一般的函数调用无异，我们可以跟进去看看：

view
plain

242:          return calculate<m-1>::process() + m;  

00401F68   call        @ILT+40(calculate<4>::process) (0040102d)  

00401F6D   add         eax,5  

243:      }  

    上面的代码省略了中间的跳转。我们发现代码继续调用了calculate<4>的静态处理函数。这种调用当然会一直持续下去。那什么时候结束呢？对。就是前面说过的calculate<1>的静态函数，就是前面说的特化函数，我们可以一起看看：

view
plain

250:      static int process()  

251:      {  

00402090   push        ebp  

00402091   mov         ebp,esp  

00402093   sub         esp,40h  

00402096   push        ebx  

00402097   push        esi  

00402098   push        edi  

00402099   lea         edi,[ebp-40h]  

0040209C   mov         ecx,10h  

004020A1   mov         eax,0CCCCCCCCh  

004020A6   rep stos    dword ptr [edi]  

252:          return 0;  

004020A8   xor         eax,eax  

253:      }  

004020AA   pop         edi  

004020AB   pop         esi  

004020AC   pop         ebx  

004020AD   mov         esp,ebp  

004020AF   pop         ebp  

004020B0   ret  

    看的出来，这里才是真正的递归出口，到了这里之后，函数开始折返，这也就意外着我们的计算即将结束。所有的流程和递归非常相似。所以递归函数和模板递归的区别就是一点：递归函数是在代码执行的时候完成的，模板递归是在编译的时候完成的。

思考题：

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