模板升华

最新推荐文章于 2022-08-08 14:58:30 发布

Jochebed666

最新推荐文章于 2022-08-08 14:58:30 发布

阅读量219

点赞数

分类专栏： c++ 文章标签：模板

本文链接：https://blog.csdn.net/Jochebed666/article/details/86556336

版权

c++ 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

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

模板参数

什么是模板参数？？？
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;
}；

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

模板的特化

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

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

举个栗子：

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

类模板特化（也就是我之前在上一篇博客中提到的具体化）

全特化（显示具体化）
全特化即是将模板参数类表中所有的参数都确定化。

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); // 调用特化的指针版本
}

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

实例化	具体化
只声明	声明+定义
template后不加<>	template后加<>

注：详细介绍可参考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;
}