【C++】模板初阶
文章目录
- 前言
-
- 一、泛型编程
- 二、函数模板
-
- 1.函数模板概念和格式
- 2.函数模板的原理
- 3.函数模板的实例化
- 4.模板参数的匹配原则
- 三、类模板
-
- 1.概念与格式
- 2.实例化
前言
在C语言阶段，我们实现一个交换函数的时候，对于每一个数据类型我们都需要写对应的交换函数，并且函数名不能够相同，比如对于整型的交换我们的函数名为Swapi,浮点型为Swapd等等，到了C++阶段，我们可以通过函数重载的方式定义多个参数不同(参数的个数和类型，顺序不同)，但是函数名相同的函数来实现，但是函数重载也有一定的缺陷,为了解决上面的问题，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;
}
使用函数重载虽然可以实现，但是有一下几个不好的地方：
1.重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数
2.代码的可维护性比较低，一个出错可能所有的重载均出错
那我们能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？
如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件(即生成具体类型的代码），那将会节省许多头发。巧的是前人早已将树栽好，我们只需在此乘凉。
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础，模板又分为函数模板和类模板。
二、函数模板
1.函数模板概念和格式
函数模板概念
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本
函数模板格式
template<class T1, class T2,......,class Tn>
返回值类型 函数名(参数列表)
{
函数体
}
其中的class关键字也可以使用typename 来替换：
template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表)
{
函数体
}
我们举一个具体样例：
template<typename T>
void Swap( T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
注意：
template为模板参数的关键字，class/typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class),类型参数用于表示该类型，我们一般用T表示
有了函数模板，我们就可以只写一个函数来实现不同数据类型(同一个功能)的函数功能：
// 函数模板
template<typename T>
void Swap(T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
int main()
{
int a = 1, b = 2;
Swap(a, b);
int x = 1, y = 2;
Swap(x, y);
double c = 1.1, d = 2.2;
Swap(c, d);
char e = 'a', f = 'b';
Swap(e, f);
return 0;
}
2.函数模板的原理
函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。
// 函数模板
template<typename T>
void Swap(T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
int main()
{
int a = 1, b = 2;
Swap(a, b);
int x = 1, y = 2;
Swap(x, y);
double c = 1.1, d = 2.2;
Swap(c, d);
char e = 'a', f = 'b';
Swap(e, f);
return 0;
}
我们可以看到a,b和x,y调用的是同一个函数，所以对于参数相同的，模板推演的是同一个函数
3.函数模板的实例化
用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。
1.隐式实例化：让编译器根据实参推演模板参数的实际类型
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.1, d2 = 20.2;
cout << Add(a1, a2) << endl;
cout << Add(d1, d2) << endl;
return 0;
}
我们调用Add函数的时候不需要显示的指定T为int 或double类型，编译器会根据实参类型自动的去推演模板参数的类型，然后再实例化对应的函数
但是对于下面的情况不能通过编译：
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.1, d2 = 20.2;
cout << Add(a1, a2) << endl;
cout << Add(d1, d2) << endl;
cout << Add(a1, d1) << endl;
return 0;
}
这是因为在编译器期间，当编译器看到该实例化的时候，需要推演其实参类型，通过参数a1将T推演为int,通过实参d1将T推演成double，但模板参数列表只有一个T，此时编译器就无法确认此处是应该把T推演成int，还是推演成double，所以编译器会报错。
【注意】在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅
此时有两种处理方式：1. 用户自己来强制转化 2.增加模板参数 3. 使用显式实例化
1.用户自己来强制转化
我们需要注意函数的形参必须使用const修饰，因为int(double) double(int)传递给形参的都是一个临时变量，而临时变量具有常性，所以需要用const引用类接收，可以减少拷贝。
2.增加模板参数
我们这里的返回值可以是T1也可以是T2
3.使用显式实例化：在函数名后的<>中指定模板参数的实际类型
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.1, d2 = 20.2;
cout << Add<int>(a1, a2) << endl;
cout << Add<double>(d1, d2) << endl;
cout << Add<int>(a1, d1) << endl;
cout << Add<double>(a1, d1) << endl;
return 0;
}
显示实例化的原理和用户强制转换相似，只不过这里编译器会自动将d1强转为int,把a1强转为double,然后再将临时变量传递给形参，所以也需要const修饰
如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错
4.模板参数的匹配原则
1.一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
// 专门处理int的加法函数
int Add(int left, int right)
{
cout << "int Add(int left, int right)" << endl;
return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
cout << "T Add(T left, T right)" << endl;
return left + right;
}
int main()
{
Add(1, 2); // 与非模板函数匹配，编译器不需要特化
Add<int>(1, 2); // 调用编译器特化的Add版本
return 0;
}
我们可以看到，当一个非模板函数可以和一个同名的函数模板同时存在，如果我们不显式实例化，编译器会去调用非函数模板函数，而不会去实例化模板，如果我们显式实例化，则编译器就会调用通过函数模板实例化得到的函数
显式实例化后的程序能够正常运行，这说明了通过函数模板实例化出的函数和非模板函数的函数名修饰规则不同，否则机会报错
2.对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板
// 专门处理int的加法函数
int Add(int left, int right)
{
cout << "int Add(int left, int right)" << endl;
return left + right;
}
// 通用加法函数
template<class T1,class T2>
T1 Add(T1 left, T2 right)
{
cout << "T Add(T left, T right)" << endl;
return left + right;
}
int main()
{
Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
Add(1, 2.0); // // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
return 0;
}
3.模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
三、类模板
1.概念与格式
和非模板函数一样，我们之前实现的类也有一个缺点，就是只能实例化出一种类型的对象，比如Stack所以我们这里以Stack为例：
typedef int STDataType;
class Stack
{
public:
Stack(int capacity = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * capacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
_top = 0;
_capacity = capacity;
}
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
void Push(STDataType x)
{
// 扩容
_a[_top++] = x;
}
private:
STDataType* _a;
int _top;
int _capacity;
};
int main()
{
Stack st1;
st1.Push(1);
st1.Push(2);
Stack st2;
st2.Push(1.1);
st2.Push(2.1);
return 0;
}
我们可以看到，虽然可以通过修改STDataType 来让_a存储不同类型的数据，但是在同一个项目中，STDataType只能被指定为一种类型，所以不能处理上面这种情况，那么和模板函数一样，我们也需要一个类模板来解决这个问题，使用一个模板来实例化出不同的类。
类模板的定义格式
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};
此时我们就可以使用类模板来实现Stack:
template<typename T>
class Stack
{
public:
Stack(int capacity = 4)
{
_a = (T*)malloc(sizeof(T)*capacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
_top = 0;
_capacity = capacity;
}
~Stack()
{
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
void Push(const T& x)
{
// 扩容
_a[_top++] = x;
}
private:
T* _a;
int _top;
int _capacity;
};
【注意】
1.类模板中函数放在类外进行定义时，需要加模板参数列表
template <class T>
Vector<T>::~Vector()
{
if(_pData)
delete[] _pData;
_size = _capacity = 0;
}
2.类模板一般没有推演时机，函数模板实参传递形参，推演模板参数，所以我们就只能显示实例化，此外，他们是同一个类模板实例化出来的，但是模板参数不同，他们就是不同类型
2.实例化
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类，这是因为C++中类名就是类型，但是类模板和普通类不同，只有我们对类模板进行显式实例化之后编译器才会生成具体的类，而这个类才是我们能够正常使用的类，所以实例化的结果才是真正的类。
// Stack类名，Stack才是类型
Stack<int> s1;
Stack<double> s2;