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

最新推荐文章于 2024-01-02 10:00:00 发布
最新推荐文章于 2024-01-02 10:00:00 发布
阅读量84 收藏
点赞数
分类专栏： C/C++ Linux/Unix
原文链接：https://blog.csdn.net/feixiaoxing/article/details/6798532
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/feixiaoxing/article/details/6798532

【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】


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


 
 
  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递增的总和是多少。那么这样的一段代码，用递归应该怎么写呢？大家可以自己试一下。下面的代码是我自己的一个方案，供大家参考。 


 
 
  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）的数值。这就是递归处理的全过程。

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


 
 
  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的时候，并不再继续向下处理了，计算开始回归。那么这个类怎么应用呢，我们来一起看一看： 


 
 
  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:  }
    上面就是调用引申的汇编的代码。汇编和一般的函数调用无异，我们可以跟进去看看： 


 
 
  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>的静态函数，就是前面说的特化函数，我们可以一起看看： 


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     250:      static 
     
     int process()
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     251:      {
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     0040209
     
     0   
     
     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. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     004020B
     
     0   ret
    看的出来，这里才是真正的递归出口，到了这里之后，函数开始折返，这也就意外着我们的计算即将结束。所有的流程和递归非常相似。所以递归函数和模板递归的区别就是一点：递归函数是在代码执行的时候完成的，模板递归是在编译的时候完成的。

思考题：

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


【预告： 下面一片博客介绍泛型函数处理】




石上清泉80
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
牛客校招面试题（附答案与解析）c++
07-31
5. **模板**：C++的模板允许创建泛型代码，可以用于编写通用的函数和类。模板的理解和使用是高级C++开发者必备的技能。 6. **STL**：STL（标准模板库）包括容器（如vector、list、set、map等）、迭代器、算法和函数...
C++入门思维导图（自用）
最新发布
06-19
- **注意事项**: 不宜用于递归函数，一般不超过10行代码。 ### 13. 静态断言 - **C++静态断言**: `static_assert`用于检查模板参数是否满足条件。 - **C++20概念**: `concept`进一步增强了模板参数的类型检查能力...
基础算法-递归讲解及模板(C++实现)
关注网络安全、云原生安全
07-23 1344
在看本文之前，需要了解一下函数调用的过程： 1.计算参数值,将函数压入函数栈 2.执行函数 3.结束本函数，栈帧返回至上层函数 我们平时写的main也是个函数，在里面调用其他的函数。 递归函数模板: //递归函数 void 递归函数(参数列表) { if(结束条件)//满足后执行下列语句，结束当前函数并返回 { //执行函数体，结束函数前该干的事情 } ...
C++类---构造汇编操作
jhui163的专栏
11-08 788
今天在atlaux2.h 里面发现一个类，很好奇。因为他是下面的写法。。。//ATLAUX2.h            -- COM/ATL Useful Helpers#pragma pack(push, 1) template class CAuxThunk {   BYTE    m_mov;          // mov ecx, %pThis   DWORD   m_this;         //   BYTE    m_jmp;          // jmp func  
C++类对象调用时的汇编表示
sanqiuai的博客
05-01 302
C代码 Class.h class Creature { public: int hp; int mp; char* name; void Attack(); void Defend(); void Dead(); Creature(char* name); }; class Player:public Creature { public: int nSmart; int nPower; void Buy(); Player(char* name); }; Cla
C\C++参考手册C\C++参考手册
02-26
- **类与对象**：定义类，创建和使用对象。 - **继承与多态**：单一继承、多重继承，虚函数和多态性。 - **封装与抽象**：访问修饰符（public、private、protected），接口与实现分离。 - **模板**：函数模板、...
MinGW64(Dev-C++5.11版)
02-04
5. **模板**：泛型编程，用于创建可处理不同数据类型的函数或类。 6. **异常处理**：try-catch语句用于捕获和处理运行时错误。 了解这些基础知识后，结合MinGW64和Dev-C++5.11，开发者可以高效地进行C++程序开发。...
C++ 简单递归
10-31
简单递归求数列 ex:1,2,3,6,9,54,63
从汇编看C++系列前4篇
05-27
当遇到较大较复杂的编程任务时，用 C 就会比较吃力，这个时候就应该使用 C++，因此有必要对 C++ 再深究一下。从汇编角度研究 C++，能看到最彻底最本质的东西，学习效果也最好，也更容易看清C++面向对象的底层实质。因此，从今天起，我会写一个专题系列 《从汇编看 C++》 发布到我的博客里，欢迎收看 目前，我总共写了4篇，他们是： 1.《从汇编看C++ 之函数开销》 2.《从汇编看C++ 之类成员》 3.《从汇编看C++ 之引用指针动态内存》 4.《从汇编看C++ 之虚函数接口多态》 欢迎大家下载，并到我微博上交流指正，我会继续努力（我微博上也叫小力庭）
c++封装的二叉排序树， c++ 封装 二叉排序树 私有成员函数递归 非递归的插入 实现的树的各种操作。
04-23
c++ 封装 二叉排序树 私有成员函数递归 非递归的插入 实现的树的各种操作，并且利用c++的面向对象思想进行封装，内部包含三个文件BinaryTree.cpp， BinaryTree.hpp ， main.cpp
递归函数入门（c/c++）
weixin_64214636的博客
04-21 3055
一、什么是递归函数 函数自己调用自己，这样的调用过程被称为递归。 难点：如何结束递归，递归结束的条件。 二、三要素 1.函数所要实现的功能 2.终止的条件 3.找出与函数等价的关系式 三、认识递归 ...
用汇编理解C++
wzn491574452的博客
04-22 4437
用汇编理解C++在各种高级语言发展成熟的今天，我们几乎不会再去用汇编进行编程了。但是在实际编程过程中，确经常会碰到一些莫名奇怪地问题，此时如果能从汇编的角度对代码进行理解的话也许就可以发现其中的问题所在，同时也便于更深次理解高级语言的运行原理。因此本篇文章旨在让大家能更好地理解C++，即使没有汇编基础的人也能看懂。一、汇编和C++的关系要说到它俩的关系，首先得提一下机器语言。机器语言是机器指令的集...
C++语言基础--递归函数
信息学奥赛学案
02-21 6795
对于很多编程初学者来说，递归算法是学习语言的最大障碍之一。可能也有一大部分人知道递归，也能看的懂递归，但在实际做题过程中，却不知道怎么使用 递归的定义 1、很官方的说法 递归，在数学与计算机科学中，是指在函数的定义中使用函数自身的方法。 也就是说，递归算法是一种直接或者间接调用自身函数或者方法的算法。 2、递归的核心思想 通俗来说，递归算法的实质是把问题分解成规模缩小的同类问题的子问题，然后递归调用方法来表示问题的解。 这就是分治的思想 3、递归的自我感觉 以下纯是个人感受，递归可以视为循环的扩展，我们利
C++ 递归函数 详细解析——C++日常学习随笔
青少年编程学习指导
12-31 3088
1. 递归函数 1.1 递归函数的定义 递归函数：即在函数体中出现调用自身的函数，即函数Func(Type a,……)直接或间接调用函数本身； 递归函数：在数学上，关于递归函数的定义如下：对于某一函数f(x)，其定义域是集合A，那么若对于A集合中的某一个值x0，其函数值f(x0)由f(f(x0))决定，那么就称f(x)为递归函数； 递归函数：不能定义为内联函数；
C++模板元编程之模板递归
https://github.com/JelinYao
04-18 6800
如何提高程序运行效率？在编译时就把需要计算的结果算出来，避免运行时占用CPU时间去做耗时计算，这就是模板递归的原理。 举例说明： 1、计算100的阶乘 //一般情况下，我们是这样做的：int GetFactorial(const int n) {  int nResult=1;//n=0或者1时返回1  assert(n>=0);  if(1!=n)   nResult=GetFa
C++递归/递归函数（详细讲解）
宇宙超粒终端控制中心的博客
01-02 2525
递归是一种将问题分解为更小子问题的策略，理解递归问题的整体结构和递归边界是关键。递归边界是确定递归何时结束的条件，正确地确定递归边界是确保递归算法正确运行的关键。一旦确定了递归边界，就可以根据问题的具体情况设计递归函数，将问题分解为更小的子问题，并逐个解决这些子问题。在设计和实现递归函数时，要确保递归调用能够正确地解决子问题，并将子问题的解组合起来以形成原问题的解。通常，递归函数会包含一个或多个递归调用，以便处理更小的子问题。
C++递归函数详解：计算阶乘与理解运算符
递归函数是C++编程中的一个重要概念，尤其在算法设计和数据结构中扮演着关键角色。在本题中，我们分析的是一个名为`fun`的递归函数，其定义如下： ```cpp int fun ( int n ) { if ( n ) return 1; else return n...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值