模板升华

淩亂°似流年 2022-03-25 08:48 155阅读 0赞

之前写了一篇关于模板的博客https://blog.csdn.net/Jochebed666/article/details/86547166，对模板进行了简单的介绍和运用。  
下面详细介绍一下模板：

**模板参数**  
![模板参数][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pvY2hlYmVkNjY2_size_16_color_FFFFFF_t_70]  
什么是模板参数？？？  
template<typename T,……>/template<class T,……>，  
<>里的就是模板参数。  
模板参数分为**类型形参**与**非类型形参**。  
**类型形参**：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。  
**非类型形参**：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

举个栗子：

template<class T, size_t N = 10>
    class Array
    { 
    public:
     T& operator[](size_t index)
     { 
     return _array[index];
     }
     const T& operator[](size_t index)const
     { 
     return _array[index];
     }
     size_t Size()const
     { 
     return _size;
     }
     bool Empty()const
     { 
     return 0 == _size;
     }
    private:
     T _array[N];
     size_t _size;
    }；

那么为什么不用宏呢？  
因为宏有一个很大的缺点：宏不能调试、不能类型检查。

**模板的特化**

在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。  
**函数模板特化**  
函数模板的特化步骤：

1.  必须要先有一个基础的函数模板
2.  关键字template后面接一对**空的尖括号<>**
3.  函数名后跟一对尖括号，尖括号中指定需要**特化的类型**
4.  函数**形参表**: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

举个栗子：

template<>
    bool IsEqual<char*>(char*& left, char*& right)
    { 
     if(strcmp(left, right) > 0)
     	return true;
     return false;
    }

**类模板特化**（也就是我之前在上一篇博客中提到的**具体化**）  
![类模板特化][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pvY2hlYmVkNjY2_size_16_color_FFFFFF_t_70 1]  
*全特化（显示具体化）*  
全特化即是将模板参数类表中所有的参数都确定化。

template<>
    class Data<int, char>
    { 
    public:
     Data() { cout<<"Data<int, char>" <<endl;}
    private:
     T1 _d1;
     T2 _d2;
    };

*偏特化（部分具体化）*  
偏特化即任何针对模版参数进一步进行条件限制设计的特化版本。  
偏特化有以下两种表现方式：  
部分特化  
将模板参数类表中的一部分参数特化。

// 将第二个参数特化为int
    template <class T1>
    class Data<T1, int>
    { 
    public:
     Data() { cout<<"Data<T1, int>" <<endl;}
    private:
     T1 _d1;
     int _d2;
    };

参数更进一步的限制  
偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

//两个参数偏特化为指针类型
    template <typename T1, typename T2>
    class Data <T1*, T2*>
    {  
    public:
     Data() { cout<<"Data<T1*, T2*>" <<endl;}
     
    private:
     T1 _d1;
     T2 _d2;
    };
    //两个参数偏特化为引用类型
    template <typename T1, typename T2>
    class Data <T1&, T2&>
    { 
    public:
     Data(const T1& d1, const T2& d2)
     : _d1(d1)
     , _d2(d2)
     { 
     cout<<"Data<T1&, T2&>" <<endl;
     }
     
    private:
     const T1 & _d1;
     const T2 & _d2; 
     };
    void test2 () 
    { 
     Data<double , int> d1; // 调用特化的int版本
     Data<int , double> d2; // 调用基础的模板 
     Data<int *, int*> d3; // 调用特化的指针版本
     Data<int&, int&> d4(1, 2); // 调用特化的指针版本
    }

简单总结一下关于实例化和具体化的区别：

<table> 
 <thead> 
  <tr> 
   <th>实例化</th> 
   <th>具体化</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>只声明</td> 
   <td>声明+定义</td> 
  </tr> 
  <tr> 
   <td>template后不加&lt;&gt;</td> 
   <td>template后加&lt;&gt;</td> 
  </tr> 
 </tbody> 
