用汇编的眼光看C++（之模板类）16

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

 
    如果类是一种确定的数据类型，那么模板就是一种对类的抽象。假设有这么一种类，它需要进行数据的计算，而且类型还很多，那么我们可能就要针对不同类型的数据定义不同的类。我们可以用下面一段代码说明问题：
[cpp] view plaincopy
  1. class int_process  
  2. {  
  3.     int a;  
  4.     int b;  
  5. public:  
  6.     int_process(int m, int n):a(m), b(n) {}  
  7.     ~int_process() {}  
  8.     int add() {return a + b;}  
  9.     int sub() {return a - b;}  
  10.     int mul() {return a * b;}  
  11.     int div() {return a / b;}  
  12. };  
  13.   
  14. class short_process  
  15. {  
  16.     short a;  
  17.     short b;  
  18. public:  
  19.     short_process(short m, short n):a(m), b(n) {}  
  20.     ~short_process() {}  
  21.     short add() {return a + b;}  
  22.     short sub() {return a - b;}  
  23.     short mul() {return a * b;}  
  24.     short div() {return a / b;}  
  25. };  
    上面的代码内容其实比较简单，大家可以看明白。第一个类是int_process，主要是整数的加、减、乘、除的计算。第二类是 short_process，主要处理的短整数的加、减、乘、除计算。两个类处理的内容其实非常相似。那么有没有一种简单的办法可以同时处理这两个类？ 有！这就是模板。我们可以把具体的数据类型抽象出来，形成一种新的类模式。这就是模板类。下面的代码就是模板类：
[cpp] view plaincopy
  1. template <typename type>  
  2. class data_process  
  3. {  
  4.     type a;  
  5.     type b;  
  6. public:  
  7.     data_process(type m, type n):a(m), b(n) {}  
  8.     ~data_process() {}  
  9.     type add() {return a + b;}  
  10.     type sub() {return a - b;}  
  11.     type mul() {return a * b;}  
  12.     type div() {return a / b;}  
  13. };  
    我们看到类把具体的数据类型都抽象成了type。至此，不管是输入值、输出数值，我们都换成了type。至于类的名称，我们也从原来特定的数据类型计 算，转变成了通用的data_process，当然这种名称的定义不是太重要的。那么模板类定义之后，我们应该怎么应用呢？大家继续看代码：
[cpp] view plaincopy
  1. void process()  
  2. {  
  3.     data_process<int> d(1,2);  
  4.     data_process<char> m('1', '2');  
  5.     data_process<double> p(1.2, 2.3);  
  6. }  
    大家从上面的代码也看的出，模板类的定义并不复杂，只是在模板类的名称之后添加一下具体的数据类型就可以了。如果是int类型的，那么处理int的数 据；同理，如果处理的是char或者是double类型数据，我们就可以按照char或者是double类型的数据进行计算，十分方便。当谈，处理的数据 远远不止C++语言本身定义的char、double、float、int、short、long这几种数据类型，如果type本身就是一种class类 型，同时这样class类型也支持+、-、*、/运算，那么本身也是可以用作模板的。我们这里介绍int、char、double只是为了简单地说明问 题。看到类的声明后，我们不禁有一个疑问，既然模板类只有一个，那么这些模板类的构造函数、析构函数、成员函数的处理都相同吗？我们不妨看看看一看他们的 汇编代码：
[cpp] view plaincopy
  1. 60:       data_process<int> d(1,2);  
  2. 0040126D   push        2  
  3. 0040126F   push        1  
  4. 00401271   lea         ecx,[ebp-14h]  
  5. 00401274   call        @ILT+45(data_process<int>::data_process<int>) (00401032)  
  6. 00401279   mov         dword ptr [ebp-4],0  
  7. 61:       data_process<char> m('1', '2');  
  8. 00401280   push        32h  
  9. 00401282   push        31h  
  10. 00401284   lea         ecx,[ebp-18h]  
  11. 00401287   call        @ILT+55(data_process<char>::data_process<char>) (0040103c)  
  12. 0040128C   mov         byte ptr [ebp-4],1  
  13. 62:       data_process<double> p(1.2, 2.3);  
  14. 00401290   push        40026666h  
  15. 00401295   push        66666666h  
  16. 0040129A   push        3FF33333h  
  17. 0040129F   push        33333333h  
  18. 004012A4   lea         ecx,[ebp-28h]  
  19. 004012A7   call        @ILT+60(data_process<double>::data_process<double>) (00401041)  
  20. 004012AC   mov         byte ptr [ebp-4],2  
  21. 63:       int i_d = d.add();  
  22. 004012B0   lea         ecx,[ebp-14h]  
  23. 004012B3   call        @ILT+70(data_process<int>::add) (0040104b)  
  24. 004012B8   mov         dword ptr [ebp-2Ch],eax  
  25. 64:       char c_m = m.add();  
  26. 004012BB   lea         ecx,[ebp-18h]  
  27. 004012BE   call        @ILT+80(data_process<char>::add) (00401055)  
  28. 004012C3   mov         byte ptr [ebp-30h],al  
  29. 65:       double d_p = p.add();  
  30. 004012C6   lea         ecx,[ebp-28h]  
  31. 004012C9   call        @ILT+75(data_process<double>::add) (00401050)  
  32. 004012CE   fstp        qword ptr [ebp-38h]  
  33. 66:  
  34. 67:   }  
    上面的代码有点长，我们大家来一起看一下：
    60句： 定义int型的class类型，可以看到data_process<int>构造函数地址是0x401032
    61句： 定义char型的class类型，看到data_process<char>构造函数地址是0x40103c
    62句：定义double型的class类型，看到data_process<double>构造函数地址是0x401041
    63句：调用data_process<int>的add成员函数，地址为0x40104b 
    64句：调用data_process<char>的add成员函数，地址为0x401055
    65句：调用data_process<double>的add成员函数，地址为0x401050
    
    上面的代码表明，其实编译器为我们函数中出现的每一个具体类实例化了一遍。针对每一个类型，模板的构造函数、析构函数、成员函数都要独立生成，这从上面 的函数地址就可以看出来，没有什么神奇的。所以，我们明白了模板的本质就是对不同数据类型的相似性操作进行共同属性提取，合成模板。在应用的时候，编译器 根据我们使用中的数据类型独立生成每一个类，构建每一个基本运算变量和运算函数，仅此而已。
 
模板注意事项：
    （1）class上出现的问题在模板类上都会出现
    （2）先把class写好，然后再转变成模板类
    （3）如果不是数据类型的差异，而是共有数据数量上的差异，请选用继承代替模板
    （4）模板中的type可以是自定义类型
    （5）模板代码只能出现在头文件中，出现在*.cpp文件中没有意义，单独的*.cpp模板代码因为没有涉及具体类型，因此不会编译成任何二进制代码
    （6）不同版本的vc对模板支持有差异，编译错误不一定是你自己的原因，但是绝大部分应该是你的原因
    （7）模板生成的告警很冗长，一个warning或者是error 30~50行很正常，不要害怕，孰能生巧
 
 

【预告： 下面的博客介绍模板函数】

posted @ 2012-01-18 11:12  董雨  阅读(166)  评论(0)  编辑  收藏  举报