模板（C++）
模板
- class和typename使用
- 非类型模板参数
- 类模板的特化
-
- 概念
- 函数模板特化 （基本都是重新实现函数，不用特化）
- 类模板特化
-
- 全特化
- 偏特化
- 模板的分离编译
-
- 分离编译概念
- 模板的分离编译
- 解决方法
- 模板总结
简单认识模板在这个博客中，我们对模板进行简单的认识。接下来对模板继续深化认识。
class和typename使用
template<class Container>
void Print(const Container& v)
{
Container::const_iterator it = v.begin();
//...
}
分析代码：了解class和typename使用
非类型模板参数
模板参数：类型形参和非类型形参
- 类型形参：出现在模板参数列表中，跟在class或者typename的参数类型
- 非类型形参：常量作为类（函数）模板的一个参数，在模板中可将该参数当常量使用
eg:
namespace kpl
{
//定义一个模板类型的静态数组
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;
};
}
int main()
{
//想要静态存储10个，或者100个数据
//array a1; 存10个数据
//array a2; 存100个数据
//为了解决上述问题，出现非类型模板参数
kpl::array<int, 10> a1;
kpl::array<int, 100> a2;
return 0;
}
非类型模板参数的限制：（了解）
- 浮点数、类对象以及字符串不允许作为非类型模板参数
- 非类型的模板参数必须在编译期间就能确认结果 。
类模板的特化
类模板的特化分为：函数模板特化和类模板特化
概念
对于一些特殊类型，使用模板可能得到一些错误的结果，所以就需要特殊处理
eg:例子中借用自定义类型，日期类Date
template<class T>
bool Less(T left, T right)
{
return left < right;
}
int main()
{
cout << Less(1, 2) << endl; //结果正确
Date d1(2023, 8, 10);
Date d2(2023, 8, 18);
cout << Less(d1, d2) << endl; //结果正确
Date* p1 = &d1;
Date* p2 = &d2;
cout << Less(p1, p2) << endl; //结果错误
return 0;
}
代码分析：
在特殊场景下，结果错误。我们使用日期类指针比较，发现结果不是日期的比较而是指针的比较。
为了解决上述问题就需要对模板进行特化。即在原模板类的基础上，针对特殊类型进行特殊化的实现方式
函数模板特化 （基本都是重新实现函数，不用特化）
要求：
- 必须要现有一个基础的函数模板
- 关键字template后跟<>
- 函数名后跟<>，尖括号中指定需要特化的类型
- 函数形参表：必须和模板函数的基础参数类型完全相同。
eg::例子中借用自定义类型，日期类Date
//函数模板
template<class T>
bool Less(T left, T right)
{
return left < right;
}
//对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
return *left < *right;
}
int main()
{
cout << Less(1, 2) << endl;
Date d1(2023, 8, 10);
Date d2(2023, 8, 18);
cout << Less(d1, d2) << endl;
Date* p1 = &d1;
Date* p2 = &d2;
cout << Less(p1, p2) << endl; //调用特化版本，而不是走模板生成
}
注意：一般如果函数模板遇到不能处理或处理有误的情况，为了实现简单通常都是将该函数直接给出
eg：
bool Less(Date* left, Date* right)
{
return *left < *right;
}
类模板特化
全特化
全特化即将模板参数列表中所有的参数都确定化
template<class T1, class T2>
class Data
{
public:
Data()
{
cout << "Data" << endl;
}
private:
T1 _d1;
T2 _d2;
};
template<>
class Data<int, char>
{
public:
Data()
{
cout << "Data" << endl;
}
private:
int _d1;
char _d2;
};
int main()
{
Data<int, int> d1;
Data<int, char> d2;
return 0;
}
//output:
//Data偏特化
偏特化即任何针对模板参数进一步进行条件限制的特化版本
eg:对一下模板类
template<class T1, class T2>
class Data
{
public:
Data()
{
cout << "Data" << endl;
}
private:
T1 _d1;
T2 _d2;
};
偏特化的两种表现方式：
- 部分特化
将模板参数表一部分特化
//将第二个参数转成int
template<class T1>
class Data<T1, int>
{
public:
Data()
{
cout << "Data" << endl;
}
private:
T1 _d1;
int _d2;
};
- 参数更进一步限制
//两个参数偏特化为指针类型
template<typename T1, typename T2>
class Data<T1*, T2*>
{
public:
Data()
{
cout << "Data" << 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" << endl;
}
private:
const T1& _d1;
const T2& _d2;
};
偏特化代码测试：
int main()
{
Data<double, int> d1; //调用特化的int版本
Data<int, double> d2; //调用基础版本
Data<int*, int*> d3; //调用特化的指针版本
Data<int&, int&> d4(1, 2); //调用特化的引用版本
return 0;
}
//output:
//Data模板的分离编译
分离编译概念
分离编译模式：一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程
模板的分离编译
头文件声明: 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函数调用Add： main.cpp
#include "a.h"
int main()
{
Add(1, 2);
Add(1.0, 2.0);
return 0;
}
代码分析：
解决方法
- 在模板定义的位置显示实例化（不推荐）
eg:比较麻烦，需要什么类型的就要实例化一份
template
class Add<int>;
template
class Add<double>;
- 将声明个定义放在一个文件“xxx.hpp”里面或者xxx.h也可以（推荐）
eg:
namespace kpl
{
template<class T, class Container = std::deque<T>>
class stack
{
public:
void push(const T& x);
void pop();
private:
Container _con;
};
template<class T, class Container>
void stack<T, Container>::push(const T& x)
{
_con.push_back(x);
}
template<class T, class Container>
void stack<T, Container>::pop()
{
_con.pop_back();
}
}
模板总结
- 优点
- 模板复用了代码，节约资源，更快的迭代开发
- 增强了代码的灵活行
- 缺点
- 导致代码膨胀的问题，也导致编译时间长
- 模板编译出现错误，错误信息长且乱，不便解决