</table>

> 注：详细介绍可参考https://blog.csdn.net/chenyiming\_1990/article/details/10526371\#的博客

**类型萃取**  
由于深浅拷贝的不一致导致我们要对自定义类型和内置类型进行判断而产生类型萃取。

// 代表内置类型
    struct __true_type { };
    // 代表自定义类型
    struct __false_type { };
    //__true_type、__false_type这两个是对象的类型，可以不需要形参的值
    template <class type>
    struct __type_traits
    { 
    typedef __false_type is_POD_type;
    };
    // 对所有内置类型进行特化
    template<>
    struct __type_traits<char>
    { 
    typedef __true_type is_POD_type;
    };
    template<>
    struct __type_traits<signed char>
    { 
    typedef __true_type is_POD_type;
    };
    template<>
    struct __type_traits<unsigned char>
    { 
    typedef __true_type is_POD_type;
    };
    template<>
    struct __type_traits<int>
    { 
    typedef __true_type is_POD_type;
    };
    template<>
    struct __type_traits<float>
    { 
    typedef __true_type is_POD_type;
    };
    template<>
    struct __type_traits<double>
    { 
    typedef __true_type is_POD_type;
    };
    // 注意：在重载内置类型时，所有的内置类型都必须重载出来，包括有符号和无符号
    // 在需要区分内置类型与自定义类型的位置，标准库通常都是通过__true_type与__false_type给出一对重载的函数，然后用一个通用函数对其进行封装
    // 注意：第三个参数可以不提供名字，该参数最主要的作用就是让两个_copy函数形成重载
    template<class T>
    void _copy(T* dst, T* src, size_t n, __true_type)
    { 
    memcpy(dst, src, n*sizeof(T));
    }
    template<class T>
    void _copy(T* dst, T* src, size_t n, __false_type)
    { 
    for (size_t i = 0; i < n; ++i)
    dst[i] = src[i];
    }
    template<class T>
    void Copy(T* dst, T* src, size_t n)
    { 
    _copy(dst, src, n, __type_traits<T>::is_POD_type());
    }

类型萃取的设计模式提高了代码的复用性，也提升了代码的性能。

> 注：类型萃取和STL中迭代器相关的可参考，讲解较为细致https://blog.csdn.net/bit\_clearoff/article/details/53728516

**模板分离编译**  
什么是分离编译  
一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为**分离编译模式**。  
模板出现在.cpp文件中实现时，链接出错，所以模板实现放在.h文件里，不支持分离编译，模板没有实例化，无法在.o文件中找到所调用的函数的地址。  
*模板的分离编译*  
假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义。

举个栗子：

// a.h
    template<class T>
    T Add(const T& left, const T& right);
    // a.cpp
    template<class T>
    T Add(const T& left, const T& right)
    { 
     return left + right;
    }
    // main.cpp
    #include"a.h"
    int main()
    { 
     Add(1, 2);
     Add(1.0, 2.0);
     
     return 0;
    }

解决方法

1.  将声明和定义放到一个文件 “xxx.hpp” 里面或者xxx.h其实也是可以的。推荐使用这种。
2.  模板定义的位置显式实例化。这种方法不实用，不推荐使用。

**模板总结**  
【优点】

1.  模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
2.  增强了代码的灵活性
3.  解决代码膨张  
    【缺陷】
4.  模板会导致代码膨胀问题，也会导致编译时间变长
5.  出现模板编译错误时，错误信息非常凌乱，不易定位错误
6.  指明要生成什么类型的代码，用什么就要显示实例化什么，  
    比较麻烦

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pvY2hlYmVkNjY2_size_16_color_FFFFFF_t_70]: /images/20220325/0687fe07d0b1440f8a3b4c43f6874a74.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pvY2hlYmVkNjY2_size_16_color_FFFFFF_t_70 1]: /images/20220325/93e8b44884aa44a196d31c0dcfd87e3c.png