模板(初阶)
一.了解泛型编程
泛型编程:编写与类型无关的通用代码,是代码复用的一种手段。模板是泛型编程的基础。
C++的模板是一种通用编程工具,它允许我们编写通用代码,使得一段代码可以应用于多种不同的数据类型。泛型编程是指使用这些通用工具来编写程序,这种方法可以提高程序的可重用性和可维护性。
模板可分为:函数模板和类模板。
二.设计一个通用的交换函数
2.1使用函数重载
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;
}
//等等
2.2使用函数模板
template<typename T>
void Swap(T& x, T& y)
{
T temp = x;
x = y;
y = temp;
}
使用函数模板时,编译器会通过实参的类型来生成具体类型的函数来完成交换功能。
三.函数模板
3.1函数模板概念
函数模板代表了一个函数家族,该函数模板与类型无关,在使用时被参数化,根据实参类型产生函数的特定类型版本。
3.2函数模板格式
使用关键字typename是用来定义模板参数,也可以使用class(切记:不能使用struct代替class)。
template<typename T1, typename T2,…,typename Tn>
template<typename T>
void Swap(T& x, T& y)
{
T temp = x;
x = y;
y = temp;
}
注意:函数模板本身并不是函数,是编译器用使用它来产生特定具体类型函数的模具。
3.3函数模板实例化
用不同类型的参数使用函数模板时,称为函数模板的实例化。
3.3.1隐式实例化
让编译器根据实参推演模板参数的实际类型
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
double d1 = 10.0, d2 = 20.0;
Add(d1, d2);
return 0;
}
解释:当用double类型使用函数模板时,编译器通过对实参类型的推演,将T确定为double类型,然后产生一份专门处理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.0, d2 = 20.0;
//报错:模板 参数“T”不明确
//Add(a1, d1);
return 0;
}
- 解决方法1:用户自己强制类型转换
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.0, d2 = 20.0;
//用户自己强制类型转换
Add(a1, (int)d1);
return 0;
}
解决方法2:显式实例化
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.0, d2 = 20.0;
//显式实例化
Add<int>(a1, d1);
return 0;
}
3.3.2显式实例化
在函数名后面加上指定的类型实例化,如果类型不匹配,编译器会尝试进行隐式类型转换,如果无法转换成功编译器将会报错。
template<class T>
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;
//显式实例化
Add<int>(a1, d1);
return 0;
}
必须使用显式实例化的场景
template<typename T>
T* Alloc(int n)
{
return new[n];
}
int main()
{
double* p1 = Alloc<double>(10);
return 0;
}
3.3.3模板参数的匹配原则
- 一个非模板函数可以和一个同名的函数模板同时存在,而且该函数模板还可以被实例化为这个非模板函数
// 专门处理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函
}
- 模板函数不允许自动类型转换,但普通函数可以进行自动类型转换
四.类模板
4.1类模板定义格式
template<class T1, class T2, …, class Tn>
class 类模板名
{
// 类内成员定义
};
4.2定义多种类型的栈
4.2.1分别定义不同类型的栈
typedef int DataType;
class StackInt
{
};
typedef double DataType;
class StackDouble
{
};
4.2.2类模板
template<class T>
class Stack
{
public:
Stack(size_t capacity = 3)
{
_array = new T[capacity];
_capacity = capacity;
_size = 0;
}
void Push(const T& data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 其他方法...
~Stack()
{
if (_array)
{
delete[] _array;
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
T* _array;
int _capacity;
int _size;
};
注意:类模板无法通过推演实例化,只能显式实例化。
4.3类模板实例化
类模板实例化与函数模板实例化不同,类模板实例化需要在类模板名字后跟<>,然后将实例化的类型放在<>中即可,类模板名字不是真正的类,而实例化的结果才是真正的类。
注意:
Stack是类名
Stack < T > 是类型
int main()
{
//Stack是类名 Stack<int>是类型
Stack<int> st1;
Stack<double> st2;
return 0;
}
4.4类模板声明和定义分离注意事项
类模板中函数放在类外进行定义时,需要加模板参数列表,并且需要在域操作符前指定类型。
template<class T>
class Stack
{
public:
Stack(size_t capacity = 3);
void Push(const T& data);
// 其他方法...
~Stack()
{
if (_array)
{
delete[] _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;
}
template<class T>
void Stack<T>::Push(const T& data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}