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;
}
但是真的很方便吗?这里只有三种类型的数据需要交换,若是我们需要增加交换的数据呢?再CV然后写一个函数吗?
这肯定是不现实的,所以很明显函数重载虽然可以实现,但是有一下几个不好的地方:
那是否能做到这么一点,告诉编译器一个模子,让编译器根据不同的类型利用该模子来生成代码
这样,我们先通过一个案例来做引入
所以,总结上面的这么一个技术,C++的祖师爷呢就想到了【模版】这个东西,告诉编译器一个模子,然后其余的工作交给它来完成,根据不同的需求生成不同的代码
这就是泛型编程:编写与类型无关的通用代码,是代码复用的一种手段。模板是泛型编程的基础
知晓了模版的基本概念后,首先我们要来看的就是【函数模版】
函数模板代表了一个函数家族,该函数模板与类型无关,在使用时被参数化,根据实参类型产生函数的特定类型版本
通过函数模板,可以编写一种通用的函数定义,使其能够适用于多种数据类型,从而提高代码的复用性和灵活性。
template
返回值类型 函数名(参数列表){}
马上,我们就来为上面的swap()
函数写一个通用的函数模版把
template
void Swap(T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
那我现在想问一个问题,请问它们调用的真的是同一个函数吗?
接下去我们来说说这个函数模版的原理,带你理清编译器内部究竟做了什么事情
还是不太懂的老铁可以看看下面这张图,就能明白了
那我现在还想问,如果我使用的是两个日期类Date
的对象呢,能不能对它们进行交换
那如果是指针呢?也会去调用吗?
既然谈到了这个【Swap】交换函数,我们就顺便来说说库里的这个【swap】
上面我们所定义的都是单个模版参数,那多个模版参数是否可以定义呢?
template
T1 Func(const T1& x, const T2& y)
{
cout << x << " " << y << endl;
}
然后我们来讲讲【函数模板的实例化】
用不同类型的参数使用函数模板时,称为函数模板的实例化。模板参数实例化分为:隐式实例化和显式实例化
template
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.0, d2 = 20.0;
// 根据实参传递的类型,推演T的类型
cout << Add(a1, a2) << endl;
cout << Add(d1, d2) << endl;
}
但是呢像下面这种就不可以了,因为a1是【int】类型,d1是【double】类型,在编译期间,当编译器看到该实例化时,需要推演其实参类型 通过实参a1将T推演为int类型,通过实参d1将T推演为double类型,但模板参数列表中只有一个T, 编译器无法确定此处到底该将T确定为int 或者 double类型而报错。此时在函数调用完后进行返回时,编译器也识别不出是哪个类型了,它们两个就像在打架一样,很难一绝高下
cout << Add(a1, d2) << endl
好比你做错事了,你爸爸让你罚站,不让你吃饭,此时呢你妈妈回来了,让你赶紧过来吃饭,那此时你该听谁的呢?
那当他们商量好了之后,就会有下面这两种情况
int
类型然后再传递进去,此时就不会出现类型冲突的问题了 cout << Add(a1, (int)d2) << endl;
double
类型然后再传递进去,也不会出现类型冲突的问题 cout << Add((double)a1, d2) << endl;
// 显式实例化,用指定类型实例化
cout << Add(a1, d2) << endl;
cout << Add(a1, d2) << endl;
虽然上面我们介绍了两种处理方式,但是对于某些场景来说,却只能进行【显式实例化】
template
T* Alloc(int n)
{
return new T[n];
}
// 有些函数无法自动推,只能显示实例化
double* p1 = Alloc(10);
float* p1 = Alloc(20);
int* p2 = Alloc(30);
① 一个非模板函数可以和一个同名的函数模板同时存在,而且该函数模板还可以被实例化为这个非模板函数
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template
T Add(T left, T right)
{
return left + right;
}
int main(void)
{
Add(1, 2);
Add(1, 2);
return 0;
}
② 对于非模板函数和同名函数模板,如果其他条件都相同,在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数, 那么将选择模板
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template
T1 Add(T1 left, T2 right)
{
return left + right;
}
int main(void)
{
Add(1, 2);
Add(1, 2.2);
return 0;
}
③ 模板函数不允许自动类型转换,但普通函数可以进行自动类型转换
// 普通函数,允许自动类型转换
void print(int value) {
std::cout << "Integer: " << value << std::endl;
}
int main() {
print(3);
print(3.14);
return 0;
}
template
void print(T a, T b) {
cout << a << " " << b << endl;
}
int a = 1;
double b = 1.11;
print(a, b);
// 强制类型转换
print(a, (int)b);
print((double)a, b);
// 显式实例化
print(a, b);
print(a, b);
讲完了函数模版后,我们再来说说类模版,也就是对一个类来说,也是可以定义为一个模版的
template
class 类模板名
{
// 类内成员定义
};
我们以下面这个Stack类为例来进行讲解
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 3)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(DataType data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 其他方法...
~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
如果没有模版技术的话你会如何去解决这个问题呢?很简单那就是定义多个类
StackInt
存放整型数据,StackDouble
存放浮点型数据但是本文我们重点要讲解的就是【模版技术】,技术界有一句话说得好 “不要重复造轮子”
template
class Stack
{
public:
Stack(size_t capacity = 3)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(T data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 其他方法...
~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
T* _array;
int _capacity;
int _size;
};
template // 类模版
class Stack
{
public:
Stack(size_t capacity = 3);
void Push(T data);
~Stack();
private:
T* _array;
int _capacity;
int _size;
};
缺少类模版“Stack”的参数列表
,因为这个成员函数内部也使用到了模版参数T,那么这个函数也要变为函数模版才行template
Stack::Stack(size_t capacity)
{
_array = new T(capacity);
_capacity = capacity;
_size = 0;
}
template // 每个函数或类前都要加上其对应的模版参数
void Stack::Push(T data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
template
Stack::~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
清楚了什么是类模版之后,我们就将上面的这个Stack类模版给实例化出来吧
类模板实例化与函数模板实例化不同,类模板实例化需要在类模板名字后跟<>,然后将实例化的类型放在<>中即可,类模板名字不是真正的类,而实例化的结果才是真正的类
int main(void)
{
Stack s1; // int
Stack s2; // double
Stack s3; // char
return 0;
}
最后我们来总结一下本文所学习的内容
总而言之,模版是C++的一个亮点所在,也是学习STL的基础,望读者扎实掌握
以上就是本文要介绍的所有内容,感谢您的阅读
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
此文借鉴与https://blog.csdn.net/Fire_Cloud_1/article/details/131611593