C++为什么要引入模版?
当我们想用一个函数完成多个类型参数的操作时,发现每次都要重新再写一个函数再使用,对于重载的函数虽然可以使用,但是每次用新的类型都需要再去重载一次函数**。** 例如实现交换的函数:
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
void Swap(double& left, double& right)
{
double temp = left;
left = right;
right = temp;
}
void Swap(char& left, char& right)
{
char temp = left;
left = right;
right = temp;
}
·····
缺点:
泛型编程:编写与类型无关的通用代码,是代码复用的一种手段。模板是泛型编程的基础。
于是在C++中引入了模版的概念.
类似于实现一种类型功能的函数所使用的模具。
template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}
示例:
template<typename T>
void Swap( T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
函数的内容并不是由写的函数模板部分来进行实现,而是编译器通过传入的实参类型进行推演生成对应类型的函数,然后调用对应类型的函数进行实现功能(对T进行替换)。
template<typename T>
// 加const是因为下面传参会产生临时变量,临时变量具有常性
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a = 10;
int b = 90;
double c = 1;
cout << Add(a, c) << endl;
return 0;
}
如上述代码,当在使用函数模板时传入的两个参数是两种不同类型的变量,而在使用的函数模板中链各个形参位置都是同一个T,这样的话编译器就无法确定到底是使用a的int还是c的double(报错)。所以在该种情况下应该使用函数模板的实例化。(用户也可以自己进行类型强制转换
Add(a, (int)d);
)
下面是进行修改后的代码,实例化格式也如下:
// 显式实例化:在函数名后的<>中指定模板参数的实际类型
cout << Add<int>(a, c) << endl;
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非模板函数匹配,编译器不需要特化
Add<int>(1, 2); // 调用编译器特化的Add版本
}
模板函数因为匹配度更高或者更具体而被优先选择
当调用一个函数时,编译器首先尝试找到一个非模板函数与传入的参数类型完全匹配。如果有这样的非模板函数,并且它比任何可能通过模板实例化得到的函数更合适(考虑类型转换的成本等),那么编译器就会选择这个非模板函数。
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非函数模板类型完全匹配,不需要函数模板实例化
Add(1, 2.0); // 模板函数可以生成更加匹配的版本,编译器根据实参生成更加匹配的Add函数
}
当用两种类型进行使用就会调用模板函数。
在C++中,当考虑函数重载和类型转换时,非模板函数相比模板函数有一个特点,即非模板函数可以利用C++的隐式类型转换规则(也称为标准转换序列),而模板函数则不会自动考虑这些转换,除非显式实例化或通过其他方式明确指定。
具体来说:
但如果有多个模版参数的话,模板函数就会自动生成相对应的函数进行使用。当然如果通过显式模板实参或者其它上下文(如函数参数的类型推导)使得编译器能够明确地实例化模板,那么相应的类型转换规则(包括用户自定义转换)仍然会在实例化后的函数调用中生效。
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};
// 类模板
template<class T>
class Stack
{
public:
Stack(size_t capacity = 3);
void Push(const T& data);
// 其他方法...
~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
T* _array;
int _capacity;
int _size;
};
例如用模版定义一个栈,现在需要将代码量比较大的成员函数放在类外声明,格式如下:
template<class T>
Stack<T>::Stack(size_t capacity)
{
_array = new T[capacity];
_capacity = capacity;
_size = 0;
}
在类模板中,当你在类定义之外(类外)声明或定义成员函数时,需要使用模板语法来指定模板参数,这是因为成员函数实际上是模板类的成员,它们的实现依赖于类模板的类型参数。所以,正确的语法格式是先指明模板参数列表,然后是类名(包括模板参数),接着是成员函数的名称和其他参数列表。
类模板实例化与函数模板实例化不同,类模板实例化需要在类模板名字后跟<>,然后将实例化的类型放在<>中即可,类模板名字不是真正的类,而实例化的结果才是真正的类
int main()
{
Stack<int> s1; // int
Stack<double> s2; // double
Stack<char> s3; // char
return 0;
}